TEST_F(TypeParserTests, TestIntPointerDataTypeParsing) {
this->setInput("*Int a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Pointer, type.kind());
ASSERT_EQ(1, type.subtypeCount());
type = type.subtypeAtIndex(0);
ASSERT_EQ(DataType::Integer, type.kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, TestCharASCIITypeParsing) {
this->setInput("Char:ascii a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Character, type.kind());
ASSERT_EQ(DataType::CharacterEncoding::ASCII, type.characterEncoding());
}
TEST_F(TypeParserTests, TestCharUTF32BETypeParsing) {
this->setInput("Char:utf32be a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Character, type.kind());
ASSERT_EQ(DataType::CharacterEncoding::UTF32BE, type.characterEncoding());
}
DataType TypeParser::parseTypePostfixes(const DataType& type) {
DataType newType(type);
if (_helper->nextIf(Token::Type::OperatorNot)) {
newType.setAccess(DataType::Access::ReadWrite);
}
if (_helper->nextIf(Token::Type::OperatorQuestionMark)) {
switch (type.kind()) {
case DataType::Kind::Pointer:
newType.setKind(DataType::Kind::NullablePointer);
break;
case DataType::Kind::GenericPointer:
newType.setKind(DataType::Kind::GenericNullablePointer);
break;
case DataType::Kind::Generic:
newType = DataType::wrapInType(DataType::Kind::GenericNullablePointer, newType);
break;
default:
newType = DataType::wrapInType(DataType::Kind::NullablePointer, newType);
break;
}
}
return newType;
}
TEST_F(TypeParserTests, TestIntDataTypeParsing) {
this->setInput("Int a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Integer, type.kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, MutableBoolean) {
this->setInput("Bool! a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Kind::Boolean, type.kind());
EXPECT_EQ(DataType::Access::ReadWrite, type.access());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, Vararg) {
this->setInput("Vararg a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Kind::Vararg, type.kind());
ASSERT_EQ(0, type.subtypeCount());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, PointerToFunction) {
this->setInput("*() -> Void a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Kind::Pointer, type.kind());
ASSERT_EQ(1, type.subtypeCount());
ASSERT_EQ(DataType::Kind::Function, type.subtypeAtIndex(0).kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, Function) {
this->setInput("() -> Void a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Function, type.kind());
ASSERT_EQ(0, type.subtypeCount());
ASSERT_EQ(DataType::Kind::Void, type.returnType().kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, TupleOfSingleInt) {
this->setInput("(Int) a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Tuple, type.kind());
ASSERT_EQ(1, type.subtypeCount());
ASSERT_EQ(DataType::Integer, type.subtypeAtIndex(0).kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, ClosureWithNonVoidReturn) {
this->setInput("{} -> Int a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Kind::Closure, type.kind());
ASSERT_EQ(0, type.subtypeCount());
ASSERT_EQ(DataType::Kind::Integer, type.returnType().kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, TestRealDataTypeParsing) {
this->setInput("Real a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Real, type.kind());
ASSERT_EQ(0, type.widthSpecifier());
ASSERT_EQ(0, type.alignmentSpecifier());
ASSERT_EQ(0, type.vectorSizeSpecifier());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, TestIntWithSizeAlignmentAndVectorDataTypeParsing) {
this->setInput("Int:16:4:4 a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Integer, type.kind());
ASSERT_EQ(16, type.widthSpecifier());
ASSERT_EQ(4, type.alignmentSpecifier());
ASSERT_EQ(4, type.vectorSizeSpecifier());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, MutablePointerToPointerToMutableBoolean) {
this->setInput("*!*Bool! a\n");
DataType type = this->typeParser()->parseType();
EXPECT_EQ(DataType::Pointer, type.kind());
EXPECT_EQ(DataType::Access::ReadWrite, type.access());
ASSERT_EQ(1, type.subtypeCount());
type = type.subtypeAtIndex(0);
EXPECT_EQ(DataType::Pointer, type.kind());
EXPECT_EQ(DataType::Access::Read, type.access());
ASSERT_EQ(1, type.subtypeCount());
type = type.subtypeAtIndex(0);
EXPECT_EQ(DataType::Boolean, type.kind());
EXPECT_EQ(DataType::Access::ReadWrite, type.access());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(ParserTests_Types, GlobalMutableBooleanPointerToMutablePointer) {
ASTNode* node = this->parseNode("*!*Bool! value\n");
node = node->childAtIndex(0);
DataType type = node->dataType();
ASSERT_EQ("Variable Declaration", node->nodeName());
ASSERT_EQ("value", node->name());
EXPECT_EQ(DataType::Pointer, type.kind());
EXPECT_EQ(DataType::Access::ReadWrite, type.access());
ASSERT_EQ(1, node->dataType().subtypeCount());
type = type.subtypeAtIndex(0);
EXPECT_EQ(DataType::Pointer, type.kind());
EXPECT_EQ(DataType::Access::Read, type.access());
ASSERT_EQ(1, type.subtypeCount());
type = type.subtypeAtIndex(0);
EXPECT_EQ(DataType::Boolean, type.kind());
EXPECT_EQ(DataType::Access::ReadWrite, type.access());
}
TEST_F(TypeParserTests, ClosureWithTupleReturn) {
this->setInput("{} -> (Int, Int) a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Kind::Closure, type.kind());
ASSERT_EQ(0, type.subtypeCount());
ASSERT_EQ(DataType::Kind::Tuple, type.returnType().kind());
ASSERT_EQ(2, type.returnType().subtypeCount());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, ClosureWithOneParam) {
this->setInput("{Int} -> Void a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Kind::Closure, type.kind());
ASSERT_EQ(0, type.subtypeCount());
ASSERT_EQ(2, type.parameterCount());
ASSERT_EQ(DataType::Integer, type.parameterAtIndex(1).kind());
ASSERT_EQ(DataType::Kind::Void, type.returnType().kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, TestSizedIntArrayDataTypeParsing) {
this->setInput("[3]Int a");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Array, type.kind());
ASSERT_EQ(3, type.arrayCount());
ASSERT_EQ(1, type.subtypeCount());
ASSERT_EQ(DataType::Integer, type.subtypeAtIndex(0).kind());
ASSERT_EQ(0, type.subtypeAtIndex(0).subtypeCount());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, FunctionWithTwoParams) {
this->setInput("(Int, Float) -> Void a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Function, type.kind());
ASSERT_EQ(2, type.parameterCount());
ASSERT_EQ(DataType::Integer, type.parameterAtIndex(0).kind());
ASSERT_EQ(DataType::Float, type.parameterAtIndex(1).kind());
ASSERT_EQ(DataType::Kind::Void, type.returnType().kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, FunctionWithOnePointerParam) {
this->setInput("(*Int) -> Void a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Function, type.kind());
ASSERT_EQ(1, type.parameterCount());
ASSERT_EQ(DataType::Pointer, type.parameterAtIndex(0).kind());
ASSERT_EQ(DataType::Integer, type.parameterAtIndex(0).subtypeAtIndex(0).kind());
ASSERT_EQ(DataType::Kind::Void, type.returnType().kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, OptionalBoolean) {
this->setInput("Bool? a\n");
DataType type = this->typeParser()->parseType();
EXPECT_EQ(DataType::NullablePointer, type.kind());
EXPECT_EQ(DataType::Access::Read, type.access());
ASSERT_EQ(1, type.subtypeCount());
EXPECT_EQ(DataType::Boolean, type.subtypeAtIndex(0).kind());
EXPECT_EQ(DataType::Access::Read, type.subtypeAtIndex(0).access());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, PointerToArrayOfIntParsing) {
this->setInput("*[5]Int a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Pointer, type.kind());
ASSERT_EQ(1, type.subtypeCount());
ASSERT_EQ(DataType::Array, type.subtypeAtIndex(0).kind());
ASSERT_EQ(1, type.subtypeAtIndex(0).subtypeCount());
ASSERT_EQ(5, type.subtypeAtIndex(0).arrayCount());
ASSERT_EQ(DataType::Integer, type.subtypeAtIndex(0).subtypeAtIndex(0).kind());
ASSERT_EQ("a", this->peek().str());
}
TEST_F(TypeParserTests, TupleOfTwoNamedInts) {
this->setInput("(Int x, Int y) a\n");
DataType type = this->typeParser()->parseType();
ASSERT_EQ(DataType::Tuple, type.kind());
ASSERT_EQ(2, type.subtypeCount());
ASSERT_EQ(DataType::Integer, type.subtypeAtIndex(0).kind());
ASSERT_EQ("x", type.subtypeAtIndex(0).label());
ASSERT_EQ(DataType::Integer, type.subtypeAtIndex(1).kind());
ASSERT_EQ("y", type.subtypeAtIndex(1).label());
ASSERT_EQ("a", this->peek().str());
}
DataType TypeParser::parseTypeSpecifiers(const DataType& type) {
if (type.kind() == DataType::Kind::Character) {
return this->parseCharacterTypeSpecifiers(type);
}
DataType newType(type);
uint32_t value = 0;
// width specifier (or, colon)
if (_helper->nextIf(Token::Type::PunctuationColon)) {
if (_helper->peek().type() != Token::Type::PunctuationColon) {
if (!this->parseIntegerSpecifierValue(&value)) {
return DataType();
}
newType.setWidthSpecifier(value);
}
}
// alignment (or, colon)
if (_helper->nextIf(Token::Type::PunctuationColon)) {
if (_helper->peek().type() != Token::Type::PunctuationColon) {
if (!this->parseIntegerSpecifierValue(&value)) {
return DataType();
}
newType.setAlignmentSpecifier(value);
}
}
// vector
if (_helper->nextIf(Token::Type::PunctuationColon)) {
if (!this->parseIntegerSpecifierValue(&value)) {
return DataType();
}
newType.setVectorSizeSpecifier(value);
}
return newType;
}
DataType
DataType_Handler::data_type (
const CORBA::TypeCode_ptr& src)
{
DANCE_TRACE("DataType_Handler::data_type");
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:
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR, "DataType_Handler::data_type - Invalid typecode\n"));
throw Config_Error ("", "Invalid typecode");
}
return type;
}
///This method takes a CIAO::Config_Handlers::DataType
///and returns the corresponding CORBA::TypeCode.
CORBA::TypeCode_ptr
DataType_Handler::data_type (const DataType& desc)
{
DANCE_TRACE("DataType_Handler::destructor");
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:
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR, "DataType_Handler::data_type - Invalid typecode in any\n"));
throw Config_Error ("", "Invalid typecode");
}
// This case used to be supported...is it not in the schema?
// case TCKind::tk_Object)
// return CORBA::TypeCode::_duplicate (CORBA::_tc_Object);*/
}
DynamicAny::DynAny_ptr
DynAny_Handler::extract_into_dynany (const DataType &type,
const DataValue &value,
CORBA::TypeCode_ptr req_tc)
{
DANCE_TRACE("DynAny_Handler::extract_into_dynany");
DynamicAny::DynAny_var retval;
if (req_tc)
retval = this->daf_->create_dyn_any_from_type_code (req_tc);
TCKind::Value tkind = type.kind ().integral ();
if ((value.count_short () && tkind != TCKind::tk_short_l) ||
(value.count_long () && tkind != TCKind::tk_long_l) ||
(value.count_ushort () && tkind != TCKind::tk_ushort_l ) ||
(value.count_ulong () && tkind != TCKind::tk_ulong_l) ||
(value.count_float () && tkind != TCKind::tk_float_l) ||
(value.count_double () && tkind != TCKind::tk_double_l) ||
(value.count_boolean () && tkind != TCKind::tk_boolean_l) ||
(value.count_octet () && tkind != TCKind::tk_octet_l) ||
(value.count_longlong () && tkind != TCKind::tk_longlong_l) ||
(value.count_ulonglong () && tkind != TCKind::tk_ulonglong_l) ||
(value.count_string () && !(tkind == TCKind::tk_string_l ||
tkind == TCKind::tk_char_l ||
tkind == TCKind::tk_wchar_l)))
{
throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Wrong value type for data type"));
}
switch (tkind)
{
// ========== BASIC TYPES
case TCKind::tk_null_l:
case TCKind::tk_void_l:
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR,
ACE_TEXT ("DynAny_Handler::extract_into_dynany - Don't know how to handle null or void types\n")));
throw Config_Error (ACE_TEXT (""),
ACE_TEXT ("Null or void types not supported"));
break;
case TCKind::tk_short_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_short);
}
CORBA::Short s = 0;
if (value.count_short ())
{
s = *(*value.begin_short ());
}
retval->insert_short (s);
}
break;
case TCKind::tk_long_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_long);
}
CORBA::Long l = 0;
if (value.count_long ())
{
l = *(*value.begin_long ());
}
retval->insert_long (l);
}
break;
case TCKind::tk_ushort_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ushort);
}
CORBA::UShort us = 0;
if (value.count_ushort ())
{
us = *(*value.begin_ushort ());
}
retval->insert_ushort (us);
}
break;
case TCKind::tk_ulong_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulong);
}
CORBA::ULong ul = 0;
if (value.count_ulong ())
{
ul = *(*value.begin_ulong ());
}
retval->insert_ulong (ul);
}
break;
case TCKind::tk_float_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_float);
}
CORBA::Float f = 0.0f;
if (value.count_float ())
{
f = *(*value.begin_float ());
}
retval->insert_float (f);
}
break;
case TCKind::tk_double_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_double);
}
CORBA::Double d = 0.0;
if (value.count_double ())
{
d = *(*value.begin_double ());
}
retval->insert_double (d);
}
break;
case TCKind::tk_boolean_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_boolean);
}
CORBA::Boolean b = false;
if (value.count_boolean ())
{
b = *(*value.begin_boolean ());
}
retval->insert_boolean (b);
}
break;
case TCKind::tk_octet_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_octet);
}
CORBA::Octet o = 0;
if (value.count_octet ())
{
o = *(*(value.begin_octet ()));
}
retval->insert_octet (o);
}
break;
case TCKind::tk_longlong_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_longlong);
}
CORBA::LongLong ll = 0;
if (value.count_longlong ())
{
ll = *(*value.begin_longlong ());
}
retval->insert_longlong (ll);
}
break;
case TCKind::tk_ulonglong_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulonglong);
}
CORBA::ULongLong ull = 0;
if (value.count_ulonglong ())
{
ull = *(*value.begin_ulonglong ());
}
retval->insert_ulonglong (ull);
}
break;
case TCKind::tk_string_l:
return DynString_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_char_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_char);
}
CORBA::Char c = 0;
if (value.count_string ())
{
c = *(*value.begin_string ())->c_str ();
}
retval->insert_char (c);
}
break;
case TCKind::tk_wchar_l:
{
if (!req_tc)
{
retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_wchar);
}
CORBA::WChar wc = 0;
if (value.count_string ())
{
wc = *(*value.begin_string ())->c_str ();
}
retval->insert_wchar (wc);
}
break;
case TCKind::tk_enum_l:
return DynEnum_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_sequence_l:
return DynSequence_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_struct_l:
return DynStruct_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_alias_l:
return DynAlias_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_array_l:
return DynArray_Handler::extract_into_dynany (type, value, req_tc);
case TCKind::tk_longdouble_l:
// Not supported since a longdouble is defined in the xsd as double.
// We are then creating a long double initialized with a regular
// double. This is a very tricky conversion and doesn't work in
// combination with certain (versions of) compilers.
case TCKind::tk_wstring_l:
case TCKind::tk_fixed_l:
case TCKind::tk_any_l:
case TCKind::tk_TypeCode_l:
case TCKind::tk_Principal_l:
case TCKind::tk_objref_l:
case TCKind::tk_union_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:
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR,
DLINFO ACE_TEXT ("DynAny_Handler::extract_into_dynany - Type not supported\n")));
throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Type not supported"));
}
return retval._retn ();
}
CORBA::TypeCode_ptr
DynAny_Handler::create_typecode (const DataType &type)
{
DANCE_TRACE("DynAny_Handler::create_typecode");
switch (type.kind ().integral ())
{
// ========== BASIC TYPES
case TCKind::tk_null_l:
case TCKind::tk_void_l:
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_WARNING,
ACE_TEXT ("I don't know how to handle null or void types\n")));
throw Config_Error (ACE_TEXT (""),
ACE_TEXT ("Null or void types not supported"));
break;
case TCKind::tk_short_l:
return CORBA::_tc_short;
case TCKind::tk_long_l:
return CORBA::_tc_long;
case TCKind::tk_ushort_l:
return CORBA::_tc_ushort;
case TCKind::tk_ulong_l:
return CORBA::_tc_ulong;
case TCKind::tk_float_l:
return CORBA::_tc_float;
case TCKind::tk_double_l:
return CORBA::_tc_double;
case TCKind::tk_boolean_l:
return CORBA::_tc_boolean;
case TCKind::tk_char_l:
return CORBA::_tc_char;
case TCKind::tk_octet_l:
return CORBA::_tc_octet;
case TCKind::tk_string_l:
return DynString_Handler::create_typecode (type);
case TCKind::tk_longlong_l:
return CORBA::_tc_longlong;
case TCKind::tk_ulonglong_l:
return CORBA::_tc_ulonglong;
case TCKind::tk_longdouble_l:
// Disabled since a longdouble is defined in the xsd as double.
// We are then creating a long double initialized from a regular
// double. This is a very tricky conversion and doesn't work in
// combination with certain (versions of) compilers.
break;
case TCKind::tk_wchar_l:
return CORBA::_tc_wchar;
case TCKind::tk_wstring_l:
break;
case TCKind::tk_enum_l:
return DynEnum_Handler::create_typecode (type);
case TCKind::tk_struct_l:
return DynStruct_Handler::create_typecode (type);
case TCKind::tk_sequence_l:
return DynSequence_Handler::create_typecode (type);
case TCKind::tk_alias_l:
return DynAlias_Handler::create_typecode (type);
case TCKind::tk_array_l:
return DynArray_Handler::create_typecode (type);
case TCKind::tk_fixed_l:
case TCKind::tk_any_l:
case TCKind::tk_TypeCode_l:
case TCKind::tk_Principal_l:
case TCKind::tk_objref_l:
case TCKind::tk_union_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:
DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR, DLINFO ACE_TEXT ("DynAny_Handler::create_typecode - Type not supported\n")));
throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Type not supported"));
}
return 0;
}
