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

Sequence.h

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file    Sequence.h
00006  *
00007  *  $Id: Sequence.h,v 1.1.1.4 2003/02/21 18:36:45 chad Exp $
00008  *
00009  *  @author Carlos O'Ryan
00010  *  @author Aniruddha Gokhale
00011  */
00012 //=============================================================================
00013 
00014 
00015 #ifndef TAO_SEQUENCE_H
00016 #define TAO_SEQUENCE_H
00017 
00018 #include "ace/pre.h"
00019 
00020 #include "tao/corbafwd.h"
00021 
00022 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00023 # pragma once
00024 #endif /* ACE_LACKS_PRAGMA_ONCE */
00025 
00026 #include "tao/Managed_Types.h"
00027 #include "ace/Log_Msg.h"        /* For "ACE_ASSERT" */
00028 
00029 class CORBA_Object;
00030 class CORBA_Environment;
00031 
00032 /**
00033  * @class TAO_Base_Sequence
00034  *
00035  * @brief Base class for TAO sequences.
00036  *
00037  * This class provides a common interface for all IDL sequences,
00038  * hence the interpreted marshal engine can manipulate them in a
00039  * type safe manner.
00040  */
00041 class TAO_Export TAO_Base_Sequence
00042 {
00043 public:
00044   /// We give access to TAO_Marshal_Sequence, this allows a safe yet
00045   /// small footprint implementation of the marshal engine.
00046   friend class TAO_Marshal_Sequence;
00047 
00048   /// Destructor.
00049   virtual ~TAO_Base_Sequence (void);
00050 
00051   /// Return the maximum length of the sequence
00052   CORBA::ULong maximum (void) const;
00053 
00054   /**
00055    * Ensure that the buffer contains space for at least <length>
00056    * elements.  The constructor must be called for any new elements,
00057    * the old ones (if any) must be copied into the buffer using
00058    * operator= and then their destructors must be called.  Finally the
00059    * old buffer must be released.
00060    */
00061   virtual void _allocate_buffer (CORBA::ULong length) = 0;
00062 
00063   /// Must deallocate the buffer and then set it to zero.
00064   virtual void _deallocate_buffer (void) = 0;
00065 
00066   /**
00067    * Some sequences (of objects and strings) require some cleanup if
00068    * the sequence is shrunk. The spec requires the destructor to
00069    * release the objects only from position <0> to <length-1>; so
00070    * shrink and then delete could result in a memory leak.
00071    */
00072   virtual void _shrink_buffer (CORBA::ULong new_length,
00073                                CORBA::ULong old_length);
00074 
00075   /// Used for sequences of objects to downcast a recently demarshalled
00076   /// object reference into the right type.
00077   virtual void _downcast (void *target,
00078                           CORBA_Object *src
00079                           ACE_ENV_ARG_DECL_WITH_DEFAULTS);
00080 
00081   /// Used for sequences of object to convert from the derived type
00082   /// into the Object class.
00083   virtual CORBA_Object *_upcast (void *src) const;
00084 
00085   // = orbos/98-01-11 proposed extensions.
00086   /// Returns the state of the sequence release flag.
00087   CORBA::Boolean release (void) const;
00088 
00089 protected:
00090   /// Default constructor.
00091   TAO_Base_Sequence (void);
00092 
00093   /// Constructor with control of ownership.
00094   TAO_Base_Sequence (CORBA::ULong maximum,
00095                      CORBA::ULong length,
00096                      void *buffer,
00097                      CORBA::Boolean release = 0);
00098 
00099   /// Assume ownership and set length to 0.
00100   TAO_Base_Sequence (CORBA::ULong maximum,
00101                      void *buffer);
00102 
00103 public:
00104 
00105   // = The following two functions should be protected but we made it
00106   // public because it breaks some compilers.
00107 
00108   TAO_Base_Sequence (const TAO_Base_Sequence &rhs);
00109   TAO_Base_Sequence &operator= (const TAO_Base_Sequence &rhs);
00110   // Copy constructor and assignment operator are protected, the
00111   // derived classes must provided the right semantics for the buffer
00112   // copy, only the static fields are actually copy.
00113 
00114 protected:
00115 
00116   /// The maximum number of elements the buffer can contain.
00117   CORBA::ULong maximum_;
00118 
00119   /// The current number of elements in the buffer.
00120   CORBA::ULong length_;
00121 
00122   /// The buffer with all the elements, casting must be done in derived
00123   /// classes.
00124   void *buffer_;
00125 
00126   /// If true then the sequence should release the buffer when it is
00127   /// destroyed.
00128   CORBA::Boolean release_;
00129 };
00130 
00131 // ****************************************************************
00132 
00133 /**
00134  * @class TAO_Unbounded_Base_Sequence
00135  *
00136  * @brief Base class for all bounded sequences.
00137  *
00138  * This class implements part of the funcionality common to all
00139  * bounded sequences, using this intermediate class instead of
00140  * virtual methods on TAO_Base_Sequence give us a slight
00141  * improvement of performance, but also reduces the amount of
00142  * generated code in the templates.
00143  */
00144 class TAO_Export TAO_Unbounded_Base_Sequence : public TAO_Base_Sequence
00145 {
00146 public:
00147   /**
00148    * = SPEC {16.11.2}
00149    * For an unbounded sequence, setting the length to a larger value
00150    * than the current length may reallocate the sequence
00151    * data. Reallocation is conceptually equivalent to creating a new
00152    * sequence of the desired new length, copying the old sequence
00153    * elements zero through length into the new sequence, and then
00154    * assigning the old sequence to be the same as the new sequence.
00155    */
00156   void length (CORBA::ULong length);
00157 
00158   /**
00159    * return the current length, it cannot go into the base class due
00160    * to the C++ name lookup rules (if you don't know what I'm talking
00161    * about, then try moving it there).
00162    */
00163   CORBA::ULong length (void) const;
00164 
00165   /// destructor.
00166   virtual ~TAO_Unbounded_Base_Sequence (void);
00167 
00168 protected:
00169   /// Default constructor.
00170   TAO_Unbounded_Base_Sequence (void);
00171 
00172   /// Constructor with control of ownership.
00173   TAO_Unbounded_Base_Sequence (CORBA::ULong maximum,
00174                                CORBA::ULong length,
00175                                void *buffer,
00176                                CORBA::Boolean release = 0);
00177 
00178   /// Assume ownership and set length to 0.
00179   TAO_Unbounded_Base_Sequence (CORBA::ULong maximum,
00180                                void *buffer);
00181 };
00182 
00183 // ****************************************************************
00184 
00185 /**
00186  * @class TAO_Bounded_Base_Sequence
00187  *
00188  * @brief Base class for all bounded sequences.
00189  *
00190  * This class implements part of the funcionality common to all
00191  * bounded sequences, using this intermediate class instead of
00192  * virtual methods on TAO_Base_Sequence give us a slight
00193  * improvement of performance, but also reduces the amount of
00194  * generated code in the templates.
00195  */
00196 class TAO_Export TAO_Bounded_Base_Sequence : public TAO_Base_Sequence
00197 {
00198 public:
00199   /// Set the length, for this sequences this call is ignored if the
00200   /// new length is greater that the maximum.
00201   void length (CORBA::ULong length);
00202 
00203   /**
00204    * Return the current length, it cannot go into the base class due
00205    * to the C++ name lookup rules (if you don't know what I'm talking
00206    * about, then try moving it there).
00207    */
00208   CORBA::ULong length (void) const;
00209 
00210   /// Destructor.
00211   virtual ~TAO_Bounded_Base_Sequence (void);
00212 
00213 protected:
00214   /// Default constructor.
00215   TAO_Bounded_Base_Sequence (void);
00216 
00217   /// Constructor with control of ownership.
00218   TAO_Bounded_Base_Sequence (CORBA::ULong maximum,
00219                              CORBA::ULong length,
00220                              void *buffer,
00221                              CORBA::Boolean release = 0);
00222 
00223   /// Assume ownership and set length to 0.
00224   TAO_Bounded_Base_Sequence (CORBA::ULong maximum,
00225                              void *buffer);
00226 };
00227 
00228 // ****************************************************************
00229 
00230 /**
00231  * @class TAO_Unbounded_String_Sequence
00232  *
00233  * @brief Unbounded sequence of strings.
00234  *
00235  * IDL sequences of strings must automatically duplicate and
00236  * release their members based on some global <release> flag.
00237  */
00238 class TAO_Export TAO_Unbounded_String_Sequence
00239   : public TAO_Unbounded_Base_Sequence
00240 {
00241 
00242   // = SPEC
00243   // 16.8 Mapping for Structured Types
00244   // The mapping for struct, union, and sequence (but not array) is a
00245   // C++ struct or class with a default constructor, a copy
00246   // constructor, an assignment operator, and a destructor.
00247   //
00248 public:
00249   // = Operations for the Unbounded_ObjectSequence
00250 
00251   /**
00252    * {orbos/97-05-15:16.8}
00253    * The default constructor initializes object reference members to
00254    * appropriately typed nil object references and string members to
00255    * NULL; all other members are initialized via their default
00256    * constructors.
00257    *
00258    * {orbos/97-05-15:16.11}
00259    * For both bounded and unbounded sequences, the default constructor
00260    * (as shown in the example above) sets the sequence length equal to
00261    * 0.
00262    */
00263   TAO_Unbounded_String_Sequence (void);
00264 
00265   /**
00266    * Unbounded sequences provide a constructor that allows only the
00267    * initial value of the maximum length to be set (the ``maximum
00268    * constructor'' shown in the example above). This allows
00269    * applications to control how much buffer space is initially
00270    * allocated by the sequence. This constructor also sets the length
00271    * to 0 and the release flag to TRUE.
00272    */
00273   TAO_Unbounded_String_Sequence (CORBA::ULong maximum);
00274 
00275   /**
00276    * The ``T *data'' constructor (as shown in the example above)
00277    * allows the length and contents of a bounded or unbounded sequence
00278    * to be set. For unbounded sequences, it also allows the initial
00279    * value of the maximum length to be set. For this constructor,
00280    * ownership of the content's vector is determined by the release
00281    * parameter---FALSE means the caller owns the storage, while TRUE
00282    * means that the sequence assumes ownership of the storage.
00283    * If release is TRUE, the content's vector must have been allocated
00284    * using the sequence allocbuf function, and the sequence will pass
00285    * it to freebuf when finished with it.
00286    */
00287   TAO_Unbounded_String_Sequence (CORBA::ULong maximum,
00288                                  CORBA::ULong length,
00289                                  char* *data,
00290                                  CORBA::Boolean release = 0);
00291 
00292   /**
00293    * The copy constructor performs a deep copy from the existing
00294    * structure to create a new structure, including calling _duplicate
00295    * on all object  reference members and performing the necessary
00296    * heap allocations for all string members.
00297    *
00298    * The copy constructor creates a new sequence with the same maximum
00299    * and length as the given sequence, copies each of its current
00300    * elements (items zero through length-1), and sets the release
00301    * flag to TRUE.
00302    */
00303   TAO_Unbounded_String_Sequence(const TAO_Unbounded_String_Sequence&);
00304 
00305   /// The destructor releases all object reference members and frees
00306   /// all string members.
00307   ~TAO_Unbounded_String_Sequence (void);
00308 
00309   /**
00310    * The assignment operator first releases all object reference
00311    * members and frees all string  members, and then performs a
00312    * deep­copy to create a new structure.
00313    *
00314    * The assignment operator deep­copies its parameter, releasing
00315    * old storage if necessary. It behaves as if the original sequence
00316    * is destroyed via its destructor and then the source sequence
00317    * copied using the copy constructor. If release=TRUE, the
00318    * destructor destroys each of the current elements (items zero
00319    * through length--1).
00320    * For an unbounded sequence, if a reallocation is necessary due to
00321    * a change in the length and the sequence was created using the
00322    * release=TRUE parameter in its constructor, the sequence will
00323    * deallocate the old storage. If release is FALSE under these
00324    * circumstances, old storage will not be freed before the
00325    * reallocation is performed. After reallocation, the release flag
00326    * is always set to TRUE.
00327    */
00328   TAO_Unbounded_String_Sequence &operator= (
00329       const TAO_Unbounded_String_Sequence &
00330     );
00331 
00332   /// read-write accessor
00333   TAO_SeqElem_String_Manager operator[] (CORBA::ULong slot) const;
00334 
00335   /**
00336    * The allocbuf function allocates a vector of T elements that can
00337    * be passed to the T *data constructor. The length of the vector is
00338    * given by the nelems function argument.  The allocbuf function
00339    * initializes each element using its default constructor, except
00340    * for strings, which are initialized to null pointers, and object
00341    * references, which are initialized to suitably typed nil object
00342    * references. A null pointer is returned if allocbuf for some
00343    * reason cannot allocate the requested vector. Vectors allocated by
00344    * allocbuf should be freed using the freebuf function.
00345    */
00346   static char* *allocbuf (CORBA::ULong);
00347 
00348   /**
00349    * The freebuf function ensures that the destructor for each element
00350    * is called before the buffer is destroyed, except for string
00351    * elements, which are freed using string_free(), and object
00352    * reference elements, which are freed using release(). The freebuf
00353    * function will ignore null pointers passed to it.
00354    */
00355   static void freebuf (char **);
00356 
00357   // = Fast buffer accessors.
00358   char **get_buffer (CORBA::Boolean orphan = 0);
00359   const char **get_buffer (void) const;
00360 
00361   // Functions to create, destroy, and adjust the underlying buffer.
00362   virtual void _allocate_buffer (CORBA::ULong length);
00363   virtual void _deallocate_buffer (void);
00364   virtual void _shrink_buffer (CORBA::ULong new_length,
00365                                CORBA::ULong old_length);
00366 
00367   // Parameters work the same as in constructor of the same signature.
00368   void replace (CORBA::ULong maximum,
00369                 CORBA::ULong length,
00370                 char* *data,
00371                 CORBA::Boolean release = 0);
00372 };
00373 
00374 // ****************************************************************
00375 
00376 /**
00377  * @class TAO_Unbounded_WString_Sequence
00378  *
00379  * @brief Unbounded sequence of wstrings.
00380  *
00381  * IDL sequences of wstrings must automatically duplicate and
00382  * release their members based on some global <release> flag.
00383  */
00384 class TAO_Export TAO_Unbounded_WString_Sequence
00385   : public TAO_Unbounded_Base_Sequence
00386 {
00387 
00388   // = SPEC
00389   // 16.8 Mapping for Structured Types
00390   // The mapping for struct, union, and sequence (but not array) is a
00391   // C++ struct or class with a default constructor, a copy
00392   // constructor, an assignment operator, and a destructor.
00393   //
00394 public:
00395   // = Operations for the Unbounded_ObjectSequence
00396 
00397   /**
00398    * {orbos/97-05-15:16.8}
00399    * The default constructor initializes object reference members to
00400    * appropriately typed nil object references and wstring members to
00401    * NULL; all other members are initialized via their default
00402    * constructors.
00403    *
00404    * {orbos/97-05-15:16.11}
00405    * For both bounded and unbounded sequences, the default constructor
00406    * (as shown in the example above) sets the sequence length equal to
00407    * 0.
00408    */
00409   TAO_Unbounded_WString_Sequence (void);
00410 
00411   /**
00412    * Unbounded sequences provide a constructor that allows only the
00413    * initial value of the maximum length to be set (the ``maximum
00414    * constructor'' shown in the example above). This allows
00415    * applications to control how much buffer space is initially
00416    * allocated by the sequence. This constructor also sets the length
00417    * to 0 and the release flag to TRUE.
00418    */
00419   TAO_Unbounded_WString_Sequence (CORBA::ULong maximum);
00420 
00421   /**
00422    * The ``T *data'' constructor (as shown in the example above)
00423    * allows the length and contents of a bounded or unbounded sequence
00424    * to be set. For unbounded sequences, it also allows the initial
00425    * value of the maximum length to be set. For this constructor,
00426    * ownership of the contents vector is determined by the release
00427    * parameter---FALSE means the caller owns the storage, while TRUE
00428    * means that the sequence assumes ownership of the storage.
00429    * If release is TRUE, the contents vector must have been allocated
00430    * using the sequence allocbuf function, and the sequence will pass
00431    * it to freebuf when finished with it.
00432    */
00433   TAO_Unbounded_WString_Sequence (CORBA::ULong maximum,
00434                                   CORBA::ULong length,
00435                                   CORBA::WChar* *data,
00436                                   CORBA::Boolean release = 0);
00437 
00438   /**
00439    * The copy constructor performs a deep copy from the existing
00440    * structure to create a new structure, including calling _duplicate
00441    * on all object  reference members and performing the necessary
00442    * heap allocations for all string members.
00443    *
00444    * The copy constructor creates a new sequence with the same maximum
00445    * and length as the given sequence, copies each of its current
00446    * elements (items zero through length-1), and sets the release
00447    * flag to TRUE.
00448    */
00449   TAO_Unbounded_WString_Sequence (const TAO_Unbounded_WString_Sequence&);
00450 
00451   /// The destructor releases all object reference members and frees
00452   /// all string members.
00453   ~TAO_Unbounded_WString_Sequence (void);
00454 
00455   /**
00456    * The assignment operator first releases all object reference
00457    * members and frees all wstring  members, and then performs a
00458    * deep­copy to create a new structure.
00459    *
00460    * The assignment operator deep­copies its parameter, releasing
00461    * old storage if necessary. It behaves as if the original sequence
00462    * is destroyed via its destructor and then the source sequence
00463    * copied using the copy constructor. If release=TRUE, the
00464    * destructor destroys each of the current elements (items zero
00465    * through length--1).
00466    * For an unbounded sequence, if a reallocation is necessary due to
00467    * a change in the length and the sequence was created using the
00468    * release=TRUE parameter in its constructor, the sequence will
00469    * deallocate the old storage. If release is FALSE under these
00470    * circumstances, old storage will not be freed before the
00471    * reallocation is performed. After reallocation, the release flag
00472    * is always set to TRUE.
00473    */
00474   TAO_Unbounded_WString_Sequence &operator= (
00475       const TAO_Unbounded_WString_Sequence &
00476     );
00477 
00478   /// Read-write accessor
00479   TAO_SeqElem_WString_Manager operator[] (CORBA::ULong slot) const;
00480 
00481   /**
00482    * The allocbuf function allocates a vector of T elements that can
00483    * be passed to the T *data constructor. The length of the vector is
00484    * given by the nelems function argument.  The allocbuf function
00485    * initializes each element using its default constructor, except
00486    * for strings, which are initialized to null pointers, and object
00487    * references, which are initialized to suitably typed nil object
00488    * references. A null pointer is returned if allocbuf for some
00489    * reason cannot allocate the requested vector. Vectors allocated by
00490    * allocbuf should be freed using the freebuf function.
00491    */
00492   static CORBA::WChar* *allocbuf (CORBA::ULong);
00493 
00494   /**
00495    * The freebuf function ensures that the destructor for each element
00496    * is called before the buffer is destroyed, except for string
00497    * elements, which are freed using wstring_free(), and object
00498    * reference elements, which are freed using release(). The freebuf
00499    * function will ignore null pointers passed to it.
00500    */
00501   static void freebuf (CORBA::WChar **);
00502 
00503   // = Fast buffer accessors.
00504   CORBA::WChar **get_buffer (CORBA::Boolean orphan = 0);
00505   const CORBA::WChar **get_buffer (void) const;
00506 
00507   // Functions to create, destroy, and adjust the underlying buffer.
00508   virtual void _allocate_buffer (CORBA::ULong length);
00509   virtual void _deallocate_buffer (void);
00510   virtual void _shrink_buffer (CORBA::ULong new_length,
00511                                CORBA::ULong old_length);
00512 
00513   // Parameters work the same as in constructor of the same signature.
00514   void replace (CORBA::ULong maximum,
00515                 CORBA::ULong length,
00516                 CORBA::WChar* *data,
00517                 CORBA::Boolean release = 0);
00518 };
00519 
00520 // ****************************************************************
00521 
00522 class ACE_Message_Block;
00523 template<class T> class TAO_Unbounded_Sequence;
00524 // forward declaration, we are going to specialize that template
00525 // here.
00526 // The template itself requires this file so every user of the
00527 // template should also see the specialization.
00528 
00529 ACE_TEMPLATE_SPECIALIZATION
00530 /**
00531  * @class TAO_Unbounded_Sequence<CORBA::Octet>
00532  *
00533  * @brief An unbounded sequence of Octets
00534  *
00535  * Marshalling and demarshalling octet sequences can be highly
00536  * optimize, for instance at demarshalling we don't require a copy
00537  * from the CDR buffer to the octet sequence buffer, we can simply
00538  * hold a duplicate of the underlying ACE_Message_Block.
00539  * Specializing the TAO_Unbounded_Sequence<T> parametric
00540  * class, is an excellent way to achieve this optimizations.
00541  */
00542 class TAO_Export TAO_Unbounded_Sequence<CORBA::Octet>
00543   : public TAO_Unbounded_Base_Sequence
00544 {
00545 public:
00546   /// For efficient marshalling and demarshalling.
00547   friend class TAO_Marshal_Sequence;
00548 
00549   /// see TAO_Unbounded_Sequence in "Sequence_T.h"
00550   TAO_Unbounded_Sequence (void);
00551   TAO_Unbounded_Sequence (CORBA::ULong max);
00552   TAO_Unbounded_Sequence (CORBA::ULong max,
00553                           CORBA::ULong length,
00554                           CORBA::Octet *data,
00555                           CORBA::Boolean release = 0);
00556   virtual ~TAO_Unbounded_Sequence (void);
00557 
00558   /// Use in the implementation of insertion and extraction operators
00559   /// from CORBA::Any
00560   static void _tao_any_destructor (void*);
00561 
00562   /**
00563    * The copy constructor and assignment operators *do* copy the data,
00564    * though we could simply duplicate the ref count in the
00565    * ACE_Message_Block this will change the semantics for this
00566    * operations.
00567    */
00568   TAO_Unbounded_Sequence (const TAO_Unbounded_Sequence<CORBA::Octet> &);
00569   TAO_Unbounded_Sequence<CORBA::Octet>& operator= (
00570       const TAO_Unbounded_Sequence<CORBA::Octet> &
00571     );
00572 
00573   /**
00574    * See the general description in "Sequence_T.h"
00575    * NOTE: This last two methods can be rendered useless in certain
00576    * cases, see below.
00577    */
00578   CORBA::Octet &operator[] (CORBA::ULong);
00579   const CORBA::Octet &operator[] (CORBA::ULong) const;
00580 
00581   // = Static operations.
00582 
00583   /// Allocate storage for the sequence, please note that the storage
00584   /// is always held in a ACE_Message_Block.
00585   static CORBA::Octet *allocbuf (CORBA::ULong);
00586 
00587   /// Free the storage.
00588   static void freebuf (CORBA::Octet *);
00589 
00590   /// Implement the methods for all the sequence, please seee
00591   /// TAO_Base_Sequence.
00592   virtual void _allocate_buffer (CORBA::ULong length);
00593   virtual void _deallocate_buffer (void);
00594 
00595   // = Fast buffer accessors.
00596   CORBA::Octet *get_buffer (CORBA::Boolean orphan = 0);
00597   const CORBA::Octet *get_buffer (void) const;
00598 
00599   // NOTE: This last two methods can be rendered useless in certain
00600   // cases, see below.
00601   /// See the general description of this methods in "Sequence_T.h".
00602   void replace (CORBA::ULong max,
00603                 CORBA::ULong length,
00604                 CORBA::Octet *data,
00605                 CORBA::Boolean release = 0);
00606 
00607   // = TAO extensions
00608 
00609 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
00610 
00611   /// Returns the underlying message block, the caller must *not*
00612   /// release the copy.
00613   ACE_Message_Block* mb (void) const;
00614 
00615   /// Create a sequence of octets from a single message block (i.e. it
00616   /// ignores any chaining in the meesage block).
00617   TAO_Unbounded_Sequence (CORBA::ULong length,
00618                           const ACE_Message_Block* mb);
00619 
00620   /// Replaces the current buffer with <mb>, using only <length> bytes.
00621   /// It takes a duplicate of <mb> so the user still owns it.
00622   void replace (CORBA::ULong length, const ACE_Message_Block* mb);
00623 
00624   //
00625   // NOTE:
00626   // In the last two methods if the <mb> is the head of a chain then
00627   // the following methods are not warranteed to work properly:
00628   //    operator[]
00629   //    get_buffer ()
00630   // the main purpose of this method is to support custom marshaling;
00631   // so the complete chain is marshaled when the octet sequence is.
00632   //
00633 
00634 private:
00635   ACE_Message_Block* mb_;
00636 #endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
00637 };
00638 
00639 // ****************************************************************
00640 
00641 // Comparison of octet sequence.
00642 TAO_Export int operator== (const TAO_Unbounded_Sequence<CORBA::Octet> &l,
00643                            const TAO_Unbounded_Sequence<CORBA::Octet> &r);
00644 
00645 TAO_Export int operator!= (const TAO_Unbounded_Sequence<CORBA::Octet> &l,
00646                            const TAO_Unbounded_Sequence<CORBA::Octet> &r);
00647 
00648 // ****************************************************************
00649 
00650 #if defined (__ACE_INLINE__)
00651 #include "tao/Sequence.i"
00652 #endif /* __ACE_INLINE__ */
00653 
00654 #include "tao/Sequence_T.h"
00655 
00656 #include "ace/post.h"
00657 
00658 #endif /* TAO_SEQUENCE_H */

Generated on Mon Jun 16 13:49:43 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002