it_print_any.cxx

这是经典的CORBA程序

    {
        print_octet(out, value[0]);
        CORBA::ULong i = 1;
        for (i = 1; i < value.length(); ++i)
        {
            out << ",";
            print_octet(out, value[i]);
        }
    }
    out << "}";
}


void
IT_AnyPrinter::print_object(
    ostream& out,
    CORBA::Object_ptr value,
    int                         // indent parameter, ignored.
)
{
    out << "objref{";
    if (CORBA::is_nil(value))
    {
        out << "<nil>";
    }
    else
    {
        try 
        {
            CORBA::String_var id = value->_it_get_type_id();
            out << id.in();
        }
        catch (const CORBA::Exception&)
        {
            out << "<unknown interface>";
        }
    }
    out << "}";
}


// print_value -- print arbitrary value type.
// 
void
IT_AnyPrinter::print_value(
    ostream& out,
    CORBA::ValueBase* value,
    int indent
)
{
    CORBA::Any any;
    any <<= value;
    print_any_contents(out, any, indent);
}


// print_abstract -- print an abstract interface.
// 
void
IT_AnyPrinter::print_abstract(
    ostream& out,
    CORBA::AbstractBase_ptr abstract,
    int indent
)
{
    CORBA::Object_var as_object = abstract->_to_object();
    CORBA::ValueBase_var as_value = abstract->_to_value();
    out << "abstract_interface {";
    if (!CORBA::is_nil(as_object)) 
    {
        print_object(out, as_object);
    }
    else if (!CORBA::is_nil(as_value))
    {
        print_value(out, as_value, indent);
    }
    else 
    {
        out << "unknown type";
    }
    out << "}";
}


// print_any -- print an any.
// 
void
IT_AnyPrinter::print_any(
    ostream& out,
    const CORBA::Any& any,
    int ind
)
{
    out << "any { " << endl;
    indent(out, ind+1) << "type = ";
    CORBA::TypeCode_var tc = any.type();
    print_typecode(out, tc);
    out << endl;
    indent(out, ind+1) << "value = ";
    print_any_contents(out, any, ind+1);
    out << endl;
    indent(out, ind) << "}";
}


// indent -- print an indent.
//
ostream&
IT_AnyPrinter::indent(
    ostream& out,
    int i
) 
{
    for ( ; i > 0; --i )
    {
        out << m_indent_string;
    }
    return out;
}


// print_simple_any_contents -- print the contents of a simple any.
// Prints contents if possible without resorting to DynAny
// and returns true, otherwise returns false.
// 
CORBA::Boolean
IT_AnyPrinter::print_simple_any_contents(
    ostream& out,
    const CORBA::Any& any,
    int indent
)
{
    // Types with a by-value extraction operator.
    // 
    CORBA::Short the_short;
    if (any >>= the_short)
    {
        print_short(out, the_short);
        return 1;
    }
    CORBA::UShort the_ushort;
    if (any >>= the_ushort)
    {
        print_ushort(out, the_ushort);
        return 1;
    }
    CORBA::Long the_long;
    if (any >>= the_long)
    {
        print_long(out, the_long);
        return 1;
    }
    CORBA::ULong the_ulong;
    if (any >>= the_ulong)
    {
        print_ulong(out, the_ulong);
        return 1;
    }
    CORBA::LongLong the_longlong;
    if (any >>= the_longlong)
    {
        print_longlong(out, the_longlong);
        return 1;
    }
    CORBA::ULongLong the_ulonglong;
    if (any >>= the_ulonglong)
    {
        print_ulonglong(out, the_ulonglong);
        return 1;
    }
    CORBA::Float the_float;
    if (any >>= the_float)
    {
        print_float(out, the_float);
        return 1;
    }
    CORBA::Double the_double;
    if (any >>= the_double)
    {
        print_double(out, the_double);
        return 1;
    }
    CORBA::LongDouble the_longdouble;
    if (any >>= the_longdouble)
    {
        print_longdouble(out, the_longdouble);
        return 1;
    }

    // Types that have by-value extraction with helpers.
    // 
    CORBA::Boolean the_boolean;
    if (any >>= CORBA::Any::to_boolean(the_boolean))
    {
        print_boolean(out, the_boolean);
        return 1;
    }
    CORBA::Octet the_octet;
    if (any >>= CORBA::Any::to_octet(the_octet))
    {
        print_octet(out, the_octet);
        return 1;
    }
    CORBA::Char the_char;
    if (any >>= CORBA::Any::to_char(the_char))
    {
        print_char(out, the_char);
        return 1;
    }
    CORBA::WChar the_wchar;
    if (any >>= CORBA::Any::to_wchar(the_wchar))
    {
        print_wchar(out, the_wchar);
        return 1;
    }

    // Types with by-pointer extraction
    //

    // REVISIT aconway 14 Dec 1999 -- should use const pointer.
    // Non-const pointer extraction is deprecated, but const
    // extraction is missing from orb.hh in bl118 (bug 53975) 
    // 
    CORBA::Principal* pp;
    if (any >>= pp)
    {
        print_principal(out, *pp);
        return 1;    
    }
    CORBA::TypeCode_ptr the_TypeCode;
    if (any >>= the_TypeCode)
    {
        print_typecode(out, the_TypeCode);
        return 1;
    }

    // Extracting and widening to object requires us to release the reference.
    // 
    CORBA::Object_var ref;
    if (any >>= CORBA::Any::to_object(ref))
    {
        print_object(out, ref);
        return 1;
    }

    // Remaining types require extra help from the typecode information.
    // 
    CORBA::TypeCode_var original_tc  = any.type();
    CORBA::TypeCode_var real_tc  = unalias_tc(original_tc);

    
    // String types may be bounded.
    //
    if (real_tc->kind() == CORBA::tk_string ||
        real_tc->kind() == CORBA::tk_wstring
    ) 
    {
        CORBA::ULong bound = real_tc->length();
        const CORBA::Char* the_string;
        if (any >>= CORBA::Any::to_string(the_string, bound))
        {
            print_string(out, the_string);
            return 1;
        }
        const CORBA::WChar* the_wstring;
        if (any >>= CORBA::Any::to_wstring(the_wstring, bound))
        {
            print_wstring(out, the_wstring);
            return 1;
        }
    }
    

    // Fixed needs digits and scale from typecode.
    // 
    if (real_tc->kind() == CORBA::tk_fixed)
    {
        CORBA::Fixed the_fixed;
        if (any >>= CORBA::Any::to_fixed(the_fixed,
                                         real_tc->fixed_digits(),
                                         real_tc->fixed_scale())
        )
        {
            print_fixed(out, the_fixed);
            return 1;
        }
    }

    // Finally the following types don't have printable values other
    // than their typecodes.
    // 
    switch (real_tc->kind())
    {
    case CORBA::tk_null:
    case CORBA::tk_void:
        out << "<";
        print_typecode(out, real_tc);
        out << ">";
        return 1;
    case CORBA::tk_abstract_interface:
    case CORBA::tk_native:
        print_typecode(out, real_tc);
        return 1;
    }
    
    // If we get here, we can't print the value so return false.
    return 0;
}


void
IT_AnyPrinter::print_dyn_struct(
    ostream& out,
    DynamicAny::DynStruct_ptr ds,
    int ind
)
{
    CORBA::TypeCode_var original_tc = ds->type();
    CORBA::TypeCode_var real_tc = unalias_tc(original_tc);
    CORBA::String_var name = real_tc->name();
    CORBA::Boolean is_exception = (real_tc->kind() == CORBA::tk_except);
    DynamicAny::NameValuePairSeq_var members = ds->get_members();
    
    out << (is_exception ? "exception " : "struct ") << name;
    if (members->length() == 0) {
        out << " { }";
        return;
    }
    out << " {" << endl;
    CORBA::ULong i = 0;
    for (i = 0; i < members->length(); ++i)
    {
        indent(out, ind+1) << members[i].id << " = ";
        print_any_contents(out, members[i].value, ind+1);
        out << endl;
    }
    indent(out, ind) << "}";
}


void
IT_AnyPrinter::print_dyn_union(
    ostream& out,
    DynamicAny::DynUnion_ptr du,
    int ind
)
{
    CORBA::TypeCode_var original_tc = du->type();
    CORBA::TypeCode_var real_tc = unalias_tc(original_tc);
    CORBA::String_var name = real_tc->name();
    
    out << "union " << name << " switch ("
          <<tckind_to_string(du->discriminator_kind())
          << ") {" << endl;
    indent(out, ind+1) << "_d = ";
    DynamicAny::DynAny_var dd = du->get_discriminator();
    CORBA::Any_var ad = dd->to_any();
    print_any_contents(out, ad, ind+1);
    out << endl;
    if (!du->has_no_active_member())
    {
        CORBA::String_var member_name = du->member_name();
        DynamicAny::DynAny_var dm = du->member();
        CORBA::Any_var am = dm->to_any();
        indent(out, ind+1) << member_name << " = ";
        print_any_contents(out, am, ind+1);
        out << endl;
    }
    indent(out, ind) << "}";
}


void
IT_AnyPrinter::print_dyn_enum(
    ostream& out,
    DynamicAny::DynEnum_ptr de,
    int ind
)
{
    CORBA::String_var value = de->get_as_string();
    out << value;
}


void
IT_AnyPrinter::print_dyn_sequence(
    ostream& out,
    DynamicAny::DynSequence_ptr dseq,
    int ind
)
{
    CORBA::TypeCode_var original_tc = dseq->type();
    CORBA::TypeCode_var real_tc = unalias_tc(original_tc);
    CORBA::TypeCode_var contains = real_tc->content_type();
    CORBA::ULong bound = real_tc->length();
    DynamicAny::AnySeq_var elements = dseq->get_elements();
    out << "sequence<"
          <<tckind_to_string(contains->kind());
    if (bound > 0)
    {
        out << ", " << bound;
    }
    out << "> ";
    if (elements->length() == 0) {
        out << "{ }";
        return;
    }
    out << "{" << endl;
    CORBA::ULong i = 0;
    for (i = 0; i < elements->length(); ++i)
    {
        indent(out, ind+1) << "[" << i << "] = ";
        print_any_contents(out, elements[i], ind+1);
        out << endl;
    }
    indent(out, ind) << "}";
}


void
IT_AnyPrinter::print_dyn_array(
    ostream& out,
    DynamicAny::DynArray_ptr darr,
    int ind
)
{
    CORBA::TypeCode_var original_tc = darr->type();
    CORBA::TypeCode_var real_tc = unalias_tc(original_tc);
    CORBA::TypeCode_var contains = real_tc->content_type();
    CORBA::ULong dimension = real_tc->length();
    DynamicAny::AnySeq_var elements = darr->get_elements();
    out << "array "
          <<tckind_to_string(contains->kind())
          << "[" << dimension << "] ";
    if (elements->length() == 0) {
        out << "{ }";
        return;
    }
    out << "{" << endl;
    CORBA::ULong i = 0;
    for (i = 0; i < elements->length(); ++i)
    {
        indent(out, ind+1) << "[" << i << "] = ";
        print_any_contents(out, elements[i], ind+1);
        out << endl;
    }
    indent(out, ind) << "}";
}


void
IT_AnyPrinter::print_dyn_value(
    ostream& out,
    DynamicAny::DynValue_ptr dv,
    int ind
)
{
    CORBA::TypeCode_var original_tc = dv->type();
    CORBA::TypeCode_var real_tc = unalias_tc(original_tc);
    CORBA::String_var name = real_tc->name();
    DynamicAny::NameValuePairSeq_var members = dv->get_members();
    
    out << "valuetype " << name;

    if (members->length() == 0) {
	out << "{ }";
	return;
    }
    out << "{" << endl;
    CORBA::ULong i = 0;
    for (i = 0; i < members->length(); ++i)
    {
	indent(out, ind+1) << members[i].id << " = ";
	print_any_contents(out, members[i].value, ind+1);
	out << endl;
    }
    indent(out, ind) << "}";
}

void
IT_AnyPrinter::print_dyn_value_box(
    ostream& out,
    DynamicAny::DynValueBox_ptr dv,
    int ind
)
{
    CORBA::TypeCode_var original_tc = dv->type();
    CORBA::TypeCode_var real_tc = unalias_tc(original_tc);
    CORBA::String_var name = real_tc->name();

    out << "boxed value " << name << " = ";
    CORBA::Any_var any = dv->get_boxed_value();
    print_any_contents(out, any, ind+1);
}