// **********************************************************************
//
// 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 "tcap.h"

//
// IDL:tcap/UserDataType:1.0
//
OBTypeCodeConst tcap__tc_UserDataType(
"01000000150000004c000000010000001a00000049444c3a746361702f5573657244617461547"
"970653a312e300000000d00000055736572446174615479706500000000130000000c00000001"
"0000000a00000000000000"
);

//
// IDL:tcap/RoutingType:1.0
//
OBTypeCodeConst tcap__tc_RoutingType(
"010000001500000038000000010000001900000049444c3a746361702f526f7574696e6754797"
"0653a312e30000000000c000000526f7574696e67547970650002000000"
);

//
// IDL:tcap/AddressType:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< tcap_AddressType >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< tcap_AddressType >)
#endif
#endif

#ifdef OB_CLEAR_MEM
tcap_AddressType::tcap_AddressType()
{
    memset(&routingIndicator, 0, sizeof(routingIndicator));
    memset(&pointCode, 0, sizeof(pointCode));
    memset(&subSystemNumber, 0, sizeof(subSystemNumber));
}
#endif

tcap_AddressType::tcap_AddressType(const tcap_AddressType& _ob_a)
    : routingIndicator(_ob_a.routingIndicator),
      pointCode(_ob_a.pointCode),
      subSystemNumber(_ob_a.subSystemNumber),
      globalTitle(_ob_a.globalTitle)
{
}

tcap_AddressType&
tcap_AddressType::operator=(const tcap_AddressType& _ob_a)
{
    if(this != &_ob_a)
    {
        routingIndicator = _ob_a.routingIndicator;
        pointCode = _ob_a.pointCode;
        subSystemNumber = _ob_a.subSystemNumber;
        globalTitle = _ob_a.globalTitle;
    }
    return *this;
}

void
OBMarshal(const tcap_AddressType& val, CORBA_Octet*& oct)
{
    OBMarshal(val.routingIndicator, oct);
    OBMarshal(val.pointCode, oct);
    OBMarshal(val.subSystemNumber, oct);
    OBMarshal(val.globalTitle.in(), oct);
}

void
OBMarshalCount(const tcap_AddressType& val, CORBA_ULong& count)
{
    OBMarshalCount(val.routingIndicator, count);
    OBMarshalCount(val.pointCode, count);
    OBMarshalCount(val.subSystemNumber, count);
    OBMarshalCount(val.globalTitle.in(), count);
}

void
OBUnmarshal(tcap_AddressType& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.routingIndicator, coct, swap);
    OBUnmarshal(val.pointCode, coct, swap);
    OBUnmarshal(val.subSystemNumber, coct, swap);
    OBUnmarshal(val.globalTitle.inout(), coct, swap);
}

OBTypeCodeConst tcap__tc_AddressType(
"010000000f000000d4000000010000001900000049444c3a746361702f4164647265737354797"
"0653a312e30000000000c0000004164647265737354797065000400000011000000726f757469"
"6e67496e64696361746f72000000001500000038000000010000001900000049444c3a7463617"
"02f526f7574696e67547970653a312e30000000000c000000526f7574696e6754797065000200"
"00000a000000706f696e74436f6465000000030000001000000073756253797374656d4e756d6"
"2657200030000000c000000676c6f62616c5469746c65001200000000000000"
);

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

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

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

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

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

//
// IDL:tcap/tcapDown:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< tcap_tcapDown >;
template class OBObjForSeq< tcap_tcapDown >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< tcap_tcapDown >)
#pragma define(OBObjForSeq< tcap_tcapDown >)
#endif
#endif

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

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

tcap_tcapDown_ptr
tcap_tcapDown::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:tcap/tcapDown:1.0");

        if(v)
            return _duplicate((tcap_tcapDown_ptr)v);

        if(p -> _OB_remoteIsA("IDL:tcap/tcapDown:1.0"))
        {
            tcap_tcapDown_ptr val = new tcap_tcapDown;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

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

const char*
tcap_tcapDown::_OB_typeId() const
{
    return "IDL:tcap/tcapDown:1.0";
}

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

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

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

OBTypeCodeConst tcap__tc_tcapDown(
"010000000e0000002d000000010000001600000049444c3a746361702f74636170446f776e3a3"
"12e300000000900000074636170446f776e00"
);

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

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

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

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

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

        return true;
    }
    else
        return false;
}

//
// IDL:tcap/tcapDown/N_UNITDATAreq:1.0
//
void
tcap_tcapDown::N_UNITDATAreq(const tcap_AddressType& _ob_a0,
                             const tcap_AddressType& _ob_a1,
                             const tcap_UserDataType& _ob_a2)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "N_UNITDATAreq");
    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, "N_UNITDATAreq", _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);
        N_UNITDATAreq(_ob_a0, _ob_a1, _ob_a2);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// IDL:tcap/tcapUp:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< tcap_tcapUp >;
template class OBObjForSeq< tcap_tcapUp >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjVar< tcap_tcapUp >)
#pragma define(OBObjForSeq< tcap_tcapUp >)
#endif
#endif

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

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

tcap_tcapUp_ptr
tcap_tcapUp::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:tcap/tcapUp:1.0");

        if(v)
            return _duplicate((tcap_tcapUp_ptr)v);

        if(p -> _OB_remoteIsA("IDL:tcap/tcapUp:1.0"))
        {
            tcap_tcapUp_ptr val = new tcap_tcapUp;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

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

const char*
tcap_tcapUp::_OB_typeId() const
{
    return "IDL:tcap/tcapUp:1.0";
}

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

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

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

OBTypeCodeConst tcap__tc_tcapUp(
"010000000e00000027000000010000001400000049444c3a746361702f7463617055703a312e3"
"0000700000074636170557000"
);

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

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

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

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

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

        return true;
    }
    else
        return false;
}

//
// IDL:tcap/tcapUp/N_UNITDATAind:1.0
//
void
tcap_tcapUp::N_UNITDATAind(const tcap_AddressType& _ob_a0,
                           const tcap_AddressType& _ob_a1,
                           const tcap_UserDataType& _ob_a2)
{
    if(CORBA_is_nil(_ob_clt_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_clt_ -> offset(this, "N_UNITDATAind");
    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, "N_UNITDATAind", _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);
        N_UNITDATAind(_ob_a0, _ob_a1, _ob_a2);
        return;
    }

    if(_ob_ex)
        throw CORBA_UNKNOWN();
}

//
// OBFixSeq< OBUnsignedChar >
//
#ifdef OB_use_OBFixSeq_OBUnsignedChar_from_tcap_h

static OBTypeCodeConst _tc_OBFixSeq_OBUnsignedChar(
"01000000130000000c000000010000000a00000000000000"
);

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

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

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

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

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

#endif