// **********************************************************************
//
// 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
// License: non-commercial

#ifndef __CosEventComm_h__
#define __CosEventComm_h__

//
// IDL:omg.org/CosEventComm:1.0
//

//
// IDL:omg.org/CosEventComm/PushConsumer:1.0
//
class CosEventComm_PushConsumer;
typedef CosEventComm_PushConsumer* CosEventComm_PushConsumer_ptr;
typedef CosEventComm_PushConsumer* CosEventComm_PushConsumerRef;
void OBDuplicate(CosEventComm_PushConsumer_ptr);
void OBRelease(CosEventComm_PushConsumer_ptr);
typedef OBObjVar< CosEventComm_PushConsumer > CosEventComm_PushConsumer_var;

//
// IDL:omg.org/CosEventComm/PushSupplier:1.0
//
class CosEventComm_PushSupplier;
typedef CosEventComm_PushSupplier* CosEventComm_PushSupplier_ptr;
typedef CosEventComm_PushSupplier* CosEventComm_PushSupplierRef;
void OBDuplicate(CosEventComm_PushSupplier_ptr);
void OBRelease(CosEventComm_PushSupplier_ptr);
typedef OBObjVar< CosEventComm_PushSupplier > CosEventComm_PushSupplier_var;

//
// IDL:omg.org/CosEventComm/PullSupplier:1.0
//
class CosEventComm_PullSupplier;
typedef CosEventComm_PullSupplier* CosEventComm_PullSupplier_ptr;
typedef CosEventComm_PullSupplier* CosEventComm_PullSupplierRef;
void OBDuplicate(CosEventComm_PullSupplier_ptr);
void OBRelease(CosEventComm_PullSupplier_ptr);
typedef OBObjVar< CosEventComm_PullSupplier > CosEventComm_PullSupplier_var;

//
// IDL:omg.org/CosEventComm/PullConsumer:1.0
//
class CosEventComm_PullConsumer;
typedef CosEventComm_PullConsumer* CosEventComm_PullConsumer_ptr;
typedef CosEventComm_PullConsumer* CosEventComm_PullConsumerRef;
void OBDuplicate(CosEventComm_PullConsumer_ptr);
void OBRelease(CosEventComm_PullConsumer_ptr);
typedef OBObjVar< CosEventComm_PullConsumer > CosEventComm_PullConsumer_var;

//
// IDL:omg.org/CosEventComm/Disconnected:1.0
//
struct CosEventComm_Disconnected : public CORBA_UserException
{
    CosEventComm_Disconnected() { }
    CosEventComm_Disconnected(const CosEventComm_Disconnected&);
    virtual ~CosEventComm_Disconnected() { }
    CosEventComm_Disconnected& operator=(const CosEventComm_Disconnected&);

    static CosEventComm_Disconnected* _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 const OBTypeCodeConst CosEventComm__tc_Disconnected;

//
// IDL:omg.org/CosEventComm/PushConsumer:1.0
//
class CosEventComm_PushConsumer : virtual public CORBA_Object
{
    CosEventComm_PushConsumer(const CosEventComm_PushConsumer&);
    void operator=(const CosEventComm_PushConsumer&);

public:

    CosEventComm_PushConsumer() { }

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

    static inline CosEventComm_PushConsumer_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:omg.org/CosEventComm/PushConsumer/push:1.0
    //
    virtual void push(const CORBA_Any& data);

    //
    // IDL:omg.org/CosEventComm/PushConsumer/disconnect_push_consumer:1.0
    //
    virtual void disconnect_push_consumer();
};

extern const OBTypeCodeConst CosEventComm__tc_PushConsumer;

//
// IDL:omg.org/CosEventComm/PushSupplier:1.0
//
class CosEventComm_PushSupplier : virtual public CORBA_Object
{
    CosEventComm_PushSupplier(const CosEventComm_PushSupplier&);
    void operator=(const CosEventComm_PushSupplier&);

public:

    CosEventComm_PushSupplier() { }

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

    static inline CosEventComm_PushSupplier_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:omg.org/CosEventComm/PushSupplier/disconnect_push_supplier:1.0
    //
    virtual void disconnect_push_supplier();
};

extern const OBTypeCodeConst CosEventComm__tc_PushSupplier;

//
// IDL:omg.org/CosEventComm/PullSupplier:1.0
//
class CosEventComm_PullSupplier : virtual public CORBA_Object
{
    CosEventComm_PullSupplier(const CosEventComm_PullSupplier&);
    void operator=(const CosEventComm_PullSupplier&);

public:

    CosEventComm_PullSupplier() { }

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

    static inline CosEventComm_PullSupplier_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:omg.org/CosEventComm/PullSupplier/pull:1.0
    //
    virtual CORBA_Any* pull();

    //
    // IDL:omg.org/CosEventComm/PullSupplier/try_pull:1.0
    //
    virtual CORBA_Any* try_pull(CORBA_Boolean& has_event);

    //
    // IDL:omg.org/CosEventComm/PullSupplier/disconnect_pull_supplier:1.0
    //
    virtual void disconnect_pull_supplier();
};

extern const OBTypeCodeConst CosEventComm__tc_PullSupplier;

//
// IDL:omg.org/CosEventComm/PullConsumer:1.0
//
class CosEventComm_PullConsumer : virtual public CORBA_Object
{
    CosEventComm_PullConsumer(const CosEventComm_PullConsumer&);
    void operator=(const CosEventComm_PullConsumer&);

public:

    CosEventComm_PullConsumer() { }

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

    static inline CosEventComm_PullConsumer_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:omg.org/CosEventComm/PullConsumer/disconnect_pull_consumer:1.0
    //
    virtual void disconnect_pull_consumer();
};

extern const OBTypeCodeConst CosEventComm__tc_PullConsumer;

//
// IDL:omg.org/CosEventComm/Disconnected:1.0
//
void OBMarshal(const CosEventComm_Disconnected&, CORBA_Octet*&);
void OBMarshalCount(const CosEventComm_Disconnected&, CORBA_ULong&);
void OBUnmarshal(CosEventComm_Disconnected&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:omg.org/CosEventComm/PushConsumer:1.0
//
inline void
CORBA_release(CosEventComm_PushConsumer_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// IDL:omg.org/CosEventComm/PushSupplier:1.0
//
inline void
CORBA_release(CosEventComm_PushSupplier_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// IDL:omg.org/CosEventComm/PullSupplier:1.0
//
inline void
CORBA_release(CosEventComm_PullSupplier_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// IDL:omg.org/CosEventComm/PullConsumer:1.0
//
inline void
CORBA_release(CosEventComm_PullConsumer_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

#endif
