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

// Version: 3.0.1
// License: non-commercial

#include <OB/CORBA.h>
#include <OB/TemplateI.h>
#include "trs.h"

//
// IDL:trs/Address:1.0
//
OBTypeCodeConst trs__tc_Address(
"010000001500000030000000010000001400000049444c3a7472732f416464726573733a312e3"
"0000800000041646472657373001200000000000000"
);

//
// IDL:trs/LinkNumber:1.0
//
OBTypeCodeConst trs__tc_LinkNumber(
"010000001500000034000000010000001700000049444c3a7472732f4c696e6b4e756d6265723"
"a312e3000000b0000004c696e6b4e756d626572000005000000"
);

//
// IDL:trs/LinkNumberList:1.0
//
OBTypeCodeConst trs__tc_LinkNumberList(
"010000001500000084000000010000001b00000049444c3a7472732f4c696e6b4e756d6265724"
"c6973743a312e3000000f0000004c696e6b4e756d6265724c6973740000130000004400000001"
"0000001500000034000000010000001700000049444c3a7472732f4c696e6b4e756d6265723a3"
"12e3000000b0000004c696e6b4e756d62657200000500000000000000"
);

//
// IDL:trs/ParameterValue:1.0
//
OBTypeCodeConst trs__tc_ParameterValue(
"01000000150000003c000000010000001b00000049444c3a7472732f506172616d65746572566"
"16c75653a312e3000000f000000506172616d6574657256616c7565000005000000"
);

//
// IDL:trs/Parameter:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< trs_Parameter >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< trs_Parameter >)
#endif
#endif

#ifdef OB_CLEAR_MEM
trs_Parameter::trs_Parameter()
{
    memset(&value, 0, sizeof(value));
}
#endif

trs_Parameter::trs_Parameter(const trs_Parameter& _ob_a)
    : name(_ob_a.name),
      value(_ob_a.value)
{
}

trs_Parameter&
trs_Parameter::operator=(const trs_Parameter& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        value = _ob_a.value;
    }
    return *this;
}

void
OBMarshal(const trs_Parameter& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.value, oct);
}

void
OBMarshalCount(const trs_Parameter& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.value, count);
}

void
OBUnmarshal(trs_Parameter& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.value, coct, swap);
}

OBTypeCodeConst trs__tc_Parameter(
"010000000f00000098000000010000001600000049444c3a7472732f506172616d657465723a3"
"12e300000000a000000506172616d6574657200000002000000050000006e616d650000000012"
"000000000000000600000076616c7565000000150000003c000000010000001b00000049444c3"
"a7472732f506172616d6574657256616c75653a312e3000000f000000506172616d6574657256"
"616c7565000005000000"
);

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

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

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

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

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

//
// IDL:trs/DTLstack:1.0
//
OBTypeCodeConst trs__tc_DTLstack(
"010000001500000078000000010000001500000049444c3a7472732f44544c737461636b3a312"
"e30000000000900000044544c737461636b000000001300000040000000010000001500000030"
"000000010000001400000049444c3a7472732f416464726573733a312e3000080000004164647"
"265737300120000000000000000000000"
);

//
// IDL:trs/DTLstackList:1.0
//
OBTypeCodeConst trs__tc_DTLstackList(
"0100000015000000c8000000010000001900000049444c3a7472732f44544c737461636b4c697"
"3743a312e30000000000d00000044544c737461636b4c69737400000000130000008800000001"
"0000001500000078000000010000001500000049444c3a7472732f44544c737461636b3a312e3"
"0000000000900000044544c737461636b00000000130000004000000001000000150000003000"
"0000010000001400000049444c3a7472732f416464726573733a312e300008000000416464726"
"573730012000000000000000000000000000000"
);

//
// IDL:trs/ParameterList:1.0
//
OBTypeCodeConst trs__tc_ParameterList(
"0100000015000000e8000000010000001a00000049444c3a7472732f506172616d657465724c6"
"973743a312e300000000e000000506172616d657465724c69737400000013000000a800000001"
"0000000f00000098000000010000001600000049444c3a7472732f506172616d657465723a312"
"e300000000a000000506172616d6574657200000002000000050000006e616d65000000001200"
"0000000000000600000076616c7565000000150000003c000000010000001b00000049444c3a7"
"472732f506172616d6574657256616c75653a312e3000000f000000506172616d657465725661"
"6c756500000500000000000000"
);

//
// IDL:trs/NoRoute:1.0
//
#ifdef OB_CLEAR_MEM
trs_NoRoute::trs_NoRoute()
{
    memset(&cause, 0, sizeof(cause));
}
#endif

trs_NoRoute::trs_NoRoute(const trs_NoRoute& _ob_a)
    : CORBA_UserException(_ob_a),
      cause(_ob_a.cause)
{
}

trs_NoRoute::trs_NoRoute(CORBA_ULong _ob_a0)
    : cause(_ob_a0)
{
}

trs_NoRoute&
trs_NoRoute::operator=(const trs_NoRoute& _ob_a)
{
    if(this != &_ob_a)
    {
        cause = _ob_a.cause;
    }
    return *this;
}

trs_NoRoute*
trs_NoRoute::_narrow(CORBA_Exception* p)
{
#ifdef HAVE_NO_RTTI
    if(p)
        return (trs_NoRoute*)(p -> _OB_narrowHelp("IDL:trs/NoRoute:1.0"));
    else
        return 0;
#else
    return dynamic_cast<trs_NoRoute*>(p);
#endif
}

#ifdef HAVE_NO_RTTI
void*
trs_NoRoute::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:trs/NoRoute:1.0", _ob_id) == 0)
        return (void*)this;
    else
        return CORBA_UserException::_OB_narrowHelp(_ob_id);
}
#endif

const char*
trs_NoRoute::_OB_typeId() const
{
    return "IDL:trs/NoRoute:1.0";
}

CORBA_Exception*
trs_NoRoute::_OB_clone() const
{
    return new trs_NoRoute(*this);
}

void
OBMarshal(const trs_NoRoute& val, CORBA_Octet*& oct)
{
    OBMarshal("IDL:trs/NoRoute:1.0", oct);
    OBMarshal(val.cause, oct);
}

void
OBMarshalCount(const trs_NoRoute& val, CORBA_ULong& count)
{
    OBMarshalCount("IDL:trs/NoRoute:1.0", count);
    OBMarshalCount(val.cause, count);
}

void
OBUnmarshal(trs_NoRoute& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_String_var id;
    OBUnmarshal(id.inout(), coct, swap);
    assert(strcmp(id, "IDL:trs/NoRoute:1.0") == 0);
    OBUnmarshal(val.cause, coct, swap);
}

OBTypeCodeConst trs__tc_NoRoute(
"01000000160000003c000000010000001400000049444c3a7472732f4e6f526f7574653a312e3"
"000080000004e6f526f757465000100000006000000636175736500000005000000"
);

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

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

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

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

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

//
// IDL:trs/InvalidAddress:1.0
//
trs_InvalidAddress::trs_InvalidAddress(const trs_InvalidAddress& _ob_a)
    : CORBA_UserException(_ob_a)
{
}

trs_InvalidAddress&
trs_InvalidAddress::operator=(const trs_InvalidAddress&)
{
    return *this;
}

trs_InvalidAddress*
trs_InvalidAddress::_narrow(CORBA_Exception* p)
{
#ifdef HAVE_NO_RTTI
    if(p)
        return (trs_InvalidAddress*)(p -> _OB_narrowHelp("IDL:trs/InvalidAddress:1.0"));
    else
        return 0;
#else
    return dynamic_cast<trs_InvalidAddress*>(p);
#endif
}

#ifdef HAVE_NO_RTTI
void*
trs_InvalidAddress::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:trs/InvalidAddress:1.0", _ob_id) == 0)
        return (void*)this;
    else
        return CORBA_UserException::_OB_narrowHelp(_ob_id);
}
#endif

const char*
trs_InvalidAddress::_OB_typeId() const
{
    return "IDL:trs/InvalidAddress:1.0";
}

CORBA_Exception*
trs_InvalidAddress::_OB_clone() const
{
    return new trs_InvalidAddress(*this);
}

void
OBMarshal(const trs_InvalidAddress&, CORBA_Octet*& oct)
{
    OBMarshal("IDL:trs/InvalidAddress:1.0", oct);
}

void
OBMarshalCount(const trs_InvalidAddress&, CORBA_ULong& count)
{
    OBMarshalCount("IDL:trs/InvalidAddress:1.0", count);
}

void
OBUnmarshal(trs_InvalidAddress&, const CORBA_Octet*& coct, bool swap)
{
    CORBA_String_var id;
    OBUnmarshal(id.inout(), coct, swap);
    assert(strcmp(id, "IDL:trs/InvalidAddress:1.0") == 0);
}

OBTypeCodeConst trs__tc_InvalidAddress(
"01000000160000003c000000010000001b00000049444c3a7472732f496e76616c69644164647"
"26573733a312e3000000f000000496e76616c696441646472657373000000000000"
);

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

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

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

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

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

//
// IDL:trs/Link:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< trs_Link >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< trs_Link >)
#endif
#endif

#ifdef OB_CLEAR_MEM
trs_Link::trs_Link()
{
    memset(&linkNumber, 0, sizeof(linkNumber));
}
#endif

trs_Link::trs_Link(const trs_Link& _ob_a)
    : destination(_ob_a.destination),
      linkNumber(_ob_a.linkNumber),
      qosParameters(_ob_a.qosParameters)
{
}

trs_Link&
trs_Link::operator=(const trs_Link& _ob_a)
{
    if(this != &_ob_a)
    {
        destination = _ob_a.destination;
        linkNumber = _ob_a.linkNumber;
        qosParameters = _ob_a.qosParameters;
    }
    return *this;
}

void
OBMarshal(const trs_Link& val, CORBA_Octet*& oct)
{
    OBMarshal(val.destination.in(), oct);
    OBMarshal(val.linkNumber, oct);
    OBMarshal(val.qosParameters, oct);
}

void
OBMarshalCount(const trs_Link& val, CORBA_ULong& count)
{
    OBMarshalCount(val.destination.in(), count);
    OBMarshalCount(val.linkNumber, count);
    OBMarshalCount(val.qosParameters, count);
}

void
OBUnmarshal(trs_Link& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.destination.inout(), coct, swap);
    OBUnmarshal(val.linkNumber, coct, swap);
    OBUnmarshal(val.qosParameters, coct, swap);
}

OBTypeCodeConst trs__tc_Link(
"010000000f000000c4010000010000001100000049444c3a7472732f4c696e6b3a312e3000000"
"000050000004c696e6b00000000030000000c00000064657374696e6174696f6e001500000030"
"000000010000001400000049444c3a7472732f416464726573733a312e3000080000004164647"
"26573730012000000000000000b0000006c696e6b4e756d626572000015000000340000000100"
"00001700000049444c3a7472732f4c696e6b4e756d6265723a312e3000000b0000004c696e6b4"
"e756d6265720000050000000e000000716f73506172616d657465727300000015000000e80000"
"00010000001a00000049444c3a7472732f506172616d657465724c6973743a312e300000000e0"
"00000506172616d657465724c69737400000013000000a8000000010000000f00000098000000"
"010000001600000049444c3a7472732f506172616d657465723a312e300000000a00000050617"
"2616d6574657200000002000000050000006e616d650000000012000000000000000600000076"
"616c7565000000150000003c000000010000001b00000049444c3a7472732f506172616d65746"
"57256616c75653a312e3000000f000000506172616d6574657256616c75650000050000000000"
"0000"
);

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

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

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

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

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

//
// IDL:trs/LinkList:1.0
//
OBTypeCodeConst trs__tc_LinkList(
"01000000150000000c020000010000001500000049444c3a7472732f4c696e6b4c6973743a312"
"e3000000000090000004c696e6b4c6973740000000013000000d4010000010000000f000000c4"
"010000010000001100000049444c3a7472732f4c696e6b3a312e3000000000050000004c696e6"
"b00000000030000000c00000064657374696e6174696f6e001500000030000000010000001400"
"000049444c3a7472732f416464726573733a312e3000080000004164647265737300120000000"
"00000000b0000006c696e6b4e756d62657200001500000034000000010000001700000049444c"
"3a7472732f4c696e6b4e756d6265723a312e3000000b0000004c696e6b4e756d6265720000050"
"000000e000000716f73506172616d657465727300000015000000e8000000010000001a000000"
"49444c3a7472732f506172616d657465724c6973743a312e300000000e000000506172616d657"
"465724c69737400000013000000a8000000010000000f00000098000000010000001600000049"
"444c3a7472732f506172616d657465723a312e300000000a000000506172616d6574657200000"
"002000000050000006e616d650000000012000000000000000600000076616c75650000001500"
"00003c000000010000001b00000049444c3a7472732f506172616d6574657256616c75653a312"
"e3000000f000000506172616d6574657256616c75650000050000000000000000000000"
);

//
// IDL:trs/Node:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< trs_Node >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< trs_Node >)
#endif
#endif

trs_Node::trs_Node(const trs_Node& _ob_a)
    : prefix(_ob_a.prefix),
      links(_ob_a.links)
{
}

trs_Node&
trs_Node::operator=(const trs_Node& _ob_a)
{
    if(this != &_ob_a)
    {
        prefix = _ob_a.prefix;
        links = _ob_a.links;
    }
    return *this;
}

void
OBMarshal(const trs_Node& val, CORBA_Octet*& oct)
{
    OBMarshal(val.prefix.in(), oct);
    OBMarshal(val.links, oct);
}

void
OBMarshalCount(const trs_Node& val, CORBA_ULong& count)
{
    OBMarshalCount(val.prefix.in(), count);
    OBMarshalCount(val.links, count);
}

void
OBUnmarshal(trs_Node& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.prefix.inout(), coct, swap);
    OBUnmarshal(val.links, coct, swap);
}

OBTypeCodeConst trs__tc_Node(
"010000000f00000090020000010000001100000049444c3a7472732f4e6f64653a312e3000000"
"000050000004e6f64650000000002000000070000007072656669780000150000003000000001"
"0000001400000049444c3a7472732f416464726573733a312e300008000000416464726573730"
"01200000000000000060000006c696e6b73000000150000000c02000001000000150000004944"
"4c3a7472732f4c696e6b4c6973743a312e3000000000090000004c696e6b4c697374000000001"
"3000000d4010000010000000f000000c4010000010000001100000049444c3a7472732f4c696e"
"6b3a312e3000000000050000004c696e6b00000000030000000c00000064657374696e6174696"
"f6e001500000030000000010000001400000049444c3a7472732f416464726573733a312e3000"
"08000000416464726573730012000000000000000b0000006c696e6b4e756d626572000015000"
"00034000000010000001700000049444c3a7472732f4c696e6b4e756d6265723a312e3000000b"
"0000004c696e6b4e756d6265720000050000000e000000716f73506172616d657465727300000"
"015000000e8000000010000001a00000049444c3a7472732f506172616d657465724c6973743a"
"312e300000000e000000506172616d657465724c69737400000013000000a8000000010000000"
"f00000098000000010000001600000049444c3a7472732f506172616d657465723a312e300000"
"000a000000506172616d6574657200000002000000050000006e616d650000000012000000000"
"000000600000076616c7565000000150000003c000000010000001b00000049444c3a7472732f"
"506172616d6574657256616c75653a312e3000000f000000506172616d6574657256616c75650"
"000050000000000000000000000"
);

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

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

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

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

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

//
// IDL:trs/RouteServerCallback:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< trs_RouteServerCallback >;
template class OBObjForSeq< trs_RouteServerCallback >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< trs_RouteServerCallback >)
#pragma define(OBObjForSeq< trs_RouteServerCallback >)
#endif
#endif

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

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

trs_RouteServerCallback_ptr
trs_RouteServerCallback::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:trs/RouteServerCallback:1.0");

        if(v)
            return _duplicate((trs_RouteServerCallback_ptr)v);

        if(p -> _OB_remoteIsA("IDL:trs/RouteServerCallback:1.0"))
        {
            trs_RouteServerCallback_ptr val = new trs_RouteServerCallback;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
trs_RouteServerCallback::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:trs/RouteServerCallback:1.0", _ob_id) == 0)
        return (void*)this;
    else
        return CORBA_Object::_OB_narrowHelp(_ob_id);
}

const char*
trs_RouteServerCallback::_OB_typeId() const
{
    return "IDL:trs/RouteServerCallback:1.0";
}

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

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:trs/RouteServerCallback:1.0");

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

OBTypeCodeConst trs__tc_RouteServerCallback(
"010000000e00000040000000010000002000000049444c3a7472732f526f75746553657276657"
"243616c6c6261636b3a312e300014000000526f75746553657276657243616c6c6261636b00"
);

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

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

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

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:trs/RouteServerCallback:1.0");

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

        return true;
    }
    else
        return false;
}

//
// IDL:trs/RouteServerCallback/routeSelection:1.0
//
void
trs_RouteServerCallback::routeSelection(const trs_LinkNumberList& _ob_a0,
                                        const trs_DTLstackList& _ob_a1,
                                        CORBA_ULong _ob_a2)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "routeSelection");
    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, "routeSelection", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_);

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

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:trs/RouteServer:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< trs_RouteServer >;
template class OBObjForSeq< trs_RouteServer >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< trs_RouteServer >)
#pragma define(OBObjForSeq< trs_RouteServer >)
#endif
#endif

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

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

trs_RouteServer_ptr
trs_RouteServer::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:trs/RouteServer:1.0");

        if(v)
            return _duplicate((trs_RouteServer_ptr)v);

        if(p -> _OB_remoteIsA("IDL:trs/RouteServer:1.0"))
        {
            trs_RouteServer_ptr val = new trs_RouteServer;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
trs_RouteServer::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:trs/RouteServer:1.0", _ob_id) == 0)
        return (void*)this;
    else
        return CORBA_Object::_OB_narrowHelp(_ob_id);
}

const char*
trs_RouteServer::_OB_typeId() const
{
    return "IDL:trs/RouteServer:1.0";
}

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

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:trs/RouteServer:1.0");

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

OBTypeCodeConst trs__tc_RouteServer(
"010000000e00000030000000010000001800000049444c3a7472732f526f75746553657276657"
"23a312e30000c000000526f75746553657276657200"
);

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

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

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

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:trs/RouteServer:1.0");

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

        return true;
    }
    else
        return false;
}

//
// IDL:trs/RouteServer/registerNode:1.0
//
void
trs_RouteServer::registerNode(const trs_Node& _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "registerNode");
    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, "registerNode", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

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

    if(_ob_ex)
    {
        CORBA_String_var _ob_id;
        const CORBA_Octet* _ob_coid = _ob_co;
        OBUnmarshal(_ob_id.inout(), _ob_coid, _ob_sw);

        if(strcmp(_ob_id, "IDL:trs/InvalidAddress:1.0") == 0)
        {
            trs_InvalidAddress _ob_except;
            OBUnmarshal(_ob_except, _ob_co, _ob_sw);

            throw _ob_except;
        }
        else
            throw CORBA_UNKNOWN();
    }
}

//
// IDL:trs/RouteServer/unregisterNode:1.0
//
void
trs_RouteServer::unregisterNode(const trs_Node& _ob_a0)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "unregisterNode");
    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, "unregisterNode", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

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

    if(_ob_ex)
    {
        CORBA_String_var _ob_id;
        const CORBA_Octet* _ob_coid = _ob_co;
        OBUnmarshal(_ob_id.inout(), _ob_coid, _ob_sw);

        if(strcmp(_ob_id, "IDL:trs/InvalidAddress:1.0") == 0)
        {
            trs_InvalidAddress _ob_except;
            OBUnmarshal(_ob_except, _ob_co, _ob_sw);

            throw _ob_except;
        }
        else
            throw CORBA_UNKNOWN();
    }
}

//
// IDL:trs/RouteServer/addLinks:1.0
//
void
trs_RouteServer::addLinks(const trs_Node& _ob_a0,
                          const trs_LinkList& _ob_a1)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "addLinks");
    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, "addLinks", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

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

    if(_ob_ex)
    {
        CORBA_String_var _ob_id;
        const CORBA_Octet* _ob_coid = _ob_co;
        OBUnmarshal(_ob_id.inout(), _ob_coid, _ob_sw);

        if(strcmp(_ob_id, "IDL:trs/InvalidAddress:1.0") == 0)
        {
            trs_InvalidAddress _ob_except;
            OBUnmarshal(_ob_except, _ob_co, _ob_sw);

            throw _ob_except;
        }
        else
            throw CORBA_UNKNOWN();
    }
}

//
// IDL:trs/RouteServer/removeLinks:1.0
//
void
trs_RouteServer::removeLinks(const trs_Node& _ob_a0,
                             const trs_LinkList& _ob_a1)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "removeLinks");
    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, "removeLinks", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

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

    if(_ob_ex)
    {
        CORBA_String_var _ob_id;
        const CORBA_Octet* _ob_coid = _ob_co;
        OBUnmarshal(_ob_id.inout(), _ob_coid, _ob_sw);

        if(strcmp(_ob_id, "IDL:trs/InvalidAddress:1.0") == 0)
        {
            trs_InvalidAddress _ob_except;
            OBUnmarshal(_ob_except, _ob_co, _ob_sw);

            throw _ob_except;
        }
        else
            throw CORBA_UNKNOWN();
    }
}

//
// IDL:trs/RouteServer/updateLinks:1.0
//
void
trs_RouteServer::updateLinks(const trs_Node& _ob_a0,
                             const trs_LinkList& _ob_a1)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "updateLinks");
    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, "updateLinks", _ob_buf, _ob_sw, _ob_ex, _ob_fo, _ob_tout_);

    const CORBA_Octet* _ob_co = _ob_buf.data + _ob_off;

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

    if(_ob_ex)
    {
        CORBA_String_var _ob_id;
        const CORBA_Octet* _ob_coid = _ob_co;
        OBUnmarshal(_ob_id.inout(), _ob_coid, _ob_sw);

        if(strcmp(_ob_id, "IDL:trs/InvalidAddress:1.0") == 0)
        {
            trs_InvalidAddress _ob_except;
            OBUnmarshal(_ob_except, _ob_co, _ob_sw);

            throw _ob_except;
        }
        else
            throw CORBA_UNKNOWN();
    }
}

//
// IDL:trs/RouteServer/selectRoute:1.0
//
void
trs_RouteServer::selectRoute(const char* _ob_a0,
                             const char* _ob_a1,
                             const trs_DTLstack& _ob_a2,
                             const trs_ParameterList& _ob_a3,
                             trs_RouteServerCallback_ptr _ob_a4,
                             CORBA_ULong _ob_a5)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "selectRoute");
    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);

    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);

    _ob_clt_ -> oneway(this, "selectRoute", _ob_buf);
}

//
// OBFixSeq< CORBA_ULong >
//
#ifdef OB_use_OBFixSeq_CORBA__ULong_from_trs_h

static OBTypeCodeConst _tc_OBFixSeq_CORBA__ULong(
"010000001300000044000000010000001500000034000000010000001700000049444c3a74727"
"32f4c696e6b4e756d6265723a312e3000000b0000004c696e6b4e756d62657200000500000000"
"000000"
);

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

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

void
operator<<=(CORBA_Any& any, const OBFixSeq< CORBA_ULong >& seq)
{
    static const OBInfo< OBFixSeq< CORBA_ULong > > info;
    OBFixSeq< CORBA_ULong >* p = new OBFixSeq< CORBA_ULong >(seq);
    any.replace(_tc_OBFixSeq_CORBA__ULong, p, true, &info);
}

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

        p = (OBFixSeq< CORBA_ULong >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBStrSeq
//
#ifdef OB_use_OBStrSeq_from_trs_h

static OBTypeCodeConst _tc_OBStrSeq(
"010000001300000040000000010000001500000030000000010000001400000049444c3a74727"
"32f416464726573733a312e3000080000004164647265737300120000000000000000000000"
);

#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* bufp = (const OBBuffer*)any.value();
            const CORBA_Octet* coct = bufp -> data;
            OBStrSeq* v = new OBStrSeq;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

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

#endif

//
// OBVarSeq< OBStrSeq >
//
#ifdef OB_use_OBVarSeq_OBStrSeq_from_trs_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< OBStrSeq >;
template class OBSeqVar< OBVarSeq< OBStrSeq > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< OBStrSeq >)
#pragma define(OBSeqVar< OBVarSeq< OBStrSeq > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< OBStrSeq >& 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< OBStrSeq >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< OBStrSeq >& 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_OBStrSeq(
"010000001300000088000000010000001500000078000000010000001500000049444c3a74727"
"32f44544c737461636b3a312e30000000000900000044544c737461636b000000001300000040"
"000000010000001500000030000000010000001400000049444c3a7472732f416464726573733"
"a312e300008000000416464726573730012000000000000000000000000000000"
);

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

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

void
operator<<=(CORBA_Any& any, const OBVarSeq< OBStrSeq >& seq)
{
    static const OBInfo< OBVarSeq< OBStrSeq > > info;
    OBVarSeq< OBStrSeq >* p = new OBVarSeq< OBStrSeq >(seq);
    any.replace(_tc_OBVarSeq_OBStrSeq, p, true, &info);
}

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

        p = (OBVarSeq< OBStrSeq >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< trs_Parameter >
//
#ifdef OB_use_OBVarSeq_trs__Parameter_from_trs_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< trs_Parameter >;
template class OBSeqVar< OBVarSeq< trs_Parameter > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< trs_Parameter >)
#pragma define(OBSeqVar< OBVarSeq< trs_Parameter > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< trs_Parameter >& 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< trs_Parameter >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< trs_Parameter >& 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_trs__Parameter(
"0100000013000000a8000000010000000f00000098000000010000001600000049444c3a74727"
"32f506172616d657465723a312e300000000a000000506172616d657465720000000200000005"
"0000006e616d650000000012000000000000000600000076616c7565000000150000003c00000"
"0010000001b00000049444c3a7472732f506172616d6574657256616c75653a312e3000000f00"
"0000506172616d6574657256616c756500000500000000000000"
);

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

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

void
operator<<=(CORBA_Any& any, const OBVarSeq< trs_Parameter >& seq)
{
    static const OBInfo< OBVarSeq< trs_Parameter > > info;
    OBVarSeq< trs_Parameter >* p = new OBVarSeq< trs_Parameter >(seq);
    any.replace(_tc_OBVarSeq_trs__Parameter, p, true, &info);
}

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

        p = (OBVarSeq< trs_Parameter >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< trs_Link >
//
#ifdef OB_use_OBVarSeq_trs__Link_from_trs_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< trs_Link >;
template class OBSeqVar< OBVarSeq< trs_Link > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< trs_Link >)
#pragma define(OBSeqVar< OBVarSeq< trs_Link > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< trs_Link >& 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< trs_Link >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< trs_Link >& 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_trs__Link(
"0100000013000000d4010000010000000f000000c4010000010000001100000049444c3a74727"
"32f4c696e6b3a312e3000000000050000004c696e6b00000000030000000c0000006465737469"
"6e6174696f6e001500000030000000010000001400000049444c3a7472732f416464726573733"
"a312e300008000000416464726573730012000000000000000b0000006c696e6b4e756d626572"
"00001500000034000000010000001700000049444c3a7472732f4c696e6b4e756d6265723a312"
"e3000000b0000004c696e6b4e756d6265720000050000000e000000716f73506172616d657465"
"727300000015000000e8000000010000001a00000049444c3a7472732f506172616d657465724"
"c6973743a312e300000000e000000506172616d657465724c69737400000013000000a8000000"
"010000000f00000098000000010000001600000049444c3a7472732f506172616d657465723a3"
"12e300000000a000000506172616d6574657200000002000000050000006e616d650000000012"
"000000000000000600000076616c7565000000150000003c000000010000001b00000049444c3"
"a7472732f506172616d6574657256616c75653a312e3000000f000000506172616d6574657256"
"616c75650000050000000000000000000000"
);

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

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

void
operator<<=(CORBA_Any& any, const OBVarSeq< trs_Link >& seq)
{
    static const OBInfo< OBVarSeq< trs_Link > > info;
    OBVarSeq< trs_Link >* p = new OBVarSeq< trs_Link >(seq);
    any.replace(_tc_OBVarSeq_trs__Link, p, true, &info);
}

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

        p = (OBVarSeq< trs_Link >*)any.value();
        return true;
    }
    else
        return false;
}

#endif
