Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

CORBA_NVList Class Reference

NVList ... this is used in the (client side) DII (Dynamic Invocation Interface) to hold parameters, except for the return parameter. It's used in the same role in the (server side) DSI (Dynamic Skeleton Interface). More...

#include <NVList.h>

Collaboration diagram for CORBA_NVList:

Collaboration graph
[legend]
List of all members.

Public Types

typedef CORBA_NVList_ptr _ptr_type
typedef CORBA_NVList_var _var_type

Public Methods

 ~CORBA_NVList (void)
 destructor. More...

CORBA::ULong count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const
 return the current number of elements in the list. More...

CORBA_NamedValue_ptr add (CORBA::Flags ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 add an element and just initialize the flags. More...

CORBA_NamedValue_ptr add_item (const char *, CORBA::Flags ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 add an element and initialize its name and flags. More...

CORBA_NamedValue_ptr add_value (const char *, const CORBA::Any &, CORBA::Flags ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 initializes a value, name, and flags. More...

CORBA_NamedValue_ptr add_item_consume (char *, CORBA::Flags ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 just like add_item. In addition, memory management of char * name is taken over by the NVList. More...

CORBA_NamedValue_ptr add_value_consume (char *, CORBA::Any_ptr, CORBA::Flags ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 just like add_value. In addition, the NVList controls the memory management of the char *name and Any *value parameter. More...

CORBA_NamedValue_ptr item (CORBA::ULong n ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 retrieve the item at the nth location. Raises Bounds. More...

void remove (CORBA::ULong n ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 remove element at index n. Raises Bounds. More...

CORBA::ULong _incr_refcnt (void)
CORBA::ULong _decr_refcnt (void)
void _tao_incoming_cdr (TAO_InputCDR &cdr, int flag, int &lazy_evaluation ACE_ENV_ARG_DECL)
void _tao_encode (TAO_OutputCDR &cdr, TAO_ORB_Core *orb_core, int flag ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 Encode the NVList into the CDR stream. <flag> masks the type of arguments (IN, OUT or INOUT) that are to be marshaled. More...

void _tao_decode (TAO_InputCDR &cdr, int flag ACE_ENV_ARG_DECL)
 Decode the NVList arguments from the <cdr> stream. More...

ptr_arith_t _tao_target_alignment (void)
CORBA::Boolean _lazy_has_arguments (void) const

Static Public Methods

CORBA_NVList * _duplicate (CORBA_NVList *)
CORBA_NVList * _nil (void)

Private Methods

 CORBA_NVList (void)
 constructor - cannot be instantiated directly other than through the ORB::create_list method. More...

CORBA_NamedValue_ptr add_element (CORBA::Flags ACE_ENV_ARG_DECL_WITH_DEFAULTS)
 helper to increase the list size. This is used by all the add_ methods of the NVList class. More...

void evaluate (ACE_ENV_SINGLE_ARG_DECL)
 Lazy evaluation routine to fill up the Anys in the NVList from the CDR stream. More...


Private Attributes

ACE_Unbounded_Queue< CORBA_NamedValue_ptrvalues_
 internal list of parameters stored as NamedValues. More...

CORBA::ULong max_
 maximum length of list. More...

CORBA::ULong refcount_
 maintains how many references exist to this object. More...

TAO_SYNCH_MUTEX refcount_lock_
 Protects the reference count. More...

TAO_InputCDRincoming_
int incoming_flag_
 The flags used to check which parameters are actually extracted from the <incoming_> buffer. More...


Friends

class CORBA_ORB
class CORBA_Request

Detailed Description

NVList ... this is used in the (client side) DII (Dynamic Invocation Interface) to hold parameters, except for the return parameter. It's used in the same role in the (server side) DSI (Dynamic Skeleton Interface).

Each user (client, server) provides the typecode and memory for each parameter using an NVList, then talks to the ORB using a Request or ServerRequest pseudo-object. The ORB copies data to/from the IPC messages (e.g. IIOP::Request, IIOP::Response) as appropriate.

Definition at line 177 of file NVList.h.


Member Typedef Documentation

typedef CORBA_NVList_ptr CORBA_NVList::_ptr_type
 

Definition at line 272 of file NVList.h.

typedef CORBA_NVList_var CORBA_NVList::_var_type
 

Definition at line 273 of file NVList.h.


Constructor & Destructor Documentation

CORBA_NVList::~CORBA_NVList void   
 

destructor.

Definition at line 79 of file NVList.cpp.

References ACE_Unbounded_Queue_Iterator::advance, ACE_Unbounded_Queue_Iterator::done, ACE_Unbounded_Queue_Iterator::first, incoming_, max_, and ACE_Unbounded_Queue_Iterator::next.

00080 {
00081   // initialize an iterator and delete each NamedValue
00082   ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> iter (this->values_);
00083 
00084   for (iter.first (); !iter.done (); iter.advance ())
00085     {
00086       CORBA::NamedValue_ptr *nv;
00087       (void) iter.next (nv);
00088       delete *nv;
00089     }
00090 
00091   this->max_ = 0;
00092 
00093   // Remove the CDR stream if it is present.
00094   delete this->incoming_;
00095 }

ACE_INLINE CORBA_NVList::CORBA_NVList void    [private]
 

constructor - cannot be instantiated directly other than through the ORB::create_list method.

Definition at line 241 of file NVList.i.

00242   : max_ (0),
00243     refcount_ (1),
00244     incoming_ (0),
00245     incoming_flag_ (0)
00246 {
00247 }


Member Function Documentation

CORBA::ULong CORBA_NVList::_decr_refcnt void   
 

Definition at line 66 of file NVList.cpp.

References ACE_GUARD_RETURN, refcount_, and TAO_SYNCH_MUTEX.

00067 {
00068   {
00069     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_, 0);
00070     this->refcount_--;
00071     if (this->refcount_ != 0)
00072       return this->refcount_;
00073   }
00074 
00075   delete this;
00076   return 0;
00077 }

ACE_INLINE CORBA_NVList * CORBA_NVList::_duplicate CORBA_NVList *    [static]
 

Definition at line 259 of file NVList.i.

References _incr_refcnt.

Referenced by CORBA_NVList_out::operator=, and CORBA_NVList_var::operator=.

00260 {
00261   if (x != 0)
00262     x->_incr_refcnt ();
00263   return x;
00264 }

CORBA::ULong CORBA_NVList::_incr_refcnt void   
 

Definition at line 59 of file NVList.cpp.

References ACE_GUARD_RETURN, refcount_, and TAO_SYNCH_MUTEX.

Referenced by _duplicate.

00060 {
00061   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_, 0);
00062   return this->refcount_++;
00063 }

CORBA::Boolean CORBA_NVList::_lazy_has_arguments void    const
 

If this list is used by a DII request, this will tell us if our CDR stream contains any marshaled arguments (needed for GIOP 1.2).

Definition at line 442 of file NVList.cpp.

References count, incoming_, and ACE_InputCDR::length.

00443 {
00444   if (this->incoming_ != 0)
00445     {
00446       return this->incoming_->length () == 0 ? 0 : 1;
00447     }
00448   else
00449     {
00450       return this->count () == 0 ? 0 : 1;
00451     }
00452 }

ACE_INLINE CORBA_NVList * CORBA_NVList::_nil void    [static]
 

Definition at line 267 of file NVList.i.

Referenced by CORBA_NVList_var::_retn, CORBA_NVList_out::CORBA_NVList_out, and CORBA_NVList_var::out.

00268 {
00269   return 0;
00270 }

void CORBA_NVList::_tao_decode TAO_InputCDR   cdr,
int flag    ACE_ENV_ARG_DECL
 

Decode the NVList arguments from the <cdr> stream.

Definition at line 378 of file NVList.cpp.

References ACE_BIT_DISABLED, ACE_CHECK, ACE_DEBUG, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_TEXT, ACE_Unbounded_Queue_Iterator::advance, ACE_Unbounded_Queue_Iterator::done, ACE_Unbounded_Queue_Iterator::first, item, LM_DEBUG, and ACE_Unbounded_Queue_Iterator::next.

Referenced by _tao_incoming_cdr, and evaluate.

00381 {
00382   if (TAO_debug_level > 3)
00383     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode\n")));
00384 
00385   // Then unmarshal each "in" and "inout" parameter.
00386   ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
00387 
00388   for (i.first (); !i.done (); i.advance ())
00389     {
00390       CORBA::NamedValue_ptr *item;
00391       (void) i.next (item);
00392 
00393       CORBA::NamedValue_ptr nv = *item;
00394 
00395       // check if it is an in or inout parameter
00396       // @@ this is where we assume that the NVList is coming from
00397       //    a Server-side request, we could probably handle both
00398       //    cases with a flag, but there is no clear need for that.
00399       if (ACE_BIT_DISABLED (nv->flags (), flag))
00400         continue;
00401 
00402       if (TAO_debug_level > 3)
00403         ACE_DEBUG ((LM_DEBUG,
00404                     ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode - %s\n"),
00405                     nv->name ()?nv->name ():"(no name given)" ));
00406 
00407       CORBA::Any_ptr any = nv->value ();
00408       any->_tao_decode (incoming
00409                          ACE_ENV_ARG_PARAMETER);
00410       ACE_CHECK;
00411     }
00412 }

void CORBA_NVList::_tao_encode TAO_OutputCDR   cdr,
TAO_ORB_Core   orb_core,
int flag    ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

Encode the NVList into the CDR stream. <flag> masks the type of arguments (IN, OUT or INOUT) that are to be marshaled.

Definition at line 299 of file NVList.cpp.

References ACE_BIT_DISABLED, ACE_CHECK, ACE_DEBUG, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_GUARD, ACE_TEXT, ACE_Unbounded_Queue_Iterator::advance, ACE_Unbounded_Queue_Iterator::done, ACE_Unbounded_Queue_Iterator::first, incoming_, item, LM_DEBUG, max_, CORBA_NamedValue::name, ACE_Unbounded_Queue_Iterator::next, TAO_Marshal_Object::perform_append, TAO_SYNCH_MUTEX, CORBA_NamedValue::value, and ACE_OutputCDR::write_octet_array_mb.

00303 {
00304   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_);
00305   if (this->incoming_ != 0)
00306     {
00307       if (this->max_ == 0)
00308         {
00309           // The list is empty aggresively reduce copies and just send
00310           // the CDR stream, we assume that
00311           // TAO_Server_Request::init_reply
00312           // has inserted appropiated padding already to make this
00313           // operation correct
00314           cdr.write_octet_array_mb (this->incoming_->start ());
00315           return;
00316         }
00317 
00318       // Then unmarshal each "in" and "inout" parameter.
00319       ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
00320 
00321       for (i.first (); !i.done (); i.advance ())
00322         {
00323           CORBA::NamedValue_ptr *item;
00324           (void) i.next (item);
00325 
00326           CORBA::NamedValue_ptr nv = *item;
00327 
00328           if (ACE_BIT_DISABLED (nv->flags (), flag))
00329             continue;
00330 
00331           if (TAO_debug_level > 3)
00332             {
00333               const char* arg = nv->name ();
00334               if (arg == 0)
00335                 arg = "(nil)";
00336 
00337               ACE_DEBUG ((LM_DEBUG,
00338                           ACE_TEXT ("NVList::_tao_encode - parameter <%s>\n"),
00339                           arg));
00340             }
00341           CORBA::TypeCode_var tc = nv->value ()->type ();
00342           (void) TAO_Marshal_Object::perform_append (tc.in (),
00343                                                      this->incoming_,
00344                                                      &cdr
00345                                                       ACE_ENV_ARG_PARAMETER);
00346           ACE_CHECK;
00347         }
00348 
00349       delete this->incoming_;
00350       this->incoming_ = 0;
00351       return;
00352     }
00353 
00354   // The list is already evaluated, we cannot optimize the copies, go
00355   // ahead with the slow way to do things.
00356 
00357   // Then marshal each "in" and "inout" parameter.
00358   ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
00359 
00360   for (i.first (); !i.done (); i.advance ())
00361     {
00362       CORBA::NamedValue_ptr *item;
00363       (void) i.next (item);
00364 
00365       CORBA::NamedValue_ptr nv = *item;
00366 
00367       if (ACE_BIT_DISABLED (nv->flags (), flag))
00368         continue;
00369 
00370       nv->value ()->_tao_encode (cdr,
00371                                  orb_core
00372                                   ACE_ENV_ARG_PARAMETER);
00373       ACE_CHECK;
00374     }
00375 }

void CORBA_NVList::_tao_incoming_cdr TAO_InputCDR   cdr,
int    flag,
int &lazy_evaluation    ACE_ENV_ARG_DECL
 

Set the incoming CDR stream, this is used by TAO to perform lazy evaluation of the NVList in an incoming ServerRequest. The <flag> is used to check which parameters (IN, OUT and/or INOUT) are to be extracted

Definition at line 267 of file NVList.cpp.

References _tao_decode, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_GUARD, ACE_NEW, incoming_, incoming_flag_, max_, and TAO_SYNCH_MUTEX.

00271 {
00272   // If the list is empty then using lazy evaluation is the only
00273   // choice.
00274   // @@ There are other cases where we can use lazy evaluation, for
00275   //    example if the list is not empty but the anys own all their
00276   //    objects.
00277   if (lazy_evaluation == 0 && this->max_ == 0)
00278     lazy_evaluation = 1;
00279 
00280   if (lazy_evaluation == 0)
00281     {
00282       this->_tao_decode (cdr,
00283                          flag
00284                           ACE_ENV_ARG_PARAMETER);
00285       return;
00286     }
00287   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_);
00288   if (this->incoming_ != 0)
00289     {
00290       delete this->incoming_;
00291       this->incoming_ = 0;
00292     }
00293 
00294   ACE_NEW (this->incoming_, TAO_InputCDR (cdr));
00295   this->incoming_flag_ = flag;
00296 }

ptr_arith_t CORBA_NVList::_tao_target_alignment void   
 

Return the required alignment to marshal the NVList without any re-alignment. It returns ACE_CDR::MAX_ALIGNMENT to indicate errors.

Definition at line 415 of file NVList.cpp.

References ACE_GUARD_RETURN, incoming_, ACE_CDR::MAX_ALIGNMENT, ptr_arith_t, ACE_Message_Block::rd_ptr, ACE_InputCDR::start, and TAO_SYNCH_MUTEX.

00416 {
00417   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_,
00418                     ACE_CDR::MAX_ALIGNMENT);
00419   if (this->incoming_ == 0)
00420     return ACE_CDR::MAX_ALIGNMENT;
00421 
00422   const char* rd = this->incoming_->start ()->rd_ptr ();
00423   return ptr_arith_t(rd) % ACE_CDR::MAX_ALIGNMENT;
00424 }

CORBA::NamedValue_ptr CORBA_NVList::add CORBA::Flags    ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

add an element and just initialize the flags.

Definition at line 99 of file NVList.cpp.

References ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, and add_element.

00101 {
00102   // call the helper to allocate a NamedValue element (if necessary)
00103   return this->add_element (flags ACE_ENV_ARG_PARAMETER);
00104 }

CORBA::NamedValue_ptr CORBA_NVList::add_element CORBA::Flags    ACE_ENV_ARG_DECL_WITH_DEFAULTS [private]
 

helper to increase the list size. This is used by all the add_ methods of the NVList class.

Definition at line 223 of file NVList.cpp.

References ACE_BIT_DISABLED, ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW_RETURN, ACE_THROW_RETURN, ACE_Unbounded_Queue< CORBA_NamedValue_ptr >::enqueue_tail, evaluate, max_, and values_.

Referenced by add, add_item, add_item_consume, and add_value.

00225 {
00226   this->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
00227   ACE_CHECK_RETURN (CORBA::NamedValue::_nil ());
00228 
00229   if (ACE_BIT_DISABLED (flags,
00230                         CORBA::ARG_IN | CORBA::ARG_OUT | CORBA::ARG_INOUT))
00231     ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
00232 
00233   CORBA::NamedValue_ptr nv;
00234 
00235   // allocate a new NamedValue
00236   ACE_NEW_RETURN (nv, CORBA::NamedValue, 0);
00237 
00238   // set the flags and enqueue in the queue
00239   nv->flags_ = flags;
00240   if (this->values_.enqueue_tail (nv) == -1)
00241     {
00242       delete nv;
00243       return 0;
00244     }
00245 
00246   this->max_++;
00247   return nv; // success
00248 }

CORBA::NamedValue_ptr CORBA_NVList::add_item const char *   ,
CORBA::Flags    ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

add an element and initialize its name and flags.

Definition at line 108 of file NVList.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, add_element, and CORBA::string_dup.

00111 {
00112   // call the helper to allocate a NamedValue element
00113   CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
00114   ACE_CHECK_RETURN (0);
00115 
00116   if (nv)
00117     {
00118       // now initialize the fields
00119       nv->name_ = CORBA::string_dup (name);
00120       return nv;
00121     }
00122   else
00123     return 0;
00124 }

CORBA::NamedValue_ptr CORBA_NVList::add_item_consume char *   ,
CORBA::Flags    ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

just like add_item. In addition, memory management of char * name is taken over by the NVList.

Definition at line 165 of file NVList.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, and add_element.

00168 {
00169 
00170   // call the helper to allocate a NamedValue element
00171   CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
00172   ACE_CHECK_RETURN (0);
00173 
00174   if (nv)
00175     {
00176       // now initialize the fields
00177 
00178       // consume the name
00179       nv->name_ = name;
00180       return nv;
00181     }
00182   else
00183     return 0;
00184 }

CORBA::NamedValue_ptr CORBA_NVList::add_value const char *   ,
const CORBA::Any  ,
CORBA::Flags    ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

initializes a value, name, and flags.

Definition at line 128 of file NVList.cpp.

References ACE_BIT_ENABLED, ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, add_element, and CORBA::string_dup.

00132 {
00133   // call the helper to allocate a NamedValue element
00134   CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
00135   ACE_CHECK_RETURN (0);
00136   if (nv)
00137     {
00138       // now initialize the fields
00139       nv->name_ = CORBA::string_dup (name);
00140       if (ACE_BIT_ENABLED (flags, CORBA::IN_COPY_VALUE))
00141         // IN_COPY_VALUE means that the parameter is not "borrowed" by
00142         // the ORB, but rather that the ORB copies its value.
00143         //
00144         // Initialize the newly allocated memory using a copy
00145         // constructor that places the new "Any" value at just the right
00146         // place, and makes a "deep copy" of the data.
00147         nv->any_ = value;
00148       else
00149         {
00150           // The normal behaviour for parameters is that the ORB "borrows"
00151           // their memory for the duration of calls.
00152           //
00153           nv->any_._tao_replace (value.type_.in (),
00154                                  value.byte_order_,
00155                                  value.cdr_);
00156         }
00157       return nv;
00158     }
00159   else
00160     return 0;
00161 }

CORBA_NamedValue_ptr CORBA_NVList::add_value_consume char *   ,
CORBA::Any_ptr   ,
CORBA::Flags    ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

just like add_value. In addition, the NVList controls the memory management of the char *name and Any *value parameter.

ACE_INLINE CORBA::ULong CORBA_NVList::count ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS    const
 

return the current number of elements in the list.

Definition at line 250 of file NVList.i.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, and max_.

Referenced by _lazy_has_arguments.

00251 {
00252   (ACE_const_cast(CORBA_NVList*,this))->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
00253   ACE_CHECK_RETURN (0);
00254 
00255   return this->max_;
00256 }

void CORBA_NVList::evaluate ACE_ENV_SINGLE_ARG_DECL    [private]
 

Lazy evaluation routine to fill up the Anys in the NVList from the CDR stream.

Definition at line 427 of file NVList.cpp.

References _tao_decode, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_DECL, ACE_GUARD, incoming_, incoming_flag_, and TAO_SYNCH_MUTEX.

Referenced by add_element, and item.

00428 {
00429   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_);
00430   if (this->incoming_ == 0)
00431     return;
00432 
00433   auto_ptr<TAO_InputCDR> incoming (this->incoming_);
00434   this->incoming_ = 0;
00435 
00436   this->_tao_decode (*(incoming.get ()),
00437                      this->incoming_flag_
00438                       ACE_ENV_ARG_PARAMETER);
00439 }

CORBA::NamedValue_ptr CORBA_NVList::item CORBA::ULong   ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

retrieve the item at the nth location. Raises Bounds.

Definition at line 252 of file NVList.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_DECL, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, evaluate, ACE_Unbounded_Queue< CORBA_NamedValue_ptr >::get, max_, and values_.

Referenced by _tao_decode, and _tao_encode.

00253 {
00254   this->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
00255   ACE_CHECK_RETURN (CORBA::NamedValue::_nil ());
00256 
00257   if (n >= this->max_) // 0 based indexing
00258     ACE_THROW_RETURN (CORBA::Bounds (), 0);
00259 
00260   CORBA::NamedValue_ptr *nv;
00261 
00262   this->values_.get (nv, n);
00263   return *nv;
00264 }

void CORBA_NVList::remove CORBA::ULong   ACE_ENV_ARG_DECL_WITH_DEFAULTS
 

remove element at index n. Raises Bounds.

Definition at line 215 of file NVList.cpp.

References ACE_ENV_ARG_DECL_NOT_USED.

00216 {
00217   // not implemented
00218   // @@ (ASG) - TODO
00219 }


Friends And Related Function Documentation

friend class CORBA_ORB [friend]
 

Definition at line 314 of file NVList.h.

friend class CORBA_Request [friend]
 

Definition at line 315 of file NVList.h.


Member Data Documentation

TAO_InputCDR* CORBA_NVList::incoming_ [private]
 

When the NVList is used as part of a Server Request we can simply store the CDR buffer and perform lazy evaluation to compute the Anys.

Definition at line 308 of file NVList.h.

Referenced by _lazy_has_arguments, _tao_encode, _tao_incoming_cdr, _tao_target_alignment, evaluate, and ~CORBA_NVList.

int CORBA_NVList::incoming_flag_ [private]
 

The flags used to check which parameters are actually extracted from the <incoming_> buffer.

Definition at line 312 of file NVList.h.

Referenced by _tao_incoming_cdr, and evaluate.

CORBA::ULong CORBA_NVList::max_ [private]
 

maximum length of list.

Definition at line 295 of file NVList.h.

Referenced by _tao_encode, _tao_incoming_cdr, add_element, count, item, and ~CORBA_NVList.

CORBA::ULong CORBA_NVList::refcount_ [private]
 

maintains how many references exist to this object.

Definition at line 298 of file NVList.h.

Referenced by _decr_refcnt, and _incr_refcnt.

TAO_SYNCH_MUTEX CORBA_NVList::refcount_lock_ [private]
 

Protects the reference count.

Definition at line 301 of file NVList.h.

ACE_Unbounded_Queue<CORBA_NamedValue_ptr> CORBA_NVList::values_ [private]
 

internal list of parameters stored as NamedValues.

Definition at line 292 of file NVList.h.

Referenced by add_element, and item.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 14:59:31 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002