dynanyimpl.h

编译工具

  virtual ~DynUnionEnumDisc();

  /*******************
  * public interface *
  *******************/
  virtual DynamicAny::DynAny_ptr copy();

  virtual char* get_as_string();
  virtual void set_as_string(const char* value);
  virtual CORBA::ULong get_as_ulong();
  virtual void set_as_ulong(CORBA::ULong value);

  /****************************
  * exposed private interface *
  ****************************/
  virtual int NP_nodetype() const;

  /***********
  * internal *
  ***********/
  void set_to_initial_value();
  virtual void set_value(TypeCode_union::Discriminator v);
  // Must NOT hold DynAnyImplBase::lock.

  TypeCode_enum* actualTc() const {
    return (TypeCode_enum*) DynAnyImplBase::actualTc();
  }

  virtual void _NP_incrRefCount();
  virtual void _NP_decrRefCount();
  // Must not hold DynAnyImplBase::refCountLock.

  virtual void* _ptrToObjRef(const char* repoId);
};

//////////////////////////////////////////////////////////////////////
/////////////////////////// DynUnionImpl /////////////////////////////
//////////////////////////////////////////////////////////////////////

class DynUnionImpl : public DynAnyImplBase,
		     public DynamicAny::DynUnion
{
public:
  DynUnionImpl(TypeCode_base* tc, CORBA::Boolean is_root=1);
  virtual ~DynUnionImpl();

  /*******************
  * public interface *
  *******************/
  virtual void assign(DynamicAny::DynAny_ptr dyn_any);
  virtual DynamicAny::DynAny_ptr copy();
  virtual CORBA::Boolean equal(DynamicAny::DynAny_ptr dyn_any);

  virtual void insert_boolean   (CORBA::Boolean      	value);
  virtual void insert_octet     (CORBA::Octet        	value);
  virtual void insert_char      (CORBA::Char         	value);
  virtual void insert_short     (CORBA::Short        	value);
  virtual void insert_ushort    (CORBA::UShort       	value);
  virtual void insert_long      (CORBA::Long         	value);
  virtual void insert_ulong     (CORBA::ULong        	value);
#ifndef NO_FLOAT				 	      
  virtual void insert_float     (CORBA::Float        	value);
  virtual void insert_double    (CORBA::Double       	value);
#endif						 	      
  virtual void insert_string    (const char*         	value);
  virtual void insert_reference (CORBA::Object_ptr   	value);
  virtual void insert_typecode  (CORBA::TypeCode_ptr 	value);
#ifdef HAS_LongLong				 	      
  virtual void insert_longlong  (CORBA::LongLong     	value);
  virtual void insert_ulonglong (CORBA::ULongLong    	value);
#endif						 	      
#ifdef HAS_LongDouble				 	      
  virtual void insert_longdouble(CORBA::LongDouble   	value);
#endif						 	      
  virtual void insert_wchar     (CORBA::WChar        	value);
  virtual void insert_wstring   (const CORBA::WChar* 	value);
  virtual void insert_any       (const CORBA::Any&   	value);
  virtual void insert_dyn_any   (DynamicAny::DynAny_ptr value);

  virtual CORBA::Boolean      	 get_boolean();
  virtual CORBA::Octet        	 get_octet();
  virtual CORBA::Char         	 get_char();
  virtual CORBA::Short        	 get_short();
  virtual CORBA::UShort       	 get_ushort();
  virtual CORBA::Long         	 get_long();
  virtual CORBA::ULong        	 get_ulong();
#ifndef NO_FLOAT
  virtual CORBA::Float        	 get_float();
  virtual CORBA::Double       	 get_double();
#endif			 	   
  virtual char*               	 get_string();
  virtual CORBA::Object_ptr   	 get_reference();
  virtual CORBA::TypeCode_ptr 	 get_typecode();
#ifdef HAS_LongLong
  virtual CORBA::LongLong     	 get_longlong();
  virtual CORBA::ULongLong    	 get_ulonglong();
#endif			 	   
#ifdef HAS_LongDouble
  virtual CORBA::LongDouble   	 get_longdouble();
#endif
  virtual CORBA::WChar        	 get_wchar();
  virtual CORBA::WChar*       	 get_wstring();
  virtual CORBA::Any*         	 get_any();
  virtual DynamicAny::DynAny_ptr get_dyn_any();

  virtual void insert_boolean_seq   (CORBA::BooleanSeq&    value);
  virtual void insert_octet_seq     (CORBA::OctetSeq&      value);
  virtual void insert_char_seq      (CORBA::CharSeq&       value);
  virtual void insert_short_seq     (CORBA::ShortSeq&      value);
  virtual void insert_ushort_seq    (CORBA::UShortSeq&     value);
  virtual void insert_long_seq      (CORBA::LongSeq&       value);
  virtual void insert_ulong_seq     (CORBA::ULongSeq&      value);
#ifndef NO_FLOAT
  virtual void insert_float_seq     (CORBA::FloatSeq&      value);
  virtual void insert_double_seq    (CORBA::DoubleSeq&     value);
#endif
#ifdef HAS_LongLong
  virtual void insert_longlong_seq  (CORBA::LongLongSeq&   value);
  virtual void insert_ulonglong_seq (CORBA::ULongLongSeq&  value);
#endif
#ifdef HAS_LongDouble						 
  virtual void insert_longdouble_seq(CORBA::LongDoubleSeq& value);
#endif								 
  virtual void insert_wchar_seq     (CORBA::WCharSeq&      value);

  virtual CORBA::BooleanSeq*    get_boolean_seq();
  virtual CORBA::OctetSeq*      get_octet_seq();
  virtual CORBA::CharSeq*       get_char_seq();
  virtual CORBA::ShortSeq*      get_short_seq();
  virtual CORBA::UShortSeq*     get_ushort_seq();
  virtual CORBA::LongSeq*       get_long_seq();
  virtual CORBA::ULongSeq* 	get_ulong_seq();
#ifndef NO_FLOAT
  virtual CORBA::FloatSeq* 	get_float_seq();
  virtual CORBA::DoubleSeq*     get_double_seq();
#endif
#ifdef HAS_LongLong
  virtual CORBA::LongLongSeq*   get_longlong_seq();
  virtual CORBA::ULongLongSeq*  get_ulonglong_seq();
#endif
#ifdef HAS_LongDouble
  virtual CORBA::LongDoubleSeq* get_longdouble_seq();
#endif
  virtual CORBA::WCharSeq*      get_wchar_seq();

  virtual CORBA::Boolean seek(CORBA::Long index);
  virtual void rewind();
  virtual CORBA::Boolean next();
  virtual CORBA::ULong component_count();
  virtual DynamicAny::DynAny_ptr current_component();

  virtual DynamicAny::DynAny_ptr get_discriminator();
  virtual void set_discriminator(DynamicAny::DynAny_ptr d);
  virtual void set_to_default_member();
  virtual void set_to_no_active_member();
  virtual CORBA::Boolean has_no_active_member();
  virtual CORBA::TCKind discriminator_kind();
  virtual DynamicAny::DynAny_ptr member();
  virtual char*  member_name();
  virtual CORBA::TCKind member_kind();
  virtual CORBA::Boolean is_set_to_default_member();

  /****************************
  * exposed private interface *
  ****************************/
  virtual int NP_nodetype() const;

  virtual void _NP_incrRefCount();
  virtual void _NP_decrRefCount();
  // Must not hold DynAnyImplBase::refCountLock.

  virtual void* _ptrToObjRef(const char* repoId);

  static const char* _PD_repoId;
  // Fake repoId for use by _ptrToObjRef

  /***********
  * internal *
  ***********/
  virtual void set_to_initial_value();
  virtual int copy_to(cdrMemoryStream& mbs);
  virtual int copy_from(cdrMemoryStream& mbs);
  virtual void onDispose();

  void discriminatorHasChanged();
  // If necassary detaches the old member, and creates a new member
  // of the appropriate type.

  inline TypeCode_union::Discriminator NP_disc_value() const {
    return pd_disc_value;
  }
  inline CORBA::Long NP_disc_index() const {
    return pd_member ? pd_disc_index : -1;
  }

  TypeCode_union* actualTc() const {
    return (TypeCode_union*) DynAnyImplBase::actualTc();
  }

private:
  cdrMemoryStream& writeCurrent(CORBA::TCKind kind) {
    switch( pd_curr_index ) {
    case 0:
      if( kind != pd_disc_kind )  throw DynamicAny::DynAny::TypeMismatch();
      pd_disc->pd_buf.rewindPtrs();
      pd_disc->setValid();
      return pd_disc->pd_buf;
    case 1:
      if( pd_member_kind != kind )  throw DynamicAny::DynAny::TypeMismatch();
      pd_member->pd_buf.rewindPtrs();
      // Must be a DynAnyImpl ...
      ToDynAnyImpl(pd_member)->setValid();
      return pd_member->pd_buf;
    default:
      throw DynamicAny::DynAny::InvalidValue();
    }
#ifdef NEED_DUMMY_RETURN
    return pd_buf;
#endif
  }

  cdrMemoryStream& readCurrent(CORBA::TCKind kind) {
    switch( pd_curr_index ) {
    case 0:
      if( kind != pd_disc_kind || !pd_disc->isValid() )
	throw DynamicAny::DynAny::TypeMismatch();
      pd_disc->pd_buf.rewindInputPtr();
      return pd_disc->pd_buf;
    case 1:
      // If !pd_member, then pd_member_kind == tk_null.
      if( pd_member_kind != kind || !ToDynAnyImpl(pd_member)->isValid() )
	throw DynamicAny::DynAny::TypeMismatch();
      pd_member->pd_buf.rewindInputPtr();
      return pd_member->pd_buf;
    default:
      throw DynamicAny::DynAny::InvalidValue();
    }
#ifdef NEED_DUMMY_RETURN
    return pd_buf;
#endif
  }

  void detachMember() {
    if( pd_member ) {
      pd_member->detach();
      pd_member->destroy();
      pd_member->_NP_decrRefCount();
      pd_member = 0;
      pd_member_kind = CORBA::tk_null;
    }
  }

  /*
  ** DynUnionImpl does not use an internal buffer to store the value.
  ** Instead an instance of a DynAny is created for each of the
  ** discriminator and the member value.
  */

  DynUnionDisc*                 pd_disc;
  TypeCode_base*                pd_disc_type;
  CORBA::TCKind                 pd_disc_kind;
  TypeCode_union::Discriminator pd_disc_value;
  CORBA::Long                   pd_disc_index;  // invalid if !pd_member

  DynAnyImplBase* pd_member;            // may be 0
  CORBA::TCKind   pd_member_kind;       // tk_null if !pd_member

  int pd_curr_index;                    // -1, 0 or 1
};

//////////////////////////////////////////////////////////////////////
///////////////////////// DynSequenceImpl ////////////////////////////
//////////////////////////////////////////////////////////////////////

class DynSequenceImpl : public DynAnyConstrBase,
			public DynamicAny::DynSequence
{
public:
  DynSequenceImpl(TypeCode_base* tc, CORBA::Boolean is_root=1);
  virtual ~DynSequenceImpl();

  /*******************
  * public interface *
  *******************/
  virtual DynamicAny::DynAny_ptr copy();

  virtual CORBA::ULong get_length();
  virtual void set_length (CORBA::ULong len);
  virtual DynamicAny::AnySeq* get_elements();
  virtual void set_elements(const DynamicAny::AnySeq& value);
  virtual DynamicAny::DynAnySeq* get_elements_as_dyn_any();
  virtual void set_elements_as_dyn_any(const DynamicAny::DynAnySeq& value);

  /****************************
  * exposed private interface *
  ****************************/
  virtual int NP_nodetype() const;

  virtual void _NP_incrRefCount();
  virtual void _NP_decrRefCount();
  // Must not hold DynAnyImplBase::refCountLock.

  virtual void* _ptrToObjRef(const char* repoId);

  /***********
  * internal *
  ***********/
  virtual int copy_to(cdrMemoryStream& mbs);
  virtual int copy_from(cdrMemoryStream& mbs);
  virtual TypeCode_base* nthComponentTC(unsigned n);
  // Overrides DynAnyConstrBase

  virtual SeqLocation prepareSequenceWrite(CORBA::TCKind kind,
					   CORBA::ULong len);

  virtual SeqLocation prepareSequenceRead(CORBA::TCKind kind);

private:
  CORBA::ULong pd_bound;  // 0 if unbounded sequence, bound otherwise
};


//////////////////////////////////////////////////////////////////////
/////////////////////////// DynArrayImpl /////////////////////////////
//////////////////////////////////////////////////////////////////////

class DynArrayImpl : public DynAnyConstrBase,
		     public DynamicAny::DynArray
{
public:
  DynArrayImpl(TypeCode_base* tc, CORBA::Boolean is_root=1);
  virtual ~DynArrayImpl();

  /*******************
  * public interface *
  *******************/
  virtual DynamicAny::DynAny_ptr copy();

  virtual DynamicAny::AnySeq* get_elements();
  virtual void set_elements(const DynamicAny::AnySeq& value);
  virtual DynamicAny::DynAnySeq* get_elements_as_dyn_any();
  virtual void set_elements_as_dyn_any(const DynamicAny::DynAnySeq& value);

  /****************************
  * exposed private interface *
  ****************************/
  virtual int NP_nodetype() const;

  virtual void _NP_incrRefCount();
  virtual void _NP_decrRefCount();
  // Must not hold DynAnyImplBase::refCountLock.

  virtual void* _ptrToObjRef(const char* repoId);

  /***********
  * internal *
  ***********/
  virtual TypeCode_base* nthComponentTC(unsigned n);
  // Overrides DynAnyConstrBase

  virtual SeqLocation prepareSequenceWrite(CORBA::TCKind kind,
					   CORBA::ULong len);

  virtual SeqLocation prepareSequenceRead(CORBA::TCKind kind);
private:
};


//////////////////////////////////////////////////////////////////////
////////////////////////////// Narrowing /////////////////////////////
//////////////////////////////////////////////////////////////////////

// <p> must not be nil.
inline DynAnyImplBase* ToDynAnyImplBase(DynamicAny::DynAny_ptr p)
{
  DynAnyImplBase* daib =
    (DynAnyImplBase*)p->_ptrToObjRef(DynAnyImplBase::_PD_repoId);
  OMNIORB_ASSERT(daib);
  return daib;
}

// <p> must not be nil.
inline DynAnyImpl* ToDynAnyImpl(DynamicAny::DynAny_ptr p)
{
  DynAnyImpl* dai = (DynAnyImpl*)p->_ptrToObjRef(DynAnyImpl::_PD_repoId);
  OMNIORB_ASSERT(dai);
  return dai;
}

// <p> must not be nil.
inline DynAnyConstrBase* ToDynAnyConstrBase(DynamicAny::DynAny_ptr p)
{
  DynAnyConstrBase* dacb = (DynAnyConstrBase*)p->
                                   _ptrToObjRef(DynAnyConstrBase::_PD_repoId);
  OMNIORB_ASSERT(dacb);
  return dacb;
}

// <p> must not be nil.
inline DynUnionImpl* ToDynUnionImpl(DynamicAny::DynAny_ptr p)
{
  DynUnionImpl* daui = (DynUnionImpl*)p->
                                  _ptrToObjRef(DynUnionImpl::_PD_repoId);
  OMNIORB_ASSERT(daui);
  return daui;
}

//////////////////////////////////////////////////////////////////////
/////////////////////////// DynAnyFactoryImpl ////////////////////////
//////////////////////////////////////////////////////////////////////

class DynAnyFactoryImpl : public DynamicAny::DynAnyFactory
{
public:
  DynAnyFactoryImpl() :
    OMNIORB_BASE_CTOR(DynamicAny::)DynAnyFactory(0), pd_refCount(1) {}

  virtual ~DynAnyFactoryImpl();

  // IDL defined functions
  virtual DynamicAny::DynAny_ptr
  create_dyn_any(const CORBA::Any& value);

  virtual DynamicAny::DynAny_ptr
  create_dyn_any_from_type_code(CORBA::TypeCode_ptr type);

  // Internals
  virtual void* _ptrToObjRef(const char* repoId);

  virtual void _NP_incrRefCount();
  virtual void _NP_decrRefCount();

  static DynamicAny::DynAnyFactory_ptr theFactory();

private:
  int pd_refCount;
};


OMNI_NAMESPACE_END(omni)

#endif  // __DYNANYIMPL_H__