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

//
// IDL:toveSwitch:1.0
//

//
// IDL:toveSwitch/userInterface:1.0
//
class toveSwitch_userInterface;
typedef toveSwitch_userInterface* toveSwitch_userInterface_ptr;
typedef toveSwitch_userInterface* toveSwitch_userInterfaceRef;
void OBDuplicate(toveSwitch_userInterface_ptr);
void OBRelease(toveSwitch_userInterface_ptr);
typedef OBObjVar< toveSwitch_userInterface > toveSwitch_userInterface_var;

//
// IDL:toveSwitch/switchInterface:1.0
//
class toveSwitch_switchInterface;
typedef toveSwitch_switchInterface* toveSwitch_switchInterface_ptr;
typedef toveSwitch_switchInterface* toveSwitch_switchInterfaceRef;
void OBDuplicate(toveSwitch_switchInterface_ptr);
void OBRelease(toveSwitch_switchInterface_ptr);
typedef OBObjVar< toveSwitch_switchInterface > toveSwitch_switchInterface_var;

//
// IDL:toveSwitch/Parameter:1.0
//
struct toveSwitch_Parameter
{
    toveSwitch_Parameter() { }
    toveSwitch_Parameter(const toveSwitch_Parameter&);
    ~toveSwitch_Parameter() { }
    toveSwitch_Parameter& operator=(const toveSwitch_Parameter&);

    CORBA_String_var id;
    CORBA_String_var value;
    CORBA_String_var type;
};

typedef OBVarVar< toveSwitch_Parameter > toveSwitch_Parameter_var;

extern OBTypeCodeConst toveSwitch__tc_Parameter;

//
// IDL:toveSwitch/ParameterList:1.0
//
typedef OBVarSeq< toveSwitch_Parameter > toveSwitch_ParameterList;
typedef OBSeqVar< OBVarSeq< toveSwitch_Parameter > > toveSwitch_ParameterList_var;
extern OBTypeCodeConst toveSwitch__tc_ParameterList;

//
// IDL:toveSwitch/InvalidPort:1.0
//
struct toveSwitch_InvalidPort : public CORBA_UserException
{
#ifdef OB_CLEAR_MEM
    toveSwitch_InvalidPort();
#else
    toveSwitch_InvalidPort() { }
#endif
    toveSwitch_InvalidPort(const toveSwitch_InvalidPort&);
    toveSwitch_InvalidPort(CORBA_Long);
    virtual ~toveSwitch_InvalidPort() { }
    toveSwitch_InvalidPort& operator=(const toveSwitch_InvalidPort&);

    static toveSwitch_InvalidPort* _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_Long port;
};

extern OBTypeCodeConst toveSwitch__tc_InvalidPort;

//
// IDL:toveSwitch/InvalidLed:1.0
//
struct toveSwitch_InvalidLed : public CORBA_UserException
{
#ifdef OB_CLEAR_MEM
    toveSwitch_InvalidLed();
#else
    toveSwitch_InvalidLed() { }
#endif
    toveSwitch_InvalidLed(const toveSwitch_InvalidLed&);
    toveSwitch_InvalidLed(CORBA_Long);
    virtual ~toveSwitch_InvalidLed() { }
    toveSwitch_InvalidLed& operator=(const toveSwitch_InvalidLed&);

    static toveSwitch_InvalidLed* _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_Long led;
};

extern OBTypeCodeConst toveSwitch__tc_InvalidLed;

//
// IDL:toveSwitch/InvalidCommand:1.0
//
struct toveSwitch_InvalidCommand : public CORBA_UserException
{
    toveSwitch_InvalidCommand() { }
    toveSwitch_InvalidCommand(const toveSwitch_InvalidCommand&);
    toveSwitch_InvalidCommand(const char*);
    virtual ~toveSwitch_InvalidCommand() { }
    toveSwitch_InvalidCommand& operator=(const toveSwitch_InvalidCommand&);

    static toveSwitch_InvalidCommand* _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_String_var command;
};

extern OBTypeCodeConst toveSwitch__tc_InvalidCommand;

//
// IDL:toveSwitch/InvalidEvent:1.0
//
struct toveSwitch_InvalidEvent : public CORBA_UserException
{
    toveSwitch_InvalidEvent() { }
    toveSwitch_InvalidEvent(const toveSwitch_InvalidEvent&);
    toveSwitch_InvalidEvent(const char*);
    virtual ~toveSwitch_InvalidEvent() { }
    toveSwitch_InvalidEvent& operator=(const toveSwitch_InvalidEvent&);

    static toveSwitch_InvalidEvent* _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_String_var event;
};

extern OBTypeCodeConst toveSwitch__tc_InvalidEvent;

//
// IDL:toveSwitch/InvalidVariable:1.0
//
struct toveSwitch_InvalidVariable : public CORBA_UserException
{
    toveSwitch_InvalidVariable() { }
    toveSwitch_InvalidVariable(const toveSwitch_InvalidVariable&);
    toveSwitch_InvalidVariable(const char*);
    virtual ~toveSwitch_InvalidVariable() { }
    toveSwitch_InvalidVariable& operator=(const toveSwitch_InvalidVariable&);

    static toveSwitch_InvalidVariable* _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_String_var variable;
};

extern OBTypeCodeConst toveSwitch__tc_InvalidVariable;

//
// IDL:toveSwitch/InvalidValue:1.0
//
struct toveSwitch_InvalidValue : public CORBA_UserException
{
    toveSwitch_InvalidValue() { }
    toveSwitch_InvalidValue(const toveSwitch_InvalidValue&);
    toveSwitch_InvalidValue(const char*);
    virtual ~toveSwitch_InvalidValue() { }
    toveSwitch_InvalidValue& operator=(const toveSwitch_InvalidValue&);

    static toveSwitch_InvalidValue* _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_String_var value;
};

extern OBTypeCodeConst toveSwitch__tc_InvalidValue;

//
// IDL:toveSwitch/RegisteringError:1.0
//
struct toveSwitch_RegisteringError : public CORBA_UserException
{
    toveSwitch_RegisteringError() { }
    toveSwitch_RegisteringError(const toveSwitch_RegisteringError&);
    virtual ~toveSwitch_RegisteringError() { }
    toveSwitch_RegisteringError& operator=(const toveSwitch_RegisteringError&);

    static toveSwitch_RegisteringError* _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 toveSwitch__tc_RegisteringError;

//
// IDL:toveSwitch/userInterface:1.0
//
class toveSwitch_userInterface : virtual public CORBA_Object
{
    toveSwitch_userInterface(const toveSwitch_userInterface&);
    void operator=(const toveSwitch_userInterface&);

protected:

    toveSwitch_userInterface() { }

public:

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

    static inline toveSwitch_userInterface_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:toveSwitch/userInterface/ledOn:1.0
    //
    virtual void ledOn(CORBA_Long port,
                       CORBA_Long led);

    //
    // IDL:toveSwitch/userInterface/ledOff:1.0
    //
    virtual void ledOff(CORBA_Long port,
                        CORBA_Long led);

    //
    // IDL:toveSwitch/userInterface/ledBlink:1.0
    //
    virtual void ledBlink(CORBA_Long port,
                          CORBA_Long led,
                          CORBA_Long command);

    //
    // IDL:toveSwitch/userInterface/printInfo:1.0
    //
    virtual void printInfo(const char* text);

    //
    // IDL:toveSwitch/userInterface/event:1.0
    //
    virtual void event(const char* event);
};

extern OBTypeCodeConst toveSwitch__tc_userInterface;

//
// IDL:toveSwitch/switchInterface:1.0
//
class toveSwitch_switchInterface : virtual public CORBA_Object
{
    toveSwitch_switchInterface(const toveSwitch_switchInterface&);
    void operator=(const toveSwitch_switchInterface&);

protected:

    toveSwitch_switchInterface() { }

public:

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

    static inline toveSwitch_switchInterface_ptr
    _nil()
    {
        return 0;
    }

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

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

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

    //
    // IDL:toveSwitch/switchInterface/registerUserInterface:1.0
    //
    virtual void registerUserInterface(CORBA_Object_ptr iface);

    //
    // IDL:toveSwitch/switchInterface/unregisterUserInterface:1.0
    //
    virtual void unregisterUserInterface(CORBA_Object_ptr iface);

    //
    // IDL:toveSwitch/switchInterface/getValue:1.0
    //
    virtual char* getValue(const char* name);

    //
    // IDL:toveSwitch/switchInterface/setValue:1.0
    //
    virtual void setValue(const char* name,
                          const char* value);

    //
    // IDL:toveSwitch/switchInterface/execute:1.0
    //
    virtual void execute(const char* command,
                         toveSwitch_ParameterList& parameters);
};

extern OBTypeCodeConst toveSwitch__tc_switchInterface;

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

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

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

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

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

//
// IDL:toveSwitch/InvalidPort:1.0
//
void OBMarshal(const toveSwitch_InvalidPort&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_InvalidPort&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_InvalidPort&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/InvalidLed:1.0
//
void OBMarshal(const toveSwitch_InvalidLed&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_InvalidLed&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_InvalidLed&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/InvalidCommand:1.0
//
void OBMarshal(const toveSwitch_InvalidCommand&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_InvalidCommand&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_InvalidCommand&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/InvalidEvent:1.0
//
void OBMarshal(const toveSwitch_InvalidEvent&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_InvalidEvent&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_InvalidEvent&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/InvalidVariable:1.0
//
void OBMarshal(const toveSwitch_InvalidVariable&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_InvalidVariable&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_InvalidVariable&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/InvalidValue:1.0
//
void OBMarshal(const toveSwitch_InvalidValue&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_InvalidValue&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_InvalidValue&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/RegisteringError:1.0
//
void OBMarshal(const toveSwitch_RegisteringError&, CORBA_Octet*&);
void OBMarshalCount(const toveSwitch_RegisteringError&, CORBA_ULong&);
void OBUnmarshal(toveSwitch_RegisteringError&, const CORBA_Octet*&, bool);

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

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

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

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

//
// IDL:toveSwitch/userInterface:1.0
//
inline void
CORBA_release(toveSwitch_userInterface_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// IDL:toveSwitch/switchInterface:1.0
//
inline void
CORBA_release(toveSwitch_switchInterface_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

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

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

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

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

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

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

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

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

//
// OBVarSeq< toveSwitch_Parameter >
//
#ifndef OB_use_OBVarSeq_toveSwitch__Parameter
#define OB_use_OBVarSeq_toveSwitch__Parameter
#define OB_use_OBVarSeq_toveSwitch__Parameter_from_toveswitch_h

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

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

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

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

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

#endif

#endif