// **********************************************************************
//
// Generated by the ORBacus IDL to C++ Translator
//
// Copyright (c) 1999
// Object Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

#ifndef TEST_IMPL_H
#define TEST_IMPL_H

#include <Test1_skel.h>
#include <Test2_skel.h>

class TestInterface_impl : virtual public TestInterface_skel
{
protected:

    CORBA_Short aShort;
    CORBA_UShort aUShort;
    CORBA_Long aLong;
    CORBA_ULong aULong;
    CORBA_Float aFloat;
    CORBA_Double aDouble;
    CORBA_Boolean aBoolean;
    CORBA_Char aChar;
    CORBA_Octet aOctet;
    CORBA_String_var aString;
    CORBA_Any aAny;
    TestEnum aTestEnum;
    TestInterface_var aTestInterface;
    FixedStruct aFixedStruct;
    VariableStruct aVariableStruct;
    FixedUnion aFixedUnion;
    VariableUnion aVariableUnion;
    StringSequence aStringSequence;
    FixedArray aFixedArray;
    VariableArray aVariableArray;
    FixedArraySequence aFixedArraySequence;
    VariableArraySequence aVariableArraySequence;

public:

    virtual void opVoid();

    virtual StringSequence* opContext(const char*, CORBA_Context_ptr);

    virtual CORBA_Short attrShort();
    virtual void attrShort(CORBA_Short);

    virtual CORBA_Short opShort(CORBA_Short a0,
				CORBA_Short& a1,
				CORBA_Short& a2);

    virtual CORBA_Long attrLong();
    virtual void attrLong(CORBA_Long);

    virtual CORBA_Long opLong(CORBA_Long a0,
			      CORBA_Long& a1,
			      CORBA_Long& a2);

    virtual CORBA_UShort attrUShort();
    virtual void attrUShort(CORBA_UShort);

    virtual CORBA_UShort opUShort(CORBA_UShort a0,
				  CORBA_UShort& a1,
				  CORBA_UShort& a2);

    virtual CORBA_ULong attrULong();
    virtual void attrULong(CORBA_ULong);

    virtual CORBA_ULong opULong(CORBA_ULong a0,
				CORBA_ULong& a1,
				CORBA_ULong& a2);

    virtual CORBA_Float attrFloat();
    virtual void attrFloat(CORBA_Float);

    virtual CORBA_Float opFloat(CORBA_Float a0,
				CORBA_Float& a1,
				CORBA_Float& a2);

    virtual CORBA_Double attrDouble();
    virtual void attrDouble(CORBA_Double);

    virtual CORBA_Double opDouble(CORBA_Double a0,
				  CORBA_Double& a1,
				  CORBA_Double& a2);

    virtual CORBA_Boolean attrBoolean();
    virtual void attrBoolean(CORBA_Boolean);

    virtual CORBA_Boolean opBoolean(CORBA_Boolean a0,
				    CORBA_Boolean& a1,
				    CORBA_Boolean& a2);
    
    virtual CORBA_Char attrChar();
    virtual void attrChar(CORBA_Char);

    virtual CORBA_Char opChar(CORBA_Char a0,
			      CORBA_Char& a1,
			      CORBA_Char& a2);

    virtual CORBA_Octet attrOctet();
    virtual void attrOctet(CORBA_Octet);

    virtual CORBA_Octet opOctet(CORBA_Octet a0,
				CORBA_Octet& a1,
				CORBA_Octet& a2);

    virtual char* attrString();
    virtual void attrString(const char*);

    virtual char* opString(const char* a0,
                           char*& a1,
                           char*& a2);

    virtual CORBA_Any* attrAny();
    virtual void attrAny(const CORBA_Any&);

    virtual CORBA_Any* opAny(const CORBA_Any& a0,
			     CORBA_Any& a1,
			     CORBA_Any*& a2);

    virtual TestEnum attrTestEnum();
    virtual void attrTestEnum(TestEnum);

    virtual TestEnum opTestEnum(TestEnum a0,
                                TestEnum& a1,
                                TestEnum& a2);

    virtual TestInterface_ptr attrTestInterface();
    virtual void attrTestInterface(TestInterface_ptr);

    virtual TestInterface_ptr opTestInterface(TestInterface_ptr a0,
					      TestInterface_ptr& a1,
					      TestInterface_ptr& a2);
    
    virtual FixedStruct attrFixedStruct();
    virtual void attrFixedStruct(const FixedStruct&);

    virtual FixedStruct opFixedStruct(const FixedStruct& a0,
                                      FixedStruct& a1,
                                      FixedStruct& a2);

    virtual VariableStruct* attrVariableStruct();
    virtual void attrVariableStruct(const VariableStruct&);

    virtual VariableStruct* opVariableStruct(const VariableStruct& a0,
                                             VariableStruct& a1,
                                             VariableStruct*& a2);

    virtual FixedUnion attrFixedUnion();
    virtual void attrFixedUnion(const FixedUnion&);

    virtual FixedUnion opFixedUnion(const FixedUnion& a0,
				    FixedUnion& a1,
				    FixedUnion& a2);

    virtual VariableUnion* attrVariableUnion();
    virtual void attrVariableUnion(const VariableUnion&);

    virtual VariableUnion* opVariableUnion(const VariableUnion& a0,
					   VariableUnion& a1,
					   VariableUnion*& a2);

    virtual StringSequence* attrStringSequence();
    virtual void attrStringSequence(const StringSequence&);

    virtual StringSequence* opStringSequence(const StringSequence& a0,
                                             StringSequence& a1,
                                             StringSequence*& a2);

    virtual FixedArray_slice* attrFixedArray();
    virtual void attrFixedArray(const FixedArray);

    virtual FixedArray_slice* opFixedArray(const FixedArray a0,
					   FixedArray a1,
					   FixedArray a2);

    virtual VariableArray_slice* attrVariableArray();
    virtual void attrVariableArray(const VariableArray);

    virtual VariableArray_slice* opVariableArray(const VariableArray a0,
						 VariableArray a1,
						 VariableArray_slice*& a2);

    virtual FixedArraySequence* attrFixedArraySequence();
    virtual void attrFixedArraySequence(const FixedArraySequence&);

    virtual FixedArraySequence*
    opFixedArraySequence(const FixedArraySequence& a0,
			 FixedArraySequence& a1,
			 FixedArraySequence*& a2);

    virtual VariableArraySequence* attrVariableArraySequence();
    virtual void attrVariableArraySequence(const VariableArraySequence&);

    virtual VariableArraySequence*
    opVariableArraySequence(const VariableArraySequence& a0,
			    VariableArraySequence& a1,
			    VariableArraySequence*& a2);

    virtual void releaseInternal();
    virtual void deactivate();
};

class TestInterfaceEx_impl : virtual public TestInterfaceEx_skel,
			     virtual public TestInterface_impl
{
public:

    virtual void opVoidEx();

    virtual CORBA_Short opShortEx(CORBA_Short a0,
				  CORBA_Short& a1,
				  CORBA_Short& a2);

    virtual CORBA_Long opLongEx(CORBA_Long a0,
				CORBA_Long& a1,
				CORBA_Long& a2);

    virtual CORBA_UShort opUShortEx(CORBA_UShort a0,
				    CORBA_UShort& a1,
				    CORBA_UShort& a2);

    virtual CORBA_ULong opULongEx(CORBA_ULong a0,
				  CORBA_ULong& a1,
				  CORBA_ULong& a2);

    virtual CORBA_Float opFloatEx(CORBA_Float a0,
				  CORBA_Float& a1,
				  CORBA_Float& a2);

    virtual CORBA_Double opDoubleEx(CORBA_Double a0,
				    CORBA_Double& a1,
				    CORBA_Double& a2);

    virtual CORBA_Boolean opBooleanEx(CORBA_Boolean a0,
				      CORBA_Boolean& a1,
				      CORBA_Boolean& a2);
    
    virtual CORBA_Char opCharEx(CORBA_Char a0,
				CORBA_Char& a1,
				CORBA_Char& a2);

    virtual CORBA_Octet opOctetEx(CORBA_Octet a0,
				  CORBA_Octet& a1,
				  CORBA_Octet& a2);

    virtual char* opStringEx(const char* a0,
			     char*& a1,
			     char*& a2);

    virtual CORBA_Any* opAnyEx(const CORBA_Any& a0,
			       CORBA_Any& a1,
			       CORBA_Any*& a2);

    virtual TestEnum opTestEnumEx(TestEnum a0,
				  TestEnum& a1,
				  TestEnum& a2);

    virtual TestInterface_ptr opTestInterfaceEx(TestInterface_ptr a0,
						TestInterface_ptr& a1,
						TestInterface_ptr& a2);
    
    virtual FixedStruct opFixedStructEx(const FixedStruct& a0,
					FixedStruct& a1,
					FixedStruct& a2);

    virtual VariableStruct* opVariableStructEx(const VariableStruct& a0,
					       VariableStruct& a1,
					       VariableStruct*& a2);

    virtual FixedUnion opFixedUnionEx(const FixedUnion& a0,
				      FixedUnion& a1,
				      FixedUnion& a2);

    virtual VariableUnion* opVariableUnionEx(const VariableUnion& a0,
					     VariableUnion& a1,
					     VariableUnion*& a2);

    virtual StringSequence* opStringSequenceEx(const StringSequence& a0,
					       StringSequence& a1,
					       StringSequence*& a2);

    virtual FixedArray_slice* opFixedArrayEx(const FixedArray a0,
					     FixedArray a1,
					     FixedArray a2);

    virtual VariableArray_slice* opVariableArrayEx(const VariableArray a0,
						   VariableArray a1,
						   VariableArray_slice*& a2);

    virtual FixedArraySequence*
    opFixedArraySequenceEx(const FixedArraySequence& a0,
			   FixedArraySequence& a1,
			   FixedArraySequence*& a2);

    virtual VariableArraySequence*
    opVariableArraySequenceEx(const VariableArraySequence& a0,
			      VariableArraySequence& a1,
			      VariableArraySequence*& a2);

    virtual void op_UNKNOWN_Ex();
    virtual void op_BAD_PARAM_Ex();
    virtual void op_NO_MEMORY_Ex();
    virtual void op_IMP_LIMIT_Ex();
    virtual void op_COMM_FAILURE_Ex();
    virtual void op_INV_OBJREF_Ex();
    virtual void op_NO_PERMISSION_Ex();
    virtual void op_INTERNAL_Ex();
    virtual void op_MARSHAL_Ex();
    virtual void op_INITIALIZE_Ex();
    virtual void op_NO_IMPLEMENT_Ex();
    virtual void op_BAD_TYPECODE_Ex();
    virtual void op_BAD_OPERATION_Ex();
    virtual void op_NO_RESOURCES_Ex();
    virtual void op_NO_RESPONSE_Ex();
    virtual void op_PERSIST_STORE_Ex();
    virtual void op_BAD_INV_ORDER_Ex();
    virtual void op_TRANSIENT_Ex();
    virtual void op_FREE_MEM_Ex();
    virtual void op_INV_IDENT_Ex();
    virtual void op_INV_FLAG_Ex();
    virtual void op_INTF_REPOS_Ex();
    virtual void op_BAD_CONTEXT_Ex();
    virtual void op_OBJ_ADAPTER_Ex();
    virtual void op_DATA_CONVERSION_Ex();
    virtual void op_OBJECT_NOT_EXIST_Ex();
    virtual void op_TRANSACTION_REQUIRED_Ex();
    virtual void op_TRANSACTION_ROLLEDBACK_Ex();
    virtual void op_INVALID_TRANSACTION_Ex();
    virtual void op_INV_POLICY_Ex();
};

class TestInterfaceTimeout_impl : virtual public TestInterfaceTimeout_skel,
				  virtual public TestInterfaceEx_impl
{
public:

    virtual void sleepOneway(CORBA_ULong sec);
    virtual void sleepTwoway(CORBA_ULong sec);
};

#endif
