it_print_any.cxx

这是经典的CORBA程序

// ******************************************************************
//
//
//	  Copyright (c) 1993-2003 IONA Technologies PLC.
//			 All Rights Reserved.
//
//
// ******************************************************************


#include <assert.h>
#include <orbix/print_any.h>
#include <it_cal/iostream.h>

IT_USING_NAMESPACE_STD


IT_PrintAny::IT_PrintAny(
    const CORBA::Any& any,
    CORBA::ORB_ptr orb,
    int indent,
    const char* indent_string
) : m_any(any),
    m_orb(CORBA::ORB::_duplicate(orb)),
    m_indent(indent),
    m_indent_string(indent_string)
{
    // Empty.
}


// operator << -- ostream operator for IT_PrintAny.
// 
ostream&
operator <<(
    ostream& out,
    const IT_PrintAny& print_any
)
{
    IT_AnyPrinter printer(
        print_any.m_orb,
        print_any.m_indent_string
    );
    printer.print_any_contents(out, print_any.m_any, print_any.m_indent);
    return out;
}


IT_AnyPrinter::IT_AnyPrinter(
    CORBA::ORB_ptr orb,
    const char* indent_string
) :
    m_factory(DynamicAny::DynAnyFactory::_nil()),
    m_indent_string(CORBA::string_dup(indent_string))
{
    try 
    {
        CORBA::Object_var obj = 
            orb->resolve_initial_references("DynAnyFactory");
        m_factory = DynamicAny::DynAnyFactory::_narrow(obj);
    }
    catch (const CORBA::Exception&)
    {
        // Ignore errors here, check before use.
    }
    if (m_indent_string.in() == 0)
    {
        m_indent_string = CORBA::string_dup("    ");
    }
}


IT_AnyPrinter::~IT_AnyPrinter()
{
    // Deliberately emtpy.
}

// unalias_tc -- strip away layers of aliasing to find the underlying typecode.
// 
static CORBA::TypeCode_ptr
unalias_tc(
    CORBA::TypeCode_ptr original_tc
)
{
    CORBA::TypeCode_var tc = CORBA::TypeCode::_duplicate(original_tc);
    while (tc->kind() == CORBA::tk_alias)
    {
        tc = tc->content_type();
    }
    return tc._retn();
}


// print_any_contents -- print the contents of an any.
// 
void
IT_AnyPrinter::print_any_contents(
    ostream& out,
    const CORBA::Any& any,
    int ind
)
{
    if (print_simple_any_contents(out, any))
    {
        return;
    }

    // Check for case where an any contains an any.
    // REVISIT aconway 14 Dec 1999 -- should use const extraction operator
    // but const operator is missing in bl118 (bug 53975)
    // 
    CORBA::Any* inner_any;      // Should be const CORBA::Any*
    if (any >>= inner_any)
    {
        print_any(out, *inner_any, ind);
        return;
    }

    // We need to use a DynAny
    // 
    CORBA::TypeCode_var original_tc = any.type();
    if (CORBA::is_nil(m_factory))
    {
        out << "<ERROR: No DynAnyFactory, cannot print ";
        print_typecode(out, original_tc);
        out << ".>";
        return;
    }

    try 
    {
        DynamicAny::DynAny_var da = m_factory->create_dyn_any(any);

        DynamicAny::DynStruct_var ds = DynamicAny::DynStruct::_narrow(da);
        if (!CORBA::is_nil(ds))
        {
            print_dyn_struct(out, ds, ind);
            return;
        }

        DynamicAny::DynUnion_var du = DynamicAny::DynUnion::_narrow(da);
        if (!CORBA::is_nil(du))
        {
            print_dyn_union(out, du, ind);
            return;
        }

        DynamicAny::DynEnum_var de = DynamicAny::DynEnum::_narrow(da);
        if(!CORBA::is_nil(de))
        {
            print_dyn_enum(out, de, ind);
            return;
        }

        DynamicAny::DynSequence_var dseq= DynamicAny::DynSequence::_narrow(da);
        if (!CORBA::is_nil(dseq))
        {
            print_dyn_sequence(out, dseq, ind);
            return;
        }

        DynamicAny::DynArray_var darr = DynamicAny::DynArray::_narrow(da);
        if (!CORBA::is_nil(darr))
        {
            print_dyn_array(out, darr, ind);
            return;
        }

        DynamicAny::DynValue_var dv = DynamicAny::DynValue::_narrow(da);
        if(!CORBA::is_nil(dv))
        {
            print_dyn_value(out, dv, ind);
            return;
        }

        DynamicAny::DynValueBox_var dvb = DynamicAny::DynValueBox::_narrow(da);
        if(!CORBA::is_nil(dvb))
        {
            print_dyn_value_box(out, dvb, ind);
            return;
        }


        // If we get here we don't know how to print it, invoke the
        // catch block.
        //
        throw CORBA::BAD_PARAM();
    }
    catch (const CORBA::Exception& ex)
    {
        indent(out, ind) << "<ERROR:Cannot print " ;
        print_typecode(out, original_tc);
        out <<  ", "  << ex << ".>" << endl;
        return;
    }
}


void
IT_AnyPrinter::print_boolean(
    ostream& out,
    CORBA::Boolean value,
    int                         // indent parameter, ignored.
)
{
    out << (value ? "true" : "false");
}

void
IT_AnyPrinter::print_char(
    ostream& out,
    CORBA::Char value,
    int                         // indent parameter, ignored.
)
{
    out << "'" << value << "'";
}


// wchar_to_string -- convert a wchar to a \xhhhh escape sequence.
// 
static IT_String
wchar_to_string(
    CORBA::WChar value
)
{
    // REVISIT aconway 10 Dec 1999 -- proper handling for wchars.
    // This is a quick and dirty way to dump wchars to an ostream.
    // Proper handling probably requires ISO C++ and wostream
    // versions of all the print_ functions.
    // 
    if (value == 0)
    {
        return IT_String("\\0");
    }
    else 
    {
        IT_String result("\\x");
        for ( ; value != 0; value >>= 4)
        {
            char digit = char(value & 0xf);
            digit = (digit < 10) ? (digit + '0') : (digit - 10 + 'a');
            result.insert(2, 1, digit);
        }
        return result;
    }
}


void
IT_AnyPrinter::print_wchar(
    ostream& out,
    CORBA::WChar value,
    int                         // indent parameter, ignored.
)
{
    out << "L'" << wchar_to_string(value) << "'";
}


void
IT_AnyPrinter::print_octet(
    ostream& out,
    CORBA::Octet value,
    int                         // indent parameter, ignored.
)
{
    out << IT_STATIC_CAST(unsigned int, value);
}


void
IT_AnyPrinter::print_short(
    ostream& out,
    CORBA::Short value,
    int                         // indent parameter, ignored.
)
{
    out << value;
}


void
IT_AnyPrinter::print_ushort(
    ostream& out,
    CORBA::UShort value,
    int                         // indent parameter, ignored.
)
{
    out << value << "u";
}


void
IT_AnyPrinter::print_long(
    ostream& out,
    CORBA::Long value,
    int                         // indent parameter, ignored.
)
{
    out << value << "l";
}


void
IT_AnyPrinter::print_ulong(
    ostream& out,
    CORBA::ULong value,
    int                         // indent parameter, ignored.
)
{
    out << value << "ul";
}


void
IT_AnyPrinter::print_longlong(
    ostream& out,
    CORBA::LongLong value,
    int                         // indent parameter, ignored.
)
{
    // Print by converting to fixed, which can be printed on all platforms.
    // 
    CORBA::Fixed f(value);
    out << f << "ll";
}


void
IT_AnyPrinter::print_ulonglong(
    ostream& out,
    CORBA::ULongLong value,
    int                         // indent parameter, ignored.
)
{
    // Print by converting to fixed, which can be printed on all platforms.
    // 
    CORBA::Fixed f(value);
    out << f << "ull";
}


void
IT_AnyPrinter::print_float(
    ostream& out,
    CORBA::Float value,
    int                         // indent parameter, ignored.
)
{
    out << value << "f";
}


void
IT_AnyPrinter::print_double(
    ostream& out,
    CORBA::Double value,
    int                         // indent parameter, ignored.
)
{
    out << value;
}


void
IT_AnyPrinter::print_longdouble(
    ostream& out,
    CORBA::LongDouble value,
    int                         // indent parameter, ignored.
)
{
    // Print by converting to fixed, which can be printed on all platforms.
    // 
    CORBA::Fixed f(value);
    out << f << "l";
}


void
IT_AnyPrinter::print_fixed(
    ostream& out,
    const CORBA::Fixed& value,
    int                         // indent parameter, ignored.
)
{
    out << value << "d";
}


void
IT_AnyPrinter::print_string(
    ostream& out,
    const CORBA::Char* value,
    int                         // indent parameter, ignored.
)
{
    out << "\"" << value << "\"";
}


void
IT_AnyPrinter::print_wstring(
    ostream& out,
    const CORBA::WChar* value,
    int                         // indent parameter, ignored.
)
{
    out << "L\"";
    for ( ; *value != 0; ++value)
    {
        out << wchar_to_string(*value);
    }
    out << "\"";
}


// tckind_to_string -- convert a CORBA::TCKind to a string.
// Return value is a static constant, and must not be deleted.
//
const char*
IT_AnyPrinter::tckind_to_string(
    CORBA::TCKind kind
)
{
    const char* tk = "<invalid_type_kind>"; 
    switch (kind)
    {
    case CORBA::tk_null:                tk =  "null"; break;
    case CORBA::tk_void:                tk =  "void"; break;
    case CORBA::tk_short:               tk =  "short"; break;
    case CORBA::tk_long:                tk =  "long"; break;
    case CORBA::tk_ushort:              tk =  "ushort"; break;
    case CORBA::tk_ulong:               tk =  "ulong"; break;
    case CORBA::tk_float:               tk =  "float"; break;
    case CORBA::tk_double:              tk =  "double"; break;
    case CORBA::tk_boolean:             tk =  "boolean"; break;
    case CORBA::tk_char:                tk =  "char"; break;
    case CORBA::tk_octet:               tk =  "octet"; break;
    case CORBA::tk_any:                 tk =  "any"; break;
    case CORBA::tk_TypeCode:            tk =  "TypeCode"; break;
    case CORBA::tk_Principal:           tk =  "Principal"; break;
    case CORBA::tk_objref:              tk =  "objref"; break;
    case CORBA::tk_struct:              tk =  "struct"; break;
    case CORBA::tk_union:               tk =  "union"; break;
    case CORBA::tk_enum:                tk =  "enum"; break;
    case CORBA::tk_string:              tk =  "string"; break;
    case CORBA::tk_sequence:            tk =  "sequence"; break;
    case CORBA::tk_array:               tk =  "array"; break;
    case CORBA::tk_alias:               tk =  "alias"; break;
    case CORBA::tk_except:              tk =  "except"; break;
    case CORBA::tk_longlong:            tk =  "longlong"; break;
    case CORBA::tk_ulonglong:           tk =  "ulonglong"; break;
    case CORBA::tk_longdouble:          tk =  "longdouble"; break;
    case CORBA::tk_wchar:               tk =  "wchar"; break;
    case CORBA::tk_wstring:             tk =  "wstring"; break;
    case CORBA::tk_fixed:               tk =  "fixed"; break;
    case CORBA::tk_value:               tk =  "value"; break;
    case CORBA::tk_value_box:           tk =  "value_box"; break;
    case CORBA::tk_native:              tk =  "native"; break;
    case CORBA::tk_abstract_interface:  tk =  "abstract_interface"; break;
    }
    return tk;
}


void
IT_AnyPrinter::print_typecode(
    ostream& out,
    CORBA::TypeCode_ptr value,
    int                         // indent parameter, ignored.
)
{
    const char* tk = tckind_to_string(value->kind());
    out << tk;
    try {
        const char* id = value->id();
        out << "{" << id << "}";
    }
    catch(const CORBA::TypeCode::BadKind&)
    {
        // Some types don't have an ID. Nothing more to print in this case.
    }
}


void
IT_AnyPrinter::print_principal(
    ostream& out,
    const CORBA::Principal& value,
    int                         // indent parameter, ignored.
)
{
    out << "CORBA::Principal:{";
    if (value.length() > 0)