// **********************************************************************
//
// 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 __tcap_h__
#define __tcap_h__

//
// IDL:tcap:1.0
//

//
// IDL:tcap/tcapDown:1.0
//
class tcap_tcapDown;
typedef tcap_tcapDown* tcap_tcapDown_ptr;
typedef tcap_tcapDown* tcap_tcapDownRef;
void OBDuplicate(tcap_tcapDown_ptr);
void OBRelease(tcap_tcapDown_ptr);
typedef OBObjVar< tcap_tcapDown > tcap_tcapDown_var;

//
// IDL:tcap/tcapUp:1.0
//
class tcap_tcapUp;
typedef tcap_tcapUp* tcap_tcapUp_ptr;
typedef tcap_tcapUp* tcap_tcapUpRef;
void OBDuplicate(tcap_tcapUp_ptr);
void OBRelease(tcap_tcapUp_ptr);
typedef OBObjVar< tcap_tcapUp > tcap_tcapUp_var;

//
// IDL:tcap/UserDataType:1.0
//
typedef OBFixSeq< CORBA_Octet > tcap_UserDataType;
typedef OBSeqVar< OBFixSeq< CORBA_Octet > > tcap_UserDataType_var;
extern OBTypeCodeConst tcap__tc_UserDataType;

//
// IDL:tcap/RoutingType:1.0
//
typedef CORBA_Short tcap_RoutingType;
extern OBTypeCodeConst tcap__tc_RoutingType;

//
// IDL:tcap/AddressType:1.0
//
struct tcap_AddressType
{
#ifdef OB_CLEAR_MEM
    tcap_AddressType();
#else
    tcap_AddressType() { }
#endif
    tcap_AddressType(const tcap_AddressType&);
    ~tcap_AddressType() { }
    tcap_AddressType& operator=(const tcap_AddressType&);

    tcap_RoutingType routingIndicator;
    CORBA_Long pointCode;
    CORBA_Long subSystemNumber;
    CORBA_String_var globalTitle;
};

typedef OBVarVar< tcap_AddressType > tcap_AddressType_var;

extern OBTypeCodeConst tcap__tc_AddressType;

//
// IDL:tcap/tcapDown:1.0
//
class tcap_tcapDown : virtual public CORBA_Object
{
    tcap_tcapDown(const tcap_tcapDown&);
    void operator=(const tcap_tcapDown&);

protected:

    tcap_tcapDown() { }

public:

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

    static inline tcap_tcapDown_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:tcap/tcapDown/N_UNITDATAreq:1.0
    //
    virtual void N_UNITDATAreq(const tcap_AddressType& calledAddress,
                               const tcap_AddressType& callingAddress,
                               const tcap_UserDataType& userData);
};

extern OBTypeCodeConst tcap__tc_tcapDown;

//
// IDL:tcap/tcapUp:1.0
//
class tcap_tcapUp : virtual public CORBA_Object
{
    tcap_tcapUp(const tcap_tcapUp&);
    void operator=(const tcap_tcapUp&);

protected:

    tcap_tcapUp() { }

public:

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

    static inline tcap_tcapUp_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:tcap/tcapUp/N_UNITDATAind:1.0
    //
    virtual void N_UNITDATAind(const tcap_AddressType& calledAddress,
                               const tcap_AddressType& callingAddress,
                               const tcap_UserDataType& userData);
};

extern OBTypeCodeConst tcap__tc_tcapUp;

//
// IDL:tcap/AddressType:1.0
//
void OBMarshal(const tcap_AddressType&, CORBA_Octet*&);
void OBMarshalCount(const tcap_AddressType&, CORBA_ULong&);
void OBUnmarshal(tcap_AddressType&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:tcap/tcapDown:1.0
//
inline void
CORBA_release(tcap_tcapDown_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// IDL:tcap/tcapUp:1.0
//
inline void
CORBA_release(tcap_tcapUp_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// OBFixSeq< OBUnsignedChar >
//
#ifndef OB_use_OBFixSeq_OBUnsignedChar
#define OB_use_OBFixSeq_OBUnsignedChar
#define OB_use_OBFixSeq_OBUnsignedChar_from_tcap_h

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

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

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

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

#endif

#endif