diff options
Diffstat (limited to 'modules/CIAO/tools/Config_Handlers/DynAny_Handler')
7 files changed, 728 insertions, 0 deletions
diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp new file mode 100644 index 00000000000..77567e3739c --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp @@ -0,0 +1,180 @@ +//$Id$ + +#include "DataType_Handler.h" +#include "tao/AnyTypeCode/TypeCode.h" + +namespace CIAO{ + + namespace Config_Handlers{ + + DataType_Handler::DataType_Handler (void) + { + } + DataType_Handler::~DataType_Handler (void) + { + } + + ///This method takes a <CIAO::Config_Handlers::DataType> + ///and returns the corresponding CORBA::TypeCode. + CORBA::TypeCode_ptr + DataType_Handler::data_type (const DataType& desc) + { + + TCKind kind (desc.kind ()); + + switch (kind.integral ()) + { + case TCKind::tk_null_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_null); + + + case TCKind::tk_short_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_short); + + + case TCKind::tk_long_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_long); + + + case TCKind::tk_ushort_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_ushort); + + + case TCKind::tk_ulong_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_ulong); + + + case TCKind::tk_float_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_float); + + + case TCKind::tk_double_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_double); + + + case TCKind::tk_boolean_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_boolean); + + + case TCKind::tk_char_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_char); + + + case TCKind::tk_octet_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_octet); + + + case TCKind::tk_string_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_string); + + + case TCKind::tk_longlong_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_longlong); + + + case TCKind::tk_ulonglong_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_ulonglong); + + + case TCKind::tk_longdouble_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_longdouble); + + + case TCKind::tk_wchar_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_wchar); + + + case TCKind::tk_wstring_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_wstring); + + + case TCKind::tk_any_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_any); + + + case TCKind::tk_TypeCode_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_TypeCode); + + + default: + ACE_ERROR ((LM_ERROR, "Invalid typecode in any\n")); + throw 1; + } + + // This case used to be supported...is it not in the schema? + // case TCKind::tk_Object) + // return CORBA::TypeCode::_duplicate (CORBA::_tc_Object);*/ + + } + + DataType + DataType_Handler::data_type ( + const CORBA::TypeCode_ptr& src) + { + DataType type; + + switch (src->kind ()) + { + case ::CORBA::tk_null: + type.kind (TCKind::tk_null); + break; + case CORBA::tk_short: + type.kind (TCKind::tk_short); + break; + case CORBA::tk_long: + type.kind (TCKind::tk_long); + break; + case CORBA::tk_ushort: + type.kind (TCKind::tk_ushort); + break; + case CORBA::tk_ulong: + type.kind (TCKind::tk_ulong); + break; + case CORBA::tk_float: + type.kind (TCKind::tk_float); + break; + case CORBA::tk_double: + type.kind (TCKind::tk_double); + break; + case CORBA::tk_boolean: + type.kind (TCKind::tk_boolean); + break; + case CORBA::tk_char: + type.kind (TCKind::tk_char); + break; + case CORBA::tk_octet: + type.kind (TCKind::tk_octet); + break; + case CORBA::tk_string: + type.kind (TCKind::tk_string); + break; + case CORBA::tk_longlong: + type.kind (TCKind::tk_longlong); + break; + case CORBA::tk_ulonglong: + type.kind (TCKind::tk_ulonglong); + break; + case CORBA::tk_longdouble: + type.kind (TCKind::tk_longdouble); + break; + case CORBA::tk_wchar: + type.kind (TCKind::tk_wchar); + break; + case CORBA::tk_wstring: + type.kind (TCKind::tk_wstring); + break; + case CORBA::tk_any: + type.kind (TCKind::tk_any); + break; + case CORBA::tk_TypeCode: + type.kind (TCKind::tk_TypeCode); + default: + ACE_ERROR ((LM_ERROR, "Invalid typecode\n")); + throw 1; + } + + return type; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h new file mode 100644 index 00000000000..c16b4b21fe3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h @@ -0,0 +1,60 @@ +//================================================ +/** + * @file DataType_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef DATATYPE_HANDLER_H +#define DATATYPE_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "ciao/DeploymentC.h" +#include "Basic_Deployment_Data.hpp" + + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace CIAO{ + + namespace Config_Handlers{ + + /* + * @class DataType_Handler + * + * @brief Handler class for <ComponentPortDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + + class DataType_Handler{ + + public: + + DataType_Handler (void); + virtual ~DataType_Handler (void); + + ////This method takes a <CIAO::Config_Handlers::DataType> + ///and returns the corresponding CORBA::TypeCode. + static void + data_type (CORBA::TypeCode_ptr& type, + const DataType& desc); + + static DataType data_type (const CORBA::TypeCode_ptr& type); + }; + + } +} + +#include /**/ "ace/post.h" +#endif /* DATATYPE_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp new file mode 100644 index 00000000000..64690ad61c1 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp @@ -0,0 +1,241 @@ +// $Id$ + +#include /**/ "ace/pre.h" + +#include "DynAny_Handler.h" +#include "DynEnum_Handler.h" +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + DynAny_Handler::DynAny_Handler (void) : + orb_ (0), + daf_ (0) + { + int argc = 0; + char **argv = 0; + + orb_ = CORBA::ORB_init (argc, argv); + + CORBA::Object_var temp = orb_->resolve_initial_references ("DynAnyFactory"); + daf_ = DynamicAny::DynAnyFactory::_narrow (temp.in ()); + + if (CORBA::is_nil (daf_.in ())) + { + ACE_ERROR ((LM_ERROR, "Unable to narrow Dynamic Any factory\n")); + throw 1; + } + } + + DynAny_Handler::~DynAny_Handler (void) + { + } + + CORBA::ORB_ptr + DynAny_Handler::orb () + { + return orb_.in (); + } + + DynamicAny::DynAnyFactory_ptr + DynAny_Handler::daf () + { + return daf_.in (); + } + + DynamicAny::DynAny_ptr + DynAny_Handler::extract_into_dynany (const DataType& type, + const DataValue& value) + { + DynamicAny::DynAny_var retval; + + switch (type.kind ().integral ()) + { + // ========== BASIC TYPES + case TCKind::tk_null_l: + case TCKind::tk_void_l: + ACE_ERROR ((LM_WARNING, "I don't know how to handle null or void types\n")); + + case TCKind::tk_short_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_short); + retval->insert_short (CORBA::Short (static_cast < ::XMLSchema::short_ const & > (*value.begin_short ()))); + break; + + case TCKind::tk_long_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_long); + retval->insert_long (CORBA::Long (static_cast < ::XMLSchema::int_ const& > (*value.begin_long ()))); + break; + + case TCKind::tk_ushort_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ushort); + retval->insert_ushort (CORBA::UShort (static_cast< ::XMLSchema::unsignedShort const & > (*value.begin_ushort ()))); + break; + + case TCKind::tk_ulong_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulong); + retval->insert_ulong (CORBA::ULong (static_cast < ::XMLSchema::unsignedInt const& > (*value.begin_ulong ()))); + break; + + case TCKind::tk_float_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_float); + retval->insert_float (CORBA::Float (*value.begin_float ())); + break; + + case TCKind::tk_double_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_double); + retval->insert_double (CORBA::Double (*value.begin_double ())); + break; + + case TCKind::tk_boolean_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_boolean); + retval->insert_boolean (static_cast < ::XMLSchema::boolean const& > (*value.begin_boolean ())); + break; + + case TCKind::tk_char_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_char); + retval->insert_char (CORBA::Char (*value.begin_string ()->c_str ())); + break; + + case TCKind::tk_octet_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_octet); + retval->insert_octet (static_cast <const unsigned char &> (*value.begin_octet ())); + break; + + case TCKind::tk_string_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_string); + retval->insert_string (value.begin_string ()->c_str ()); + break; + + case TCKind::tk_longlong_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_longlong); + retval->insert_longlong (CORBA::LongLong (static_cast < ::XMLSchema::long_ const& > (*value.begin_longlong ()))); + break; + + case TCKind::tk_ulonglong_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulonglong); + retval->insert_ulonglong (CORBA::ULongLong (static_cast < ::XMLSchema::unsignedLong const& > (*value.begin_ulonglong ()))); + break; + + case TCKind::tk_longdouble_l: + break; + + case TCKind::tk_wchar_l: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_wchar); + retval->insert_wchar (CORBA::WChar (*value.begin_string ()->c_str ())); + break; + + case TCKind::tk_wstring_l: + break; + + case TCKind::tk_enum_l: + ACE_ERROR ((LM_ERROR, "Preparing to extract into enum\n")); + return DynEnum_Handler::extract_into_dynany (type, value); + + case TCKind::tk_wfixed_l: + case TCKind::tk_any_l: + case TCKind::tk_TypeCode_l: + case TCKind::tk_Principal_l: + case TCKind::tk_objref_l: + case TCKind::tk_struct_l: + case TCKind::tk_union_l: + case TCKind::tk_sequence_l: + case TCKind::tk_array_l: + case TCKind::tk_alias_l: + case TCKind::tk_except_l: + case TCKind::tk_value_l: + case TCKind::tk_value_box_l: + case TCKind::tk_native_l: + case TCKind::tk_abstract_interface_l: + case TCKind::tk_local_interface_l: + case TCKind::tk_component_l: + case TCKind::tk_home_l: + case TCKind::tk_event_l: + ACE_ERROR ((LM_ERROR, "Type not supported\n")); + throw 1; + } + + return retval._retn (); + } + + Any + DynAny_Handler::extract_from_dynany (const CORBA::Any &any) + { + DynamicAny::DynAny_var dyn = this->daf_->create_dyn_any (any); + + DataValue val; + + switch (dyn->type ()->kind ()) + { + case CORBA::tk_short: + val.add_short (dyn->get_short ()); + return Any (TCKind::tk_short, val); + + case CORBA::tk_long: + val.add_long (dyn->get_long ()); + return Any (TCKind::tk_long, val); + + case CORBA::tk_ushort: + val.add_ushort (dyn->get_ushort ()); + return Any (TCKind::tk_ushort, val); + + case CORBA::tk_ulong: + val.add_ulong (dyn->get_ulong ()); + return Any (TCKind::tk_ulong, val); + + case CORBA::tk_float: + val.add_float (dyn->get_float ()); + return Any (TCKind::tk_float, val); + + case CORBA::tk_double: + val.add_double (dyn->get_double ()); + return Any (TCKind::tk_double, val); + + case CORBA::tk_boolean: + val.add_boolean (dyn->get_boolean ()); + return Any (TCKind::tk_boolean, val); + + case CORBA::tk_octet: + val.add_octet (dyn->get_octet ()); + return Any (TCKind::tk_octet, val); + + case CORBA::tk_string: + val.add_string (dyn->get_string ()); + return Any (TCKind::tk_string, val); + + case CORBA::tk_longlong: + val.add_longlong (dyn->get_longlong ()); + return Any (TCKind::tk_longlong, val); + + case CORBA::tk_ulonglong: + val.add_ulonglong (dyn->get_ulonglong ()); + return Any (TCKind::tk_ulonglong, val); + + case CORBA::tk_longdouble: + // return Any (TCKind::tk_longdouble); + // @@MAJO: Need to add longdouble to schema. + //val.add_longdouble (dyn->get_longdouble ()); + + case CORBA::tk_wchar: + // return Any (TCKind::tk_wchar); + // @@MAJO: Need to add wchar to schema + // val.add_wchar (dyn->get_wchar ()); + case CORBA::tk_char: + // return Any (TCKind::tk_char); + // @@MAJO: Need to add char into the schema. + // val.add_char (dyn->get_char ()); + + case CORBA::tk_wstring: + case CORBA::tk_any: + case CORBA::tk_TypeCode: + case ::CORBA::tk_null: + default: + ACE_ERROR ((LM_ERROR, "DynAny_Handler: I have no idea how to perform a referse mapping.\n")); + throw 1; + } + + } + } +} +#include /**/ "ace/post.h" diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h new file mode 100644 index 00000000000..a209b3eae2c --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h @@ -0,0 +1,72 @@ +//============================================================== +/** + * @file DynAny_Handler.h + * + * $Id$ + * + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_DYNANY_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNANY_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" + +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" +#include "ace/Singleton.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class Any_Handler + * + * @brief Handler class for <ComponentInterfaceDescription> types. + * + * This class defines handler methods to map values from + * XSC Any objects, parsed from the descriptor files, to the + * corresponding CORBA IDL Any type. + * + */ + class DynAny_Handler_Export DynAny_Handler + { + public: + DynAny_Handler (); + + ~DynAny_Handler (void); + + DynamicAny::DynAny_ptr extract_into_dynany (const DataType& type, + const DataValue& value); + + Any extract_from_dynany (const CORBA::Any &any); + + CORBA::ORB_ptr orb (); + + DynamicAny::DynAnyFactory_ptr daf (); + + private: + + CORBA::ORB_var orb_; + + DynamicAny::DynAnyFactory_var daf_; + }; + + typedef ACE_Singleton<DynAny_Handler, ACE_Null_Mutex> DynAny_Singleton; + #define DYNANY_HANDLER DynAny_Singleton::instance() + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ANY_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h new file mode 100644 index 00000000000..78a3ee57b77 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl DynAny_Handler +// ------------------------------ +#ifndef DYNANY_HANDLER_EXPORT_H +#define DYNANY_HANDLER_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (DYNANY_HANDLER_HAS_DLL) +# define DYNANY_HANDLER_HAS_DLL 1 +#endif /* ! DYNANY_HANDLER_HAS_DLL */ + +#if defined (DYNANY_HANDLER_HAS_DLL) && (DYNANY_HANDLER_HAS_DLL == 1) +# if defined (DYNANY_HANDLER_BUILD_DLL) +# define DynAny_Handler_Export ACE_Proper_Export_Flag +# define DYNANY_HANDLER_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define DYNANY_HANDLER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* DYNANY_HANDLER_BUILD_DLL */ +# define DynAny_Handler_Export ACE_Proper_Import_Flag +# define DYNANY_HANDLER_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define DYNANY_HANDLER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* DYNANY_HANDLER_BUILD_DLL */ +#else /* DYNANY_HANDLER_HAS_DLL == 1 */ +# define DynAny_Handler_Export +# define DYNANY_HANDLER_SINGLETON_DECLARATION(T) +# define DYNANY_HANDLER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* DYNANY_HANDLER_HAS_DLL == 1 */ + +// Set DYNANY_HANDLER_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (DYNANY_HANDLER_NTRACE) +# if (ACE_NTRACE == 1) +# define DYNANY_HANDLER_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define DYNANY_HANDLER_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !DYNANY_HANDLER_NTRACE */ + +#if (DYNANY_HANDLER_NTRACE == 1) +# define DYNANY_HANDLER_TRACE(X) +#else /* (DYNANY_HANDLER_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define DYNANY_HANDLER_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (DYNANY_HANDLER_NTRACE == 1) */ + +#endif /* DYNANY_HANDLER_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp new file mode 100644 index 00000000000..8773f7b9014 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp @@ -0,0 +1,72 @@ +// $Id$ + +#include "DynEnum_Handler.h" +#include "DynAny_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "tao/AnyTypeCode/TypeCode.h" +#include "tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h" +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "tao/AnyTypeCode/Enum_TypeCode.h" +#include "tao/IFR_Client/IFR_BasicC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + DynamicAny::DynAny_ptr + DynEnum_Handler::extract_into_dynany (const DataType &type, + const DataValue &value) + { + if (!type.enum_p ()) + { + ACE_ERROR ((LM_ERROR, "ERROR: Enum type descriptioin required")); + throw 1; + } + + // Construct TypeCode for the enum + CORBA::EnumMemberSeq members; + members.length (type.enum_ ().count_member ()); + CORBA::ULong index (0); + + for (EnumType::member_const_iterator i = type.enum_ ().begin_member (); + i != type.enum_ ().end_member (); + ++i) + { + members[index++] = i->c_str (); + } + + // Grab pointer to the DynAny_Handler to use the orb and any factory. + // DynAny_Handler *dah = DynAny_Handler::instance (); + + // @@ Leak this guy onto the heap to avoid a compile problem. + CORBA::TypeCode_ptr tc = + DYNANY_HANDLER->orb ()->create_enum_tc (type.enum_ ().typeId ().c_str (), + type.enum_ ().name ().c_str (), + members); + + ACE_ERROR ((LM_ERROR, "Type: %s \nName: %s\nvalue: %s\n", + type.enum_ ().typeId ().c_str (), + type.enum_ ().name ().c_str (), + value.begin_enum ()->c_str ())); + + // Make the actual DynEnum + DynamicAny::DynAny_var temp = + DYNANY_HANDLER->daf ()->create_dyn_any_from_type_code (tc); + DynamicAny::DynEnum_var retval = DynamicAny::DynEnum::_narrow (temp.in ()); + + retval->set_as_string (value.begin_enum ()->c_str ()); + + return retval._retn (); + } + + void + DynEnum_Handler::extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn) + { + ACE_UNUSED_ARG (dyn); + ACE_ERROR ((LM_ERROR, "Extracting Enums not yet supported\n")); + } + } +} + + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h new file mode 100644 index 00000000000..009b8b37659 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h @@ -0,0 +1,49 @@ +/** + * $Id$ + * + * @file DynEnum_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ + +#ifndef CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" + +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class DynEnum_Handler + * @brief Translates enums specified in deployment plans into Dynamic Anys + * + */ + class DynEnum_Handler + { + public: + static DynamicAny::DynAny_ptr extract_into_dynany (const DataType &type, + const DataValue &value); + + static void extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn); + }; + + } +} + + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H*/ + |