dynany.cc

来自「编译工具」· CC 代码 · 共 2,941 行 · 第 1/5 页

  if( canAppendComponent(i) ) {
    AnyP* anyp = (AnyP*)a.NP_pd();
    try {
      cdrMemoryStream src(anyp->theMemoryStream(), 1);
      tcParser::copyStreamToMemStream_flush(anyp->getTC(), src, pd_buf);
    }
    catch(CORBA::MARSHAL&) {
      // <pd_buf> may have been partly written to, so we can't
      // append to it any more. Appends are only allowed if
      // pd_n_in_buf == pd_n_really_in_buf so ...
      pd_n_really_in_buf++;
      return 0;
    }
    pd_n_in_buf++;
    pd_n_really_in_buf++;
    return 1;
  }

  if( i < pd_first_in_comp )  createComponent(i);

  cdrMemoryStream buf(((AnyP*)a.NP_pd())->theMemoryStream(), 1);
  return pd_components[i]->copy_from(buf);
}





//////////////////////////////////////////////////////////////////////
//////////////////////////// DynStructImpl ///////////////////////////
//////////////////////////////////////////////////////////////////////

DynStructImpl::DynStructImpl(TypeCode_base* tc, CORBA::Boolean is_root)
  : DynAnyConstrBase(tc, dt_struct, is_root)
{
  setNumComponents(actualTc()->NP_member_count());
}


DynStructImpl::~DynStructImpl()
{
}

//////////////////////
// public interface //
//////////////////////

DynamicAny::DynAny_ptr
DynStructImpl::copy()
{
  CHECK_NOT_DESTROYED;
  DynStructImpl* da = new DynStructImpl(TypeCode_collector::duplicateRef(tc()),
					DYNANY_ROOT);
  try {
    da->assign(this);
  }
  catch(...) {
    da->_NP_decrRefCount();
    throw;
  }
  return da;
}

char*
DynStructImpl::current_member_name()
{
  CHECK_NOT_DESTROYED;
  if( pd_n_components == 0 ) throw DynamicAny::DynAny::TypeMismatch();    
  if( pd_curr_index < 0 )    throw DynamicAny::DynAny::InvalidValue();

  return CORBA::string_dup(actualTc()->NP_member_name(pd_curr_index));
}


CORBA::TCKind
DynStructImpl::current_member_kind()
{
  CHECK_NOT_DESTROYED;
  if( pd_n_components == 0 ) throw DynamicAny::DynAny::TypeMismatch();    
  if( pd_curr_index < 0 )    throw DynamicAny::DynAny::InvalidValue();

  return actualTc()->NP_member_type(pd_curr_index)->kind();
}


DynamicAny::NameValuePairSeq*
DynStructImpl::get_members()
{
  CHECK_NOT_DESTROYED;
  DynamicAny::NameValuePairSeq* nvps = new DynamicAny::NameValuePairSeq();

  nvps->length(pd_n_components);

  for( unsigned i = 0; i < pd_n_components; i++ ) {
    (*nvps)[i].id = CORBA::string_dup(actualTc()->NP_member_name(i));
    if( !component_to_any(i, (*nvps)[i].value) ) {
      delete nvps;
      OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
		    CORBA::COMPLETED_NO);
    }
  }
  return nvps;
}


void
DynStructImpl::set_members(const DynamicAny::NameValuePairSeq& nvps)
{
  CHECK_NOT_DESTROYED;
  if( nvps.length() != pd_n_components )
    throw DynamicAny::DynAny::InvalidValue();

  for( unsigned i = 0; i < pd_n_components; i++ ) {
    if( ((const char*)(nvps[i].id))[0] != '\0' &&
	strcmp((const char*)(nvps[i].id), actualTc()->NP_member_name(i)) )
      throw DynamicAny::DynAny::TypeMismatch();

    if( !component_from_any(i, nvps[i].value) )
      throw DynamicAny::DynAny::TypeMismatch();
  }
  pd_curr_index = (pd_n_components == 0) ? -1 : 0;
}


DynamicAny::NameDynAnyPairSeq*
DynStructImpl::get_members_as_dyn_any()
{
  CHECK_NOT_DESTROYED;

  if (pd_n_in_buf != pd_first_in_comp)
    OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
		  CORBA::COMPLETED_NO);

  DynamicAny::NameDynAnyPairSeq* nvps = new DynamicAny::NameDynAnyPairSeq();

  nvps->length(pd_n_components);

  createComponent(0);
  // All components are now in the buffer

  for( unsigned i = 0; i < pd_n_components; i++ ) {
    (*nvps)[i].id = CORBA::string_dup(actualTc()->NP_member_name(i));
    pd_components[i]->_NP_incrRefCount();
    (*nvps)[i].value = pd_components[i];
  }
  return nvps;
}

void
DynStructImpl::set_members_as_dyn_any(const DynamicAny::NameDynAnyPairSeq& nvps)
{
  CHECK_NOT_DESTROYED;

  if( nvps.length() != pd_n_components )
    throw DynamicAny::DynAny::InvalidValue();

  pd_n_in_buf = 0;
  pd_first_in_comp = 0;

  CORBA::TypeCode_var tc;

  for( unsigned i = 0; i < pd_n_components; i++ ) {
    if( ((const char*)(nvps[i].id))[0] != '\0' &&
	strcmp((const char*)(nvps[i].id), actualTc()->NP_member_name(i)) )
      throw DynamicAny::DynAny::TypeMismatch();

    tc = nvps[i].value->type();
    if( !tc->equivalent(nthComponentTC(i)) ) {
      pd_first_in_comp = pd_n_components;
      throw DynamicAny::DynAny::TypeMismatch();
    }
    pd_components[i] = ToDynAnyImplBase(nvps[i].value);
    pd_components[i]->_NP_incrRefCount();
  }
  pd_curr_index = (pd_n_components == 0) ? -1 : 0;
}




///////////////////////////////
// exposed private interface //
///////////////////////////////

int
DynStructImpl::NP_nodetype() const
{
  return dt_struct;
}


//////////////
// internal //
//////////////

TypeCode_base*
DynStructImpl::nthComponentTC(unsigned n)
{
  if( n >= pd_n_components )
    throw omniORB::fatalException(__FILE__,__LINE__,
		    "DynStructImpl::nthComponentTC() - n out of bounds");

  return actualTc()->NP_member_type(n);
}


DynAnyConstrBase::SeqLocation
DynStructImpl::prepareSequenceWrite(CORBA::TCKind kind, CORBA::ULong len)
{
  // Note that we ignore then length here. When the insert function
  // tries to call insert on the sub-component, that call will check
  // the length.

  const TypeCode_base* tc = actualTc();

  if (pd_curr_index < 0)
    throw DynamicAny::DynAny::InvalidValue();

  const TypeCode_base* ctc;
  ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
  CORBA::TCKind k = ctc->NP_kind();

  if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
      TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
    return SEQ_COMPONENT;
  }
  throw DynamicAny::DynAny::TypeMismatch();
#ifdef NEED_DUMMY_RETURN
  return SEQ_COMPONENT;
#endif
}

DynAnyConstrBase::SeqLocation
DynStructImpl::prepareSequenceRead(CORBA::TCKind kind)
{
  const TypeCode_base* tc = actualTc();

  if (pd_curr_index < 0)
    throw DynamicAny::DynAny::InvalidValue();

  const TypeCode_base* ctc;
  ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
  CORBA::TCKind k = ctc->NP_kind();

  if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
      TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
    return SEQ_COMPONENT;
  }
  throw DynamicAny::DynAny::TypeMismatch();
#ifdef NEED_DUMMY_RETURN
  return SEQ_COMPONENT;
#endif
}


void
DynStructImpl::_NP_incrRefCount()
{
  DynAnyImplBase::_NP_incrRefCount();
}

void
DynStructImpl::_NP_decrRefCount()
{
  DynAnyImplBase::_NP_decrRefCount();
}

void*
DynStructImpl::_ptrToObjRef(const char* repoId)
{
  if( omni::ptrStrMatch(repoId, DynAnyConstrBase::_PD_repoId) )
    return (DynAnyConstrBase*) this;
  
  if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
    return (DynAnyImplBase*) this;
  
  if( omni::ptrStrMatch(repoId, DynamicAny::DynStruct::_PD_repoId) )
    return (DynamicAny::DynStruct_ptr) this;
  
  if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
    return (DynamicAny::DynAny_ptr) this;
  
  if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
    return (CORBA::Object_ptr) this;

  return 0;
}



//////////////////////////////////////////////////////////////////////
/////////////////////////// DynUnionDisc /////////////////////////////
//////////////////////////////////////////////////////////////////////

DynUnionDisc::~DynUnionDisc()
{
}


void
DynUnionDisc::assign(DynamicAny::DynAny_ptr da)
{
  DynAnyImpl::assign(da);
  if( pd_union )  pd_union->discriminatorHasChanged();
}

void
DynUnionDisc::insert_boolean(CORBA::Boolean value)
{
  CHECK_NOT_DESTROYED;
  doWrite(CORBA::tk_boolean).marshalBoolean(value);
  if( pd_union )  pd_union->discriminatorHasChanged();
}


void
DynUnionDisc::insert_octet(CORBA::Octet value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}


void
DynUnionDisc::insert_char(CORBA::Char value)
{
  CHECK_NOT_DESTROYED;
  doWrite(CORBA::tk_char).marshalChar(value);
  if( pd_union )  pd_union->discriminatorHasChanged();
}


void
DynUnionDisc::insert_short(CORBA::Short value)
{
  CHECK_NOT_DESTROYED;
  value >>= doWrite(CORBA::tk_short);
  if( pd_union )  pd_union->discriminatorHasChanged();
}


void
DynUnionDisc::insert_ushort(CORBA::UShort value)
{
  CHECK_NOT_DESTROYED;
  value >>= doWrite(CORBA::tk_ushort);
  if( pd_union )  pd_union->discriminatorHasChanged();
}


void
DynUnionDisc::insert_long(CORBA::Long value)
{
  CHECK_NOT_DESTROYED;
  value >>= doWrite(CORBA::tk_long);
  if( pd_union )  pd_union->discriminatorHasChanged();
}


void
DynUnionDisc::insert_ulong(CORBA::ULong value)
{
  CHECK_NOT_DESTROYED;
  value >>= doWrite(CORBA::tk_ulong);
  if( pd_union )  pd_union->discriminatorHasChanged();
}

#ifndef NO_FLOAT
void
DynUnionDisc::insert_float(CORBA::Float value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}


void
DynUnionDisc::insert_double(CORBA::Double value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}

#endif

void
DynUnionDisc::insert_string(const char* value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}


void
DynUnionDisc::insert_reference(CORBA::Object_ptr value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}


void
DynUnionDisc::insert_typecode(CORBA::TypeCode_ptr value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}


#ifdef HAS_LongLong
void
DynUnionDisc::insert_longlong(CORBA::LongLong value)
{
  CHECK_NOT_DESTROYED;
  value >>= doWrite(CORBA::tk_longlong);
  if( pd_union )  pd_union->discriminatorHasChanged();
}


void
DynUnionDisc::insert_ulonglong(CORBA::ULongLong value)
{
  CHECK_NOT_DESTROYED;
  value >>= doWrite(CORBA::tk_ulonglong);
  if( pd_union )  pd_union->discriminatorHasChanged();
}
#endif

#ifdef HAS_LongDouble
void
DynUnionDisc::insert_longdouble(CORBA::LongDouble value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}
#endif

void
DynUnionDisc::insert_wchar(CORBA::WChar value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}

void
DynUnionDisc::insert_wstring(const CORBA::WChar* value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}

void
DynUnionDisc::insert_any(const CORBA::Any& value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}

void
DynUnionDisc::insert_dyn_any(DynamicAny::DynAny_ptr value)
{
  CHECK_NOT_DESTROYED;
  // Not a legal discriminator type.
  throw DynamicAny::DynAny::InvalidValue();
}

///////////////////////////////
// exposed private interface //
///////////////////////////////

int
DynUnionDisc::NP_nodetype() const
{
  return dt_disc;
}

void
DynUnionDisc::set_to_initial_value()
{
  // Choose a value corresponding to the first case
  OMNIORB_ASSERT(pd_union);
  set_value(pd_union->actualTc()->NP_member_label_val(0));
}


void
DynUnionDisc::set_value(TypeCode_union::Discriminator v)
{
  switch( tckind() ) {
  case CORBA::tk_char:
    insert_char((CORBA::Char)v);
    break;
  case CORBA::tk_boolean:
    insert_boolean((CORBA::Boolean)v);
    break;
  case CORBA::tk_short:
    insert_short((CORBA::Short)v);
    break;
  case CORBA::tk_ushort:
    insert_ushort((CORBA::UShort)v);
    break;
  case CORBA::tk_long:
    insert_long((CORBA::Long)v);
    break;
  case CORBA::tk_ulong:
    insert_ulong((CORBA::ULong)v);
    break;
#ifdef HAS_LongLong
  case CORBA::tk_longlong:
    insert_longlong((CORBA::LongLong)v);
    break;
  case CORBA::tk_ulonglong:
    insert_ulonglong((CORBA::ULongLong)v);
    break;
#endif
  default:
    throw omniORB::fatalException(__FILE__,__LINE__,
       "DynUnionDisc::set_value() - illegal disciminator type");
  }
}

//////////////////////////////////////////////////////////////////////
///////////////////////// DynUnionEnumDisc ///////////////////////////
//////////////////////////////////////////////////////////////////////

DynUnionEnumDisc::DynUnionEnumDisc(TypeCode_base* tc, DynUnionImpl* un)
  : DynUnionDisc(tc, dt_enumdisc, un)
{
}


DynUnionEnumDisc::~DynUnionEnumDisc() {}

//////////////////////
// public interface //
//////////////////////

DynamicAny::DynAny_ptr
DynUnionEnumDisc::copy()
{
  CHECK_NOT_DESTROYED;

  DynEnumImpl* da = new DynEnumImpl(TypeCode_collector::duplicateRef(tc()),
				    DYNANY_ROOT);
  try {
    da->assign(this);
  }
  catch(DynamicAny::DynAny::TypeMismatch&) {
    OMNIORB_ASSERT(0);
    // This should never happen since the types always match -- they
    // are the same TypeCode.
  }
  catch(...) {
    da->_NP_decrRefCount();
    throw;
  }
  return da;
}


char*
DynUnionEnumDisc::get_as_string()
{
  CHECK_NOT_DESTROYED;

  CORBA::ULong val;
  {
    if( !isValid() )
      OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
				    
    pd_buf.rewindInputPtr();
    val <<= pd_buf;
  }

  if( val >= act