Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

TAO_Bounded_String_Sequence< MAX > Class Template Reference

Bounded sequence of strings. More...

#include <Sequence_T.h>

Inheritance diagram for TAO_Bounded_String_Sequence< MAX >:

Inheritance graph
[legend]
Collaboration diagram for TAO_Bounded_String_Sequence< MAX >:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_Bounded_String_Sequence (void)
 TAO_Bounded_String_Sequence (CORBA::ULong length, char **value, CORBA::Boolean release=0)
 TAO_Bounded_String_Sequence (const TAO_Bounded_String_Sequence< MAX > &)
TAO_Bounded_String_Sequenceoperator= (const TAO_Bounded_String_Sequence< MAX > &)
 ~TAO_Bounded_String_Sequence (void)
TAO_SeqElem_String_Manager operator[] (CORBA::ULong slot) const
 read-write accessor
virtual void _allocate_buffer (CORBA::ULong length)
virtual void _deallocate_buffer (void)
 Must deallocate the buffer and then set it to zero.
virtual void _shrink_buffer (CORBA::ULong new_length, CORBA::ULong old_length)
void replace (CORBA::ULong length, char **value, CORBA::Boolean release=0)

Static Public Member Functions

char ** allocbuf (CORBA::ULong length)
void freebuf (char **buffer)

Detailed Description

template<size_t MAX>
class TAO_Bounded_String_Sequence< MAX >

Bounded sequence of strings.

As its unbounded counterpart it duplicates and releases strings (via CORBA::string_dup and CORBA::string_free) under the control of a per sequence flag, but the capacity of the sequence is bound on the type.


Constructor & Destructor Documentation

template<size_t MAX>
TAO_Bounded_String_Sequence< MAX >::TAO_Bounded_String_Sequence void   ) 
 

{SPEC} For bounded sequences, the maximum length is part of the type and cannot be set or modified, while for unbounded sequences, the default constructor also sets the maximum length to 0. The default constructor for a bounded sequence always allocates a contents vector, so it always sets the release flag to TRUE.

template<size_t MAX>
ACE_INLINE TAO_Bounded_String_Sequence< MAX >::TAO_Bounded_String_Sequence CORBA::ULong  length,
char **  value,
CORBA::Boolean  release = 0
 

{SPEC} The ``T *data'' constructor (as shown in the example above) allows the length and contents of a bounded or unbounded sequence to be set. For unbounded sequences, it also allows the initial value of the maximum length to be set. For this constructor, ownership of the contents vector is determined by the release parameter---FALSE means the caller owns the storage, while TRUE means that the sequence assumes ownership of the storage.

If release is TRUE, the contents vector must have been allocated using the sequence allocbuf function, and the sequence will pass it to freebuf when finished with it.

template<size_t MAX>
TAO_Bounded_String_Sequence< MAX >::TAO_Bounded_String_Sequence const TAO_Bounded_String_Sequence< MAX > &   ) 
 

{SPEC} Management Functions'' on page 16. The copy constructor creates a new sequence with the same maximum and length as the given sequence, copies each of its current elements (items zero through length--1), and sets the release flag to TRUE.

template<size_t MAX>
ACE_INLINE TAO_Bounded_String_Sequence< MAX >::~TAO_Bounded_String_Sequence void   ) 
 

{SPEC} If release=TRUE, the destructor destroys each of the current elements (items zero through length-1).


Member Function Documentation

template<size_t MAX>
void TAO_Bounded_String_Sequence< MAX >::_allocate_buffer CORBA::ULong  length  )  [virtual]
 

Ensure that the buffer contains space for at least <length> elements. The constructor must be called for any new elements, the old ones (if any) must be copied into the buffer using operator= and then their destructors must be called. Finally the old buffer must be released.

Implements TAO_Base_Sequence.

template<size_t MAX>
void TAO_Bounded_String_Sequence< MAX >::_deallocate_buffer void   )  [virtual]
 

Must deallocate the buffer and then set it to zero.

Implements TAO_Base_Sequence.

template<size_t MAX>
void TAO_Bounded_String_Sequence< MAX >::_shrink_buffer CORBA::ULong  new_length,
CORBA::ULong  old_length
[virtual]
 

Some sequences (of objects and strings) require some cleanup if the sequence is shrunk. The spec requires the destructor to release the objects only from position <0> to <length-1>; so shrink and then delete could result in a memory leak.

Reimplemented from TAO_Base_Sequence.

template<size_t MAX>
char ** TAO_Bounded_String_Sequence< MAX >::allocbuf CORBA::ULong  length  )  [static]
 

{SPEC} The allocbuf function allocates a vector of T elements that can be passed to the T *data constructor. The length of the vector is given by the nelems function argument. The allocbuf function initializes each element using its default constructor, except for strings, which are initialized to null pointers, and object references, which are initialized to suitably typed nil object references. A null pointer is returned if allocbuf for some reason cannot allocate the requested vector. Vectors allocated by allocbuf should be freed using the freebuf function.

template<size_t MAX>
void TAO_Bounded_String_Sequence< MAX >::freebuf char **  buffer  )  [static]
 

{SPEC} The freebuf function ensures that the destructor for each element is called before the buffer is destroyed, except for string elements, which are freed using string_free(), and object reference elements, which are freed using release(). The freebuf function will ignore null pointers passed to it.

template<size_t MAX>
TAO_Bounded_String_Sequence< MAX > & TAO_Bounded_String_Sequence< MAX >::operator= const TAO_Bounded_String_Sequence< MAX > &   ) 
 

{SPEC} The assignment operator deep copies its parameter, releasing old storage if necessary. It behaves as if the original sequence is destroyed via its destructor and then the source sequence copied using the copy constructor.

template<size_t MAX>
TAO_SeqElem_String_Manager TAO_Bounded_String_Sequence< MAX >::operator[] CORBA::ULong  slot  )  const
 

read-write accessor

template<size_t MAX>
void TAO_Bounded_String_Sequence< MAX >::replace CORBA::ULong  length,
char **  value,
CORBA::Boolean  release = 0
 


The documentation for this class was generated from the following files:
Generated on Sat Aug 6 03:18:25 2005 for TAO by  doxygen 1.3.9.1