CORBA::Boolean
Any_Basic_Impl::extract (const CORBA::Any &any,
CORBA::TypeCode_ptr tc,
void *_tao_elem)
{
try
{
CORBA::TypeCode_ptr any_tc = any._tao_get_typecode ();
CORBA::Boolean const _tao_equiv = any_tc->equivalent (tc);
if (!_tao_equiv)
{
return false;
}
TAO::Any_Impl * const impl = any.impl ();
if (impl && !impl->encoded ())
{
TAO::Any_Basic_Impl * const narrow_impl =
dynamic_cast<TAO::Any_Basic_Impl *> (impl);
if (narrow_impl == 0)
{
return false;
}
Any_Basic_Impl::assign_value (_tao_elem, narrow_impl);
return true;
}
TAO::Any_Basic_Impl *replacement =
TAO::Any_Basic_Impl::create_empty (any_tc);
auto_ptr<TAO::Any_Basic_Impl> replacement_safety (replacement);
// We know this will work since the unencoded case is covered above.
TAO::Unknown_IDL_Type * const unk =
dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
if (!unk)
return false;
// Get the kind of the type where we are extracting in ie. the
// aliased type if there are any. Passing the aliased kind
// will not help.
CORBA::TCKind const tck = tc->kind ();
// We don't want the rd_ptr of unk to move, in case it is
// shared by another Any. This copies the state, not the buffer.
TAO_InputCDR for_reading (unk->_tao_get_cdr ());
CORBA::Boolean const good_decode =
replacement->demarshal_value (for_reading,
static_cast<CORBA::Long> (tck));
if (good_decode)
{
Any_Basic_Impl::assign_value (_tao_elem,
replacement,
tck);
const_cast<CORBA::Any &> (any).replace (replacement);
replacement_safety.release ();
return true;
}
// Duplicated by Any_Impl base class constructor.
::CORBA::release (any_tc);
}
catch (const ::CORBA::Exception&)
{
}
return false;
}
CORBA::Boolean
TAO::Any_Array_Impl_T<T_slice, T_forany>::extract (const CORBA::Any & any,
_tao_destructor destructor,
CORBA::TypeCode_ptr tc,
T_slice *& _tao_elem)
{
_tao_elem = 0;
try
{
CORBA::TypeCode_ptr any_tc = any._tao_get_typecode ();
CORBA::Boolean const _tao_equiv = any_tc->equivalent (tc);
if (_tao_equiv == false)
{
return false;
}
TAO::Any_Impl *impl = any.impl ();
if (!impl->encoded ())
{
TAO::Any_Array_Impl_T<T_slice, T_forany> *narrow_impl =
dynamic_cast <TAO::Any_Array_Impl_T <T_slice, T_forany> *> (impl);
if (narrow_impl == 0)
{
return false;
}
_tao_elem = reinterpret_cast <T_slice*> (narrow_impl->value_);
return true;
}
TAO::Any_Array_Impl_T<T_slice, T_forany> *replacement = 0;
typedef TAO::Any_Array_Impl_T<T_slice, T_forany> ARRAY_ANY_IMPL;
ACE_NEW_RETURN (replacement,
ARRAY_ANY_IMPL (destructor,
any_tc,
T_forany::tao_alloc ()),
false);
#if defined (ACE_HAS_CPP11)
std::unique_ptr<TAO::Any_Array_Impl_T<T_slice, T_forany> > replacement_safety (replacement);
#else
auto_ptr<TAO::Any_Array_Impl_T<T_slice, T_forany> > replacement_safety (replacement);
#endif /* ACE_HAS_CPP11 */
// We know this will work since the unencoded case is covered above.
TAO::Unknown_IDL_Type * const unk =
dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
if (!unk)
return false;
// We don't want the rd_ptr of unk to move, in case it is
// shared by another Any. This copies the state, not the buffer.
TAO_InputCDR for_reading (unk->_tao_get_cdr ());
CORBA::Boolean const good_decode =
replacement->demarshal_value (for_reading);
if (good_decode)
{
_tao_elem = reinterpret_cast <T_slice*> (replacement->value_);
const_cast<CORBA::Any &> (any).replace (replacement);
replacement_safety.release ();
return true;
}
// Duplicated by Any_Impl base class constructor.
::CORBA::release (any_tc);
}
catch (const ::CORBA::Exception&)
{
}
return false;
}
CORBA::Boolean
TAO::Any_Impl_T<T>::extract (const CORBA::Any & any,
_tao_destructor destructor,
CORBA::TypeCode_ptr tc,
T *& _tao_elem)
{
_tao_elem = 0;
try
{
CORBA::TypeCode_ptr any_tc = any._tao_get_typecode ();
CORBA::Boolean const _tao_equiv = any_tc->equivalent (tc);
if (_tao_equiv == false)
{
return false;
}
TAO::Any_Impl * const impl = any.impl ();
if (impl && !impl->encoded ())
{
TAO::Any_Impl_T<T> * const narrow_impl =
dynamic_cast <TAO::Any_Impl_T<T> *> (impl);
if (narrow_impl == 0)
{
return false;
}
_tao_elem = (T *) narrow_impl->value_;
return true;
}
TAO::Any_Impl_T<T> *replacement = 0;
ACE_NEW_RETURN (replacement,
TAO::Any_Impl_T<T> (destructor,
any_tc,
0),
false);
auto_ptr<TAO::Any_Impl_T<T> > replacement_safety (replacement);
// We know this will work since the unencoded case is covered above.
TAO::Unknown_IDL_Type * const unk =
dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
if (!unk)
return false;
// We don't want the rd_ptr of unk to move, in case it is
// shared by another Any. This copies the state, not the buffer.
TAO_InputCDR for_reading (unk->_tao_get_cdr ());
CORBA::Boolean const good_decode =
replacement->demarshal_value (for_reading);
if (good_decode)
{
_tao_elem = const_cast<T *> (replacement->value_);
const_cast<CORBA::Any &> (any).replace (replacement);
replacement_safety.release ();
return true;
}
// Duplicated by Any_Impl base class constructor.
::CORBA::release (any_tc);
}
catch (const ::CORBA::Exception&)
{
}
return false;
}
