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

# TAO_Bounded_WString_Sequence Class Template Reference

Bounded sequence of wstrings. More...

`#include <Sequence_T.h>`

Inheritance diagram for TAO_Bounded_WString_Sequence:

[legend]
Collaboration diagram for TAO_Bounded_WString_Sequence:

[legend]
List of all members.

## Public Methods
| TAO_Bounded_WString_Sequence (void)
| TAO_Bounded_WString_Sequence (CORBA::ULong length, CORBA::WChar **value, CORBA::Boolean release=0)
| TAO_Bounded_WString_Sequence (const TAO_Bounded_WString_Sequence< MAX > &)
TAO_Bounded_WString_Sequence & | operator= (const TAO_Bounded_WString_Sequence< MAX > &)
| ~TAO_Bounded_WString_Sequence (void)
TAO_SeqElem_WString_Manager | operator[] (CORBA::ULong slot) const
| read-write accessor. More...
virtual void | _allocate_buffer (CORBA::ULong length)
virtual void | _deallocate_buffer (void)
| Must deallocate the buffer and then set it to zero. More...
virtual void | _shrink_buffer (CORBA::ULong new_length, CORBA::ULong old_length)
## Static Public Methods
CORBA::WChar ** | allocbuf (CORBA::ULong length)
void | freebuf (CORBA::WChar **buffer)

## Detailed Description

### template<size_t MAX>
class TAO_Bounded_WString_Sequence< MAX >

Bounded sequence of wstrings.

As its unbounded counterpart it duplicates and releases strings (via CORBA::wstring_dup and CORBA::wstring_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_WString_Sequence< MAX >::TAO_Bounded_WString_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_WString_Sequence< MAX >::TAO_Bounded_WString_Sequence | ( | CORBA::ULong | length,
|  | CORBA::WChar ** | 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_WString_Sequence< MAX >::TAO_Bounded_WString_Sequence | ( | const TAO_Bounded_WString_Sequence< MAX > & | rhs | ) |

| {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_WString_Sequence< MAX >::~TAO_Bounded_WString_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_WString_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. Reimplemented from TAO_Base_Sequence.

template<size_t MAX>
void TAO_Bounded_WString_Sequence< MAX >::_deallocate_buffer | ( | void |  | ) | `[virtual]`

| Must deallocate the buffer and then set it to zero. Reimplemented from TAO_Base_Sequence.

template<size_t MAX>
void TAO_Bounded_WString_Sequence< MAX >::_shrink_buffer | ( | CORBA::ULong | nl,
|  | CORBA::ULong | ol
| ) | `[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>
CORBA::WChar ** TAO_Bounded_WString_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 (w)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_WString_Sequence< MAX >::freebuf | ( | CORBA::WChar ** | 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 wstring_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_WString_Sequence< MAX > & TAO_Bounded_WString_Sequence< MAX >::operator= | ( | const TAO_Bounded_WString_Sequence< MAX > & | rhs | ) |

| {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_WString_Manager TAO_Bounded_WString_Sequence< MAX >::operator[] | ( | CORBA::ULong | slot | ) | const

| read-write accessor.

The documentation for this class was generated from the following files:

- Sequence_T.h
- Sequence_T.cpp
- Sequence_T.i