// **********************************************************************
//
// 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

#ifndef __trs_h__
#define __trs_h__

#include "cause.h"

//
// IDL:trs:1.0
//

//
// IDL:trs/RouteServerCallback:1.0
//
class trs_RouteServerCallback;
typedef trs_RouteServerCallback* trs_RouteServerCallback_ptr;
typedef trs_RouteServerCallback* trs_RouteServerCallbackRef;
void OBDuplicate(trs_RouteServerCallback_ptr);
void OBRelease(trs_RouteServerCallback_ptr);
typedef OBObjVar< trs_RouteServerCallback > trs_RouteServerCallback_var;

//
// IDL:trs/RouteServer:1.0
//
class trs_RouteServer;
typedef trs_RouteServer* trs_RouteServer_ptr;
typedef trs_RouteServer* trs_RouteServerRef;
void OBDuplicate(trs_RouteServer_ptr);
void OBRelease(trs_RouteServer_ptr);
typedef OBObjVar< trs_RouteServer > trs_RouteServer_var;

//
// IDL:trs/Address:1.0
//
typedef char* trs_Address;
typedef CORBA_String_var trs_Address_var;
extern OBTypeCodeConst trs__tc_Address;

//
// IDL:trs/LinkNumber:1.0
//
typedef CORBA_ULong trs_LinkNumber;
extern OBTypeCodeConst trs__tc_LinkNumber;

//
// IDL:trs/LinkNumberList:1.0
//
typedef OBFixSeq< trs_LinkNumber > trs_LinkNumberList;
typedef OBSeqVar< OBFixSeq< trs_LinkNumber > > trs_LinkNumberList_var;
extern OBTypeCodeConst trs__tc_LinkNumberList;

//
// IDL:trs/ParameterValue:1.0
//
typedef CORBA_ULong trs_ParameterValue;
extern OBTypeCodeConst trs__tc_ParameterValue;

//
// IDL:trs/Parameter:1.0
//
struct trs_Parameter
{
#ifdef OB_CLEAR_MEM
    trs_Parameter();
#else
    trs_Parameter() { }
#endif
    trs_Parameter(const trs_Parameter&);
    ~trs_Parameter() { }
    trs_Parameter& operator=(const trs_Parameter&);

    CORBA_String_var name;
    trs_ParameterValue value;
};

typedef OBVarVar< trs_Parameter > trs_Parameter_var;

extern OBTypeCodeConst trs__tc_Parameter;

//
// IDL:trs/DTLstack:1.0
//
typedef OBStrSeq trs_DTLstack;
typedef OBSeqVar< OBStrSeq > trs_DTLstack_var;
extern OBTypeCodeConst trs__tc_DTLstack;

//
// IDL:trs/DTLstackList:1.0
//
typedef OBVarSeq< trs_DTLstack > trs_DTLstackList;
typedef OBSeqVar< OBVarSeq< trs_DTLstack > > trs_DTLstackList_var;
extern OBTypeCodeConst trs__tc_DTLstackList;

//
// IDL:trs/ParameterList:1.0
//
typedef OBVarSeq< trs_Parameter > trs_ParameterList;
typedef OBSeqVar< OBVarSeq< trs_Parameter > > trs_ParameterList_var;
extern OBTypeCodeConst trs__tc_ParameterList;

//
// IDL:trs/NoRoute:1.0
//
struct trs_NoRoute : public CORBA_UserException
{
#ifdef OB_CLEAR_MEM
    trs_NoRoute();
#else
    trs_NoRoute() { }
#endif
    trs_NoRoute(const trs_NoRoute&);
    trs_NoRoute(CORBA_ULong);
    virtual ~trs_NoRoute() { }
    trs_NoRoute& operator=(const trs_NoRoute&);

    static trs_NoRoute* _narrow(CORBA_Exception*);
#ifdef HAVE_NO_RTTI
    virtual void* _OB_narrowHelp(const char*) const;
#endif
    virtual const char* _OB_typeId() const;
    virtual CORBA_Exception* _OB_clone() const;

    CORBA_ULong cause;
};

extern OBTypeCodeConst trs__tc_NoRoute;

//
// IDL:trs/InvalidAddress:1.0
//
struct trs_InvalidAddress : public CORBA_UserException
{
    trs_InvalidAddress() { }
    trs_InvalidAddress(const trs_InvalidAddress&);
    virtual ~trs_InvalidAddress() { }
    trs_InvalidAddress& operator=(const trs_InvalidAddress&);

    static trs_InvalidAddress* _narrow(CORBA_Exception*);
#ifdef HAVE_NO_RTTI
    virtual void* _OB_narrowHelp(const char*) const;
#endif
    virtual const char* _OB_typeId() const;
    virtual CORBA_Exception* _OB_clone() const;
};

extern OBTypeCodeConst trs__tc_InvalidAddress;

//
// IDL:trs/Link:1.0
//
struct trs_Link
{
#ifdef OB_CLEAR_MEM
    trs_Link();
#else
    trs_Link() { }
#endif
    trs_Link(const trs_Link&);
    ~trs_Link() { }
    trs_Link& operator=(const trs_Link&);

    trs_Address_var destination;
    trs_LinkNumber linkNumber;
    trs_ParameterList qosParameters;
};

typedef OBVarVar< trs_Link > trs_Link_var;

extern OBTypeCodeConst trs__tc_Link;

//
// IDL:trs/LinkList:1.0
//
typedef OBVarSeq< trs_Link > trs_LinkList;
typedef OBSeqVar< OBVarSeq< trs_Link > > trs_LinkList_var;
extern OBTypeCodeConst trs__tc_LinkList;

//
// IDL:trs/Node:1.0
//
struct trs_Node
{
    trs_Node() { }
    trs_Node(const trs_Node&);
    ~trs_Node() { }
    trs_Node& operator=(const trs_Node&);

    trs_Address_var prefix;
    trs_LinkList links;
};

typedef OBVarVar< trs_Node > trs_Node_var;

extern OBTypeCodeConst trs__tc_Node;

//
// IDL:trs/RouteServerCallback:1.0
//
class trs_RouteServerCallback : virtual public CORBA_Object
{
    trs_RouteServerCallback(const trs_RouteServerCallback&);
    void operator=(const trs_RouteServerCallback&);

protected:

    trs_RouteServerCallback() { }

public:

    static inline trs_RouteServerCallback_ptr
    _duplicate(trs_RouteServerCallback_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline trs_RouteServerCallback_ptr
    _nil()
    {
        return 0;
    }

    static trs_RouteServerCallback_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(trs_RouteServerCallback_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, trs_RouteServerCallback_ptr&);

    //
    // IDL:trs/RouteServerCallback/routeSelection:1.0
    //
    virtual void routeSelection(const trs_LinkNumberList& nextLinks,
                                const trs_DTLstackList& dtlStacks,
                                CORBA_ULong failure);
};

extern OBTypeCodeConst trs__tc_RouteServerCallback;

//
// IDL:trs/RouteServer:1.0
//
class trs_RouteServer : virtual public CORBA_Object
{
    trs_RouteServer(const trs_RouteServer&);
    void operator=(const trs_RouteServer&);

protected:

    trs_RouteServer() { }

public:

    static inline trs_RouteServer_ptr
    _duplicate(trs_RouteServer_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline trs_RouteServer_ptr
    _nil()
    {
        return 0;
    }

    static trs_RouteServer_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(trs_RouteServer_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, trs_RouteServer_ptr&);

    //
    // IDL:trs/RouteServer/registerNode:1.0
    //
    virtual void registerNode(const trs_Node& node);

    //
    // IDL:trs/RouteServer/unregisterNode:1.0
    //
    virtual void unregisterNode(const trs_Node& node);

    //
    // IDL:trs/RouteServer/addLinks:1.0
    //
    virtual void addLinks(const trs_Node& node,
                          const trs_LinkList& additionalLinks);

    //
    // IDL:trs/RouteServer/removeLinks:1.0
    //
    virtual void removeLinks(const trs_Node& node,
                             const trs_LinkList& removableLinks);

    //
    // IDL:trs/RouteServer/updateLinks:1.0
    //
    virtual void updateLinks(const trs_Node& node,
                             const trs_LinkList& updatedlinks);

    //
    // IDL:trs/RouteServer/selectRoute:1.0
    //
    virtual void selectRoute(const char* caller,
                             const char* calledParty,
                             const trs_DTLstack& dtlStack,
                             const trs_ParameterList& qosParameters,
                             trs_RouteServerCallback_ptr callback,
                             CORBA_ULong numberOfRoutes);
};

extern OBTypeCodeConst trs__tc_RouteServer;

//
// IDL:trs/Parameter:1.0
//
void OBMarshal(const trs_Parameter&, CORBA_Octet*&);
void OBMarshalCount(const trs_Parameter&, CORBA_ULong&);
void OBUnmarshal(trs_Parameter&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_Parameter*);
void operator<<=(CORBA_Any&, const trs_Parameter&);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_Parameter*&);

inline void
operator<<=(CORBA_Any_var& any, trs_Parameter* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const trs_Parameter& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_Parameter*& val)
{
    return any.in() >>= val;
}

//
// IDL:trs/NoRoute:1.0
//
void OBMarshal(const trs_NoRoute&, CORBA_Octet*&);
void OBMarshalCount(const trs_NoRoute&, CORBA_ULong&);
void OBUnmarshal(trs_NoRoute&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_NoRoute*);
void operator<<=(CORBA_Any&, const trs_NoRoute&);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_NoRoute*&);

inline void
operator<<=(CORBA_Any_var& any, trs_NoRoute* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const trs_NoRoute& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_NoRoute*& val)
{
    return any.in() >>= val;
}

//
// IDL:trs/InvalidAddress:1.0
//
void OBMarshal(const trs_InvalidAddress&, CORBA_Octet*&);
void OBMarshalCount(const trs_InvalidAddress&, CORBA_ULong&);
void OBUnmarshal(trs_InvalidAddress&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_InvalidAddress*);
void operator<<=(CORBA_Any&, const trs_InvalidAddress&);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_InvalidAddress*&);

inline void
operator<<=(CORBA_Any_var& any, trs_InvalidAddress* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const trs_InvalidAddress& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_InvalidAddress*& val)
{
    return any.in() >>= val;
}

//
// IDL:trs/Link:1.0
//
void OBMarshal(const trs_Link&, CORBA_Octet*&);
void OBMarshalCount(const trs_Link&, CORBA_ULong&);
void OBUnmarshal(trs_Link&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_Link*);
void operator<<=(CORBA_Any&, const trs_Link&);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_Link*&);

inline void
operator<<=(CORBA_Any_var& any, trs_Link* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const trs_Link& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_Link*& val)
{
    return any.in() >>= val;
}

//
// IDL:trs/Node:1.0
//
void OBMarshal(const trs_Node&, CORBA_Octet*&);
void OBMarshalCount(const trs_Node&, CORBA_ULong&);
void OBUnmarshal(trs_Node&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_Node*);
void operator<<=(CORBA_Any&, const trs_Node&);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_Node*&);

inline void
operator<<=(CORBA_Any_var& any, trs_Node* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const trs_Node& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_Node*& val)
{
    return any.in() >>= val;
}

//
// IDL:trs/RouteServerCallback:1.0
//
inline void
CORBA_release(trs_RouteServerCallback_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(trs_RouteServerCallback_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(trs_RouteServerCallback_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(trs_RouteServerCallback_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(trs_RouteServerCallback_ptr&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_RouteServerCallback_ptr);
void operator<<=(CORBA_Any&, trs_RouteServerCallback_ptr*);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_RouteServerCallback_ptr&);

inline void
operator<<=(CORBA_Any_var& any, trs_RouteServerCallback_ptr val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, trs_RouteServerCallback_ptr* val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_RouteServerCallback_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:trs/RouteServer:1.0
//
inline void
CORBA_release(trs_RouteServer_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(trs_RouteServer_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(trs_RouteServer_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(trs_RouteServer_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(trs_RouteServer_ptr&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, trs_RouteServer_ptr);
void operator<<=(CORBA_Any&, trs_RouteServer_ptr*);
CORBA_Boolean operator>>=(const CORBA_Any&, trs_RouteServer_ptr&);

inline void
operator<<=(CORBA_Any_var& any, trs_RouteServer_ptr val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, trs_RouteServer_ptr* val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, trs_RouteServer_ptr& val)
{
    return any.in() >>= val;
}

//
// OBFixSeq< CORBA_ULong >
//
#ifndef OB_use_OBFixSeq_CORBA__ULong
#define OB_use_OBFixSeq_CORBA__ULong
#define OB_use_OBFixSeq_CORBA__ULong_from_trs_h

void operator<<=(CORBA_Any&, OBFixSeq< CORBA_ULong >*);
void operator<<=(CORBA_Any&, const OBFixSeq< CORBA_ULong >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBFixSeq< CORBA_ULong >*&);

inline void
operator<<=(CORBA_Any_var& any, OBFixSeq< CORBA_ULong >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBFixSeq< CORBA_ULong >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBFixSeq< CORBA_ULong >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBStrSeq
//
#ifndef OB_use_OBStrSeq
#define OB_use_OBStrSeq
#define OB_use_OBStrSeq_from_trs_h

void operator<<=(CORBA_Any&, OBStrSeq*);
void operator<<=(CORBA_Any&, const OBStrSeq&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBStrSeq*&);

inline void
operator<<=(CORBA_Any_var& any, OBStrSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBStrSeq& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBStrSeq*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< OBStrSeq >
//
#ifndef OB_use_OBVarSeq_OBStrSeq
#define OB_use_OBVarSeq_OBStrSeq
#define OB_use_OBVarSeq_OBStrSeq_from_trs_h

void OBMarshal(const OBVarSeq< OBStrSeq >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< OBStrSeq >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< OBStrSeq >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< OBStrSeq >*);
void operator<<=(CORBA_Any&, const OBVarSeq< OBStrSeq >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< OBStrSeq >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< OBStrSeq >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< OBStrSeq >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< OBStrSeq >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< trs_Parameter >
//
#ifndef OB_use_OBVarSeq_trs__Parameter
#define OB_use_OBVarSeq_trs__Parameter
#define OB_use_OBVarSeq_trs__Parameter_from_trs_h

void OBMarshal(const OBVarSeq< trs_Parameter >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< trs_Parameter >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< trs_Parameter >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< trs_Parameter >*);
void operator<<=(CORBA_Any&, const OBVarSeq< trs_Parameter >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< trs_Parameter >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< trs_Parameter >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< trs_Parameter >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< trs_Parameter >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< trs_Link >
//
#ifndef OB_use_OBVarSeq_trs__Link
#define OB_use_OBVarSeq_trs__Link
#define OB_use_OBVarSeq_trs__Link_from_trs_h

void OBMarshal(const OBVarSeq< trs_Link >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< trs_Link >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< trs_Link >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< trs_Link >*);
void operator<<=(CORBA_Any&, const OBVarSeq< trs_Link >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< trs_Link >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< trs_Link >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< trs_Link >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< trs_Link >*& val)
{
    return any.in() >>= val;
}

#endif

#endif