Abstract baseclass for Valuetypes. More...
#include <ValueBase.h>
Abstract baseclass for Valuetypes.
Definition at line 124 of file ValueBase.h.
Definition at line 131 of file ValueBase.h.
| typedef ValueBase* CORBA::ValueBase::_ptr_type |
Definition at line 129 of file ValueBase.h.
Reimplemented in TAO_AMH_DSI_Exception_Holder.
Definition at line 130 of file ValueBase.h.
Definition at line 133 of file ValueBase.h.
| CORBA::ValueBase::ValueBase | ( | void | ) | [protected] |
Definition at line 71 of file ValueBase.cpp.
: is_truncatable_(0), chunking_(0) { }
| CORBA::ValueBase::ValueBase | ( | const ValueBase & | val | ) | [protected] |
Definition at line 77 of file ValueBase.cpp.
: is_truncatable_ (val.is_truncatable_), chunking_ (val.chunking_) { }
| CORBA::ValueBase::~ValueBase | ( | void | ) | [protected, virtual] |
Definition at line 83 of file ValueBase.cpp.
{
}
| virtual void CORBA::ValueBase::_add_ref | ( | void | ) | [pure virtual] |
! virtual CORBA::ValueBase* _copy_value (void) = 0;
Implemented in CORBA::DefaultValueRefCountBase.
| CORBA::ValueBase * CORBA::ValueBase::_downcast | ( | CORBA::ValueBase * | vt | ) | [static] |
Reimplemented in TAO_AMH_DSI_Exception_Holder.
Definition at line 88 of file ValueBase.cpp.
{
// Every vt is a CORBA::ValueBase :-).
return vt;
}
| virtual CORBA::ULong CORBA::ValueBase::_refcount_value | ( | void | ) | [pure virtual] |
Implemented in CORBA::DefaultValueRefCountBase.
| virtual void CORBA::ValueBase::_remove_ref | ( | void | ) | [pure virtual] |
Implemented in CORBA::DefaultValueRefCountBase.
| void CORBA::ValueBase::_tao_any_destructor | ( | void * | x | ) | [static] |
TAO extension.
Used in the implementation of CORBA::Any
Reimplemented in TAO_AMH_DSI_Exception_Holder.
Definition at line 95 of file ValueBase.cpp.
{
CORBA::ValueBase *tmp = static_cast<CORBA::ValueBase *> (x);
CORBA::remove_ref (tmp);
}
| CORBA::Boolean CORBA::ValueBase::_tao_marshal | ( | TAO_OutputCDR & | strm, | |
| const ValueBase * | _this, | |||
| ptrdiff_t | formal_type_id = 0 | |||
| ) | [static] |
Marshal a valuetype (see operator<< in tao_idl generated file how it is called)
Definition at line 152 of file ValueBase.cpp.
{
if ( ! _tao_write_special_value (strm, this_))
{
return _tao_write_value (strm, this_, formal_type_id);
}
else
return 1;
}
| virtual CORBA::Boolean CORBA::ValueBase::_tao_marshal_v | ( | TAO_OutputCDR & | ) | const [pure virtual] |
During marshal jump to the most derived part.
Implemented in TAO_AMH_DSI_Exception_Holder.
| virtual CORBA::Boolean CORBA::ValueBase::_tao_match_formal_type | ( | ptrdiff_t | ) | const [protected, pure virtual] |
Compare the supplied formal type identifier with our actual type. This is used during marshaling of valuetypes to detect when it is appropriate to not explicitly marshal the typecode for the value.
Implemented in TAO_AMH_DSI_Exception_Holder.
| virtual const char* CORBA::ValueBase::_tao_obv_repository_id | ( | void | ) | const [pure virtual] |
Return the repository id of this valuetype.
Implemented in TAO_AMH_DSI_Exception_Holder.
| virtual void CORBA::ValueBase::_tao_obv_truncatable_repo_ids | ( | Repository_Id_List & | ) | const [pure virtual] |
Give the list of the RepositoryIds in the valuetype "truncatable" inheritance hierarchy. List the id of this valuetype as first RepositoryID and go up the "truncatable" derivation hierarchy. Note the truncatable repo ids only list the truncatable base types to which this type is safe to truncate, not all its parents.
Implemented in TAO_AMH_DSI_Exception_Holder.
| CORBA::Boolean CORBA::ValueBase::_tao_read_codebase_url | ( | TAO_InputCDR & | strm, | |
| ACE_CString & | codebase_url | |||
| ) | [static, private] |
Read a codebase url from the CDR input stream, accounting for indirection.
Definition at line 1203 of file ValueBase.cpp.
{
CORBA::ULong length = 0;
size_t buffer_size = strm.length();
if (!strm.read_ulong (length))
{
return 0;
}
VERIFY_MAP(TAO_InputCDR, codebase_url_map, Codebase_URL_Map)
char * pos = strm.rd_ptr();
// 'length' may not be the codebase url length - it could be the
// FFFFFFF indirection marker instead. If it is an indirection marker, we
// get the offset following the indirection marker, otherwise we can follow
// the same logic using the offset to simply rewind to the start of length
// and re-read the length as part of the string
if (TAO_OBV_GIOP_Flags::is_indirection_tag (length))
{
return _tao_unmarshal_codebase_url_indirection (strm, codebase_url);
}
pos -= sizeof (CORBA::ULong);
// Cribbed from tc_demarshal_indirection in Typecode_CDR_Extraction.cpp
TAO_InputCDR url_stream (pos,
buffer_size,
strm.byte_order ());
if (!url_stream.good_bit ())
{
return 0;
}
if (! url_stream.read_string (codebase_url))
return 0;
// It's possible the codebase url is read again from an indirection stream,
// so make sure the codebase url is the same.
ACE_CString mapped_url;
if (strm.get_codebase_url_map ()->get()->find (pos, mapped_url) == 0)
{
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_read_codebase_url, found %X - %C\n"),
pos, mapped_url.c_str ()));
}
if (ACE_OS::strcmp (mapped_url.c_str (), codebase_url.c_str ()) != 0)
throw CORBA::INTERNAL ();
}
else if (strm.get_codebase_url_map ()->get()->bind (pos, codebase_url) != 0)
{
throw CORBA::INTERNAL ();
}
else
{
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_read_codebase_url, bound %X - %C\n"),
pos, codebase_url.c_str ()));
}
}
// Since the codebase url is always read from the indirection cdr we have to skip
// the main CDR forward if we were in fact reading from the current
// location and not rewinding back some offset.
strm.skip_bytes (length);
return 1;
}
| CORBA::Boolean CORBA::ValueBase::_tao_read_repository_id | ( | TAO_InputCDR & | strm, | |
| ACE_CString & | id | |||
| ) | [static, private] |
Read a single repository id from the CDR input stream, accounting for indirection.
Definition at line 1122 of file ValueBase.cpp.
{
CORBA::ULong length = 0;
size_t buffer_size = strm.length();
if (!strm.read_ulong (length))
{
return 0;
}
VERIFY_MAP(TAO_InputCDR, repo_id_map, Repo_Id_Map)
if (strm.get_repo_id_map ().is_nil ())
throw CORBA::INTERNAL ();
char * pos = strm.rd_ptr();
// 'length' may not be the repo id length - it could be the
// FFFFFFF indirection marker instead. If it is an indirection marker, we
// get the offset following the indirection marker, otherwise we can follow
// the same logic using the offset to simply rewind to the start of length
// and re-read the length as part of the string
if (TAO_OBV_GIOP_Flags::is_indirection_tag (length))
{
return _tao_unmarshal_repo_id_indirection (strm, id);
}
pos -= sizeof (CORBA::ULong);
// Cribbed from tc_demarshal_indirection in Typecode_CDR_Extraction.cpp
TAO_InputCDR id_stream (pos,
buffer_size,
strm.byte_order ());
if (!id_stream.good_bit ())
{
return 0;
}
if (! id_stream.read_string (id))
return 0;
// It's possible the id is read again from an indirection stream,
// so make sure the id is the same.
ACE_CString mapped_id;
if (strm.get_repo_id_map ()->get()->find (pos, mapped_id) == 0)
{
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_read_repository_id, found %X - %C\n"),
pos, mapped_id.c_str ()));
}
if (ACE_OS::strcmp (mapped_id.c_str (), id.c_str ()) != 0)
throw CORBA::INTERNAL ();
}
else if (strm.get_repo_id_map ()->get ()->bind (pos, id) != 0)
{
throw CORBA::INTERNAL ();
}
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_read_repository_id, bound %X - %C\n"),
pos, id.c_str ()));
}
// Since the ID is always read from the indirection cdr we have to skip
// the main CDR forward if we were in fact reading from the current
// location and not rewinding back some offset.
strm.skip_bytes (length);
return 1;
}
| CORBA::Boolean CORBA::ValueBase::_tao_read_repository_id_list | ( | TAO_InputCDR & | strm, | |
| Repository_Id_List & | ids | |||
| ) | [static, private] |
Read a list of repository ids from the CDR input stream, accounting for indirection
Definition at line 1090 of file ValueBase.cpp.
{
CORBA::Long num_ids = 0;
if (!strm.read_long (num_ids))
{
return 0;
}
if (num_ids == TAO_OBV_GIOP_Flags::Indirection_tag)
{
// Multiple repo id is not indirected.
return 0;
}
else
{
for (CORBA::Long i = 0; i < num_ids; ++i)
{
ACE_CString id;
if (!_tao_read_repository_id (strm, id))
{
return 0;
}
ids.push_back (id);
}
}
return 1;
}
| virtual CORBA::TypeCode_ptr CORBA::ValueBase::_tao_type | ( | void | ) | const [pure virtual] |
Implemented in TAO_AMH_DSI_Exception_Holder.
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal | ( | TAO_InputCDR & | strm, | |
| CORBA::ValueBase *& | new_object | |||
| ) | [static] |
Unmarshal a valuetype, if formal type is a pointer to ValueBase
Definition at line 166 of file ValueBase.cpp.
{
// This is for the special case only that one unmarshals in order
// to assign the newly created object directly to a ValueBase pointer.
// Implementation is like a specialized one (in TC.cpp, if T.idl is source).
// basically do:
// ValueBase::_tao_unmarshal_pre ()
// (Gets factory or possible a null or an existing object.
// Then the job is done. On an existing (backreferenced) object
// do a cast and a type check)
// new_object = factory->create_for_unmarshal ()
// (with apropriate cast)
// new_object->_tao_unmarshal_v ()
// new_object->_tao_unmarshal_post ()
CORBA::Boolean is_null_object = false;
CORBA::Boolean is_indirected = false;
CORBA::Boolean const retval =
CORBA::ValueBase::_tao_unmarshal_pre (strm,
new_object,
0,
is_null_object,
is_indirected);
if (!retval)
{
return false;
}
if (is_null_object || is_indirected)
{
return true;
}
// In this case, the codebase url and repo id is read,
// so continue unmarshal values.
if (new_object && ! new_object->_tao_unmarshal_v (strm))
{
return false;
}
return retval;
}
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_codebase_url_indirection | ( | TAO_InputCDR & | strm, | |
| ACE_CString & | codebase_url | |||
| ) | [static, private] |
Definition at line 585 of file ValueBase.cpp.
{
CORBA::Long offset = 0;
if (!strm.read_long (offset) || offset >= 0)
{
return false;
}
void* pos = strm.rd_ptr () + offset - sizeof (CORBA::Long);
if (strm.get_codebase_url_map()->get()->find (pos, codebase_url) != 0)
{
throw CORBA::INTERNAL ();
}
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_codebase_url_indirection, found %X - %C\n"),
pos, codebase_url.c_str ()));
}
return 1;
}
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_post | ( | TAO_InputCDR & | strm | ) |
Definition at line 396 of file ValueBase.cpp.
{
// (... called from T::_tao_unmarshal)
// 7. if (chunking) check the last blocksize tag for correct value. +++
// And if we're gonna to truncate, skip all the state of the more
// derived classes. (But it might need to be accessed again,
// if there are embedded objects which are referenced later
// in this CDR encoding stream.)
// 8. if (chunking) there must be some end tag. Let the CDR stream deal
// with this (and decrease the nesting level of valuetypes).
// Also the CDR stream must check for eventually outstanding end tags
// at the end of the stream which have to cause a marshal
// exception there.
return true;
}
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_pre | ( | TAO_InputCDR & | strm, | |
| CORBA::ValueBase *& | valuetype, | |||
| const char *const | repo_id, | |||
| CORBA::Boolean & | is_null_object, | |||
| CORBA::Boolean & | is_indirected | |||
| ) | [static] |
Both used internally and are called from T::_tao_unmarshal ().
Definition at line 213 of file ValueBase.cpp.
{
void* pos = strm.rd_ptr();
// Value factories are reference counted. When we get a new value
// factory from the ORB, its reference count is increased.
CORBA::ValueFactory_var factory;
// %! yet much to do ... look for +++ !
// 1. Get the <value-tag> (else it may be <indirection-tag> or <null-ref>).
// Is object yet unmarshalled (<indirection-tag> is set) ? (->1a)
// Is <null-ref> given ? Set 0 and return ok.
// 1a. Lookup the real address in memory, which should be aligned +++
// to CORBA::ValueBase. Its possible at this point that worse
// type mismatch gets by undetected, if the CDR stream fakes.
// So the type should be checked ... +++
// 2. Now at this point it must be a <value-tag> (error else).
// if (chunking) check that any last chunk ends with matching
// size. If not raise marshal exception.
// Increase the nesting level of valuetypes.
// 3. if (chunking) read and record the blocksize-tag.
// 4. Unmarshal type information and lookup factory.
// If no type information is given in the CDR encoding, as told
// from the <value-tag>, then use the repository id parameter
// (it _must_ be right).
CORBA::Long valuetag;
Repository_Id_List ids;
ACE_CString codebase_url;
is_indirected = false;
is_null_object = false;
if (! strm.read_long (valuetag))
{
return false;
}
if (TAO_OBV_GIOP_Flags::is_indirection_tag (valuetag))
{
is_indirected = true;
// value is redirected
return _tao_unmarshal_value_indirection (strm, valuetype);
}
if (TAO_OBV_GIOP_Flags::is_null_ref (valuetag))
{
// null reference is unmarshalled.
valuetype = 0;
is_null_object = true;
return true;
}
if (TAO_OBV_GIOP_Flags::has_codebase_url (valuetag))
{
ACE_CString codebase_url;
if (! _tao_read_codebase_url (strm, codebase_url))
{
return false;
}
}
if (TAO_OBV_GIOP_Flags::has_single_type_info (valuetag))
{
ACE_CString id;
if (! _tao_read_repository_id(strm, id))
{
return false;
}
ids.push_back (id);
}
else if (TAO_OBV_GIOP_Flags::has_list_type_info (valuetag))
{
if (! _tao_read_repository_id_list(strm, ids))
{
return false;
}
}
else if (TAO_OBV_GIOP_Flags::has_no_type_info (valuetag))
{
ids.push_back (repo_id);
}
else
{
if (TAO_debug_level > 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_pre, ")
ACE_TEXT ("unknown value tag: %x\n"),
valuetag));
}
return 0;
}
TAO_ORB_Core *orb_core = strm.orb_core ();
if (orb_core == 0)
{
orb_core = TAO_ORB_Core_instance ();
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_WARNING,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_pre, ")
ACE_TEXT ("WARNING: extracting valuetype using ")
ACE_TEXT ("default ORB_Core\n")));
}
}
CORBA::Boolean require_truncation = false;
CORBA::Boolean const chunking =
TAO_OBV_GIOP_Flags::is_chunked (valuetag);
CORBA::ULong const num_ids = ids.size ();
// Find the registered factory for this unmarshalling valuetype. If any
// factory for the valuetype in its truncatable derivation hierarchy
// is registered, the factory is used to create value for unmarshalling.
for (CORBA::ULong i = 0; i < num_ids; ++i)
{
factory = orb_core->orb ()->lookup_value_factory (ids[i].c_str ());
if (factory.in() != 0)
{
if (i != 0 && chunking)
{
require_truncation = true;
}
break;
}
}
if (factory.in() == 0)
{
if (TAO_debug_level > 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_pre, ")
ACE_TEXT ("OBV factory is null, id = %C\n"),
repo_id));
}
throw ::CORBA::MARSHAL (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
}
valuetype = factory->create_for_unmarshal ();
if (require_truncation)
{
valuetype->truncation_hook ();
}
if (valuetype == 0)
{
return 0; // %! except.?
}
valuetype->chunking_ = chunking;
VERIFY_MAP(TAO_InputCDR, value_map, Value_Map)
if (strm.get_value_map ()->get()->bind (pos, valuetype ) != 0)
throw CORBA::INTERNAL ();
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_pre, bound value %X - %X\n"),
pos, valuetype));
}
return true;
}
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_repo_id_indirection | ( | TAO_InputCDR & | strm, | |
| ACE_CString & | repo_id | |||
| ) | [static, private] |
Definition at line 560 of file ValueBase.cpp.
{
CORBA::Long offset = 0;
if (!strm.read_long (offset) || offset >= 0)
{
return false;
}
void* pos = strm.rd_ptr () + offset - sizeof (CORBA::Long);
if (strm.get_repo_id_map()->get()->find (pos, id) != 0)
{
throw CORBA::INTERNAL ();
}
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_repo_id_indirection, found %X - %C\n"),
pos, id.c_str ()));
}
return 1;
}
| virtual CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_v | ( | TAO_InputCDR & | ) | [pure virtual] |
Called after obtaining the fresh object from create_for_unmarshal ().
Implemented in TAO_AMH_DSI_Exception_Holder.
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_value_indirection | ( | TAO_InputCDR & | strm, | |
| CORBA::ValueBase *& | value | |||
| ) | [static, private] |
Definition at line 518 of file ValueBase.cpp.
{
if (strm.get_value_map().is_nil ())
throw CORBA::INTERNAL ();
CORBA::Long offset = 0;
if (!strm.read_long (offset) || offset >= 0)
{
return 0;
}
void* pos = strm.rd_ptr () + offset - sizeof (CORBA::Long);
if (TAO_debug_level > 9)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) ValueBase::_tao_unmarshal_value_indirection, pos %X \n"), pos));
TAO_InputCDR::Value_Map* map = strm.get_value_map()->get ();
for (TAO_InputCDR::Value_Map::ITERATOR it = map->begin (); it != map->end (); ++ it)
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) ValueBase::_tao_unmarshal_value_indirection, %X - %X \n"), it->ext_id_, it->int_id_));
}
}
void * v = 0;
if (strm.get_value_map()->get()->find (pos, v) != 0)
{
throw CORBA::INTERNAL ();
}
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_unmarshal_value_indirection, found %X - %X\n"),
pos,v));
}
value = reinterpret_cast<CORBA::ValueBase *>(v);
return true;
}
| CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_value_indirection_pre | ( | TAO_InputCDR & | strm, | |
| TAO_InputCDR & | indirected_strm | |||
| ) | [static, private] |
Definition at line 496 of file ValueBase.cpp.
{
CORBA::Long offset = 0;
if (!strm.read_long (offset) || offset >= 0)
{
return false;
}
size_t const buffer_size = -(offset) + sizeof (CORBA::Long);
// Cribbed from tc_demarshal_indirection in Typecode_CDR_Extraction.cpp
indirected_strm = TAO_InputCDR (strm.rd_ptr () + offset - sizeof (CORBA::Long),
buffer_size,
strm.byte_order ());
indirected_strm.set_repo_id_map (strm.get_repo_id_map ());
indirected_strm.set_codebase_url_map (strm.get_codebase_url_map ());
indirected_strm.set_value_map (strm.get_value_map ());
return indirected_strm.good_bit ();
}
| CORBA::Boolean CORBA::ValueBase::_tao_validate_box_type | ( | TAO_InputCDR & | strm, | |
| TAO_InputCDR & | indirected_strm, | |||
| const char *const | repo_id_expected, | |||
| CORBA::Boolean & | null_object, | |||
| CORBA::Boolean & | is_indirected | |||
| ) | [static] |
Check repository id for value box type against what is in the CDR stream.
Definition at line 416 of file ValueBase.cpp.
{
CORBA::Long value_tag;
null_object = false;
is_indirected = false;
if (!strm.read_long (value_tag))
{
return false;
}
if (TAO_OBV_GIOP_Flags::is_null_ref (value_tag))
{ // ok, null reference unmarshaled
null_object = true;
return true;
}
if (TAO_OBV_GIOP_Flags::is_indirection_tag (value_tag))
{
is_indirected = true;
// box value is redirected.
return _tao_unmarshal_value_indirection_pre (strm, indirected_strm);
}
if (!TAO_OBV_GIOP_Flags::is_value_tag (value_tag))
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - CORBA::ValueBase::_tao_validate_box_type, ")
ACE_TEXT ("not value_tag\n")));
return false;
}
if (TAO_OBV_GIOP_Flags::has_codebase_url (value_tag))
{ // Demarshal the codebase url (but we won't be using it).
ACE_CString codebase_url;
if (! _tao_read_codebase_url (strm, codebase_url))
{
return false;
}
}
if (TAO_OBV_GIOP_Flags::has_no_type_info (value_tag))
{
// No type information so assume it is the correct type.
return true;
}
if (TAO_OBV_GIOP_Flags::has_single_type_info (value_tag))
{
// Demarshal the repository id and check if it is the expected one.
ACE_CString id;
if (! _tao_read_repository_id (strm, id))
{
return false;
}
if (!ACE_OS::strcmp (id.c_str(), repo_id_expected))
{ // Repository ids matched as expected
return true;
}
}
if (TAO_OBV_GIOP_Flags::has_list_type_info (value_tag))
{
// Don't know how to handle a repository id list. It does not
// make sense for a value box anyway.
return false;
}
return false;
}
| CORBA::Boolean CORBA::ValueBase::_tao_write_repository_id | ( | TAO_OutputCDR & | strm, | |
| ACE_CString & | id | |||
| ) | [static, private] |
Definition at line 799 of file ValueBase.cpp.
{
#ifdef TAO_HAS_VALUETYPE_OUT_INDIRECTION
VERIFY_MAP(TAO_OutputCDR, repo_id_map, Repo_Id_Map)
if (strm.get_repo_id_map().is_nil ())
{
throw CORBA::INTERNAL ();
}
char* pos = 0;
if (strm.get_repo_id_map ()->get()->find (id, pos) == 0)
{
if (! strm.write_long (TAO_OBV_GIOP_Flags::Indirection_tag))
return 0;
CORBA::Long offset = - strm.offset (pos);
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_write_repository_id, id %C indirection %d\n"),
id.c_str(), offset));
}
if (! strm.write_long (offset))
return false;
}
else
{
if (strm.align_write_ptr (ACE_CDR::LONG_SIZE) != 0)
{
throw CORBA::INTERNAL ();
}
if (strm.get_repo_id_map ()->get ()->bind (id, strm.current()->wr_ptr ()) != 0)
{
throw CORBA::INTERNAL ();
}
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_write_repository_id, bound %C - %X\n"),
id.c_str (), strm.current()->wr_ptr ()));
}
if (! strm.write_string (id.c_str ()))
return false;
}
#else
if (! strm.write_string (id.c_str ()))
return 0;
#endif
return 1;
}
| CORBA::Boolean CORBA::ValueBase::_tao_write_special_value | ( | TAO_OutputCDR & | strm, | |
| const CORBA::ValueBase * | value | |||
| ) | [static, private] |
Write some special values such as null value or indirection value.
Definition at line 632 of file ValueBase.cpp.
{
// If the 'value' is null then write the null value to the stream.
if (value == 0)
{
return strm.write_long (TAO_OBV_GIOP_Flags::Null_tag);
}
else
{
#ifdef TAO_HAS_VALUETYPE_OUT_INDIRECTION
// value indirection
VERIFY_MAP(TAO_OutputCDR, value_map, Value_Map)
char* pos = 0;
if (strm.get_value_map ()->get()->find (
reinterpret_cast<void*>(const_cast <CORBA::ValueBase *> (value)), pos) == 0)
{
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t)ValueBase::_tao_write_special_value found value %X - %X\n"),
value, pos));
}
if (! strm.write_long (TAO_OBV_GIOP_Flags::Indirection_tag))
{
return false;
}
CORBA::Long const offset = - strm.offset (pos);
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - ValueBase::_tao_write_special_value value, indirection %d\n"), offset));
}
return strm.write_long (offset);
}
else {
if (strm.align_write_ptr (ACE_CDR::LONG_SIZE) != 0)
{
throw CORBA::INTERNAL ();
}
if (strm.get_value_map ()->get()->bind (
reinterpret_cast<void*>(const_cast <CORBA::ValueBase *> (value)),
strm.current()->wr_ptr() ) != 0)
{
throw CORBA::INTERNAL ();
}
else if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t)ValueBase::_tao_marshal bound value %X - %X \n"),
value, strm.current()->wr_ptr()));
}
return false;
}
#endif
return false;
}
}
| CORBA::Boolean CORBA::ValueBase::_tao_write_value | ( | TAO_OutputCDR & | strm, | |
| const CORBA::ValueBase * | value, | |||
| ptrdiff_t | formal_type_id | |||
| ) | [static, private] |
Write whole value.
Definition at line 700 of file ValueBase.cpp.
{
if (! value->_tao_write_value_header (strm, formal_type_id))
{
return false;
}
if (! value->_tao_marshal_v (strm))
{
return false;
}
return true;
}
| CORBA::Boolean CORBA::ValueBase::_tao_write_value_header | ( | TAO_OutputCDR & | strm, | |
| ptrdiff_t | formal_type_id | |||
| ) | const [private] |
Write the header of the value which includes the valuetag, number of repository ids and list of repository ids.
Definition at line 719 of file ValueBase.cpp.
{
#ifdef TAO_HAS_OPTIMIZED_VALUETYPE_MARSHALING
// this case allows TAO to avoid marshaling the typeID for values
// where the actual type matches the formal type (ie not a derived
// type).
//
// I would much prefer that there be a way to have a -ORB option to
// control this behavior, but for now there is no reference to the
// ORB Core available during marshaling (there is during unmarshaling)
// and no other way to communicate such configuration values.
CORBA::Boolean const is_formal_type =
this->_tao_match_formal_type (formal_type_id);
#else
// Unfortunately, all versions of tao prior to TAO 1.5.2 did not
// support unmarshaling of valuetypes that did not explicitly
// marshal the type id. At least it is benign to always encode the
// typecode value, even if it can be a little verbose.
CORBA::Boolean const is_formal_type = 0;
ACE_UNUSED_ARG (formal_type_id);
#endif /* TAO_HAS_OPTIMIZED_VALUETYPE_MARSHALING */
// Get the list of repository ids for this valuetype.
Repository_Id_List repository_ids;
this->_tao_obv_truncatable_repo_ids (repository_ids);
CORBA::Long const num_ids =
static_cast <CORBA::Long> (repository_ids.size ());
// Build <value-tag>, which states if chunking is used
// and if type information ((list of) repository id(s))
// is provided. The latter is necessary if the formal_type_id
// is unequal the 'true derived' type of this object.
CORBA::Long valuetag = TAO_OBV_GIOP_Flags::Value_tag_base;
// Truncatable value type, must use chunking and list all repository
// ids in its "truncatable" derivation hierarchy.
if (this->is_truncatable_ || this->chunking_)
valuetag |= TAO_OBV_GIOP_Flags::Chunking_tag_sigbits;
if (!is_formal_type || this->is_truncatable_)
valuetag |= TAO_OBV_GIOP_Flags::Type_info_single;
if (num_ids > 1)
{
valuetag |= TAO_OBV_GIOP_Flags::Type_info_list;
}
if (! strm.write_long (valuetag) // Write <value-tag>.
|| (num_ids > 1 && !strm.write_long (num_ids))) // Write <num-ids>.
{
return false;
}
#ifndef TAO_HAS_OPTIMIMIZED_VALUETYPE_MARSHALING
if (this->is_truncatable_
|| !is_formal_type /* Always evaluates to 1 in the
!TAO_HAS_OPTIMIMIZED_VALUETYPE_MARSHALING
case */
|| num_ids > 1)
{
#endif /* !TAO_HAS_OPTIMIMIZED_VALUETYPE_MARSHALING */
// Marshal type information.
for (CORBA::Long i = 0; i < num_ids; ++i )
{
if (! _tao_write_repository_id (strm, repository_ids[i]))
{
return false;
}
}
#ifndef TAO_HAS_OPTIMIMIZED_VALUETYPE_MARSHALING
}
#endif /* !TAO_HAS_OPTIMIMIZED_VALUETYPE_MARSHALING */
return true;
}
| void CORBA::ValueBase::truncation_hook | ( | ) | [virtual] |
Notify the truncated parent valuetype to skip the rest of the chunks when unmarshalling a value from its derived valuetype. This is called when the factory for the most derived valuetype (in the repository id list) does not exist and a truncated parent factory is registered.
Definition at line 1283 of file ValueBase.cpp.
{
throw ::CORBA::INTERNAL ();
}
friend class TAO_ChunkInfo [friend] |
Definition at line 127 of file ValueBase.h.
CORBA::Boolean CORBA::ValueBase::chunking_ [protected] |
This flag is set to be true when marshalling uses chunking. According to spec, the truncatable valuetype should use chunking and it can be used for marshalling large valuetype. In current implementation, we just use chunking for the truncatable valuetype.
Definition at line 234 of file ValueBase.h.
CORBA::Boolean CORBA::ValueBase::is_truncatable_ [protected] |
This flag is set to be true when the valuetype defined in the idl has the truncatable parent.
Definition at line 228 of file ValueBase.h.
1.7.0