diff options
Diffstat (limited to 'TAO/tao/Any.h')
| -rw-r--r-- | TAO/tao/Any.h | 437 |
1 files changed, 0 insertions, 437 deletions
diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h deleted file mode 100644 index beaf1ede5df..00000000000 --- a/TAO/tao/Any.h +++ /dev/null @@ -1,437 +0,0 @@ -// This may look like C, but it's really -*- C++ -*- -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// TAO -// -// = FILENAME -// Any.h -// -// = AUTHOR -// Copyright 1994-1995 by Sun Microsystems, Inc. -// and Aniruddha Gokhale. -// -// ============================================================================ - -#if !defined (TAO_ANY_H) -#define TAO_ANY_H - -class TAO_Export CORBA_Any -{ - // = TITLE - // Class "Any" can wrap values of any type, with the assistance - // of a TypeCode to describe that type. - // - // = DESCRIPTION - // This includes three constructors, a destructor, and a "replace" - // method for the "Any" data type. "Any" values pair a pointer to - // a data structure in the native binary representation (e.g. C - // struct) with a TypeCode that describes that data structure. - // - // The copy constructor and the destructor each use the TypeCode - // interpreter with specialized "visit" callback routines. The - // "visit" routines are used respectively to make "deep copies" - // and perform "deep frees" of the aritrary values as described by - // the "Any" value's typecode. - // - // Note that these "visit" routines are called directly, and they - // choose whether or not to use the TypeCode interpreter to - // examine constituents. In the simple cases, the "visit" - // routines can do their work without any further calls; only for - // constructed types is the interpreter's knowledge really - // required. - // - // THREADING NOTE: "Any" is a data structure which must be - // protected by external critical sections. Like simpler numeric - // types, "Any" instances are accessed and modified atomically. - // This implementation is reentrant, so that independent "Any" - // values may be manipulated concurrently when the underlying - // programming environment is itself reentrant. -public: - - // = Minor codes for exceptional returns - enum - { - UNINITIALIZED_type = 0xf000, - VALUE_WITHOUT_TYPE, - UNSUPPORTED_OPERATION - }; - - // = Initialization and termination operations. - - CORBA_Any (void); - // Default constructor. - - CORBA_Any (CORBA::TypeCode_ptr type, - void *value = 0, - CORBA::Boolean any_owns_data = 0); - // Constructor. The any_owns_data flag determines if the Any owns the value - - CORBA_Any (CORBA::TypeCode_ptr type, - const ACE_Message_Block* mb); - // Constructor. Used by DynAny to compose/decompose complex types using a CDR. - - CORBA_Any (const CORBA_Any &a); - // Copy constructor. - - ~CORBA_Any (void); - // Destructor. - - CORBA_Any &operator= (const CORBA_Any &); - // assignment operator - - // = NOTE: 94-9-14 has assignment operator plus many insertion, as - // specified below. - - // =type safe insertion - - void operator<<= (CORBA::Short); - // insert a short - - void operator<<= (CORBA::UShort); - // insert an unsigned short - - void operator<<= (CORBA::Long); - // insert a long - - void operator<<= (CORBA::ULong); - // insert an unsigned long - - void operator<<= (CORBA::LongLong); - // insert a long long - - void operator<<= (CORBA::ULongLong); - // insert an unsigned long long - - void operator<<= (CORBA::Float); - // insert a float - - void operator<<= (CORBA::Double); - // insert a double - - void operator<<= (const CORBA_Any&); - // insert an Any - - void operator<<= (const char*); - // insert unbounded strings - - void operator<<= (CORBA::TypeCode_ptr); - // insert a TypeCode - - void operator<<= (CORBA::Object_ptr); - // insert an object reference - - // =type safe extraction - - CORBA::Boolean operator>>= (CORBA::Short&) const; - // extract a short - - CORBA::Boolean operator>>= (CORBA::UShort&) const; - // extract an unsigned short - - CORBA::Boolean operator>>= (CORBA::Long&) const; - // extract a long - - CORBA::Boolean operator>>= (CORBA::ULong&) const; - // extract an unsigned long - - CORBA::Boolean operator>>= (CORBA::LongLong&) const; - // extract a long long - - CORBA::Boolean operator>>= (CORBA::ULongLong&) const; - // extract an unsigned long long - - CORBA::Boolean operator>>= (CORBA::Float&) const; - // extract a float - - CORBA::Boolean operator>>= (CORBA::Double&) const; - // extract a double - - CORBA::Boolean operator>>= (CORBA_Any&) const; - // extract an Any - - CORBA::Boolean operator>>= (CORBA::TypeCode_ptr&) const; - // extract a TypeCode - - CORBA::Boolean operator>>= (char*&) const; - // extract an unbounded string - - // = Special types. - - // These are needed for insertion and extraction of booleans, - // octets, chars, and bounded strings. - - struct TAO_Export from_boolean - { - from_boolean (CORBA::Boolean b); - CORBA::Boolean val_; - }; - - struct TAO_Export from_octet - { - from_octet (CORBA::Octet o); - CORBA::Octet val_; - }; - - struct TAO_Export from_char - { - from_char (CORBA::Char c); - CORBA::Char val_; - }; - - struct TAO_Export from_wchar - { - from_wchar (CORBA::WChar wc); - CORBA::WChar val_; - }; - - struct TAO_Export from_string - { - from_string (char* s, - CORBA::ULong b, - CORBA::Boolean nocopy = 0); - char *val_; - CORBA::ULong bound_; - CORBA::Boolean nocopy_; - }; - - void operator<<= (from_boolean); - // insert a boolean - - void operator<<= (from_char); - // insert a char - - void operator<<= (from_wchar); - // insert a wchar - - void operator<<= (from_octet); - // insert an octet - - void operator<<= (from_string); - // insert a bounded string - - // = Special types. - - // These extract octets, chars, booleans, bounded strings, and - // object references - - struct TAO_Export to_boolean - { - to_boolean (CORBA::Boolean &b); - CORBA::Boolean &ref_; - }; - - struct TAO_Export to_char - { - to_char (CORBA::Char &c); - CORBA::Char &ref_; - }; - - struct TAO_Export to_wchar - { - to_wchar (CORBA::WChar &wc); - CORBA::WChar &ref_; - }; - - struct TAO_Export to_octet - { - to_octet (CORBA::Octet &o); - CORBA::Octet &ref_; - }; - - struct TAO_Export to_string - { - to_string (char *&s, CORBA::ULong b); - char *&val_; - CORBA::ULong bound_; - }; - - struct TAO_Export to_object - { - to_object (CORBA::Object_ptr &obj); - CORBA::Object_ptr &ref_; - }; - - // extraction of the special types - - CORBA::Boolean operator>>= (to_boolean) const; - // extract a boolean - - CORBA::Boolean operator>>= (to_octet) const; - // extract an octet - - CORBA::Boolean operator>>= (to_char) const; - // extract a char - - CORBA::Boolean operator>>= (to_wchar) const; - // extract a wchar - - CORBA::Boolean operator>>= (to_string) const; - // extract a bounded string - - CORBA::Boolean operator>>= (to_object) const; - // extract an object reference - - // the following are unsafe operations - // ORBOS/90-01-11, pg 672: For C++ mapping using the CORBA_Environment - // parameter, two forms of the replace method are provided. - - void replace (CORBA::TypeCode_ptr type, - const void *value, - CORBA::Boolean any_owns_data, - CORBA_Environment &_env = CORBA_Environment::default_environment ()); - // Replace the current typecode and data with the specified one - - // unsafe. - - void replace (CORBA::TypeCode_ptr type, - const void *value, - CORBA_Environment &_env = CORBA_Environment::default_environment ()); - // Replace the current typecode and data with the specified one - - // unsafe. This uses a default value for the "any_owns_data" parameter - - CORBA::TypeCode_ptr type (void) const; - // Return TypeCode of the element stored in the Any. - - const void *value (void) const; - // Returns 0 if the Any has not been assigned a value, following the - // CORBA spec (ORBOS/98-01-11) it returns a non-zero value - // otherwise. TAO does *not* guarantee that this value may be casted - // to the contained type safely. - - // = Debugging method. - - static void dump (const CORBA::Any any_value); - // Prints the type and the value of the any value. Dumping is - // supported only for standard data types. - - // =TAO extension - CORBA::Boolean any_owns_data (void) const; - // does the Any own the data or not. This is used by the >>= operators - // generated by the IDL compiler. The >>= operator checks if the Any owns the - // data. If it does, then it will retrieve the data from the CDR stream - - ACE_Message_Block* _tao_get_cdr (void) const; - // CDR accessor. - -private: - CORBA::TypeCode_ptr type_; - // Typecode for the <Any>. - - void *value_; - // Value for the <Any>. - - ACE_Message_Block *cdr_; - // encoded value. - - CORBA::Boolean any_owns_data_; - // Flag that indicates the ORB is responsible for deleting the data. - - // 94-9-14 hides unsigned char insert/extract - void operator<<= (unsigned char); - CORBA::Boolean operator>>= (unsigned char&) const; - - friend class IIOP_Object; - friend class TAO_Marshal_Any; - friend class CORBA_NVList; -}; - -class TAO_Export CORBA_Any_var -{ - // = TITLE - // Provide for automatic storage deallocation on going out of - // scope. -public: - CORBA_Any_var (void); - // default constructor - - CORBA_Any_var (CORBA_Any *a); - // construct from an Any pointer - - CORBA_Any_var (const CORBA_Any_var &a); - // copy constructor - - ~CORBA_Any_var (void); - // destructor - - CORBA_Any_var &operator= (CORBA_Any *a); - // assignment from a pointer to Any - - CORBA_Any_var &operator= (const CORBA_Any_var &a); - // assignment from an Any_var - - CORBA_Any *operator-> (void); - // arrow operator (smart pointer) - - operator const CORBA_Any *() const; - // cast - - operator CORBA_Any *&(); - // cast - - const CORBA_Any &in (void) const; - // for in Any parameter - - CORBA_Any &inout (void); - // for inout Any parameter - - CORBA_Any *&out (void); - // for out Any parameter - - CORBA_Any *_retn (void); - // for Any return types - -private: - CORBA_Any *ptr_; - // Holds the Any. -}; - -class TAO_Export CORBA_Any_out -{ - // = TITLE - // CORBA_Any_out - // - // = DESCRIPTION - // The _out class for CORBA_Any. This is used to help in managing the out - // parameters. -public: - // = operations. - - CORBA_Any_out (CORBA_Any *&p); - // construction from a reference to a CORBA_Any - - CORBA_Any_out (CORBA_Any_var &p); - // construction from a var - - CORBA_Any_out (const CORBA_Any_out &s); - // copy constructor - - CORBA_Any_out &operator= (const CORBA_Any_out &s); - // assignment from a CORBA_Any_out - - CORBA_Any_out &operator= (CORBA_Any *p); - // assignment from a CORBA_Any - - CORBA_Any_out &operator= (const CORBA_Any *p); - // assignment from a const CORBA_Any - - operator CORBA_Any *&(); - // cast - - CORBA_Any *& ptr (void); - // return underlying instance - -private: - CORBA_Any *&ptr_; - // Instance - - void operator= (const CORBA_Any_var &); - // assignment from _var disallowed -}; - -#if defined (__ACE_INLINE__) -# include "tao/Any.i" -#endif /* __ACE_INLINE__ */ - -#endif /* TAO_ANY_H */ |