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

#include "toveinap.h"

//
// IDL:omg.org/CosNaming:1.0
//

//
// IDL:omg.org/CosNaming/NamingContext:1.0
//
class CosNaming_NamingContext;
typedef CosNaming_NamingContext* CosNaming_NamingContext_ptr;
typedef CosNaming_NamingContext* CosNaming_NamingContextRef;
void OBDuplicate(CosNaming_NamingContext_ptr);
void OBRelease(CosNaming_NamingContext_ptr);
typedef OBObjVar< CosNaming_NamingContext > CosNaming_NamingContext_var;

//
// IDL:omg.org/CosNaming/BindingIterator:1.0
//
class CosNaming_BindingIterator;
typedef CosNaming_BindingIterator* CosNaming_BindingIterator_ptr;
typedef CosNaming_BindingIterator* CosNaming_BindingIteratorRef;
void OBDuplicate(CosNaming_BindingIterator_ptr);
void OBRelease(CosNaming_BindingIterator_ptr);
typedef OBObjVar< CosNaming_BindingIterator > CosNaming_BindingIterator_var;

//
// IDL:CosLifeCycle:1.0
//

//
// IDL:CosLifeCycle/FactoryFinder:1.0
//
class CosLifeCycle_FactoryFinder;
typedef CosLifeCycle_FactoryFinder* CosLifeCycle_FactoryFinder_ptr;
typedef CosLifeCycle_FactoryFinder* CosLifeCycle_FactoryFinderRef;
void OBDuplicate(CosLifeCycle_FactoryFinder_ptr);
void OBRelease(CosLifeCycle_FactoryFinder_ptr);
typedef OBObjVar< CosLifeCycle_FactoryFinder > CosLifeCycle_FactoryFinder_var;

//
// IDL:CosLifeCycle/LifeCycleObject:1.0
//
class CosLifeCycle_LifeCycleObject;
typedef CosLifeCycle_LifeCycleObject* CosLifeCycle_LifeCycleObject_ptr;
typedef CosLifeCycle_LifeCycleObject* CosLifeCycle_LifeCycleObjectRef;
void OBDuplicate(CosLifeCycle_LifeCycleObject_ptr);
void OBRelease(CosLifeCycle_LifeCycleObject_ptr);
typedef OBObjVar< CosLifeCycle_LifeCycleObject > CosLifeCycle_LifeCycleObject_var;

//
// IDL:CosLifeCycle/GenericFactory:1.0
//
class CosLifeCycle_GenericFactory;
typedef CosLifeCycle_GenericFactory* CosLifeCycle_GenericFactory_ptr;
typedef CosLifeCycle_GenericFactory* CosLifeCycle_GenericFactoryRef;
void OBDuplicate(CosLifeCycle_GenericFactory_ptr);
void OBRelease(CosLifeCycle_GenericFactory_ptr);
typedef OBObjVar< CosLifeCycle_GenericFactory > CosLifeCycle_GenericFactory_var;

//
// IDL:TcSignaling:1.0
//

//
// IDL:TcSignaling/TcUserGenericFactory:1.0
//
class TcSignaling_TcUserGenericFactory;
typedef TcSignaling_TcUserGenericFactory* TcSignaling_TcUserGenericFactory_ptr;
typedef TcSignaling_TcUserGenericFactory* TcSignaling_TcUserGenericFactoryRef;
void OBDuplicate(TcSignaling_TcUserGenericFactory_ptr);
void OBRelease(TcSignaling_TcUserGenericFactory_ptr);
typedef OBObjVar< TcSignaling_TcUserGenericFactory > TcSignaling_TcUserGenericFactory_var;

//
// IDL:TcSignaling/TcFactoryFinder:1.0
//
class TcSignaling_TcFactoryFinder;
typedef TcSignaling_TcFactoryFinder* TcSignaling_TcFactoryFinder_ptr;
typedef TcSignaling_TcFactoryFinder* TcSignaling_TcFactoryFinderRef;
void OBDuplicate(TcSignaling_TcFactoryFinder_ptr);
void OBRelease(TcSignaling_TcFactoryFinder_ptr);
typedef OBObjVar< TcSignaling_TcFactoryFinder > TcSignaling_TcFactoryFinder_var;

//
// IDL:TcSignaling/GwAdmin:1.0
//
class TcSignaling_GwAdmin;
typedef TcSignaling_GwAdmin* TcSignaling_GwAdmin_ptr;
typedef TcSignaling_GwAdmin* TcSignaling_GwAdminRef;
void OBDuplicate(TcSignaling_GwAdmin_ptr);
void OBRelease(TcSignaling_GwAdmin_ptr);
typedef OBObjVar< TcSignaling_GwAdmin > TcSignaling_GwAdmin_var;

//
// IDL:TcSignaling/TcRepository:1.0
//
class TcSignaling_TcRepository;
typedef TcSignaling_TcRepository* TcSignaling_TcRepository_ptr;
typedef TcSignaling_TcRepository* TcSignaling_TcRepositoryRef;
void OBDuplicate(TcSignaling_TcRepository_ptr);
void OBRelease(TcSignaling_TcRepository_ptr);
typedef OBObjVar< TcSignaling_TcRepository > TcSignaling_TcRepository_var;

//
// IDL:TcSignaling/TcServiceFinder:1.0
//
class TcSignaling_TcServiceFinder;
typedef TcSignaling_TcServiceFinder* TcSignaling_TcServiceFinder_ptr;
typedef TcSignaling_TcServiceFinder* TcSignaling_TcServiceFinderRef;
void OBDuplicate(TcSignaling_TcServiceFinder_ptr);
void OBRelease(TcSignaling_TcServiceFinder_ptr);
typedef OBObjVar< TcSignaling_TcServiceFinder > TcSignaling_TcServiceFinder_var;

//
// IDL:TcSignaling/TcPduProvider:1.0
//
class TcSignaling_TcPduProvider;
typedef TcSignaling_TcPduProvider* TcSignaling_TcPduProvider_ptr;
typedef TcSignaling_TcPduProvider* TcSignaling_TcPduProviderRef;
void OBDuplicate(TcSignaling_TcPduProvider_ptr);
void OBRelease(TcSignaling_TcPduProvider_ptr);
typedef OBObjVar< TcSignaling_TcPduProvider > TcSignaling_TcPduProvider_var;

//
// IDL:TcSignaling/TcPduUser:1.0
//
class TcSignaling_TcPduUser;
typedef TcSignaling_TcPduUser* TcSignaling_TcPduUser_ptr;
typedef TcSignaling_TcPduUser* TcSignaling_TcPduUserRef;
void OBDuplicate(TcSignaling_TcPduUser_ptr);
void OBRelease(TcSignaling_TcPduUser_ptr);
typedef OBObjVar< TcSignaling_TcPduUser > TcSignaling_TcPduUser_var;

//
// IDL:TcSignaling/TcPduProviderFactory:1.0
//
class TcSignaling_TcPduProviderFactory;
typedef TcSignaling_TcPduProviderFactory* TcSignaling_TcPduProviderFactory_ptr;
typedef TcSignaling_TcPduProviderFactory* TcSignaling_TcPduProviderFactoryRef;
void OBDuplicate(TcSignaling_TcPduProviderFactory_ptr);
void OBRelease(TcSignaling_TcPduProviderFactory_ptr);
typedef OBObjVar< TcSignaling_TcPduProviderFactory > TcSignaling_TcPduProviderFactory_var;

//
// IDL:TcSignaling/TcUser:1.0
//
class TcSignaling_TcUser;
typedef TcSignaling_TcUser* TcSignaling_TcUser_ptr;
typedef TcSignaling_TcUser* TcSignaling_TcUserRef;
void OBDuplicate(TcSignaling_TcUser_ptr);
void OBRelease(TcSignaling_TcUser_ptr);
typedef OBObjVar< TcSignaling_TcUser > TcSignaling_TcUser_var;

//
// IDL:toveinap:1.0
//

//
// IDL:toveinap/SSF_SCF_initiator:1.0
//
class toveinap_SSF_SCF_initiator;
typedef toveinap_SSF_SCF_initiator* toveinap_SSF_SCF_initiator_ptr;
typedef toveinap_SSF_SCF_initiator* toveinap_SSF_SCF_initiatorRef;
void OBDuplicate(toveinap_SSF_SCF_initiator_ptr);
void OBRelease(toveinap_SSF_SCF_initiator_ptr);
typedef OBObjVar< toveinap_SSF_SCF_initiator > toveinap_SSF_SCF_initiator_var;

//
// IDL:toveinap/SSF_SCF_responder:1.0
//
class toveinap_SSF_SCF_responder;
typedef toveinap_SSF_SCF_responder* toveinap_SSF_SCF_responder_ptr;
typedef toveinap_SSF_SCF_responder* toveinap_SSF_SCF_responderRef;
void OBDuplicate(toveinap_SSF_SCF_responder_ptr);
void OBRelease(toveinap_SSF_SCF_responder_ptr);
typedef OBObjVar< toveinap_SSF_SCF_responder > toveinap_SSF_SCF_responder_var;

//
// IDL:toveinap/TcUserFactory:1.0
//
class toveinap_TcUserFactory;
typedef toveinap_TcUserFactory* toveinap_TcUserFactory_ptr;
typedef toveinap_TcUserFactory* toveinap_TcUserFactoryRef;
void OBDuplicate(toveinap_TcUserFactory_ptr);
void OBRelease(toveinap_TcUserFactory_ptr);
typedef OBObjVar< toveinap_TcUserFactory > toveinap_TcUserFactory_var;

//
// IDL:idl.tove/ccIf:1.0
//

//
// IDL:idl.tove/ccIf/managementServer:1.0
//
class ccIf_managementServer;
typedef ccIf_managementServer* ccIf_managementServer_ptr;
typedef ccIf_managementServer* ccIf_managementServerRef;
void OBDuplicate(ccIf_managementServer_ptr);
void OBRelease(ccIf_managementServer_ptr);
typedef OBObjVar< ccIf_managementServer > ccIf_managementServer_var;

//
// IDL:idl.tove/ccIf/Side:1.0
//
enum ccIf_Side
{
    ccIf_originating,
    ccIf_terminating
};

extern OBTypeCodeConst ccIf__tc_Side;

//
// IDL:idl.tove/ccIf/TriggerType:1.0
//
struct ccIf_TriggerType
{
#ifdef OB_CLEAR_MEM
    ccIf_TriggerType();
#else
    ccIf_TriggerType() { }
#endif
    ccIf_TriggerType(const ccIf_TriggerType&);
    ~ccIf_TriggerType() { }
    ccIf_TriggerType& operator=(const ccIf_TriggerType&);

    CORBA_String_var type;
    CORBA_String_var criteria;
    CORBA_String_var category;
    CORBA_String_var address;
    CORBA_String_var applicationContext;
    toveinap_ServiceKeyType serviceKey;
};

typedef OBVarVar< ccIf_TriggerType > ccIf_TriggerType_var;

extern OBTypeCodeConst ccIf__tc_TriggerType;

//
// IDL:idl.tove/ccIf/TriggersType:1.0
//
typedef OBVarSeq< ccIf_TriggerType > ccIf_TriggersType;
typedef OBSeqVar< OBVarSeq< ccIf_TriggerType > > ccIf_TriggersType_var;
extern OBTypeCodeConst ccIf__tc_TriggersType;

//
// IDL:idl.tove/ccIf/TDPtype:1.0
//
struct ccIf_TDPtype
{
    ccIf_TDPtype() { }
    ccIf_TDPtype(const ccIf_TDPtype&);
    ~ccIf_TDPtype() { }
    ccIf_TDPtype& operator=(const ccIf_TDPtype&);

    CORBA_String_var type;
    CORBA_String_var messageType;
    ccIf_TriggersType setTriggers;
    ccIf_TriggersType allowedTriggers;
};

typedef OBVarVar< ccIf_TDPtype > ccIf_TDPtype_var;

extern OBTypeCodeConst ccIf__tc_TDPtype;

//
// IDL:idl.tove/ccIf/TDPsType:1.0
//
typedef OBVarSeq< ccIf_TDPtype > ccIf_TDPsType;
typedef OBSeqVar< OBVarSeq< ccIf_TDPtype > > ccIf_TDPsType_var;
extern OBTypeCodeConst ccIf__tc_TDPsType;

//
// IDL:idl.tove/ccIf/managementServer:1.0
//
class ccIf_managementServer : virtual public CORBA_Object
{
    ccIf_managementServer(const ccIf_managementServer&);
    void operator=(const ccIf_managementServer&);

protected:

    ccIf_managementServer() { }

public:

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

    static inline ccIf_managementServer_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:idl.tove/ccIf/managementServer/setMessageType:1.0
    //
    virtual void setMessageType(ccIf_Side side,
                                const char* dpType,
                                const char* messageType);

    //
    // IDL:idl.tove/ccIf/managementServer/addTrigger:1.0
    //
    virtual void addTrigger(ccIf_Side side,
                            const char* dpType,
                            const ccIf_TriggerType& newTrigger);

    //
    // IDL:idl.tove/ccIf/managementServer/deleteTrigger:1.0
    //
    virtual void deleteTrigger(ccIf_Side side,
                               const char* dpType,
                               const ccIf_TriggerType& oldTrigger);

    //
    // IDL:idl.tove/ccIf/managementServer/requestTDPreport:1.0
    //
    virtual void requestTDPreport(ccIf_Side side,
                                  ccIf_TDPsType*& TDPs);

    //
    // IDL:idl.tove/ccIf/managementServer/test:1.0
    //
    virtual void test();
};

extern OBTypeCodeConst ccIf__tc_managementServer;

//
// IDL:idl.tove/ccIf/Side:1.0
//
inline void
OBMarshal(ccIf_Side val, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_ULong)val, oct);
}

inline void
OBMarshalCount(ccIf_Side, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_ULong)0, count);
}

inline void
OBUnmarshal(ccIf_Side& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong v;
    OBUnmarshal(v, coct, swap);
    val = (ccIf_Side)v;
}

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

//
// IDL:idl.tove/ccIf/TriggerType:1.0
//
void OBMarshal(const ccIf_TriggerType&, CORBA_Octet*&);
void OBMarshalCount(const ccIf_TriggerType&, CORBA_ULong&);
void OBUnmarshal(ccIf_TriggerType&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:idl.tove/ccIf/TDPtype:1.0
//
void OBMarshal(const ccIf_TDPtype&, CORBA_Octet*&);
void OBMarshalCount(const ccIf_TDPtype&, CORBA_ULong&);
void OBUnmarshal(ccIf_TDPtype&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:idl.tove/ccIf/managementServer:1.0
//
inline void
CORBA_release(ccIf_managementServer_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// OBVarSeq< ccIf_TriggerType >
//
#ifndef OB_use_OBVarSeq_ccIf__TriggerType
#define OB_use_OBVarSeq_ccIf__TriggerType
#define OB_use_OBVarSeq_ccIf__TriggerType_from_ccif_h

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

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

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

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

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

#endif

//
// OBVarSeq< ccIf_TDPtype >
//
#ifndef OB_use_OBVarSeq_ccIf__TDPtype
#define OB_use_OBVarSeq_ccIf__TDPtype
#define OB_use_OBVarSeq_ccIf__TDPtype_from_ccif_h

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

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

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

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

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

#endif

#endif