TAO_AnyTypeCode: Any.h Source File

00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file    Any.h
00006  *
00007  *  $Id: Any.h 78809 2007-07-06 10:24:12Z parsons $
00008  *
00009  *  @author Carlos O'Ryan
00010  *  @author Jeff Parsons
00011  */
00012 //=============================================================================
00013 
00014 #ifndef TAO_ANY_H
00015 #define TAO_ANY_H
00016 
00017 #include /**/ "ace/pre.h"
00018 
00019 #include "tao/AnyTypeCode/TAO_AnyTypeCode_Export.h"
00020 
00021 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00022 # pragma once
00023 #endif /* ACE_LACKS_PRAGMA_ONCE */
00024 
00025 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
00026 #include "tao/Pseudo_VarOut_T.h"
00027 #include "tao/Arg_Traits_T.h"
00028 #include "tao/Object.h"
00029 
00030 #include "ace/CDR_Stream.h"
00031 
00032 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00033 
00034 namespace TAO
00035 {
00036   class Any_Impl;
00037 }
00038 
00039 namespace CORBA
00040 {
00041   class Any;
00042   typedef Any *Any_ptr;
00043   class Any_var;
00044   class Any_out;
00045 
00046   class TypeCode;
00047   typedef TypeCode *TypeCode_ptr;
00048 
00049   class AbstractBase;
00050   typedef AbstractBase *AbstractBase_ptr;
00051 
00052   class ValueBase;
00053   class Exception;
00054 
00055   /**
00056    * @class Any
00057    *
00058    * @brief Generic container for IDL types.
00059    *
00060    * This is the top-level class of the Any implementation. It exposes the
00061    * spec-required functionality, but is mostly a wrapper for one of the
00062    * template classes below.
00063    */
00064   class TAO_AnyTypeCode_Export Any
00065   {
00066   public:
00067     typedef Any_ptr _ptr_type;
00068     typedef Any_var _var_type;
00069     typedef Any_out _out_type;
00070 
00071     Any (void);
00072     Any (const Any &);
00073 
00074     ~Any (void);
00075 
00076     Any &operator= (const Any &);
00077     TAO::Any_Impl *impl (void) const;
00078 
00079     /// Used in our destruction if we ourselves are stored in an Any.
00080     static void _tao_any_destructor (void *);
00081 
00082     /// These are needed for insertion and extraction of booleans,
00083     /// octets, chars, and bounded strings. CORBA spec requires
00084     /// that they be here, we just typedef to the already-defined
00085     /// ACE_OutputCDR types.
00086 
00087     typedef ACE_OutputCDR::from_boolean from_boolean;
00088     typedef ACE_OutputCDR::from_octet from_octet;
00089     typedef ACE_OutputCDR::from_char from_char;
00090     typedef ACE_OutputCDR::from_wchar from_wchar;
00091     typedef ACE_OutputCDR::from_string from_string;
00092     typedef ACE_OutputCDR::from_wstring from_wstring;
00093 
00094     /// Insertion of the special types.
00095 
00096     void operator<<= (from_boolean);
00097     void operator<<= (from_char);
00098     void operator<<= (from_wchar);
00099     void operator<<= (from_octet);
00100     void operator<<= (from_string);
00101     void operator<<= (from_wstring);
00102 
00103     /// These extract octets, chars, booleans, bounded strings, and
00104     /// object references. All these are defined in ACE_InputCDR.
00105 
00106     typedef ACE_InputCDR::to_boolean to_boolean;
00107     typedef ACE_InputCDR::to_char to_char;
00108     typedef ACE_InputCDR::to_wchar to_wchar;
00109     typedef ACE_InputCDR::to_octet to_octet;
00110     typedef ACE_InputCDR::to_string to_string;
00111     typedef ACE_InputCDR::to_wstring to_wstring;
00112 
00113     /// These are not in ACE.
00114 
00115     struct TAO_AnyTypeCode_Export to_object
00116     {
00117       // This signature reflects the change set out in
00118       // issue 154 of the 1.3 RTF.
00119       explicit to_object (Object_out obj);
00120       Object_ptr &ref_;
00121     };
00122 
00123     struct TAO_AnyTypeCode_Export to_abstract_base
00124     {
00125       explicit to_abstract_base (AbstractBase_ptr &obj);
00126       AbstractBase_ptr &ref_;
00127     };
00128 
00129     struct TAO_AnyTypeCode_Export to_value
00130     {
00131       explicit to_value (ValueBase *&base);
00132       ValueBase *&ref_;
00133     };
00134 
00135     /// Extraction of the special types.
00136 
00137     Boolean operator>>= (to_boolean) const;
00138     Boolean operator>>= (to_octet) const;
00139     Boolean operator>>= (to_char) const;
00140     Boolean operator>>= (to_wchar) const;
00141     Boolean operator>>= (to_string) const;
00142     Boolean operator>>= (to_wstring) const;
00143     Boolean operator>>= (to_object) const;
00144     Boolean operator>>= (to_abstract_base) const;
00145     Boolean operator>>= (to_value) const;
00146 
00147     /// TAO-specific signature.
00148     void replace (TAO::Any_Impl *);
00149 
00150     /// Return TypeCode of the element stored in the Any.
00151     TypeCode_ptr type (void) const;
00152 
00153     /// For use along with <<= of a value of aliased type when the alias must
00154     /// be preserved.
00155     void type (TypeCode_ptr);
00156 
00157     /// TAO extension, does not return a duplicate.
00158     CORBA::TypeCode_ptr _tao_get_typecode (void) const;
00159 
00160     /// TAO extension.
00161     void _tao_set_typecode (const CORBA::TypeCode_ptr);
00162 
00163     int _tao_byte_order (void) const;
00164 
00165   private:
00166     CORBA::Boolean checked_to_object (CORBA::Object_ptr &) const;
00167     CORBA::Boolean checked_to_value (CORBA::ValueBase *&) const;
00168     CORBA::Boolean checked_to_abstract_base (CORBA::AbstractBase_ptr &) const;
00169 
00170     // Unimplemented - hides unsigned char insert/extract.
00171     void operator<<= (unsigned char);
00172     CORBA::Boolean operator>>= (unsigned char&) const;
00173 
00174   private:
00175     TAO::Any_Impl *impl_;
00176 
00177     friend class TAO_Marshal_Any;
00178   };
00179 
00180   /**
00181    * @class CORBA::Any_var
00182    *
00183    * @brief Provide for automatic storage deallocation on going out of
00184    * scope.
00185    */
00186   class TAO_AnyTypeCode_Export Any_var
00187   {
00188   public:
00189     Any_var (void);
00190     Any_var (Any *a);
00191     Any_var (const Any_var &);
00192     ~Any_var (void);
00193 
00194     Any_var &operator= (Any *);
00195 
00196     /**
00197      * Assignment from an Any_var
00198      * This operation requires memory allocation.
00199      * If the allocation fails, *this is returned
00200      * unmodified.
00201      */
00202     Any_var &operator= (const Any_var &);
00203 
00204     /// Arrow operator (smart pointer).
00205     Any *operator-> (void);
00206 
00207     /// Cast.
00208     operator const Any *() const;
00209 
00210     /// Cast.
00211     operator Any *&();
00212 
00213     /// For in Any parameter.
00214     const Any &in (void) const;
00215 
00216     /// For inout Any parameter.
00217     Any &inout (void);
00218 
00219     /// For out Any parameter.
00220     Any *&out (void);
00221 
00222     /// For Any return type.
00223     Any *_retn (void);
00224 
00225     /// TAO specific extension
00226     Any *ptr (void) const;
00227   private:
00228     /// Holds the Any.
00229     Any *ptr_;
00230   };
00231 
00232   /**
00233    * @class CORBA::Any_out
00234    *
00235    * @brief CORBA::Any_out
00236    *
00237    * The _out class for CORBA::Any. This is used to help in
00238    * managing the out parameters.
00239    */
00240   class TAO_AnyTypeCode_Export Any_out
00241   {
00242   public:
00243     Any_out (Any *&);
00244     Any_out (Any_var &);
00245     Any_out (const Any_out &);
00246 
00247     /// Assignment from a Any_out.
00248     Any_out &operator= (const Any_out &s);
00249 
00250     /// Assignment from a Any.
00251     Any_out &operator= (Any *);
00252 
00253     /// Cast.
00254     operator Any *&();
00255 
00256     /// Return underlying instance.
00257     Any *& ptr (void);
00258 
00259     Any *operator-> (void);
00260 
00261   private:
00262     /// Assignment from _var disallowed.
00263     void operator= (const Any_var &);
00264 
00265   private:
00266     /// Instance.
00267     Any *&ptr_;
00268   };
00269 }
00270 
00271 TAO_AnyTypeCode_Export CORBA::Boolean
00272 operator<< (TAO_OutputCDR &, const CORBA::Any &);
00273 
00274 TAO_AnyTypeCode_Export CORBA::Boolean
00275 operator>> (TAO_InputCDR &, CORBA::Any &);
00276 
00277 #if defined (GEN_OSTREAM_OPS)
00278 
00279 // Used in optionally generated ostream operators (for debugging).
00280 TAO_AnyTypeCode_Export std::ostream &
00281 operator<< (std::ostream &, const CORBA::Any &);
00282 
00283 #endif /* GEN_OSTREAM_OPS */
00284 
00285 /// Typesafe insertion.
00286 
00287 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Short);
00288 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::UShort);
00289 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Long);
00290 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::ULong);
00291 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::LongLong);
00292 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::ULongLong);
00293 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Float);
00294 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Double);
00295 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::LongDouble);
00296 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, const CORBA::Any &);
00297 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Any *);
00298 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, const char *);
00299 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, const CORBA::WChar *);
00300 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::TypeCode_ptr);
00301 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::TypeCode_ptr *);
00302 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, const CORBA::Object_ptr);
00303 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Object_ptr *);
00304 
00305 /// Typesafe extraction.
00306 
00307 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00308                                        CORBA::Short &);
00309 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00310                                        CORBA::UShort &);
00311 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00312                                        CORBA::Long &);
00313 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00314                                        CORBA::ULong &);
00315 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00316                                        CORBA::LongLong &);
00317 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00318                                        CORBA::ULongLong &);
00319 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00320                                        CORBA::Float &);
00321 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00322                                        CORBA::Double &);
00323 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00324                                        CORBA::LongDouble &);
00325 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00326                                        const CORBA::Any *&);
00327 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00328                                        CORBA::TypeCode_ptr &);
00329 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00330                                        const CORBA::Char *&);
00331 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
00332                                        const CORBA::WChar *&);
00333 
00334 TAO_END_VERSIONED_NAMESPACE_DECL
00335 
00336 #if defined (__ACE_INLINE__)
00337 # include "tao/AnyTypeCode/Any.inl"
00338 #else
00339 
00340 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00341 
00342 /// Copying versions of insertion operators for basic types
00343 /// must also be defined for CORBA::Any_var.
00344 
00345 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Short);
00346 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::UShort);
00347 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Long);
00348 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::ULong);
00349 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::LongLong);
00350 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::ULongLong);
00351 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Float);
00352 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Double);
00353 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, const CORBA::Any *&);
00354 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, const char *);
00355 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::TypeCode_ptr);
00356 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, const CORBA::Object_ptr);
00357 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, ACE_OutputCDR::from_boolean);
00358 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Any::from_char);
00359 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Any::from_wchar);
00360 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Any::from_octet);
00361 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Any::from_string);
00362 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any_var &, CORBA::Any::from_wstring);
00363 
00364 /// These are not required by the spec, but will make users
00365 /// of other ORBs that are used to them more comfortable.
00366 
00367 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00368                                        CORBA::Short &);
00369 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00370                                        CORBA::UShort &);
00371 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00372                                        CORBA::Long &);
00373 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00374                                        CORBA::ULong &);
00375 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00376                                        CORBA::LongLong &);
00377 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00378                                        CORBA::ULongLong &);
00379 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00380                                        CORBA::Float &);
00381 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00382                                        CORBA::Double &);
00383 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00384                                        CORBA::Any &);
00385 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00386                                        CORBA::TypeCode_ptr &);
00387 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00388                                        const char *&);
00389 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00390                                        const CORBA::WChar *&);
00391 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00392                                        CORBA::Any::to_boolean);
00393 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00394                                        CORBA::Any::to_octet);
00395 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00396                                        CORBA::Any::to_char);
00397 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00398                                        CORBA::Any::to_wchar);
00399 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00400                                        CORBA::Any::to_string);
00401 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00402                                        CORBA::Any::to_wstring);
00403 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
00404                                        CORBA::Any::to_object);
00405 
00406 TAO_END_VERSIONED_NAMESPACE_DECL
00407 
00408 #endif /* __ACE_INLINE__ */
00409 
00410 #include /**/ "ace/post.h"
00411 
00412 #endif /* TAO_ANY_H */