CORBA::Boolean CORBA::ValueBase::_tao_write_repository_id (TAO_OutputCDR &strm, ACE_CString& id) { #ifdef TAO_HAS_VALUETYPE_OUT_INDIRECTION VERIFY_MAP (TAO_OutputCDR, repo_id_map, Repo_Id_Map); 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 false; } CORBA::Long offset= -strm.offset (pos); if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l 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 (); } if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l 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 TAO_ChunkInfo::reserve_chunk_size(TAO_OutputCDR &strm) { // This is called in the start_chunk(). // Reserve the chunk size the first time the start_chunk () is called // if there are several start_chunk () called continuously without // calling end_chunk (). This could happen in the _tao_marshal_state() // in the most derived valuetype. if (this->chunk_size_pos_ == 0) { // Align the wr_ptr before we reserve the space for chunk size. strm.align_write_ptr (ACE_CDR::LONG_SIZE); // Remember begin of the chunk (at chunk size position) that is needed // when we write back actual chunk size to the stream. this->chunk_size_pos_ = strm.current ()->wr_ptr (); // Insert four bytes here as a place-holder, we need to go back // later and write the actual size. if (! strm.write_long (0)) { return 0; } // Remember length before writing chunk data. This is used to calculate // the actual size of the chunk. this->length_to_chunk_octets_pos_ = strm.total_length (); } return 1; }
// this method is called by the IDL generated _tao_marshal_state() method. CORBA::Boolean TAO_ChunkInfo::end_chunk(TAO_OutputCDR &strm) { if (this->chunking_) { // Write actual chunk size at the reserved chunk size place. if (! this->write_previous_chunk_size(strm)) { return false; } // Write an end tag which is negation of value_nesting_level_. if (! strm.write_long(- this->value_nesting_level_)) { return false; } // -- this->value_nesting_level_; if ( -- this->value_nesting_level_ == 0 ) { // ending chunk for outermost value this->chunking_ = 0; } } return true; }
CORBA::Boolean operator<< (TAO_OutputCDR & cdr, CORBA::Principal * x) { if (x != 0) { CORBA::ULong length = x->id.length (); cdr.write_long (length); cdr.write_octet_array (x->id.get_buffer (), length); } else { cdr.write_ulong (0); } return (CORBA::Boolean) cdr.good_bit (); }
static int test_write (TAO_OutputCDR &cdr, int n) { CORBA::Long l = 0xdeadbeef; for (int i = 0; i < n; ++i) { if (cdr.write_long (l) == 0) ACE_ERROR_RETURN ((LM_ERROR, "write_long[%d] failed\n", i), 1); } return 0; }
CORBA::Boolean CORBA::ValueBase::_tao_write_value_header (TAO_OutputCDR &strm, ptrdiff_t formal_type_id) const { #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; }
CORBA::Boolean CORBA::ValueBase::_tao_write_special_value (TAO_OutputCDR &strm, const CORBA::ValueBase *value) { // 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) { TAOLIB_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) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_write_special_value, indirection %d=%x\n"), offset, (void *)(strm.current()->wr_ptr () + 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) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_marshal, bound value %x=%x\n"), value, strm.current()->wr_ptr())); } return false; } #endif return false; } }