// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 1999
// Object Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 3.2
// License: non-commercial

#include <OB/CORBA.h>
#include <OB/TemplateI.h>
#include <OB/IntRep.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined!
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 3020000L)
#       error ORBacus version mismatch!
#   endif
#endif

//
// IDL:omg.org/CORBA/VersionSpec:1.0
//
OBTypeCodeConst CORBA__tc_VersionSpec(
"010000001500000044000000010000002200000049444c3a6f6d672e6f72672f434f5242412f5"
"6657273696f6e537065633a312e300000000c00000056657273696f6e53706563001200000000"
"000000"
);

//
// IDL:omg.org/CORBA/Contained:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_Contained >;
template class OBObjForSeq< CORBA_Contained >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_Contained >)
#pragma define(OBObjForSeq< CORBA_Contained >)
#endif
#endif

void
OBDuplicate(CORBA_Contained_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_Contained_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_Contained_ptr
CORBA_Contained::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/Contained:1.0");

        if(v)
            return _duplicate((CORBA_Contained_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/Contained:1.0"))
        {
            CORBA_Contained_ptr val = new CORBA_Contained;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_Contained::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/Contained:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_IRObject::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_Contained::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/Contained:1.0";
}

void
OBUnmarshal(CORBA_Contained_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_Contained_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/Contained:1.0");

        if(v)
            val = CORBA_Contained::_duplicate((CORBA_Contained_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_Contained;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_Contained::_nil();
}

OBTypeCodeConst CORBA__tc_Contained(
"010000000e00000036000000010000002000000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7461696e65643a312e30000a000000436f6e7461696e656400"
);

void
operator<<=(CORBA_Any& any, CORBA_Contained_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_Contained, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_Contained_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_Contained, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_Contained_ptr& val)
{
    if(any.check_type(CORBA__tc_Contained))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/Contained:1.0");

            if(v)
                val = (CORBA_Contained_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_Contained;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_Contained, no, true);
            }
        }
        else
            val = CORBA_Contained::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/Contained/id:1.0
//
CORBA_RepositoryId
CORBA_Contained::id()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_id");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_id", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return id();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_RepositoryId _ob_r = 0;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_Contained::id(const char* _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_id");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_id", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        id(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/Contained/name:1.0
//
CORBA_Identifier
CORBA_Contained::name()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_name");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_name", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return name();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Identifier _ob_r = 0;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_Contained::name(const char* _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_name");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_name", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        name(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/Contained/version:1.0
//
CORBA_VersionSpec
CORBA_Contained::version()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_version");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_version", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return version();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_VersionSpec _ob_r = 0;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_Contained::version(const char* _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_version");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_version", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        version(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/Contained/defined_in:1.0
//
CORBA_Container_ptr
CORBA_Contained::defined_in()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_defined_in");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_defined_in", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return defined_in();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Container_ptr _ob_r = CORBA_Container::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Contained/absolute_name:1.0
//
CORBA_ScopedName
CORBA_Contained::absolute_name()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_absolute_name");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_absolute_name", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return absolute_name();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ScopedName _ob_r = 0;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Contained/containing_repository:1.0
//
CORBA_Repository_ptr
CORBA_Contained::containing_repository()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_containing_repository");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_containing_repository", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return containing_repository();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Repository_ptr _ob_r = CORBA_Repository::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Contained/Description:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_Contained::Description >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_Contained::Description >)
#endif
#endif

#ifdef OB_CLEAR_MEM
CORBA_Contained::Description::Description()
{
    memset(&kind, 0, sizeof(kind));
}
#endif

CORBA_Contained::Description::Description(const CORBA_Contained::Description& _ob_a)
    : kind(_ob_a.kind),
      value(_ob_a.value)
{
}

CORBA_Contained::Description&
CORBA_Contained::Description::operator=(const Description& _ob_a)
{
    if(this != &_ob_a)
    {
        kind = _ob_a.kind;
        value = _ob_a.value;
    }
    return *this;
}

void
OBMarshal(const CORBA_Contained::Description& val, CORBA_Octet*& oct)
{
    OBMarshal(val.kind, oct);
    OBMarshal(val.value, oct);
}

void
OBMarshalCount(const CORBA_Contained::Description& val, CORBA_ULong& count)
{
    OBMarshalCount(val.kind, count);
    OBMarshalCount(val.value, count);
}

void
OBUnmarshal(CORBA_Contained::Description& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.kind, coct, swap);
    OBUnmarshal(val.value, coct, swap);
}

OBTypeCodeConst CORBA_Contained::_tc_Description(
"010000000f000000e0010000010000002c00000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7461696e65642f4465736372697074696f6e3a312e30000c000000446573637269707469"
"6f6e0002000000050000006b696e64000000001100000072010000010000002500000049444c3"
"a6f6d672e6f72672f434f5242412f446566696e6974696f6e4b696e643a312e30000000000f00"
"0000446566696e6974696f6e4b696e6400001200000008000000646b5f6e6f6e6500070000006"
"46b5f616c6c00000d000000646b5f417474726962757465000000000c000000646b5f436f6e73"
"74616e74000d000000646b5f457863657074696f6e000000000d000000646b5f496e746572666"
"16365000000000a000000646b5f4d6f64756c650000000d000000646b5f4f7065726174696f6e"
"000000000b000000646b5f54797065646566000009000000646b5f416c696173000000000a000"
"000646b5f53747275637400000009000000646b5f556e696f6e0000000008000000646b5f456e"
"756d000d000000646b5f5072696d6974697665000000000a000000646b5f537472696e6700000"
"00c000000646b5f53657175656e63650009000000646b5f4172726179000000000e000000646b"
"5f5265706f7369746f72790000000600000076616c75650000000b000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_Contained::Description >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_Contained::Description >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_Contained::Description* p)
{
    static const OBInfo< CORBA_Contained::Description > info;
    any.replace(CORBA_Contained::_tc_Description, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_Contained::Description& val)
{
    CORBA_Contained::Description* p = new CORBA_Contained::Description(val);
    static const OBInfo< CORBA_Contained::Description > info;
    any.replace(CORBA_Contained::_tc_Description, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_Contained::Description*& p)
{
    if(any.check_type(CORBA_Contained::_tc_Description))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_Contained::Description* v = new CORBA_Contained::Description;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_Contained::Description*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/Contained/describe:1.0
//
CORBA_Contained::Description*
CORBA_Contained::describe()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "describe");
    CORBA_ULong _ob_cnt = _ob_off;

    OBBuffer _ob_buf(_ob_cnt);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "describe", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return describe();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    Description* _ob_r = new Description;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Contained/move:1.0
//
void
CORBA_Contained::move(CORBA_Container_ptr _ob_a0,
                      const char* _ob_a1,
                      const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "move");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "move", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        move(_ob_a0, _ob_a1, _ob_a2);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/InterfaceDefSeq:1.0
//
OBTypeCodeConst CORBA__tc_InterfaceDefSeq(
"01000000150000009c000000010000002600000049444c3a6f6d672e6f72672f434f5242412f4"
"96e746572666163654465665365713a312e3000000010000000496e7465726661636544656653"
"6571001300000050000000010000000e0000003d000000010000002300000049444c3a6f6d672"
"e6f72672f434f5242412f496e746572666163654465663a312e3000000d000000496e74657266"
"6163654465660000000000000000"
);

//
// IDL:omg.org/CORBA/ContainedSeq:1.0
//
OBTypeCodeConst CORBA__tc_ContainedSeq(
"010000001500000090000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7461696e65645365713a312e3000000d000000436f6e7461696e65645365710000000013"
"00000048000000010000000e00000036000000010000002000000049444c3a6f6d672e6f72672"
"f434f5242412f436f6e7461696e65643a312e30000a000000436f6e7461696e65640000000000"
"0000"
);

//
// IDL:omg.org/CORBA/Container:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_Container >;
template class OBObjForSeq< CORBA_Container >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_Container >)
#pragma define(OBObjForSeq< CORBA_Container >)
#endif
#endif

void
OBDuplicate(CORBA_Container_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_Container_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_Container_ptr
CORBA_Container::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/Container:1.0");

        if(v)
            return _duplicate((CORBA_Container_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/Container:1.0"))
        {
            CORBA_Container_ptr val = new CORBA_Container;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_Container::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/Container:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_IRObject::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_Container::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/Container:1.0";
}

void
OBUnmarshal(CORBA_Container_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_Container_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/Container:1.0");

        if(v)
            val = CORBA_Container::_duplicate((CORBA_Container_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_Container;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_Container::_nil();
}

OBTypeCodeConst CORBA__tc_Container(
"010000000e00000036000000010000002000000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7461696e65723a312e30000a000000436f6e7461696e657200"
);

void
operator<<=(CORBA_Any& any, CORBA_Container_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_Container, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_Container_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_Container, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_Container_ptr& val)
{
    if(any.check_type(CORBA__tc_Container))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/Container:1.0");

            if(v)
                val = (CORBA_Container_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_Container;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_Container, no, true);
            }
        }
        else
            val = CORBA_Container::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/Container/lookup:1.0
//
CORBA_Contained_ptr
CORBA_Container::lookup(const char* _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "lookup");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "lookup", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return lookup(_ob_a0);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Contained_ptr _ob_r = CORBA_Contained::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/contents:1.0
//
CORBA_ContainedSeq*
CORBA_Container::contents(CORBA_DefinitionKind _ob_a0,
                          CORBA_Boolean _ob_a1)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "contents");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "contents", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return contents(_ob_a0, _ob_a1);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ContainedSeq* _ob_r = new CORBA_ContainedSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/lookup_name:1.0
//
CORBA_ContainedSeq*
CORBA_Container::lookup_name(const char* _ob_a0,
                             CORBA_Long _ob_a1,
                             CORBA_DefinitionKind _ob_a2,
                             CORBA_Boolean _ob_a3)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "lookup_name");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "lookup_name", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return lookup_name(_ob_a0, _ob_a1, _ob_a2, _ob_a3);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ContainedSeq* _ob_r = new CORBA_ContainedSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/Description:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_Container::Description >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_Container::Description >)
#endif
#endif

#ifdef OB_CLEAR_MEM
CORBA_Container::Description::Description()
{
    memset(&kind, 0, sizeof(kind));
}
#endif

CORBA_Container::Description::Description(const CORBA_Container::Description& _ob_a)
    : contained_object(_ob_a.contained_object),
      kind(_ob_a.kind),
      value(_ob_a.value)
{
}

CORBA_Container::Description&
CORBA_Container::Description::operator=(const Description& _ob_a)
{
    if(this != &_ob_a)
    {
        contained_object = _ob_a.contained_object;
        kind = _ob_a.kind;
        value = _ob_a.value;
    }
    return *this;
}

void
OBMarshal(const CORBA_Container::Description& val, CORBA_Octet*& oct)
{
    OBMarshal(val.contained_object.in(), oct);
    OBMarshal(val.kind, oct);
    OBMarshal(val.value, oct);
}

void
OBMarshalCount(const CORBA_Container::Description& val, CORBA_ULong& count)
{
    OBMarshalCount(val.contained_object.in(), count);
    OBMarshalCount(val.kind, count);
    OBMarshalCount(val.value, count);
}

void
OBUnmarshal(CORBA_Container::Description& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.contained_object.inout(), coct, swap);
    OBUnmarshal(val.kind, coct, swap);
    OBUnmarshal(val.value, coct, swap);
}

OBTypeCodeConst CORBA_Container::_tc_Description(
"010000000f00000038020000010000002c00000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7461696e65722f4465736372697074696f6e3a312e30000c000000446573637269707469"
"6f6e000300000011000000636f6e7461696e65645f6f626a656374000000000e0000003600000"
"0010000002000000049444c3a6f6d672e6f72672f434f5242412f436f6e7461696e65643a312e"
"30000a000000436f6e7461696e6564000000050000006b696e640000000011000000720100000"
"10000002500000049444c3a6f6d672e6f72672f434f5242412f446566696e6974696f6e4b696e"
"643a312e30000000000f000000446566696e6974696f6e4b696e6400001200000008000000646"
"b5f6e6f6e650007000000646b5f616c6c00000d000000646b5f41747472696275746500000000"
"0c000000646b5f436f6e7374616e74000d000000646b5f457863657074696f6e000000000d000"
"000646b5f496e74657266616365000000000a000000646b5f4d6f64756c650000000d00000064"
"6b5f4f7065726174696f6e000000000b000000646b5f54797065646566000009000000646b5f4"
"16c696173000000000a000000646b5f53747275637400000009000000646b5f556e696f6e0000"
"000008000000646b5f456e756d000d000000646b5f5072696d6974697665000000000a0000006"
"46b5f537472696e670000000c000000646b5f53657175656e63650009000000646b5f41727261"
"79000000000e000000646b5f5265706f7369746f72790000000600000076616c75650000000b0"
"00000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_Container::Description >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_Container::Description >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_Container::Description* p)
{
    static const OBInfo< CORBA_Container::Description > info;
    any.replace(CORBA_Container::_tc_Description, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_Container::Description& val)
{
    CORBA_Container::Description* p = new CORBA_Container::Description(val);
    static const OBInfo< CORBA_Container::Description > info;
    any.replace(CORBA_Container::_tc_Description, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_Container::Description*& p)
{
    if(any.check_type(CORBA_Container::_tc_Description))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_Container::Description* v = new CORBA_Container::Description;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_Container::Description*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/Container/DescriptionSeq:1.0
//
OBTypeCodeConst CORBA_Container::_tc_DescriptionSeq(
"01000000150000009c020000010000002f00000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7461696e65722f4465736372697074696f6e5365713a312e3000000f0000004465736372"
"697074696f6e53657100001300000048020000010000000f00000038020000010000002c00000"
"049444c3a6f6d672e6f72672f434f5242412f436f6e7461696e65722f4465736372697074696f"
"6e3a312e30000c0000004465736372697074696f6e000300000011000000636f6e7461696e656"
"45f6f626a656374000000000e00000036000000010000002000000049444c3a6f6d672e6f7267"
"2f434f5242412f436f6e7461696e65643a312e30000a000000436f6e7461696e6564000000050"
"000006b696e64000000001100000072010000010000002500000049444c3a6f6d672e6f72672f"
"434f5242412f446566696e6974696f6e4b696e643a312e30000000000f000000446566696e697"
"4696f6e4b696e6400001200000008000000646b5f6e6f6e650007000000646b5f616c6c00000d"
"000000646b5f417474726962757465000000000c000000646b5f436f6e7374616e74000d00000"
"0646b5f457863657074696f6e000000000d000000646b5f496e74657266616365000000000a00"
"0000646b5f4d6f64756c650000000d000000646b5f4f7065726174696f6e000000000b0000006"
"46b5f54797065646566000009000000646b5f416c696173000000000a000000646b5f53747275"
"637400000009000000646b5f556e696f6e0000000008000000646b5f456e756d000d000000646"
"b5f5072696d6974697665000000000a000000646b5f537472696e670000000c000000646b5f53"
"657175656e63650009000000646b5f4172726179000000000e000000646b5f5265706f7369746"
"f72790000000600000076616c75650000000b00000000000000"
);

//
// IDL:omg.org/CORBA/Container/describe_contents:1.0
//
CORBA_Container::DescriptionSeq*
CORBA_Container::describe_contents(CORBA_DefinitionKind _ob_a0,
                                   CORBA_Boolean _ob_a1,
                                   CORBA_Long _ob_a2)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "describe_contents");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "describe_contents", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return describe_contents(_ob_a0, _ob_a1, _ob_a2);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    DescriptionSeq* _ob_r = new DescriptionSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_module:1.0
//
CORBA_ModuleDef_ptr
CORBA_Container::create_module(const char* _ob_a0,
                               const char* _ob_a1,
                               const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_module");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_module", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_module(_ob_a0, _ob_a1, _ob_a2);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ModuleDef_ptr _ob_r = CORBA_ModuleDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_constant:1.0
//
CORBA_ConstantDef_ptr
CORBA_Container::create_constant(const char* _ob_a0,
                                 const char* _ob_a1,
                                 const char* _ob_a2,
                                 CORBA_IDLType_ptr _ob_a3,
                                 const CORBA_Any& _ob_a4)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_constant");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_constant", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_constant(_ob_a0, _ob_a1, _ob_a2, _ob_a3, _ob_a4);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ConstantDef_ptr _ob_r = CORBA_ConstantDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_struct:1.0
//
CORBA_StructDef_ptr
CORBA_Container::create_struct(const char* _ob_a0,
                               const char* _ob_a1,
                               const char* _ob_a2,
                               const CORBA_StructMemberSeq& _ob_a3)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_struct");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_struct", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_struct(_ob_a0, _ob_a1, _ob_a2, _ob_a3);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_StructDef_ptr _ob_r = CORBA_StructDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_union:1.0
//
CORBA_UnionDef_ptr
CORBA_Container::create_union(const char* _ob_a0,
                              const char* _ob_a1,
                              const char* _ob_a2,
                              CORBA_IDLType_ptr _ob_a3,
                              const CORBA_UnionMemberSeq& _ob_a4)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_union");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_union", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_union(_ob_a0, _ob_a1, _ob_a2, _ob_a3, _ob_a4);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_UnionDef_ptr _ob_r = CORBA_UnionDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_enum:1.0
//
CORBA_EnumDef_ptr
CORBA_Container::create_enum(const char* _ob_a0,
                             const char* _ob_a1,
                             const char* _ob_a2,
                             const CORBA_EnumMemberSeq& _ob_a3)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_enum");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_enum", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_enum(_ob_a0, _ob_a1, _ob_a2, _ob_a3);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_EnumDef_ptr _ob_r = CORBA_EnumDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_alias:1.0
//
CORBA_AliasDef_ptr
CORBA_Container::create_alias(const char* _ob_a0,
                              const char* _ob_a1,
                              const char* _ob_a2,
                              CORBA_IDLType_ptr _ob_a3)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_alias");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_alias", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_alias(_ob_a0, _ob_a1, _ob_a2, _ob_a3);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_AliasDef_ptr _ob_r = CORBA_AliasDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_interface:1.0
//
CORBA_InterfaceDef_ptr
CORBA_Container::create_interface(const char* _ob_a0,
                                  const char* _ob_a1,
                                  const char* _ob_a2,
                                  const CORBA_InterfaceDefSeq& _ob_a3)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_interface");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_interface", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_interface(_ob_a0, _ob_a1, _ob_a2, _ob_a3);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_InterfaceDef_ptr _ob_r = CORBA_InterfaceDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Container/create_exception:1.0
//
CORBA_ExceptionDef_ptr
CORBA_Container::create_exception(const char* _ob_a0,
                                  const char* _ob_a1,
                                  const char* _ob_a2,
                                  const CORBA_StructMemberSeq& _ob_a3)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_exception");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_exception", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_exception(_ob_a0, _ob_a1, _ob_a2, _ob_a3);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ExceptionDef_ptr _ob_r = CORBA_ExceptionDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/PrimitiveKind:1.0
//
OBTypeCodeConst CORBA__tc_PrimitiveKind(
"010000001100000032010000010000002400000049444c3a6f6d672e6f72672f434f5242412f5"
"072696d69746976654b696e643a312e30000e0000005072696d69746976654b696e6400000010"
"00000008000000706b5f6e756c6c0008000000706b5f766f69640009000000706b5f73686f727"
"40000000008000000706b5f6c6f6e67000a000000706b5f7573686f727400000009000000706b"
"5f756c6f6e670000000009000000706b5f666c6f6174000000000a000000706b5f646f75626c6"
"50000000b000000706b5f626f6f6c65616e000008000000706b5f636861720009000000706b5f"
"6f637465740000000007000000706b5f616e7900000c000000706b5f54797065436f6465000d0"
"00000706b5f5072696e636970616c000000000a000000706b5f737472696e670000000a000000"
"706b5f6f626a72656600"
);

void
operator<<=(CORBA_Any& any, CORBA_PrimitiveKind val)
{
    any.replace(CORBA__tc_PrimitiveKind, new CORBA_ULong((CORBA_ULong)val), true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_PrimitiveKind& val)
{
    if(any.check_type(CORBA__tc_PrimitiveKind))
    {
        val = (CORBA_PrimitiveKind)(*(CORBA_ULong*)any.value());
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/Repository:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_Repository >;
template class OBObjForSeq< CORBA_Repository >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_Repository >)
#pragma define(OBObjForSeq< CORBA_Repository >)
#endif
#endif

void
OBDuplicate(CORBA_Repository_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_Repository_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_Repository_ptr
CORBA_Repository::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/Repository:1.0");

        if(v)
            return _duplicate((CORBA_Repository_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/Repository:1.0"))
        {
            CORBA_Repository_ptr val = new CORBA_Repository;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_Repository::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/Repository:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Container::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_Repository::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/Repository:1.0";
}

void
OBUnmarshal(CORBA_Repository_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_Repository_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/Repository:1.0");

        if(v)
            val = CORBA_Repository::_duplicate((CORBA_Repository_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_Repository;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_Repository::_nil();
}

OBTypeCodeConst CORBA__tc_Repository(
"010000000e0000003b000000010000002100000049444c3a6f6d672e6f72672f434f5242412f5"
"265706f7369746f72793a312e30000000000b0000005265706f7369746f727900"
);

void
operator<<=(CORBA_Any& any, CORBA_Repository_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_Repository, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_Repository_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_Repository, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_Repository_ptr& val)
{
    if(any.check_type(CORBA__tc_Repository))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/Repository:1.0");

            if(v)
                val = (CORBA_Repository_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_Repository;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_Repository, no, true);
            }
        }
        else
            val = CORBA_Repository::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/Repository/lookup_id:1.0
//
CORBA_Contained_ptr
CORBA_Repository::lookup_id(const char* _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "lookup_id");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "lookup_id", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return lookup_id(_ob_a0);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Contained_ptr _ob_r = CORBA_Contained::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Repository/get_primitive:1.0
//
CORBA_PrimitiveDef_ptr
CORBA_Repository::get_primitive(CORBA_PrimitiveKind _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "get_primitive");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "get_primitive", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return get_primitive(_ob_a0);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_PrimitiveDef_ptr _ob_r = CORBA_PrimitiveDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Repository/create_string:1.0
//
CORBA_StringDef_ptr
CORBA_Repository::create_string(CORBA_ULong _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_string");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_string", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_string(_ob_a0);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_StringDef_ptr _ob_r = CORBA_StringDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Repository/create_sequence:1.0
//
CORBA_SequenceDef_ptr
CORBA_Repository::create_sequence(CORBA_ULong _ob_a0,
                                  CORBA_IDLType_ptr _ob_a1)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_sequence");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_sequence", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_sequence(_ob_a0, _ob_a1);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_SequenceDef_ptr _ob_r = CORBA_SequenceDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/Repository/create_array:1.0
//
CORBA_ArrayDef_ptr
CORBA_Repository::create_array(CORBA_ULong _ob_a0,
                               CORBA_IDLType_ptr _ob_a1)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_array");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_array", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_array(_ob_a0, _ob_a1);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ArrayDef_ptr _ob_r = CORBA_ArrayDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/ModuleDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_ModuleDef >;
template class OBObjForSeq< CORBA_ModuleDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_ModuleDef >)
#pragma define(OBObjForSeq< CORBA_ModuleDef >)
#endif
#endif

void
OBDuplicate(CORBA_ModuleDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_ModuleDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_ModuleDef_ptr
CORBA_ModuleDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ModuleDef:1.0");

        if(v)
            return _duplicate((CORBA_ModuleDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/ModuleDef:1.0"))
        {
            CORBA_ModuleDef_ptr val = new CORBA_ModuleDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_ModuleDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/ModuleDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Container::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_ModuleDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/ModuleDef:1.0";
}

void
OBUnmarshal(CORBA_ModuleDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ModuleDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ModuleDef:1.0");

        if(v)
            val = CORBA_ModuleDef::_duplicate((CORBA_ModuleDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_ModuleDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_ModuleDef::_nil();
}

OBTypeCodeConst CORBA__tc_ModuleDef(
"010000000e00000036000000010000002000000049444c3a6f6d672e6f72672f434f5242412f4"
"d6f64756c654465663a312e30000a0000004d6f64756c6544656600"
);

void
operator<<=(CORBA_Any& any, CORBA_ModuleDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_ModuleDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_ModuleDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_ModuleDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ModuleDef_ptr& val)
{
    if(any.check_type(CORBA__tc_ModuleDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/ModuleDef:1.0");

            if(v)
                val = (CORBA_ModuleDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_ModuleDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_ModuleDef, no, true);
            }
        }
        else
            val = CORBA_ModuleDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ModuleDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_ModuleDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_ModuleDescription >)
#endif
#endif

CORBA_ModuleDescription::CORBA_ModuleDescription(const CORBA_ModuleDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version)
{
}

CORBA_ModuleDescription&
CORBA_ModuleDescription::operator=(const CORBA_ModuleDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
    }
    return *this;
}

void
OBMarshal(const CORBA_ModuleDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
}

void
OBMarshalCount(const CORBA_ModuleDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
}

void
OBUnmarshal(CORBA_ModuleDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
}

OBTypeCodeConst CORBA__tc_ModuleDescription(
"010000000f000000b4010000010000002800000049444c3a6f6d672e6f72672f434f5242412f4"
"d6f64756c654465736372697074696f6e3a312e3000120000004d6f64756c6544657363726970"
"74696f6e00000004000000050000006e616d65000000001500000044000000010000002100000"
"049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b00"
"00004964656e74696669657200001200000000000000030000006964000015000000480000000"
"10000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a"
"312e3000000d0000005265706f7369746f727949640000000012000000000000000b000000646"
"566696e65645f696e00001500000048000000010000002300000049444c3a6f6d672e6f72672f"
"434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f72794"
"9640000000012000000000000000800000076657273696f6e0015000000440000000100000022"
"00000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e537065633a312e3000000"
"00c00000056657273696f6e53706563001200000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_ModuleDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_ModuleDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_ModuleDescription* p)
{
    static const OBInfo< CORBA_ModuleDescription > info;
    any.replace(CORBA__tc_ModuleDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_ModuleDescription& val)
{
    CORBA_ModuleDescription* p = new CORBA_ModuleDescription(val);
    static const OBInfo< CORBA_ModuleDescription > info;
    any.replace(CORBA__tc_ModuleDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ModuleDescription*& p)
{
    if(any.check_type(CORBA__tc_ModuleDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_ModuleDescription* v = new CORBA_ModuleDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_ModuleDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ConstantDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_ConstantDef >;
template class OBObjForSeq< CORBA_ConstantDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_ConstantDef >)
#pragma define(OBObjForSeq< CORBA_ConstantDef >)
#endif
#endif

void
OBDuplicate(CORBA_ConstantDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_ConstantDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_ConstantDef_ptr
CORBA_ConstantDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ConstantDef:1.0");

        if(v)
            return _duplicate((CORBA_ConstantDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/ConstantDef:1.0"))
        {
            CORBA_ConstantDef_ptr val = new CORBA_ConstantDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_ConstantDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/ConstantDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_ConstantDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/ConstantDef:1.0";
}

void
OBUnmarshal(CORBA_ConstantDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ConstantDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ConstantDef:1.0");

        if(v)
            val = CORBA_ConstantDef::_duplicate((CORBA_ConstantDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_ConstantDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_ConstantDef::_nil();
}

OBTypeCodeConst CORBA__tc_ConstantDef(
"010000000e0000003c000000010000002200000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7374616e744465663a312e300000000c000000436f6e7374616e7444656600"
);

void
operator<<=(CORBA_Any& any, CORBA_ConstantDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_ConstantDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_ConstantDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_ConstantDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ConstantDef_ptr& val)
{
    if(any.check_type(CORBA__tc_ConstantDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/ConstantDef:1.0");

            if(v)
                val = (CORBA_ConstantDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_ConstantDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_ConstantDef, no, true);
            }
        }
        else
            val = CORBA_ConstantDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ConstantDef/type:1.0
//
CORBA_TypeCode_ptr
CORBA_ConstantDef::type()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_type");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_type", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return type();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/ConstantDef/type_def:1.0
//
CORBA_IDLType_ptr
CORBA_ConstantDef::type_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_type_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return type_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_ConstantDef::type_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_type_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        type_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/ConstantDef/value:1.0
//
CORBA_Any*
CORBA_ConstantDef::value()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_value");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_value", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return value();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Any* _ob_r = new CORBA_Any;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_ConstantDef::value(const CORBA_Any& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_value");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_value", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        value(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/ConstantDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_ConstantDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_ConstantDescription >)
#endif
#endif

CORBA_ConstantDescription::CORBA_ConstantDescription(const CORBA_ConstantDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      type(_ob_a.type),
      value(_ob_a.value)
{
}

CORBA_ConstantDescription&
CORBA_ConstantDescription::operator=(const CORBA_ConstantDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        type = _ob_a.type;
        value = _ob_a.value;
    }
    return *this;
}

void
OBMarshal(const CORBA_ConstantDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.type.in(), oct);
    OBMarshal(val.value, oct);
}

void
OBMarshalCount(const CORBA_ConstantDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.type.in(), count);
    OBMarshalCount(val.value, count);
}

void
OBUnmarshal(CORBA_ConstantDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
    OBUnmarshal(val.value, coct, swap);
}

OBTypeCodeConst CORBA__tc_ConstantDescription(
"010000000f000000d8010000010000002a00000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7374616e744465736372697074696f6e3a312e3000000014000000436f6e7374616e7444"
"65736372697074696f6e0006000000050000006e616d650000000015000000440000000100000"
"02100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e300000"
"00000b0000004964656e746966696572000012000000000000000300000069640000150000004"
"8000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f72"
"7949643a312e3000000d0000005265706f7369746f727949640000000012000000000000000b0"
"00000646566696e65645f696e00001500000048000000010000002300000049444c3a6f6d672e"
"6f72672f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f73697"
"46f727949640000000012000000000000000800000076657273696f6e00150000004400000001"
"0000002200000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e537065633a312"
"e300000000c00000056657273696f6e5370656300120000000000000005000000747970650000"
"00000c0000000600000076616c75650000000b000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_ConstantDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_ConstantDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_ConstantDescription* p)
{
    static const OBInfo< CORBA_ConstantDescription > info;
    any.replace(CORBA__tc_ConstantDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_ConstantDescription& val)
{
    CORBA_ConstantDescription* p = new CORBA_ConstantDescription(val);
    static const OBInfo< CORBA_ConstantDescription > info;
    any.replace(CORBA__tc_ConstantDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ConstantDescription*& p)
{
    if(any.check_type(CORBA__tc_ConstantDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_ConstantDescription* v = new CORBA_ConstantDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_ConstantDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/TypedefDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_TypedefDef >;
template class OBObjForSeq< CORBA_TypedefDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_TypedefDef >)
#pragma define(OBObjForSeq< CORBA_TypedefDef >)
#endif
#endif

void
OBDuplicate(CORBA_TypedefDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_TypedefDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_TypedefDef_ptr
CORBA_TypedefDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/TypedefDef:1.0");

        if(v)
            return _duplicate((CORBA_TypedefDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/TypedefDef:1.0"))
        {
            CORBA_TypedefDef_ptr val = new CORBA_TypedefDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_TypedefDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/TypedefDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        if((v = CORBA_IDLType::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_TypedefDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/TypedefDef:1.0";
}

void
OBUnmarshal(CORBA_TypedefDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_TypedefDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/TypedefDef:1.0");

        if(v)
            val = CORBA_TypedefDef::_duplicate((CORBA_TypedefDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_TypedefDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_TypedefDef::_nil();
}

OBTypeCodeConst CORBA__tc_TypedefDef(
"010000000e0000003b000000010000002100000049444c3a6f6d672e6f72672f434f5242412f5"
"47970656465664465663a312e30000000000b0000005479706564656644656600"
);

void
operator<<=(CORBA_Any& any, CORBA_TypedefDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_TypedefDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_TypedefDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_TypedefDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_TypedefDef_ptr& val)
{
    if(any.check_type(CORBA__tc_TypedefDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/TypedefDef:1.0");

            if(v)
                val = (CORBA_TypedefDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_TypedefDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_TypedefDef, no, true);
            }
        }
        else
            val = CORBA_TypedefDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/TypeDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_TypeDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_TypeDescription >)
#endif
#endif

CORBA_TypeDescription::CORBA_TypeDescription(const CORBA_TypeDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      type(_ob_a.type)
{
}

CORBA_TypeDescription&
CORBA_TypeDescription::operator=(const CORBA_TypeDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        type = _ob_a.type;
    }
    return *this;
}

void
OBMarshal(const CORBA_TypeDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.type.in(), oct);
}

void
OBMarshalCount(const CORBA_TypeDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.type.in(), count);
}

void
OBUnmarshal(CORBA_TypeDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
}

OBTypeCodeConst CORBA__tc_TypeDescription(
"010000000f000000c0010000010000002600000049444c3a6f6d672e6f72672f434f5242412f5"
"47970654465736372697074696f6e3a312e300000001000000054797065446573637269707469"
"6f6e0005000000050000006e616d65000000001500000044000000010000002100000049444c3"
"a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004964"
"656e7469666965720000120000000000000003000000696400001500000048000000010000002"
"300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000"
"000d0000005265706f7369746f727949640000000012000000000000000b000000646566696e6"
"5645f696e00001500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242"
"412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f7279496400000"
"00012000000000000000800000076657273696f6e001500000044000000010000002200000049"
"444c3a6f6d672e6f72672f434f5242412f56657273696f6e537065633a312e300000000c00000"
"056657273696f6e537065630012000000000000000500000074797065000000000c000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_TypeDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_TypeDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_TypeDescription* p)
{
    static const OBInfo< CORBA_TypeDescription > info;
    any.replace(CORBA__tc_TypeDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_TypeDescription& val)
{
    CORBA_TypeDescription* p = new CORBA_TypeDescription(val);
    static const OBInfo< CORBA_TypeDescription > info;
    any.replace(CORBA__tc_TypeDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_TypeDescription*& p)
{
    if(any.check_type(CORBA__tc_TypeDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_TypeDescription* v = new CORBA_TypeDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_TypeDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/StructDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_StructDef >;
template class OBObjForSeq< CORBA_StructDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_StructDef >)
#pragma define(OBObjForSeq< CORBA_StructDef >)
#endif
#endif

void
OBDuplicate(CORBA_StructDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_StructDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_StructDef_ptr
CORBA_StructDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/StructDef:1.0");

        if(v)
            return _duplicate((CORBA_StructDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/StructDef:1.0"))
        {
            CORBA_StructDef_ptr val = new CORBA_StructDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_StructDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/StructDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_TypedefDef::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_StructDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/StructDef:1.0";
}

void
OBUnmarshal(CORBA_StructDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_StructDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/StructDef:1.0");

        if(v)
            val = CORBA_StructDef::_duplicate((CORBA_StructDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_StructDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_StructDef::_nil();
}

OBTypeCodeConst CORBA__tc_StructDef(
"010000000e00000036000000010000002000000049444c3a6f6d672e6f72672f434f5242412f5"
"374727563744465663a312e30000a00000053747275637444656600"
);

void
operator<<=(CORBA_Any& any, CORBA_StructDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_StructDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_StructDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_StructDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_StructDef_ptr& val)
{
    if(any.check_type(CORBA__tc_StructDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/StructDef:1.0");

            if(v)
                val = (CORBA_StructDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_StructDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_StructDef, no, true);
            }
        }
        else
            val = CORBA_StructDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/StructDef/members:1.0
//
CORBA_StructMemberSeq*
CORBA_StructDef::members()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_members");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return members();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_StructMemberSeq* _ob_r = new CORBA_StructMemberSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_StructDef::members(const CORBA_StructMemberSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_members");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        members(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/UnionDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_UnionDef >;
template class OBObjForSeq< CORBA_UnionDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_UnionDef >)
#pragma define(OBObjForSeq< CORBA_UnionDef >)
#endif
#endif

void
OBDuplicate(CORBA_UnionDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_UnionDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_UnionDef_ptr
CORBA_UnionDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/UnionDef:1.0");

        if(v)
            return _duplicate((CORBA_UnionDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/UnionDef:1.0"))
        {
            CORBA_UnionDef_ptr val = new CORBA_UnionDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_UnionDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/UnionDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_TypedefDef::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_UnionDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/UnionDef:1.0";
}

void
OBUnmarshal(CORBA_UnionDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_UnionDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/UnionDef:1.0");

        if(v)
            val = CORBA_UnionDef::_duplicate((CORBA_UnionDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_UnionDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_UnionDef::_nil();
}

OBTypeCodeConst CORBA__tc_UnionDef(
"010000000e00000035000000010000001f00000049444c3a6f6d672e6f72672f434f5242412f5"
"56e696f6e4465663a312e30000009000000556e696f6e44656600"
);

void
operator<<=(CORBA_Any& any, CORBA_UnionDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_UnionDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_UnionDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_UnionDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_UnionDef_ptr& val)
{
    if(any.check_type(CORBA__tc_UnionDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/UnionDef:1.0");

            if(v)
                val = (CORBA_UnionDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_UnionDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_UnionDef, no, true);
            }
        }
        else
            val = CORBA_UnionDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/UnionDef/discriminator_type:1.0
//
CORBA_TypeCode_ptr
CORBA_UnionDef::discriminator_type()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_discriminator_type");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_discriminator_type", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return discriminator_type();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/UnionDef/discriminator_type_def:1.0
//
CORBA_IDLType_ptr
CORBA_UnionDef::discriminator_type_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_discriminator_type_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_discriminator_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return discriminator_type_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_UnionDef::discriminator_type_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_discriminator_type_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_discriminator_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        discriminator_type_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/UnionDef/members:1.0
//
CORBA_UnionMemberSeq*
CORBA_UnionDef::members()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_members");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return members();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_UnionMemberSeq* _ob_r = new CORBA_UnionMemberSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_UnionDef::members(const CORBA_UnionMemberSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_members");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        members(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/EnumDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_EnumDef >;
template class OBObjForSeq< CORBA_EnumDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_EnumDef >)
#pragma define(OBObjForSeq< CORBA_EnumDef >)
#endif
#endif

void
OBDuplicate(CORBA_EnumDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_EnumDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_EnumDef_ptr
CORBA_EnumDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/EnumDef:1.0");

        if(v)
            return _duplicate((CORBA_EnumDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/EnumDef:1.0"))
        {
            CORBA_EnumDef_ptr val = new CORBA_EnumDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_EnumDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/EnumDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_TypedefDef::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_EnumDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/EnumDef:1.0";
}

void
OBUnmarshal(CORBA_EnumDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_EnumDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/EnumDef:1.0");

        if(v)
            val = CORBA_EnumDef::_duplicate((CORBA_EnumDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_EnumDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_EnumDef::_nil();
}

OBTypeCodeConst CORBA__tc_EnumDef(
"010000000e00000034000000010000001e00000049444c3a6f6d672e6f72672f434f5242412f4"
"56e756d4465663a312e3000000008000000456e756d44656600"
);

void
operator<<=(CORBA_Any& any, CORBA_EnumDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_EnumDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_EnumDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_EnumDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_EnumDef_ptr& val)
{
    if(any.check_type(CORBA__tc_EnumDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/EnumDef:1.0");

            if(v)
                val = (CORBA_EnumDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_EnumDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_EnumDef, no, true);
            }
        }
        else
            val = CORBA_EnumDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/EnumDef/members:1.0
//
CORBA_EnumMemberSeq*
CORBA_EnumDef::members()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_members");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return members();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_EnumMemberSeq* _ob_r = new CORBA_EnumMemberSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_EnumDef::members(const CORBA_EnumMemberSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_members");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        members(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/AliasDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_AliasDef >;
template class OBObjForSeq< CORBA_AliasDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_AliasDef >)
#pragma define(OBObjForSeq< CORBA_AliasDef >)
#endif
#endif

void
OBDuplicate(CORBA_AliasDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_AliasDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_AliasDef_ptr
CORBA_AliasDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/AliasDef:1.0");

        if(v)
            return _duplicate((CORBA_AliasDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/AliasDef:1.0"))
        {
            CORBA_AliasDef_ptr val = new CORBA_AliasDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_AliasDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/AliasDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_TypedefDef::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_AliasDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/AliasDef:1.0";
}

void
OBUnmarshal(CORBA_AliasDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_AliasDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/AliasDef:1.0");

        if(v)
            val = CORBA_AliasDef::_duplicate((CORBA_AliasDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_AliasDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_AliasDef::_nil();
}

OBTypeCodeConst CORBA__tc_AliasDef(
"010000000e00000035000000010000001f00000049444c3a6f6d672e6f72672f434f5242412f4"
"16c6961734465663a312e30000009000000416c69617344656600"
);

void
operator<<=(CORBA_Any& any, CORBA_AliasDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_AliasDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_AliasDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_AliasDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_AliasDef_ptr& val)
{
    if(any.check_type(CORBA__tc_AliasDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/AliasDef:1.0");

            if(v)
                val = (CORBA_AliasDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_AliasDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_AliasDef, no, true);
            }
        }
        else
            val = CORBA_AliasDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/AliasDef/original_type_def:1.0
//
CORBA_IDLType_ptr
CORBA_AliasDef::original_type_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_original_type_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_original_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return original_type_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_AliasDef::original_type_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_original_type_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_original_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        original_type_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/PrimitiveDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_PrimitiveDef >;
template class OBObjForSeq< CORBA_PrimitiveDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_PrimitiveDef >)
#pragma define(OBObjForSeq< CORBA_PrimitiveDef >)
#endif
#endif

void
OBDuplicate(CORBA_PrimitiveDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_PrimitiveDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_PrimitiveDef_ptr
CORBA_PrimitiveDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/PrimitiveDef:1.0");

        if(v)
            return _duplicate((CORBA_PrimitiveDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/PrimitiveDef:1.0"))
        {
            CORBA_PrimitiveDef_ptr val = new CORBA_PrimitiveDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_PrimitiveDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/PrimitiveDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_IDLType::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_PrimitiveDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/PrimitiveDef:1.0";
}

void
OBUnmarshal(CORBA_PrimitiveDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_PrimitiveDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/PrimitiveDef:1.0");

        if(v)
            val = CORBA_PrimitiveDef::_duplicate((CORBA_PrimitiveDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_PrimitiveDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_PrimitiveDef::_nil();
}

OBTypeCodeConst CORBA__tc_PrimitiveDef(
"010000000e0000003d000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5"
"072696d69746976654465663a312e3000000d0000005072696d697469766544656600"
);

void
operator<<=(CORBA_Any& any, CORBA_PrimitiveDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_PrimitiveDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_PrimitiveDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_PrimitiveDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_PrimitiveDef_ptr& val)
{
    if(any.check_type(CORBA__tc_PrimitiveDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/PrimitiveDef:1.0");

            if(v)
                val = (CORBA_PrimitiveDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_PrimitiveDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_PrimitiveDef, no, true);
            }
        }
        else
            val = CORBA_PrimitiveDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/PrimitiveDef/kind:1.0
//
CORBA_PrimitiveKind
CORBA_PrimitiveDef::kind()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_kind");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_kind", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return kind();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_PrimitiveKind _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/StringDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_StringDef >;
template class OBObjForSeq< CORBA_StringDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_StringDef >)
#pragma define(OBObjForSeq< CORBA_StringDef >)
#endif
#endif

void
OBDuplicate(CORBA_StringDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_StringDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_StringDef_ptr
CORBA_StringDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/StringDef:1.0");

        if(v)
            return _duplicate((CORBA_StringDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/StringDef:1.0"))
        {
            CORBA_StringDef_ptr val = new CORBA_StringDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_StringDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/StringDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_IDLType::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_StringDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/StringDef:1.0";
}

void
OBUnmarshal(CORBA_StringDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_StringDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/StringDef:1.0");

        if(v)
            val = CORBA_StringDef::_duplicate((CORBA_StringDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_StringDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_StringDef::_nil();
}

OBTypeCodeConst CORBA__tc_StringDef(
"010000000e00000036000000010000002000000049444c3a6f6d672e6f72672f434f5242412f5"
"37472696e674465663a312e30000a000000537472696e6744656600"
);

void
operator<<=(CORBA_Any& any, CORBA_StringDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_StringDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_StringDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_StringDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_StringDef_ptr& val)
{
    if(any.check_type(CORBA__tc_StringDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/StringDef:1.0");

            if(v)
                val = (CORBA_StringDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_StringDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_StringDef, no, true);
            }
        }
        else
            val = CORBA_StringDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/StringDef/bound:1.0
//
CORBA_ULong
CORBA_StringDef::bound()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_bound");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_bound", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return bound();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ULong _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_StringDef::bound(CORBA_ULong _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_bound");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_bound", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        bound(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/SequenceDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_SequenceDef >;
template class OBObjForSeq< CORBA_SequenceDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_SequenceDef >)
#pragma define(OBObjForSeq< CORBA_SequenceDef >)
#endif
#endif

void
OBDuplicate(CORBA_SequenceDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_SequenceDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_SequenceDef_ptr
CORBA_SequenceDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/SequenceDef:1.0");

        if(v)
            return _duplicate((CORBA_SequenceDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/SequenceDef:1.0"))
        {
            CORBA_SequenceDef_ptr val = new CORBA_SequenceDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_SequenceDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/SequenceDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_IDLType::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_SequenceDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/SequenceDef:1.0";
}

void
OBUnmarshal(CORBA_SequenceDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_SequenceDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/SequenceDef:1.0");

        if(v)
            val = CORBA_SequenceDef::_duplicate((CORBA_SequenceDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_SequenceDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_SequenceDef::_nil();
}

OBTypeCodeConst CORBA__tc_SequenceDef(
"010000000e0000003c000000010000002200000049444c3a6f6d672e6f72672f434f5242412f5"
"3657175656e63654465663a312e300000000c00000053657175656e636544656600"
);

void
operator<<=(CORBA_Any& any, CORBA_SequenceDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_SequenceDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_SequenceDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_SequenceDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_SequenceDef_ptr& val)
{
    if(any.check_type(CORBA__tc_SequenceDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/SequenceDef:1.0");

            if(v)
                val = (CORBA_SequenceDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_SequenceDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_SequenceDef, no, true);
            }
        }
        else
            val = CORBA_SequenceDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/SequenceDef/bound:1.0
//
CORBA_ULong
CORBA_SequenceDef::bound()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_bound");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_bound", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return bound();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ULong _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_SequenceDef::bound(CORBA_ULong _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_bound");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_bound", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        bound(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/SequenceDef/element_type:1.0
//
CORBA_TypeCode_ptr
CORBA_SequenceDef::element_type()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_element_type");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_element_type", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return element_type();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/SequenceDef/element_type_def:1.0
//
CORBA_IDLType_ptr
CORBA_SequenceDef::element_type_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_element_type_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_element_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return element_type_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_SequenceDef::element_type_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_element_type_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_element_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        element_type_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/ArrayDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_ArrayDef >;
template class OBObjForSeq< CORBA_ArrayDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_ArrayDef >)
#pragma define(OBObjForSeq< CORBA_ArrayDef >)
#endif
#endif

void
OBDuplicate(CORBA_ArrayDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_ArrayDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_ArrayDef_ptr
CORBA_ArrayDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ArrayDef:1.0");

        if(v)
            return _duplicate((CORBA_ArrayDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/ArrayDef:1.0"))
        {
            CORBA_ArrayDef_ptr val = new CORBA_ArrayDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_ArrayDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/ArrayDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_IDLType::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_ArrayDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/ArrayDef:1.0";
}

void
OBUnmarshal(CORBA_ArrayDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ArrayDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ArrayDef:1.0");

        if(v)
            val = CORBA_ArrayDef::_duplicate((CORBA_ArrayDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_ArrayDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_ArrayDef::_nil();
}

OBTypeCodeConst CORBA__tc_ArrayDef(
"010000000e00000035000000010000001f00000049444c3a6f6d672e6f72672f434f5242412f4"
"1727261794465663a312e30000009000000417272617944656600"
);

void
operator<<=(CORBA_Any& any, CORBA_ArrayDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_ArrayDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_ArrayDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_ArrayDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ArrayDef_ptr& val)
{
    if(any.check_type(CORBA__tc_ArrayDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/ArrayDef:1.0");

            if(v)
                val = (CORBA_ArrayDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_ArrayDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_ArrayDef, no, true);
            }
        }
        else
            val = CORBA_ArrayDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ArrayDef/length:1.0
//
CORBA_ULong
CORBA_ArrayDef::length()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_length");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_length", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return length();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ULong _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_ArrayDef::length(CORBA_ULong _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_length");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_length", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        length(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/ArrayDef/element_type:1.0
//
CORBA_TypeCode_ptr
CORBA_ArrayDef::element_type()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_element_type");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_element_type", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return element_type();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/ArrayDef/element_type_def:1.0
//
CORBA_IDLType_ptr
CORBA_ArrayDef::element_type_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_element_type_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_element_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return element_type_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_ArrayDef::element_type_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_element_type_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_element_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        element_type_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_ExceptionDef >;
template class OBObjForSeq< CORBA_ExceptionDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_ExceptionDef >)
#pragma define(OBObjForSeq< CORBA_ExceptionDef >)
#endif
#endif

void
OBDuplicate(CORBA_ExceptionDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_ExceptionDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_ExceptionDef_ptr
CORBA_ExceptionDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ExceptionDef:1.0");

        if(v)
            return _duplicate((CORBA_ExceptionDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/ExceptionDef:1.0"))
        {
            CORBA_ExceptionDef_ptr val = new CORBA_ExceptionDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_ExceptionDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/ExceptionDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_ExceptionDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/ExceptionDef:1.0";
}

void
OBUnmarshal(CORBA_ExceptionDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ExceptionDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/ExceptionDef:1.0");

        if(v)
            val = CORBA_ExceptionDef::_duplicate((CORBA_ExceptionDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_ExceptionDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_ExceptionDef::_nil();
}

OBTypeCodeConst CORBA__tc_ExceptionDef(
"010000000e0000003d000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"57863657074696f6e4465663a312e3000000d000000457863657074696f6e44656600"
);

void
operator<<=(CORBA_Any& any, CORBA_ExceptionDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_ExceptionDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_ExceptionDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_ExceptionDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ExceptionDef_ptr& val)
{
    if(any.check_type(CORBA__tc_ExceptionDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/ExceptionDef:1.0");

            if(v)
                val = (CORBA_ExceptionDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_ExceptionDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_ExceptionDef, no, true);
            }
        }
        else
            val = CORBA_ExceptionDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ExceptionDef/type:1.0
//
CORBA_TypeCode_ptr
CORBA_ExceptionDef::type()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_type");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_type", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return type();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/ExceptionDef/members:1.0
//
CORBA_StructMemberSeq*
CORBA_ExceptionDef::members()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_members");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return members();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_StructMemberSeq* _ob_r = new CORBA_StructMemberSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_ExceptionDef::members(const CORBA_StructMemberSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_members");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_members", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        members(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/ExceptionDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_ExceptionDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_ExceptionDescription >)
#endif
#endif

CORBA_ExceptionDescription::CORBA_ExceptionDescription(const CORBA_ExceptionDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      type(_ob_a.type)
{
}

CORBA_ExceptionDescription&
CORBA_ExceptionDescription::operator=(const CORBA_ExceptionDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        type = _ob_a.type;
    }
    return *this;
}

void
OBMarshal(const CORBA_ExceptionDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.type.in(), oct);
}

void
OBMarshalCount(const CORBA_ExceptionDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.type.in(), count);
}

void
OBUnmarshal(CORBA_ExceptionDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
}

OBTypeCodeConst CORBA__tc_ExceptionDescription(
"010000000f000000cc010000010000002b00000049444c3a6f6d672e6f72672f434f5242412f4"
"57863657074696f6e4465736372697074696f6e3a312e30000015000000457863657074696f6e"
"4465736372697074696f6e0000000005000000050000006e616d6500000000150000004400000"
"0010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a31"
"2e30000000000b0000004964656e7469666965720000120000000000000003000000696400001"
"500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f73"
"69746f727949643a312e3000000d0000005265706f7369746f727949640000000012000000000"
"000000b000000646566696e65645f696e00001500000048000000010000002300000049444c3a"
"6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d00000052657"
"06f7369746f727949640000000012000000000000000800000076657273696f6e001500000044"
"000000010000002200000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e53706"
"5633a312e300000000c00000056657273696f6e53706563001200000000000000050000007479"
"7065000000000c000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_ExceptionDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_ExceptionDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_ExceptionDescription* p)
{
    static const OBInfo< CORBA_ExceptionDescription > info;
    any.replace(CORBA__tc_ExceptionDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_ExceptionDescription& val)
{
    CORBA_ExceptionDescription* p = new CORBA_ExceptionDescription(val);
    static const OBInfo< CORBA_ExceptionDescription > info;
    any.replace(CORBA__tc_ExceptionDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ExceptionDescription*& p)
{
    if(any.check_type(CORBA__tc_ExceptionDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_ExceptionDescription* v = new CORBA_ExceptionDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_ExceptionDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/AttributeMode:1.0
//
OBTypeCodeConst CORBA__tc_AttributeMode(
"010000001100000066000000010000002400000049444c3a6f6d672e6f72672f434f5242412f4"
"174747269627574654d6f64653a312e30000e0000004174747269627574654d6f646500000002"
"0000000c000000415454525f4e4f524d414c000e000000415454525f524541444f4e4c5900"
);

void
operator<<=(CORBA_Any& any, CORBA_AttributeMode val)
{
    any.replace(CORBA__tc_AttributeMode, new CORBA_ULong((CORBA_ULong)val), true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_AttributeMode& val)
{
    if(any.check_type(CORBA__tc_AttributeMode))
    {
        val = (CORBA_AttributeMode)(*(CORBA_ULong*)any.value());
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_AttributeDef >;
template class OBObjForSeq< CORBA_AttributeDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_AttributeDef >)
#pragma define(OBObjForSeq< CORBA_AttributeDef >)
#endif
#endif

void
OBDuplicate(CORBA_AttributeDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_AttributeDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_AttributeDef_ptr
CORBA_AttributeDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/AttributeDef:1.0");

        if(v)
            return _duplicate((CORBA_AttributeDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/AttributeDef:1.0"))
        {
            CORBA_AttributeDef_ptr val = new CORBA_AttributeDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_AttributeDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/AttributeDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_AttributeDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/AttributeDef:1.0";
}

void
OBUnmarshal(CORBA_AttributeDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_AttributeDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/AttributeDef:1.0");

        if(v)
            val = CORBA_AttributeDef::_duplicate((CORBA_AttributeDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_AttributeDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_AttributeDef::_nil();
}

OBTypeCodeConst CORBA__tc_AttributeDef(
"010000000e0000003d000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"174747269627574654465663a312e3000000d00000041747472696275746544656600"
);

void
operator<<=(CORBA_Any& any, CORBA_AttributeDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_AttributeDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_AttributeDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_AttributeDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_AttributeDef_ptr& val)
{
    if(any.check_type(CORBA__tc_AttributeDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/AttributeDef:1.0");

            if(v)
                val = (CORBA_AttributeDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_AttributeDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_AttributeDef, no, true);
            }
        }
        else
            val = CORBA_AttributeDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/AttributeDef/type:1.0
//
CORBA_TypeCode_ptr
CORBA_AttributeDef::type()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_type");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_type", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return type();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/AttributeDef/type_def:1.0
//
CORBA_IDLType_ptr
CORBA_AttributeDef::type_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_type_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return type_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_AttributeDef::type_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_type_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_type_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        type_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/AttributeDef/mode:1.0
//
CORBA_AttributeMode
CORBA_AttributeDef::mode()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_mode");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_mode", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return mode();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_AttributeMode _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_AttributeDef::mode(CORBA_AttributeMode _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_mode");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_mode", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        mode(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/AttributeDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_AttributeDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_AttributeDescription >)
#endif
#endif

#ifdef OB_CLEAR_MEM
CORBA_AttributeDescription::CORBA_AttributeDescription()
{
    memset(&mode, 0, sizeof(mode));
}
#endif

CORBA_AttributeDescription::CORBA_AttributeDescription(const CORBA_AttributeDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      type(_ob_a.type),
      mode(_ob_a.mode)
{
}

CORBA_AttributeDescription&
CORBA_AttributeDescription::operator=(const CORBA_AttributeDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        type = _ob_a.type;
        mode = _ob_a.mode;
    }
    return *this;
}

void
OBMarshal(const CORBA_AttributeDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.type.in(), oct);
    OBMarshal(val.mode, oct);
}

void
OBMarshalCount(const CORBA_AttributeDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.type.in(), count);
    OBMarshalCount(val.mode, count);
}

void
OBUnmarshal(CORBA_AttributeDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
    OBUnmarshal(val.mode, coct, swap);
}

OBTypeCodeConst CORBA__tc_AttributeDescription(
"010000000f00000046020000010000002b00000049444c3a6f6d672e6f72672f434f5242412f4"
"174747269627574654465736372697074696f6e3a312e30000015000000417474726962757465"
"4465736372697074696f6e0000000006000000050000006e616d6500000000150000004400000"
"0010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a31"
"2e30000000000b0000004964656e7469666965720000120000000000000003000000696400001"
"500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f73"
"69746f727949643a312e3000000d0000005265706f7369746f727949640000000012000000000"
"000000b000000646566696e65645f696e00001500000048000000010000002300000049444c3a"
"6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d00000052657"
"06f7369746f727949640000000012000000000000000800000076657273696f6e001500000044"
"000000010000002200000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e53706"
"5633a312e300000000c00000056657273696f6e53706563001200000000000000050000007479"
"7065000000000c000000050000006d6f646500000000110000006600000001000000240000004"
"9444c3a6f6d672e6f72672f434f5242412f4174747269627574654d6f64653a312e30000e0000"
"004174747269627574654d6f6465000000020000000c000000415454525f4e4f524d414c000e0"
"00000415454525f524541444f4e4c5900"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_AttributeDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_AttributeDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_AttributeDescription* p)
{
    static const OBInfo< CORBA_AttributeDescription > info;
    any.replace(CORBA__tc_AttributeDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_AttributeDescription& val)
{
    CORBA_AttributeDescription* p = new CORBA_AttributeDescription(val);
    static const OBInfo< CORBA_AttributeDescription > info;
    any.replace(CORBA__tc_AttributeDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_AttributeDescription*& p)
{
    if(any.check_type(CORBA__tc_AttributeDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_AttributeDescription* v = new CORBA_AttributeDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_AttributeDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/OperationMode:1.0
//
OBTypeCodeConst CORBA__tc_OperationMode(
"010000001100000062000000010000002400000049444c3a6f6d672e6f72672f434f5242412f4"
"f7065726174696f6e4d6f64653a312e30000e0000004f7065726174696f6e4d6f646500000002"
"0000000a0000004f505f4e4f524d414c0000000a0000004f505f4f4e4557415900"
);

void
operator<<=(CORBA_Any& any, CORBA_OperationMode val)
{
    any.replace(CORBA__tc_OperationMode, new CORBA_ULong((CORBA_ULong)val), true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_OperationMode& val)
{
    if(any.check_type(CORBA__tc_OperationMode))
    {
        val = (CORBA_OperationMode)(*(CORBA_ULong*)any.value());
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ParameterMode:1.0
//
OBTypeCodeConst CORBA__tc_ParameterMode(
"010000001100000074000000010000002400000049444c3a6f6d672e6f72672f434f5242412f5"
"06172616d657465724d6f64653a312e30000e000000506172616d657465724d6f646500000003"
"00000009000000504152414d5f494e000000000a000000504152414d5f4f55540000000c00000"
"0504152414d5f494e4f555400"
);

void
operator<<=(CORBA_Any& any, CORBA_ParameterMode val)
{
    any.replace(CORBA__tc_ParameterMode, new CORBA_ULong((CORBA_ULong)val), true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ParameterMode& val)
{
    if(any.check_type(CORBA__tc_ParameterMode))
    {
        val = (CORBA_ParameterMode)(*(CORBA_ULong*)any.value());
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ParameterDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_ParameterDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_ParameterDescription >)
#endif
#endif

#ifdef OB_CLEAR_MEM
CORBA_ParameterDescription::CORBA_ParameterDescription()
{
    memset(&mode, 0, sizeof(mode));
}
#endif

CORBA_ParameterDescription::CORBA_ParameterDescription(const CORBA_ParameterDescription& _ob_a)
    : name(_ob_a.name),
      type(_ob_a.type),
      type_def(_ob_a.type_def),
      mode(_ob_a.mode)
{
}

CORBA_ParameterDescription&
CORBA_ParameterDescription::operator=(const CORBA_ParameterDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        type = _ob_a.type;
        type_def = _ob_a.type_def;
        mode = _ob_a.mode;
    }
    return *this;
}

void
OBMarshal(const CORBA_ParameterDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.type.in(), oct);
    OBMarshal(val.type_def.in(), oct);
    OBMarshal(val.mode, oct);
}

void
OBMarshalCount(const CORBA_ParameterDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.type.in(), count);
    OBMarshalCount(val.type_def.in(), count);
    OBMarshalCount(val.mode, count);
}

void
OBUnmarshal(CORBA_ParameterDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
    OBUnmarshal(val.type_def.inout(), coct, swap);
    OBUnmarshal(val.mode, coct, swap);
}

OBTypeCodeConst CORBA__tc_ParameterDescription(
"010000000f00000090010000010000002b00000049444c3a6f6d672e6f72672f434f5242412f5"
"06172616d657465724465736372697074696f6e3a312e30000015000000506172616d65746572"
"4465736372697074696f6e0000000004000000050000006e616d6500000000150000004400000"
"0010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a31"
"2e30000000000b0000004964656e7469666965720000120000000000000005000000747970650"
"00000000c00000009000000747970655f646566000000000e00000034000000010000001e0000"
"0049444c3a6f6d672e6f72672f434f5242412f49444c547970653a312e3000000008000000494"
"44c5479706500050000006d6f6465000000001100000074000000010000002400000049444c3a"
"6f6d672e6f72672f434f5242412f506172616d657465724d6f64653a312e30000e00000050617"
"2616d657465724d6f64650000000300000009000000504152414d5f494e000000000a00000050"
"4152414d5f4f55540000000c000000504152414d5f494e4f555400"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_ParameterDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_ParameterDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_ParameterDescription* p)
{
    static const OBInfo< CORBA_ParameterDescription > info;
    any.replace(CORBA__tc_ParameterDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_ParameterDescription& val)
{
    CORBA_ParameterDescription* p = new CORBA_ParameterDescription(val);
    static const OBInfo< CORBA_ParameterDescription > info;
    any.replace(CORBA__tc_ParameterDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_ParameterDescription*& p)
{
    if(any.check_type(CORBA__tc_ParameterDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_ParameterDescription* v = new CORBA_ParameterDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_ParameterDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/ParDescriptionSeq:1.0
//
OBTypeCodeConst CORBA__tc_ParDescriptionSeq(
"0100000015000000f0010000010000002800000049444c3a6f6d672e6f72672f434f5242412f5"
"061724465736372697074696f6e5365713a312e3000120000005061724465736372697074696f"
"6e53657100000013000000a0010000010000000f00000090010000010000002b00000049444c3"
"a6f6d672e6f72672f434f5242412f506172616d657465724465736372697074696f6e3a312e30"
"000015000000506172616d657465724465736372697074696f6e0000000004000000050000006"
"e616d65000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f52"
"42412f4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120"
"00000000000000500000074797065000000000c00000009000000747970655f64656600000000"
"0e00000034000000010000001e00000049444c3a6f6d672e6f72672f434f5242412f49444c547"
"970653a312e300000000800000049444c5479706500050000006d6f6465000000001100000074"
"000000010000002400000049444c3a6f6d672e6f72672f434f5242412f506172616d657465724"
"d6f64653a312e30000e000000506172616d657465724d6f646500000003000000090000005041"
"52414d5f494e000000000a000000504152414d5f4f55540000000c000000504152414d5f494e4"
"f55540000000000"
);

//
// IDL:omg.org/CORBA/ContextIdentifier:1.0
//
OBTypeCodeConst CORBA__tc_ContextIdentifier(
"010000001500000094000000010000002800000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e746578744964656e7469666965723a312e300012000000436f6e746578744964656e7469"
"666965720000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f524"
"2412f4964656e7469666965723a312e30000000000b0000004964656e74696669657200001200"
"000000000000"
);

//
// IDL:omg.org/CORBA/ContextIdSeq:1.0
//
OBTypeCodeConst CORBA__tc_ContextIdSeq(
"0100000015000000ec000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7465787449645365713a312e3000000d000000436f6e7465787449645365710000000013"
"000000a4000000010000001500000094000000010000002800000049444c3a6f6d672e6f72672"
"f434f5242412f436f6e746578744964656e7469666965723a312e300012000000436f6e746578"
"744964656e7469666965720000001500000044000000010000002100000049444c3a6f6d672e6"
"f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004964656e746966"
"6965720000120000000000000000000000"
);

//
// IDL:omg.org/CORBA/ExceptionDefSeq:1.0
//
OBTypeCodeConst CORBA__tc_ExceptionDefSeq(
"01000000150000009c000000010000002600000049444c3a6f6d672e6f72672f434f5242412f4"
"57863657074696f6e4465665365713a312e3000000010000000457863657074696f6e44656653"
"6571001300000050000000010000000e0000003d000000010000002300000049444c3a6f6d672"
"e6f72672f434f5242412f457863657074696f6e4465663a312e3000000d000000457863657074"
"696f6e4465660000000000000000"
);

//
// IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
//
OBTypeCodeConst CORBA__tc_ExcDescriptionSeq(
"01000000150000002c020000010000002800000049444c3a6f6d672e6f72672f434f5242412f4"
"578634465736372697074696f6e5365713a312e3000120000004578634465736372697074696f"
"6e53657100000013000000dc010000010000000f000000cc010000010000002b00000049444c3"
"a6f6d672e6f72672f434f5242412f457863657074696f6e4465736372697074696f6e3a312e30"
"000015000000457863657074696f6e4465736372697074696f6e0000000005000000050000006"
"e616d65000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f52"
"42412f4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120"
"000000000000003000000696400001500000048000000010000002300000049444c3a6f6d672e"
"6f72672f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f73697"
"46f727949640000000012000000000000000b000000646566696e65645f696e00001500000048"
"000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727"
"949643a312e3000000d0000005265706f7369746f727949640000000012000000000000000800"
"000076657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f4"
"34f5242412f56657273696f6e537065633a312e300000000c00000056657273696f6e53706563"
"0012000000000000000500000074797065000000000c00000000000000"
);

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_OperationDef >;
template class OBObjForSeq< CORBA_OperationDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_OperationDef >)
#pragma define(OBObjForSeq< CORBA_OperationDef >)
#endif
#endif

void
OBDuplicate(CORBA_OperationDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_OperationDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_OperationDef_ptr
CORBA_OperationDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/OperationDef:1.0");

        if(v)
            return _duplicate((CORBA_OperationDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/OperationDef:1.0"))
        {
            CORBA_OperationDef_ptr val = new CORBA_OperationDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_OperationDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/OperationDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_OperationDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/OperationDef:1.0";
}

void
OBUnmarshal(CORBA_OperationDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_OperationDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/OperationDef:1.0");

        if(v)
            val = CORBA_OperationDef::_duplicate((CORBA_OperationDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_OperationDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_OperationDef::_nil();
}

OBTypeCodeConst CORBA__tc_OperationDef(
"010000000e0000003d000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"f7065726174696f6e4465663a312e3000000d0000004f7065726174696f6e44656600"
);

void
operator<<=(CORBA_Any& any, CORBA_OperationDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_OperationDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_OperationDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_OperationDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_OperationDef_ptr& val)
{
    if(any.check_type(CORBA__tc_OperationDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/OperationDef:1.0");

            if(v)
                val = (CORBA_OperationDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_OperationDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_OperationDef, no, true);
            }
        }
        else
            val = CORBA_OperationDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/OperationDef/result:1.0
//
CORBA_TypeCode_ptr
CORBA_OperationDef::result()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_result");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_result", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return result();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_TypeCode_ptr _ob_r = CORBA_TypeCode::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/OperationDef/result_def:1.0
//
CORBA_IDLType_ptr
CORBA_OperationDef::result_def()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_result_def");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_result_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return result_def();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_IDLType_ptr _ob_r = CORBA_IDLType::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_OperationDef::result_def(CORBA_IDLType_ptr _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_result_def");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_result_def", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        result_def(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/OperationDef/params:1.0
//
CORBA_ParDescriptionSeq*
CORBA_OperationDef::params()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_params");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_params", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return params();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ParDescriptionSeq* _ob_r = new CORBA_ParDescriptionSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_OperationDef::params(const CORBA_ParDescriptionSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_params");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_params", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        params(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/OperationDef/mode:1.0
//
CORBA_OperationMode
CORBA_OperationDef::mode()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_mode");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_mode", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return mode();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_OperationMode _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_OperationDef::mode(CORBA_OperationMode _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_mode");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_mode", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        mode(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/OperationDef/contexts:1.0
//
CORBA_ContextIdSeq*
CORBA_OperationDef::contexts()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_contexts");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_contexts", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return contexts();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ContextIdSeq* _ob_r = new CORBA_ContextIdSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_OperationDef::contexts(const CORBA_ContextIdSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_contexts");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_contexts", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        contexts(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/OperationDef/exceptions:1.0
//
CORBA_ExceptionDefSeq*
CORBA_OperationDef::exceptions()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_exceptions");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_exceptions", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return exceptions();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_ExceptionDefSeq* _ob_r = new CORBA_ExceptionDefSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_OperationDef::exceptions(const CORBA_ExceptionDefSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_exceptions");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_exceptions", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        exceptions(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/OperationDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_OperationDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_OperationDescription >)
#endif
#endif

#ifdef OB_CLEAR_MEM
CORBA_OperationDescription::CORBA_OperationDescription()
{
    memset(&mode, 0, sizeof(mode));
}
#endif

CORBA_OperationDescription::CORBA_OperationDescription(const CORBA_OperationDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      result(_ob_a.result),
      mode(_ob_a.mode),
      contexts(_ob_a.contexts),
      parameters(_ob_a.parameters),
      exceptions(_ob_a.exceptions)
{
}

CORBA_OperationDescription&
CORBA_OperationDescription::operator=(const CORBA_OperationDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        result = _ob_a.result;
        mode = _ob_a.mode;
        contexts = _ob_a.contexts;
        parameters = _ob_a.parameters;
        exceptions = _ob_a.exceptions;
    }
    return *this;
}

void
OBMarshal(const CORBA_OperationDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.result.in(), oct);
    OBMarshal(val.mode, oct);
    OBMarshal(val.contexts, oct);
    OBMarshal(val.parameters, oct);
    OBMarshal(val.exceptions, oct);
}

void
OBMarshalCount(const CORBA_OperationDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.result.in(), count);
    OBMarshalCount(val.mode, count);
    OBMarshalCount(val.contexts, count);
    OBMarshalCount(val.parameters, count);
    OBMarshalCount(val.exceptions, count);
}

void
OBUnmarshal(CORBA_OperationDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.result.inout(), coct, swap);
    OBUnmarshal(val.mode, coct, swap);
    OBUnmarshal(val.contexts, coct, swap);
    OBUnmarshal(val.parameters, coct, swap);
    OBUnmarshal(val.exceptions, coct, swap);
}

OBTypeCodeConst CORBA__tc_OperationDescription(
"010000000f00000094070000010000002b00000049444c3a6f6d672e6f72672f434f5242412f4"
"f7065726174696f6e4465736372697074696f6e3a312e300000150000004f7065726174696f6e"
"4465736372697074696f6e0000000009000000050000006e616d6500000000150000004400000"
"0010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a31"
"2e30000000000b0000004964656e7469666965720000120000000000000003000000696400001"
"500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f73"
"69746f727949643a312e3000000d0000005265706f7369746f727949640000000012000000000"
"000000b000000646566696e65645f696e00001500000048000000010000002300000049444c3a"
"6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d00000052657"
"06f7369746f727949640000000012000000000000000800000076657273696f6e001500000044"
"000000010000002200000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e53706"
"5633a312e300000000c00000056657273696f6e53706563001200000000000000070000007265"
"73756c7400000c000000050000006d6f646500000000110000006200000001000000240000004"
"9444c3a6f6d672e6f72672f434f5242412f4f7065726174696f6e4d6f64653a312e30000e0000"
"004f7065726174696f6e4d6f6465000000020000000a0000004f505f4e4f524d414c0000000a0"
"000004f505f4f4e4557415900000009000000636f6e74657874730000000015000000ec000000"
"010000002300000049444c3a6f6d672e6f72672f434f5242412f436f6e7465787449645365713"
"a312e3000000d000000436f6e7465787449645365710000000013000000a40000000100000015"
"00000094000000010000002800000049444c3a6f6d672e6f72672f434f5242412f436f6e74657"
"8744964656e7469666965723a312e300012000000436f6e746578744964656e74696669657200"
"00001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f49646"
"56e7469666965723a312e30000000000b0000004964656e746966696572000012000000000000"
"00000000000b000000706172616d6574657273000015000000f00100000100000028000000494"
"44c3a6f6d672e6f72672f434f5242412f5061724465736372697074696f6e5365713a312e3000"
"120000005061724465736372697074696f6e53657100000013000000a0010000010000000f000"
"00090010000010000002b00000049444c3a6f6d672e6f72672f434f5242412f506172616d6574"
"65724465736372697074696f6e3a312e30000015000000506172616d657465724465736372697"
"074696f6e0000000004000000050000006e616d65000000001500000044000000010000002100"
"000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000"
"b0000004964656e746966696572000012000000000000000500000074797065000000000c0000"
"0009000000747970655f646566000000000e00000034000000010000001e00000049444c3a6f6"
"d672e6f72672f434f5242412f49444c547970653a312e300000000800000049444c5479706500"
"050000006d6f6465000000001100000074000000010000002400000049444c3a6f6d672e6f726"
"72f434f5242412f506172616d657465724d6f64653a312e30000e000000506172616d65746572"
"4d6f64650000000300000009000000504152414d5f494e000000000a000000504152414d5f4f5"
"5540000000c000000504152414d5f494e4f555400000000000b000000657863657074696f6e73"
"0000150000002c020000010000002800000049444c3a6f6d672e6f72672f434f5242412f45786"
"34465736372697074696f6e5365713a312e3000120000004578634465736372697074696f6e53"
"657100000013000000dc010000010000000f000000cc010000010000002b00000049444c3a6f6"
"d672e6f72672f434f5242412f457863657074696f6e4465736372697074696f6e3a312e300000"
"15000000457863657074696f6e4465736372697074696f6e0000000005000000050000006e616"
"d65000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f524241"
"2f4964656e7469666965723a312e30000000000b0000004964656e74696669657200001200000"
"00000000003000000696400001500000048000000010000002300000049444c3a6f6d672e6f72"
"672f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f7"
"27949640000000012000000000000000b000000646566696e65645f696e000015000000480000"
"00010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f7279496"
"43a312e3000000d0000005265706f7369746f7279496400000000120000000000000008000000"
"76657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f434f5"
"242412f56657273696f6e537065633a312e300000000c00000056657273696f6e537065630012"
"000000000000000500000074797065000000000c00000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_OperationDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_OperationDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_OperationDescription* p)
{
    static const OBInfo< CORBA_OperationDescription > info;
    any.replace(CORBA__tc_OperationDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_OperationDescription& val)
{
    CORBA_OperationDescription* p = new CORBA_OperationDescription(val);
    static const OBInfo< CORBA_OperationDescription > info;
    any.replace(CORBA__tc_OperationDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_OperationDescription*& p)
{
    if(any.check_type(CORBA__tc_OperationDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_OperationDescription* v = new CORBA_OperationDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_OperationDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/RepositoryIdSeq:1.0
//
OBTypeCodeConst CORBA__tc_RepositoryIdSeq(
"0100000015000000a4000000010000002600000049444c3a6f6d672e6f72672f434f5242412f5"
"265706f7369746f727949645365713a312e30000000100000005265706f7369746f7279496453"
"6571001300000058000000010000001500000048000000010000002300000049444c3a6f6d672"
"e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369"
"746f7279496400000000120000000000000000000000"
);

//
// IDL:omg.org/CORBA/OpDescriptionSeq:1.0
//
OBTypeCodeConst CORBA__tc_OpDescriptionSeq(
"0100000015000000f4070000010000002700000049444c3a6f6d672e6f72672f434f5242412f4"
"f704465736372697074696f6e5365713a312e300000110000004f704465736372697074696f6e"
"5365710000000013000000a4070000010000000f00000094070000010000002b00000049444c3"
"a6f6d672e6f72672f434f5242412f4f7065726174696f6e4465736372697074696f6e3a312e30"
"0000150000004f7065726174696f6e4465736372697074696f6e0000000009000000050000006"
"e616d65000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f52"
"42412f4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120"
"000000000000003000000696400001500000048000000010000002300000049444c3a6f6d672e"
"6f72672f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f73697"
"46f727949640000000012000000000000000b000000646566696e65645f696e00001500000048"
"000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727"
"949643a312e3000000d0000005265706f7369746f727949640000000012000000000000000800"
"000076657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f4"
"34f5242412f56657273696f6e537065633a312e300000000c00000056657273696f6e53706563"
"00120000000000000007000000726573756c7400000c000000050000006d6f646500000000110"
"0000062000000010000002400000049444c3a6f6d672e6f72672f434f5242412f4f7065726174"
"696f6e4d6f64653a312e30000e0000004f7065726174696f6e4d6f6465000000020000000a000"
"0004f505f4e4f524d414c0000000a0000004f505f4f4e4557415900000009000000636f6e7465"
"7874730000000015000000ec000000010000002300000049444c3a6f6d672e6f72672f434f524"
"2412f436f6e7465787449645365713a312e3000000d000000436f6e7465787449645365710000"
"000013000000a4000000010000001500000094000000010000002800000049444c3a6f6d672e6"
"f72672f434f5242412f436f6e746578744964656e7469666965723a312e300012000000436f6e"
"746578744964656e7469666965720000001500000044000000010000002100000049444c3a6f6"
"d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004964656e"
"74696669657200001200000000000000000000000b000000706172616d6574657273000015000"
"000f0010000010000002800000049444c3a6f6d672e6f72672f434f5242412f50617244657363"
"72697074696f6e5365713a312e3000120000005061724465736372697074696f6e53657100000"
"013000000a0010000010000000f00000090010000010000002b00000049444c3a6f6d672e6f72"
"672f434f5242412f506172616d657465724465736372697074696f6e3a312e300000150000005"
"06172616d657465724465736372697074696f6e0000000004000000050000006e616d65000000"
"001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656"
"e7469666965723a312e30000000000b0000004964656e74696669657200001200000000000000"
"0500000074797065000000000c00000009000000747970655f646566000000000e00000034000"
"000010000001e00000049444c3a6f6d672e6f72672f434f5242412f49444c547970653a312e30"
"0000000800000049444c5479706500050000006d6f64650000000011000000740000000100000"
"02400000049444c3a6f6d672e6f72672f434f5242412f506172616d657465724d6f64653a312e"
"30000e000000506172616d657465724d6f64650000000300000009000000504152414d5f494e0"
"00000000a000000504152414d5f4f55540000000c000000504152414d5f494e4f555400000000"
"000b000000657863657074696f6e730000150000002c020000010000002800000049444c3a6f6"
"d672e6f72672f434f5242412f4578634465736372697074696f6e5365713a312e300012000000"
"4578634465736372697074696f6e53657100000013000000dc010000010000000f000000cc010"
"000010000002b00000049444c3a6f6d672e6f72672f434f5242412f457863657074696f6e4465"
"736372697074696f6e3a312e30000015000000457863657074696f6e4465736372697074696f6"
"e0000000005000000050000006e616d6500000000150000004400000001000000210000004944"
"4c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004"
"964656e7469666965720000120000000000000003000000696400001500000048000000010000"
"002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3"
"000000d0000005265706f7369746f727949640000000012000000000000000b00000064656669"
"6e65645f696e00001500000048000000010000002300000049444c3a6f6d672e6f72672f434f5"
"242412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f7279496400"
"00000012000000000000000800000076657273696f6e001500000044000000010000002200000"
"049444c3a6f6d672e6f72672f434f5242412f56657273696f6e537065633a312e300000000c00"
"000056657273696f6e537065630012000000000000000500000074797065000000000c0000000"
"000000000000000"
);

//
// IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
//
OBTypeCodeConst CORBA__tc_AttrDescriptionSeq(
"0100000015000000ac020000010000002900000049444c3a6f6d672e6f72672f434f5242412f4"
"17474724465736372697074696f6e5365713a312e300000000013000000417474724465736372"
"697074696f6e53657100001300000058020000010000000f00000046020000010000002b00000"
"049444c3a6f6d672e6f72672f434f5242412f4174747269627574654465736372697074696f6e"
"3a312e300000150000004174747269627574654465736372697074696f6e00000000060000000"
"50000006e616d65000000001500000044000000010000002100000049444c3a6f6d672e6f7267"
"2f434f5242412f4964656e7469666965723a312e30000000000b0000004964656e74696669657"
"20000120000000000000003000000696400001500000048000000010000002300000049444c3a"
"6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d00000052657"
"06f7369746f727949640000000012000000000000000b000000646566696e65645f696e000015"
"00000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f736"
"9746f727949643a312e3000000d0000005265706f7369746f7279496400000000120000000000"
"00000800000076657273696f6e001500000044000000010000002200000049444c3a6f6d672e6"
"f72672f434f5242412f56657273696f6e537065633a312e300000000c00000056657273696f6e"
"537065630012000000000000000500000074797065000000000c000000050000006d6f6465000"
"000001100000066000000010000002400000049444c3a6f6d672e6f72672f434f5242412f4174"
"747269627574654d6f64653a312e30000e0000004174747269627574654d6f646500000002000"
"0000c000000415454525f4e4f524d414c000e000000415454525f524541444f4e4c5900000000"
"000000"
);

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< CORBA_InterfaceDef >;
template class OBObjForSeq< CORBA_InterfaceDef >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< CORBA_InterfaceDef >)
#pragma define(OBObjForSeq< CORBA_InterfaceDef >)
#endif
#endif

void
OBDuplicate(CORBA_InterfaceDef_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(CORBA_InterfaceDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

CORBA_InterfaceDef_ptr
CORBA_InterfaceDef::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/InterfaceDef:1.0");

        if(v)
            return _duplicate((CORBA_InterfaceDef_ptr)v);

        if(p -> _OB_remoteIsA("IDL:omg.org/CORBA/InterfaceDef:1.0"))
        {
            CORBA_InterfaceDef_ptr val = new CORBA_InterfaceDef;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
CORBA_InterfaceDef::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:omg.org/CORBA/InterfaceDef:1.0", _ob_id) == 0)
        return (void*)this;
    else
    {
        void* v;
        if((v = CORBA_Container::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        if((v = CORBA_Contained::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        if((v = CORBA_IDLType::_OB_narrowHelp(_ob_id)) != 0)
            return v;
        return 0;
    }
}

const char*
CORBA_InterfaceDef::_OB_typeId() const
{
    return "IDL:omg.org/CORBA/InterfaceDef:1.0";
}

void
OBUnmarshal(CORBA_InterfaceDef_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_InterfaceDef_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:omg.org/CORBA/InterfaceDef:1.0");

        if(v)
            val = CORBA_InterfaceDef::_duplicate((CORBA_InterfaceDef_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new CORBA_InterfaceDef;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = CORBA_InterfaceDef::_nil();
}

OBTypeCodeConst CORBA__tc_InterfaceDef(
"010000000e0000003d000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"96e746572666163654465663a312e3000000d000000496e7465726661636544656600"
);

void
operator<<=(CORBA_Any& any, CORBA_InterfaceDef_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(CORBA__tc_InterfaceDef, o, true);
}

void
operator<<=(CORBA_Any& any, CORBA_InterfaceDef_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(CORBA__tc_InterfaceDef, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_InterfaceDef_ptr& val)
{
    if(any.check_type(CORBA__tc_InterfaceDef))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:omg.org/CORBA/InterfaceDef:1.0");

            if(v)
                val = (CORBA_InterfaceDef_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new CORBA_InterfaceDef;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(CORBA__tc_InterfaceDef, no, true);
            }
        }
        else
            val = CORBA_InterfaceDef::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/InterfaceDef/base_interfaces:1.0
//
CORBA_InterfaceDefSeq*
CORBA_InterfaceDef::base_interfaces()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_get_base_interfaces");

    OBBuffer _ob_buf(_ob_off);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "_get_base_interfaces", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return base_interfaces();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_InterfaceDefSeq* _ob_r = new CORBA_InterfaceDefSeq;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

void
CORBA_InterfaceDef::base_interfaces(const CORBA_InterfaceDefSeq& _ob_a)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "_set_base_interfaces");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_clt_ -> request(this, "_set_base_interfaces", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    if(_ob_fo)
    {
        const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;
        _OB_forward(_ob_co, _ob_sw);
        base_interfaces(_ob_a);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:omg.org/CORBA/InterfaceDef/is_a:1.0
//
CORBA_Boolean
CORBA_InterfaceDef::is_a(const char* _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "is_a");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "is_a", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return is_a(_ob_a0);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_Boolean _ob_r;
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/InterfaceDef/FullInterfaceDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_InterfaceDef::FullInterfaceDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_InterfaceDef::FullInterfaceDescription >)
#endif
#endif

CORBA_InterfaceDef::FullInterfaceDescription::FullInterfaceDescription(const CORBA_InterfaceDef::FullInterfaceDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      operations(_ob_a.operations),
      attributes(_ob_a.attributes),
      base_interfaces(_ob_a.base_interfaces),
      type(_ob_a.type)
{
}

CORBA_InterfaceDef::FullInterfaceDescription&
CORBA_InterfaceDef::FullInterfaceDescription::operator=(const FullInterfaceDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        operations = _ob_a.operations;
        attributes = _ob_a.attributes;
        base_interfaces = _ob_a.base_interfaces;
        type = _ob_a.type;
    }
    return *this;
}

void
OBMarshal(const CORBA_InterfaceDef::FullInterfaceDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.operations, oct);
    OBMarshal(val.attributes, oct);
    OBMarshal(val.base_interfaces, oct);
    OBMarshal(val.type.in(), oct);
}

void
OBMarshalCount(const CORBA_InterfaceDef::FullInterfaceDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.operations, count);
    OBMarshalCount(val.attributes, count);
    OBMarshalCount(val.base_interfaces, count);
    OBMarshalCount(val.type.in(), count);
}

void
OBUnmarshal(CORBA_InterfaceDef::FullInterfaceDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.operations, coct, swap);
    OBUnmarshal(val.attributes, coct, swap);
    OBUnmarshal(val.base_interfaces, coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
}

OBTypeCodeConst CORBA_InterfaceDef::_tc_FullInterfaceDescription(
"010000000f000000700d0000010000003c00000049444c3a6f6d672e6f72672f434f5242412f4"
"96e746572666163654465662f46756c6c496e746572666163654465736372697074696f6e3a31"
"2e30001900000046756c6c496e746572666163654465736372697074696f6e000000000800000"
"0050000006e616d65000000001500000044000000010000002100000049444c3a6f6d672e6f72"
"672f434f5242412f4964656e7469666965723a312e30000000000b0000004964656e746966696"
"5720000120000000000000003000000696400001500000048000000010000002300000049444c"
"3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d000000526"
"5706f7369746f727949640000000012000000000000000b000000646566696e65645f696e0000"
"1500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7"
"369746f727949643a312e3000000d0000005265706f7369746f72794964000000001200000000"
"0000000800000076657273696f6e001500000044000000010000002200000049444c3a6f6d672"
"e6f72672f434f5242412f56657273696f6e537065633a312e300000000c00000056657273696f"
"6e537065630012000000000000000b0000006f7065726174696f6e73000015000000f40700000"
"10000002700000049444c3a6f6d672e6f72672f434f5242412f4f704465736372697074696f6e"
"5365713a312e300000110000004f704465736372697074696f6e5365710000000013000000a40"
"70000010000000f00000094070000010000002b00000049444c3a6f6d672e6f72672f434f5242"
"412f4f7065726174696f6e4465736372697074696f6e3a312e300000150000004f70657261746"
"96f6e4465736372697074696f6e0000000009000000050000006e616d65000000001500000044"
"000000010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e74696669657"
"23a312e30000000000b0000004964656e74696669657200001200000000000000030000006964"
"00001500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f52657"
"06f7369746f727949643a312e3000000d0000005265706f7369746f7279496400000000120000"
"00000000000b000000646566696e65645f696e000015000000480000000100000023000000494"
"44c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d000000"
"5265706f7369746f727949640000000012000000000000000800000076657273696f6e0015000"
"00044000000010000002200000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e"
"537065633a312e300000000c00000056657273696f6e537065630012000000000000000700000"
"0726573756c7400000c000000050000006d6f6465000000001100000062000000010000002400"
"000049444c3a6f6d672e6f72672f434f5242412f4f7065726174696f6e4d6f64653a312e30000"
"e0000004f7065726174696f6e4d6f6465000000020000000a0000004f505f4e4f524d414c0000"
"000a0000004f505f4f4e4557415900000009000000636f6e74657874730000000015000000ec0"
"00000010000002300000049444c3a6f6d672e6f72672f434f5242412f436f6e74657874496453"
"65713a312e3000000d000000436f6e7465787449645365710000000013000000a400000001000"
"0001500000094000000010000002800000049444c3a6f6d672e6f72672f434f5242412f436f6e"
"746578744964656e7469666965723a312e300012000000436f6e746578744964656e746966696"
"5720000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f"
"4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120000000"
"0000000000000000b000000706172616d6574657273000015000000f001000001000000280000"
"0049444c3a6f6d672e6f72672f434f5242412f5061724465736372697074696f6e5365713a312"
"e3000120000005061724465736372697074696f6e53657100000013000000a001000001000000"
"0f00000090010000010000002b00000049444c3a6f6d672e6f72672f434f5242412f506172616"
"d657465724465736372697074696f6e3a312e30000015000000506172616d6574657244657363"
"72697074696f6e0000000004000000050000006e616d650000000015000000440000000100000"
"02100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e300000"
"00000b0000004964656e746966696572000012000000000000000500000074797065000000000"
"c00000009000000747970655f646566000000000e00000034000000010000001e00000049444c"
"3a6f6d672e6f72672f434f5242412f49444c547970653a312e300000000800000049444c54797"
"06500050000006d6f6465000000001100000074000000010000002400000049444c3a6f6d672e"
"6f72672f434f5242412f506172616d657465724d6f64653a312e30000e000000506172616d657"
"465724d6f64650000000300000009000000504152414d5f494e000000000a000000504152414d"
"5f4f55540000000c000000504152414d5f494e4f555400000000000b000000657863657074696"
"f6e730000150000002c020000010000002800000049444c3a6f6d672e6f72672f434f5242412f"
"4578634465736372697074696f6e5365713a312e3000120000004578634465736372697074696"
"f6e53657100000013000000dc010000010000000f000000cc010000010000002b00000049444c"
"3a6f6d672e6f72672f434f5242412f457863657074696f6e4465736372697074696f6e3a312e3"
"0000015000000457863657074696f6e4465736372697074696f6e000000000500000005000000"
"6e616d65000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5"
"242412f4964656e7469666965723a312e30000000000b0000004964656e746966696572000012"
"0000000000000003000000696400001500000048000000010000002300000049444c3a6f6d672"
"e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369"
"746f727949640000000012000000000000000b000000646566696e65645f696e0000150000004"
"8000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f72"
"7949643a312e3000000d0000005265706f7369746f72794964000000001200000000000000080"
"0000076657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f"
"434f5242412f56657273696f6e537065633a312e300000000c00000056657273696f6e5370656"
"30012000000000000000500000074797065000000000c00000000000000000000000b00000061"
"747472696275746573000015000000ac020000010000002900000049444c3a6f6d672e6f72672"
"f434f5242412f417474724465736372697074696f6e5365713a312e3000000000130000004174"
"74724465736372697074696f6e53657100001300000058020000010000000f000000460200000"
"10000002b00000049444c3a6f6d672e6f72672f434f5242412f41747472696275746544657363"
"72697074696f6e3a312e300000150000004174747269627574654465736372697074696f6e000"
"0000006000000050000006e616d65000000001500000044000000010000002100000049444c3a"
"6f6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b00000049646"
"56e74696669657200001200000000000000030000006964000015000000480000000100000023"
"00000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e30000"
"00d0000005265706f7369746f727949640000000012000000000000000b000000646566696e65"
"645f696e00001500000048000000010000002300000049444c3a6f6d672e6f72672f434f52424"
"12f5265706f7369746f727949643a312e3000000d0000005265706f7369746f72794964000000"
"0012000000000000000800000076657273696f6e0015000000440000000100000022000000494"
"44c3a6f6d672e6f72672f434f5242412f56657273696f6e537065633a312e300000000c000000"
"56657273696f6e537065630012000000000000000500000074797065000000000c00000005000"
"0006d6f6465000000001100000066000000010000002400000049444c3a6f6d672e6f72672f43"
"4f5242412f4174747269627574654d6f64653a312e30000e0000004174747269627574654d6f6"
"465000000020000000c000000415454525f4e4f524d414c000e000000415454525f524541444f"
"4e4c590000000000000010000000626173655f696e74657266616365730015000000a40000000"
"10000002600000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f7279496453"
"65713a312e30000000100000005265706f7369746f72794964536571001300000058000000010"
"000001500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265"
"706f7369746f727949643a312e3000000d0000005265706f7369746f727949640000000012000"
"00000000000000000000500000074797065000000000c000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_InterfaceDef::FullInterfaceDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_InterfaceDef::FullInterfaceDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_InterfaceDef::FullInterfaceDescription* p)
{
    static const OBInfo< CORBA_InterfaceDef::FullInterfaceDescription > info;
    any.replace(CORBA_InterfaceDef::_tc_FullInterfaceDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_InterfaceDef::FullInterfaceDescription& val)
{
    CORBA_InterfaceDef::FullInterfaceDescription* p = new CORBA_InterfaceDef::FullInterfaceDescription(val);
    static const OBInfo< CORBA_InterfaceDef::FullInterfaceDescription > info;
    any.replace(CORBA_InterfaceDef::_tc_FullInterfaceDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_InterfaceDef::FullInterfaceDescription*& p)
{
    if(any.check_type(CORBA_InterfaceDef::_tc_FullInterfaceDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_InterfaceDef::FullInterfaceDescription* v = new CORBA_InterfaceDef::FullInterfaceDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_InterfaceDef::FullInterfaceDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0
//
CORBA_InterfaceDef::FullInterfaceDescription*
CORBA_InterfaceDef::describe_interface()
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "describe_interface");
    CORBA_ULong _ob_cnt = _ob_off;

    OBBuffer _ob_buf(_ob_cnt);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "describe_interface", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return describe_interface();
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    FullInterfaceDescription* _ob_r = new FullInterfaceDescription;
    OBUnmarshal(*_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/InterfaceDef/create_attribute:1.0
//
CORBA_AttributeDef_ptr
CORBA_InterfaceDef::create_attribute(const char* _ob_a0,
                                     const char* _ob_a1,
                                     const char* _ob_a2,
                                     CORBA_IDLType_ptr _ob_a3,
                                     CORBA_AttributeMode _ob_a4)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_attribute");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_attribute", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_attribute(_ob_a0, _ob_a1, _ob_a2, _ob_a3, _ob_a4);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_AttributeDef_ptr _ob_r = CORBA_AttributeDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/InterfaceDef/create_operation:1.0
//
CORBA_OperationDef_ptr
CORBA_InterfaceDef::create_operation(const char* _ob_a0,
                                     const char* _ob_a1,
                                     const char* _ob_a2,
                                     CORBA_IDLType_ptr _ob_a3,
                                     CORBA_OperationMode _ob_a4,
                                     const CORBA_ParDescriptionSeq& _ob_a5,
                                     const CORBA_ExceptionDefSeq& _ob_a6,
                                     const CORBA_ContextIdSeq& _ob_a7)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "create_operation");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);
    OBMarshalCount(_ob_a7, _ob_cnt);

    OBBuffer _ob_buf(_ob_cnt);
    CORBA_Octet* _ob_o = _ob_buf.data + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);
    OBMarshal(_ob_a7, _ob_o);

    bool _ob_sw, _ob_ex, _ob_fo;
    _ob_off = _ob_clt_ -> request(this, "create_operation", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_, _ob_retry_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

    if(_ob_fo)
    {
        _OB_forward(_ob_co, _ob_sw);
        return create_operation(_ob_a0, _ob_a1, _ob_a2, _ob_a3, _ob_a4, _ob_a5, _ob_a6, _ob_a7);
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();

    CORBA_OperationDef_ptr _ob_r = CORBA_OperationDef::_nil();
    OBUnmarshal(_ob_r, _ob_co, _ob_sw);
    return _ob_r;
}

//
// IDL:omg.org/CORBA/InterfaceDescription:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< CORBA_InterfaceDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< CORBA_InterfaceDescription >)
#endif
#endif

CORBA_InterfaceDescription::CORBA_InterfaceDescription(const CORBA_InterfaceDescription& _ob_a)
    : name(_ob_a.name),
      id(_ob_a.id),
      defined_in(_ob_a.defined_in),
      version(_ob_a.version),
      base_interfaces(_ob_a.base_interfaces)
{
}

CORBA_InterfaceDescription&
CORBA_InterfaceDescription::operator=(const CORBA_InterfaceDescription& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        id = _ob_a.id;
        defined_in = _ob_a.defined_in;
        version = _ob_a.version;
        base_interfaces = _ob_a.base_interfaces;
    }
    return *this;
}

void
OBMarshal(const CORBA_InterfaceDescription& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.defined_in.in(), oct);
    OBMarshal(val.version.in(), oct);
    OBMarshal(val.base_interfaces, oct);
}

void
OBMarshalCount(const CORBA_InterfaceDescription& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.defined_in.in(), count);
    OBMarshalCount(val.version.in(), count);
    OBMarshalCount(val.base_interfaces, count);
}

void
OBUnmarshal(CORBA_InterfaceDescription& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.defined_in.inout(), coct, swap);
    OBUnmarshal(val.version.inout(), coct, swap);
    OBUnmarshal(val.base_interfaces, coct, swap);
}

OBTypeCodeConst CORBA__tc_InterfaceDescription(
"010000000f0000007c020000010000002b00000049444c3a6f6d672e6f72672f434f5242412f4"
"96e746572666163654465736372697074696f6e3a312e30000015000000496e74657266616365"
"4465736372697074696f6e0000000005000000050000006e616d6500000000150000004400000"
"0010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a31"
"2e30000000000b0000004964656e7469666965720000120000000000000003000000696400001"
"500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f73"
"69746f727949643a312e3000000d0000005265706f7369746f727949640000000012000000000"
"000000b000000646566696e65645f696e00001500000048000000010000002300000049444c3a"
"6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000d00000052657"
"06f7369746f727949640000000012000000000000000800000076657273696f6e001500000044"
"000000010000002200000049444c3a6f6d672e6f72672f434f5242412f56657273696f6e53706"
"5633a312e300000000c00000056657273696f6e53706563001200000000000000100000006261"
"73655f696e74657266616365730015000000a4000000010000002600000049444c3a6f6d672e6"
"f72672f434f5242412f5265706f7369746f727949645365713a312e3000000010000000526570"
"6f7369746f7279496453657100130000005800000001000000150000004800000001000000230"
"0000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e300000"
"0d0000005265706f7369746f7279496400000000120000000000000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< CORBA_InterfaceDescription >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< CORBA_InterfaceDescription >)
#endif
#endif

void
operator<<=(CORBA_Any& any, CORBA_InterfaceDescription* p)
{
    static const OBInfo< CORBA_InterfaceDescription > info;
    any.replace(CORBA__tc_InterfaceDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const CORBA_InterfaceDescription& val)
{
    CORBA_InterfaceDescription* p = new CORBA_InterfaceDescription(val);
    static const OBInfo< CORBA_InterfaceDescription > info;
    any.replace(CORBA__tc_InterfaceDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, CORBA_InterfaceDescription*& p)
{
    if(any.check_type(CORBA__tc_InterfaceDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            CORBA_InterfaceDescription* v = new CORBA_InterfaceDescription;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (CORBA_InterfaceDescription*)any.value();
        return true;
    }
    else
        return false;
}

//
// OBObjSeq< CORBA_InterfaceDef >
//
#ifdef OB_use_OBObjSeq_CORBA__InterfaceDef_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_InterfaceDef >;
template class OBSeqVar< OBObjSeq< CORBA_InterfaceDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_InterfaceDef >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_InterfaceDef > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_InterfaceDef >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_InterfaceDef >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_InterfaceDef >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

static OBTypeCodeConst _tc_OBObjSeq_CORBA__InterfaceDef(
"010000001300000050000000010000000e0000003d000000010000002300000049444c3a6f6d6"
"72e6f72672f434f5242412f496e746572666163654465663a312e3000000d000000496e746572"
"666163654465660000000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBObjSeq< CORBA_InterfaceDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBObjSeq< CORBA_InterfaceDef > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBObjSeq< CORBA_InterfaceDef >* p)
{
    static const OBInfo< OBObjSeq< CORBA_InterfaceDef > > info;
    any.replace(_tc_OBObjSeq_CORBA__InterfaceDef, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBObjSeq< CORBA_InterfaceDef >& seq)
{
    static const OBInfo< OBObjSeq< CORBA_InterfaceDef > > info;
    OBObjSeq< CORBA_InterfaceDef >* p = new OBObjSeq< CORBA_InterfaceDef >(seq);
    any.replace(_tc_OBObjSeq_CORBA__InterfaceDef, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBObjSeq< CORBA_InterfaceDef >*& p)
{
    if(any.check_type(_tc_OBObjSeq_CORBA__InterfaceDef))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBObjSeq< CORBA_InterfaceDef >* v = new OBObjSeq< CORBA_InterfaceDef >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBObjSeq< CORBA_InterfaceDef >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBObjSeq< CORBA_Contained >
//
#ifdef OB_use_OBObjSeq_CORBA__Contained_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_Contained >;
template class OBSeqVar< OBObjSeq< CORBA_Contained > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_Contained >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_Contained > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_Contained >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_Contained >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_Contained >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

static OBTypeCodeConst _tc_OBObjSeq_CORBA__Contained(
"010000001300000048000000010000000e00000036000000010000002000000049444c3a6f6d6"
"72e6f72672f434f5242412f436f6e7461696e65643a312e30000a000000436f6e7461696e6564"
"00000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBObjSeq< CORBA_Contained > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBObjSeq< CORBA_Contained > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBObjSeq< CORBA_Contained >* p)
{
    static const OBInfo< OBObjSeq< CORBA_Contained > > info;
    any.replace(_tc_OBObjSeq_CORBA__Contained, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBObjSeq< CORBA_Contained >& seq)
{
    static const OBInfo< OBObjSeq< CORBA_Contained > > info;
    OBObjSeq< CORBA_Contained >* p = new OBObjSeq< CORBA_Contained >(seq);
    any.replace(_tc_OBObjSeq_CORBA__Contained, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBObjSeq< CORBA_Contained >*& p)
{
    if(any.check_type(_tc_OBObjSeq_CORBA__Contained))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBObjSeq< CORBA_Contained >* v = new OBObjSeq< CORBA_Contained >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBObjSeq< CORBA_Contained >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_Container::Description >
//
#ifdef OB_use_OBVarSeq_CORBA__Container_Description_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_Container::Description >;
template class OBSeqVar< OBVarSeq< CORBA_Container::Description > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_Container::Description >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_Container::Description > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_Container::Description >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_Container::Description >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_Container::Description >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__Container_Description(
"010000001300000048020000010000000f00000038020000010000002c00000049444c3a6f6d6"
"72e6f72672f434f5242412f436f6e7461696e65722f4465736372697074696f6e3a312e30000c"
"0000004465736372697074696f6e000300000011000000636f6e7461696e65645f6f626a65637"
"4000000000e00000036000000010000002000000049444c3a6f6d672e6f72672f434f5242412f"
"436f6e7461696e65643a312e30000a000000436f6e7461696e6564000000050000006b696e640"
"00000001100000072010000010000002500000049444c3a6f6d672e6f72672f434f5242412f44"
"6566696e6974696f6e4b696e643a312e30000000000f000000446566696e6974696f6e4b696e6"
"400001200000008000000646b5f6e6f6e650007000000646b5f616c6c00000d000000646b5f41"
"7474726962757465000000000c000000646b5f436f6e7374616e74000d000000646b5f4578636"
"57074696f6e000000000d000000646b5f496e74657266616365000000000a000000646b5f4d6f"
"64756c650000000d000000646b5f4f7065726174696f6e000000000b000000646b5f547970656"
"46566000009000000646b5f416c696173000000000a000000646b5f5374727563740000000900"
"0000646b5f556e696f6e0000000008000000646b5f456e756d000d000000646b5f5072696d697"
"4697665000000000a000000646b5f537472696e670000000c000000646b5f53657175656e6365"
"0009000000646b5f4172726179000000000e000000646b5f5265706f7369746f7279000000060"
"0000076616c75650000000b00000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_Container::Description > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_Container::Description > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_Container::Description >* p)
{
    static const OBInfo< OBVarSeq< CORBA_Container::Description > > info;
    any.replace(_tc_OBVarSeq_CORBA__Container_Description, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_Container::Description >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_Container::Description > > info;
    OBVarSeq< CORBA_Container::Description >* p = new OBVarSeq< CORBA_Container::Description >(seq);
    any.replace(_tc_OBVarSeq_CORBA__Container_Description, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_Container::Description >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__Container_Description))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_Container::Description >* v = new OBVarSeq< CORBA_Container::Description >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_Container::Description >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_StructMember >
//
#ifdef OB_use_OBVarSeq_CORBA__StructMember_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_StructMember >;
template class OBSeqVar< OBVarSeq< CORBA_StructMember > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_StructMember >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_StructMember > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_StructMember >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_StructMember >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_StructMember >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__StructMember(
"010000001300000008010000010000000f000000f8000000010000002300000049444c3a6f6d6"
"72e6f72672f434f5242412f5374727563744d656d6265723a312e3000000d0000005374727563"
"744d656d6265720000000003000000050000006e616d650000000015000000440000000100000"
"02100000049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e300000"
"00000b0000004964656e746966696572000012000000000000000500000074797065000000000"
"c00000009000000747970655f646566000000000e00000034000000010000001e00000049444c"
"3a6f6d672e6f72672f434f5242412f49444c547970653a312e300000000800000049444c54797"
"0650000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_StructMember > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_StructMember > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_StructMember >* p)
{
    static const OBInfo< OBVarSeq< CORBA_StructMember > > info;
    any.replace(_tc_OBVarSeq_CORBA__StructMember, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_StructMember >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_StructMember > > info;
    OBVarSeq< CORBA_StructMember >* p = new OBVarSeq< CORBA_StructMember >(seq);
    any.replace(_tc_OBVarSeq_CORBA__StructMember, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_StructMember >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__StructMember))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_StructMember >* v = new OBVarSeq< CORBA_StructMember >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_StructMember >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_UnionMember >
//
#ifdef OB_use_OBVarSeq_CORBA__UnionMember_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_UnionMember >;
template class OBSeqVar< OBVarSeq< CORBA_UnionMember > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_UnionMember >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_UnionMember > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_UnionMember >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_UnionMember >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_UnionMember >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__UnionMember(
"010000001300000014010000010000000f00000004010000010000002200000049444c3a6f6d6"
"72e6f72672f434f5242412f556e696f6e4d656d6265723a312e300000000c000000556e696f6e"
"4d656d6265720004000000050000006e616d65000000001500000044000000010000002100000"
"049444c3a6f6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b00"
"00004964656e74696669657200001200000000000000060000006c6162656c0000000b0000000"
"500000074797065000000000c00000009000000747970655f646566000000000e000000340000"
"00010000001e00000049444c3a6f6d672e6f72672f434f5242412f49444c547970653a312e300"
"000000800000049444c547970650000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_UnionMember > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_UnionMember > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_UnionMember >* p)
{
    static const OBInfo< OBVarSeq< CORBA_UnionMember > > info;
    any.replace(_tc_OBVarSeq_CORBA__UnionMember, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_UnionMember >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_UnionMember > > info;
    OBVarSeq< CORBA_UnionMember >* p = new OBVarSeq< CORBA_UnionMember >(seq);
    any.replace(_tc_OBVarSeq_CORBA__UnionMember, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_UnionMember >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__UnionMember))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_UnionMember >* v = new OBVarSeq< CORBA_UnionMember >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_UnionMember >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBStrSeq
//
#ifdef OB_use_OBStrSeq_from_IntRep_h

static OBTypeCodeConst _tc_OBStrSeq(
"010000001300000054000000010000001500000044000000010000002100000049444c3a6f6d6"
"72e6f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004964656e74"
"69666965720000120000000000000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBStrSeq >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBStrSeq >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBStrSeq* p)
{
    static const OBInfo< OBStrSeq > info;
    any.replace(_tc_OBStrSeq, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBStrSeq& seq)
{
    static const OBInfo< OBStrSeq > info;
    OBStrSeq* p = new OBStrSeq(seq);
    any.replace(_tc_OBStrSeq, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBStrSeq*& p)
{
    if(any.check_type(_tc_OBStrSeq))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBStrSeq* v = new OBStrSeq;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBStrSeq*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_ParameterDescription >
//
#ifdef OB_use_OBVarSeq_CORBA__ParameterDescription_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_ParameterDescription >;
template class OBSeqVar< OBVarSeq< CORBA_ParameterDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_ParameterDescription >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_ParameterDescription > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_ParameterDescription >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_ParameterDescription >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_ParameterDescription >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__ParameterDescription(
"0100000013000000a0010000010000000f00000090010000010000002b00000049444c3a6f6d6"
"72e6f72672f434f5242412f506172616d657465724465736372697074696f6e3a312e30000015"
"000000506172616d657465724465736372697074696f6e0000000004000000050000006e616d6"
"5000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f"
"4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120000000"
"00000000500000074797065000000000c00000009000000747970655f646566000000000e0000"
"0034000000010000001e00000049444c3a6f6d672e6f72672f434f5242412f49444c547970653"
"a312e300000000800000049444c5479706500050000006d6f6465000000001100000074000000"
"010000002400000049444c3a6f6d672e6f72672f434f5242412f506172616d657465724d6f646"
"53a312e30000e000000506172616d657465724d6f64650000000300000009000000504152414d"
"5f494e000000000a000000504152414d5f4f55540000000c000000504152414d5f494e4f55540"
"000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_ParameterDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_ParameterDescription > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_ParameterDescription >* p)
{
    static const OBInfo< OBVarSeq< CORBA_ParameterDescription > > info;
    any.replace(_tc_OBVarSeq_CORBA__ParameterDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_ParameterDescription >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_ParameterDescription > > info;
    OBVarSeq< CORBA_ParameterDescription >* p = new OBVarSeq< CORBA_ParameterDescription >(seq);
    any.replace(_tc_OBVarSeq_CORBA__ParameterDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_ParameterDescription >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__ParameterDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_ParameterDescription >* v = new OBVarSeq< CORBA_ParameterDescription >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_ParameterDescription >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBObjSeq< CORBA_ExceptionDef >
//
#ifdef OB_use_OBObjSeq_CORBA__ExceptionDef_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_ExceptionDef >;
template class OBSeqVar< OBObjSeq< CORBA_ExceptionDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_ExceptionDef >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_ExceptionDef > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_ExceptionDef >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_ExceptionDef >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_ExceptionDef >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

static OBTypeCodeConst _tc_OBObjSeq_CORBA__ExceptionDef(
"010000001300000050000000010000000e0000003d000000010000002300000049444c3a6f6d6"
"72e6f72672f434f5242412f457863657074696f6e4465663a312e3000000d0000004578636570"
"74696f6e4465660000000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBObjSeq< CORBA_ExceptionDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBObjSeq< CORBA_ExceptionDef > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBObjSeq< CORBA_ExceptionDef >* p)
{
    static const OBInfo< OBObjSeq< CORBA_ExceptionDef > > info;
    any.replace(_tc_OBObjSeq_CORBA__ExceptionDef, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBObjSeq< CORBA_ExceptionDef >& seq)
{
    static const OBInfo< OBObjSeq< CORBA_ExceptionDef > > info;
    OBObjSeq< CORBA_ExceptionDef >* p = new OBObjSeq< CORBA_ExceptionDef >(seq);
    any.replace(_tc_OBObjSeq_CORBA__ExceptionDef, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBObjSeq< CORBA_ExceptionDef >*& p)
{
    if(any.check_type(_tc_OBObjSeq_CORBA__ExceptionDef))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBObjSeq< CORBA_ExceptionDef >* v = new OBObjSeq< CORBA_ExceptionDef >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBObjSeq< CORBA_ExceptionDef >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_ExceptionDescription >
//
#ifdef OB_use_OBVarSeq_CORBA__ExceptionDescription_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_ExceptionDescription >;
template class OBSeqVar< OBVarSeq< CORBA_ExceptionDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_ExceptionDescription >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_ExceptionDescription > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_ExceptionDescription >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_ExceptionDescription >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_ExceptionDescription >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__ExceptionDescription(
"0100000013000000dc010000010000000f000000cc010000010000002b00000049444c3a6f6d6"
"72e6f72672f434f5242412f457863657074696f6e4465736372697074696f6e3a312e30000015"
"000000457863657074696f6e4465736372697074696f6e0000000005000000050000006e616d6"
"5000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f"
"4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120000000"
"000000003000000696400001500000048000000010000002300000049444c3a6f6d672e6f7267"
"2f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f727"
"949640000000012000000000000000b000000646566696e65645f696e00001500000048000000"
"010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643"
"a312e3000000d0000005265706f7369746f727949640000000012000000000000000800000076"
"657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f434f524"
"2412f56657273696f6e537065633a312e300000000c00000056657273696f6e53706563001200"
"0000000000000500000074797065000000000c00000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_ExceptionDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_ExceptionDescription > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_ExceptionDescription >* p)
{
    static const OBInfo< OBVarSeq< CORBA_ExceptionDescription > > info;
    any.replace(_tc_OBVarSeq_CORBA__ExceptionDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_ExceptionDescription >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_ExceptionDescription > > info;
    OBVarSeq< CORBA_ExceptionDescription >* p = new OBVarSeq< CORBA_ExceptionDescription >(seq);
    any.replace(_tc_OBVarSeq_CORBA__ExceptionDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_ExceptionDescription >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__ExceptionDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_ExceptionDescription >* v = new OBVarSeq< CORBA_ExceptionDescription >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_ExceptionDescription >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_OperationDescription >
//
#ifdef OB_use_OBVarSeq_CORBA__OperationDescription_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_OperationDescription >;
template class OBSeqVar< OBVarSeq< CORBA_OperationDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_OperationDescription >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_OperationDescription > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_OperationDescription >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_OperationDescription >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_OperationDescription >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__OperationDescription(
"0100000013000000a4070000010000000f00000094070000010000002b00000049444c3a6f6d6"
"72e6f72672f434f5242412f4f7065726174696f6e4465736372697074696f6e3a312e30000015"
"0000004f7065726174696f6e4465736372697074696f6e0000000009000000050000006e616d6"
"5000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f"
"4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120000000"
"000000003000000696400001500000048000000010000002300000049444c3a6f6d672e6f7267"
"2f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f727"
"949640000000012000000000000000b000000646566696e65645f696e00001500000048000000"
"010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643"
"a312e3000000d0000005265706f7369746f727949640000000012000000000000000800000076"
"657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f434f524"
"2412f56657273696f6e537065633a312e300000000c00000056657273696f6e53706563001200"
"00000000000007000000726573756c7400000c000000050000006d6f646500000000110000006"
"2000000010000002400000049444c3a6f6d672e6f72672f434f5242412f4f7065726174696f6e"
"4d6f64653a312e30000e0000004f7065726174696f6e4d6f6465000000020000000a0000004f5"
"05f4e4f524d414c0000000a0000004f505f4f4e4557415900000009000000636f6e7465787473"
"0000000015000000ec000000010000002300000049444c3a6f6d672e6f72672f434f5242412f4"
"36f6e7465787449645365713a312e3000000d000000436f6e7465787449645365710000000013"
"000000a4000000010000001500000094000000010000002800000049444c3a6f6d672e6f72672"
"f434f5242412f436f6e746578744964656e7469666965723a312e300012000000436f6e746578"
"744964656e7469666965720000001500000044000000010000002100000049444c3a6f6d672e6"
"f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004964656e746966"
"69657200001200000000000000000000000b000000706172616d6574657273000015000000f00"
"10000010000002800000049444c3a6f6d672e6f72672f434f5242412f50617244657363726970"
"74696f6e5365713a312e3000120000005061724465736372697074696f6e53657100000013000"
"000a0010000010000000f00000090010000010000002b00000049444c3a6f6d672e6f72672f43"
"4f5242412f506172616d657465724465736372697074696f6e3a312e300000150000005061726"
"16d657465724465736372697074696f6e0000000004000000050000006e616d65000000001500"
"000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f4964656e74696"
"66965723a312e30000000000b0000004964656e74696669657200001200000000000000050000"
"0074797065000000000c00000009000000747970655f646566000000000e00000034000000010"
"000001e00000049444c3a6f6d672e6f72672f434f5242412f49444c547970653a312e30000000"
"0800000049444c5479706500050000006d6f64650000000011000000740000000100000024000"
"00049444c3a6f6d672e6f72672f434f5242412f506172616d657465724d6f64653a312e30000e"
"000000506172616d657465724d6f64650000000300000009000000504152414d5f494e0000000"
"00a000000504152414d5f4f55540000000c000000504152414d5f494e4f555400000000000b00"
"0000657863657074696f6e730000150000002c020000010000002800000049444c3a6f6d672e6"
"f72672f434f5242412f4578634465736372697074696f6e5365713a312e300012000000457863"
"4465736372697074696f6e53657100000013000000dc010000010000000f000000cc010000010"
"000002b00000049444c3a6f6d672e6f72672f434f5242412f457863657074696f6e4465736372"
"697074696f6e3a312e30000015000000457863657074696f6e4465736372697074696f6e00000"
"00005000000050000006e616d65000000001500000044000000010000002100000049444c3a6f"
"6d672e6f72672f434f5242412f4964656e7469666965723a312e30000000000b0000004964656"
"e7469666965720000120000000000000003000000696400001500000048000000010000002300"
"000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643a312e3000000"
"d0000005265706f7369746f727949640000000012000000000000000b000000646566696e6564"
"5f696e00001500000048000000010000002300000049444c3a6f6d672e6f72672f434f5242412"
"f5265706f7369746f727949643a312e3000000d0000005265706f7369746f7279496400000000"
"12000000000000000800000076657273696f6e001500000044000000010000002200000049444"
"c3a6f6d672e6f72672f434f5242412f56657273696f6e537065633a312e300000000c00000056"
"657273696f6e537065630012000000000000000500000074797065000000000c0000000000000"
"000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_OperationDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_OperationDescription > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_OperationDescription >* p)
{
    static const OBInfo< OBVarSeq< CORBA_OperationDescription > > info;
    any.replace(_tc_OBVarSeq_CORBA__OperationDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_OperationDescription >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_OperationDescription > > info;
    OBVarSeq< CORBA_OperationDescription >* p = new OBVarSeq< CORBA_OperationDescription >(seq);
    any.replace(_tc_OBVarSeq_CORBA__OperationDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_OperationDescription >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__OperationDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_OperationDescription >* v = new OBVarSeq< CORBA_OperationDescription >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_OperationDescription >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< CORBA_AttributeDescription >
//
#ifdef OB_use_OBVarSeq_CORBA__AttributeDescription_from_IntRep_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< CORBA_AttributeDescription >;
template class OBSeqVar< OBVarSeq< CORBA_AttributeDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< CORBA_AttributeDescription >)
#pragma define(OBSeqVar< OBVarSeq< CORBA_AttributeDescription > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< CORBA_AttributeDescription >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< CORBA_AttributeDescription >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< CORBA_AttributeDescription >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static OBTypeCodeConst _tc_OBVarSeq_CORBA__AttributeDescription(
"010000001300000058020000010000000f00000046020000010000002b00000049444c3a6f6d6"
"72e6f72672f434f5242412f4174747269627574654465736372697074696f6e3a312e30000015"
"0000004174747269627574654465736372697074696f6e0000000006000000050000006e616d6"
"5000000001500000044000000010000002100000049444c3a6f6d672e6f72672f434f5242412f"
"4964656e7469666965723a312e30000000000b0000004964656e7469666965720000120000000"
"000000003000000696400001500000048000000010000002300000049444c3a6f6d672e6f7267"
"2f434f5242412f5265706f7369746f727949643a312e3000000d0000005265706f7369746f727"
"949640000000012000000000000000b000000646566696e65645f696e00001500000048000000"
"010000002300000049444c3a6f6d672e6f72672f434f5242412f5265706f7369746f727949643"
"a312e3000000d0000005265706f7369746f727949640000000012000000000000000800000076"
"657273696f6e001500000044000000010000002200000049444c3a6f6d672e6f72672f434f524"
"2412f56657273696f6e537065633a312e300000000c00000056657273696f6e53706563001200"
"0000000000000500000074797065000000000c000000050000006d6f646500000000110000006"
"6000000010000002400000049444c3a6f6d672e6f72672f434f5242412f417474726962757465"
"4d6f64653a312e30000e0000004174747269627574654d6f6465000000020000000c000000415"
"454525f4e4f524d414c000e000000415454525f524541444f4e4c5900000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< CORBA_AttributeDescription > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBInfo< OBVarSeq< CORBA_AttributeDescription > >)
#endif
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< CORBA_AttributeDescription >* p)
{
    static const OBInfo< OBVarSeq< CORBA_AttributeDescription > > info;
    any.replace(_tc_OBVarSeq_CORBA__AttributeDescription, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< CORBA_AttributeDescription >& seq)
{
    static const OBInfo< OBVarSeq< CORBA_AttributeDescription > > info;
    OBVarSeq< CORBA_AttributeDescription >* p = new OBVarSeq< CORBA_AttributeDescription >(seq);
    any.replace(_tc_OBVarSeq_CORBA__AttributeDescription, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< CORBA_AttributeDescription >*& p)
{
    if(any.check_type(_tc_OBVarSeq_CORBA__AttributeDescription))
    {
        if(!any.info())
        {
            const OBBuffer* cbufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = cbufp -> data;
            OBVarSeq< CORBA_AttributeDescription >* v = new OBVarSeq< CORBA_AttributeDescription >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< CORBA_AttributeDescription >*)any.value();
        return true;
    }
    else
        return false;
}

#endif
