Encapsulation d'un module Corba en un module en technologie Up ! Virtual Technical Machine

Commande de compilation...
Commande d'enregistrement des objets Corba...
Commande d'exécution...
Fichiers sources...

upscmp Source=classab.idl AdaptateurClientCorba=Oui AdaptateurDictionnaire=Oui AdaptateurServeurUpsNet=Oui
upscmp Source=client.upl

Revenir en haut de la page...

${MICO_HOME}/bin/ird -ORBIIOPAddr inet:localhost:8888 --db ${MICO_HOME}/db/db-ird
${MICO_HOME}/bin/micod -ORBIIOPAddr inet:localhost:9999 --db ${MICO_HOME}/db/db-micod.txt --forward
${MICO_HOME}/bin/idl -ORBIfaceRepoAddr inet:localhost:8888 -ORBImplRepoAddr inet:localhost:9999 --no-codegen-c++ --no-codegen-idl --feed-ir -I ${MICO_HOME}/include/mico classab.idl

Revenir en haut de la page...

${MICO_HOME}/bin/ird -ORBIIOPAddr inet:localhost:8888 --db ${MICO_HOME}/db/db-ird
${MICO_HOME}/bin/micod -ORBIIOPAddr inet:localhost:9999 --db ${MICO_HOME}/db/db-micod.txt --forward
client -ORBIfaceRepoAddr inet:localhost:8888 -ORBImplRepoAddr inet:localhost:9999 -ORBBindAddr local:

Revenir en haut de la page...

#include <CORBA.h>
#include <classab.hh>

class CClassB : public POA_IClassB
/********************************/
{
private :
/*******/
CORBA::Short _A;

public :
/******/
CORBA::Short A();
void A(CORBA::Short value);

CClassB();
~CClassB();
};

class CClassA : public POA_IClassA
/********************************/
{
private :
/*******/
CORBA::Any* _ChampA1;
CORBA::Boolean _ChampB1;
CORBA::Char _ChampC1;
CORBA::Double _ChampD1;
FixedTmpl< 6,2 > _ChampE1;
CORBA::Float _ChampF1;
CORBA::Long _ChampG1;
CORBA::LongLong _ChampH1;
CORBA::LongDouble _ChampI1;
CORBA::Object_ptr _ChampJ1;
CORBA::Octet _ChampK1;
CORBA::Short _ChampL1;
char* _ChampM1;
CORBA::ULong _ChampN1;
CORBA::ULongLong _ChampO1;
CORBA::UShort _ChampP1;
CORBA::WChar _ChampQ1;
CORBA::WChar* _ChampR1;
::Enu _ChampS1;
::IClassB_ptr _ChampT1;
::IClassA::StructS* _ChampU1;
::IClassA::UnionU* _ChampV1;

::IClassA::SequenceAny* _ChampA2;
::IClassA::SequenceBoolean* _ChampB2;
::IClassA::SequenceChar* _ChampC2;
::IClassA::SequenceDouble* _ChampD2;
::IClassA::SequenceFixed* _ChampE2;
::IClassA::SequenceFloat* _ChampF2;
::IClassA::SequenceLong* _ChampG2;
::IClassA::SequenceLongLong* _ChampH2;
::IClassA::SequenceLongDouble* _ChampI2;
::IClassA::SequenceObject* _ChampJ2;
::IClassA::SequenceOctet* _ChampK2;
::IClassA::SequenceShort* _ChampL2;
::IClassA::SequenceString* _ChampM2;
::IClassA::SequenceUnsignedLong* _ChampN2;
::IClassA::SequenceUnsignedLongLong* _ChampO2;
::IClassA::SequenceUnsignedShort* _ChampP2;
::IClassA::SequenceWChar* _ChampQ2;
::IClassA::SequenceWString* _ChampR2;
::IClassA::SequenceEnu* _ChampS2;
::IClassA::SequenceIClassB* _ChampT2;
::IClassA::SequenceStructS* _ChampU2;
::IClassA::SequenceUnionU* _ChampV2;

public :
/******/
CORBA::Any* ChampA1();
void ChampA1(const CORBA::Any& value);
CORBA::Boolean ChampB1();
void ChampB1(CORBA::Boolean value);
CORBA::Char ChampC1();
void ChampC1(CORBA::Char value);
CORBA::Double ChampD1();
void ChampD1(CORBA::Double value);
FixedTmpl< 6,2 > ChampE1();
void ChampE1(FixedTmpl< 6,2 > value);
CORBA::Float ChampF1();
void ChampF1(CORBA::Float value);
CORBA::Long ChampG1();
void ChampG1(CORBA::Long value);
CORBA::LongLong ChampH1();
void ChampH1(CORBA::LongLong value);
CORBA::LongDouble ChampI1();
void ChampI1(CORBA::LongDouble value);
CORBA::Object_ptr ChampJ1();
void ChampJ1(CORBA::Object_ptr value);
CORBA::Octet ChampK1();
void ChampK1(CORBA::Octet value);
CORBA::Short ChampL1();
void ChampL1(CORBA::Short value);
char* ChampM1();
void ChampM1(const char* value);
CORBA::ULong ChampN1();
void ChampN1(CORBA::ULong value);
CORBA::ULongLong ChampO1();
void ChampO1(CORBA::ULongLong value);
CORBA::UShort ChampP1();
void ChampP1(CORBA::UShort value);
CORBA::WChar ChampQ1();
void ChampQ1(CORBA::WChar value);
CORBA::WChar* ChampR1();
void ChampR1(const CORBA::WChar* value);
::Enu ChampS1();
void ChampS1(::Enu value);
::IClassB_ptr ChampT1();
void ChampT1(::IClassB_ptr value);
::IClassA::StructS* ChampU1();
void ChampU1(const ::IClassA::StructS& value);
::IClassA::UnionU* ChampV1();
void ChampV1(const ::IClassA::UnionU& value);

::IClassA::SequenceAny* ChampA2();
void ChampA2(const ::IClassA::SequenceAny& value);
::IClassA::SequenceBoolean* ChampB2();
void ChampB2(const ::IClassA::SequenceBoolean& value);
::IClassA::SequenceChar* ChampC2();
void ChampC2(const ::IClassA::SequenceChar& value);
::IClassA::SequenceDouble* ChampD2();
void ChampD2(const ::IClassA::SequenceDouble& value);
::IClassA::SequenceFixed* ChampE2();
void ChampE2(const ::IClassA::SequenceFixed& value);
::IClassA::SequenceFloat* ChampF2();
void ChampF2(const ::IClassA::SequenceFloat& value);
::IClassA::SequenceLong* ChampG2();
void ChampG2(const ::IClassA::SequenceLong& value);
::IClassA::SequenceLongLong* ChampH2();
void ChampH2(const ::IClassA::SequenceLongLong& value);
::IClassA::SequenceLongDouble* ChampI2();
void ChampI2(const ::IClassA::SequenceLongDouble& value);
::IClassA::SequenceObject* ChampJ2();
void ChampJ2(const ::IClassA::SequenceObject& value);
::IClassA::SequenceOctet* ChampK2();
void ChampK2(const ::IClassA::SequenceOctet& value);
::IClassA::SequenceShort* ChampL2();
void ChampL2(const ::IClassA::SequenceShort& value);
::IClassA::SequenceString* ChampM2();
void ChampM2(const ::IClassA::SequenceString& value);
::IClassA::SequenceUnsignedLong* ChampN2();
void ChampN2(const ::IClassA::SequenceUnsignedLong& value);
::IClassA::SequenceUnsignedLongLong* ChampO2();
void ChampO2(const ::IClassA::SequenceUnsignedLongLong& value);
::IClassA::SequenceUnsignedShort* ChampP2();
void ChampP2(const ::IClassA::SequenceUnsignedShort& value);
::IClassA::SequenceWChar* ChampQ2();
void ChampQ2(const ::IClassA::SequenceWChar& value);
::IClassA::SequenceWString* ChampR2();
void ChampR2(const ::IClassA::SequenceWString& value);
::IClassA::SequenceEnu* ChampS2();
void ChampS2(const ::IClassA::SequenceEnu& value);
::IClassA::SequenceIClassB* ChampT2();
void ChampT2(const ::IClassA::SequenceIClassB& value);
::IClassA::SequenceStructS* ChampU2();
void ChampU2(const ::IClassA::SequenceStructS& value);
::IClassA::SequenceUnionU* ChampV2();
void ChampV2(const ::IClassA::SequenceUnionU& value);

void AppelZ1();
CORBA::Any* AppelA1(const CORBA::Any& P1, CORBA::Any& P2);
CORBA::Boolean AppelB1(CORBA::Boolean P1, CORBA::Boolean& P2);
CORBA::Char AppelC1(CORBA::Char P1, CORBA::Char& P2);
CORBA::Double AppelD1(CORBA::Double P1, CORBA::Double& P2);
FixedTmpl< 6,2 > AppelE1(FixedTmpl< 6,2 > P1, FixedTmpl< 6,2 >& P2);
CORBA::Float AppelF1(CORBA::Float P1, CORBA::Float& P2);
CORBA::Long AppelG1(CORBA::Long P1, CORBA::Long& P2);
CORBA::LongLong AppelH1(CORBA::LongLong P1, CORBA::LongLong& P2);
CORBA::LongDouble AppelI1(CORBA::LongDouble P1, CORBA::LongDouble& P2);
CORBA::Object_ptr AppelJ1(CORBA::Object_ptr P1, CORBA::Object_ptr& P2);
CORBA::Octet AppelK1(CORBA::Octet P1, CORBA::Octet& P2);
CORBA::Short AppelL1(CORBA::Short P1, CORBA::Short& P2);
char* AppelM1(const char* P1, char*& P2);
CORBA::ULong AppelN1(CORBA::ULong P1, CORBA::ULong& P2);
CORBA::ULongLong AppelO1(CORBA::ULongLong P1, CORBA::ULongLong& P2);
CORBA::UShort AppelP1(CORBA::UShort P1, CORBA::UShort& P2);
CORBA::WChar AppelQ1(CORBA::WChar P1, CORBA::WChar& P2);
CORBA::WChar* AppelR1(const CORBA::WChar* P1, CORBA::WChar*& P2);
::Enu AppelS1(::Enu P1, ::Enu& P2);
::IClassB_ptr AppelT1(::IClassB_ptr P1, ::IClassB_ptr& P2);
::IClassA::StructS* AppelU1(const ::IClassA::StructS& P1, ::IClassA::StructS& P2);
::IClassA::UnionU* AppelV1(const ::IClassA::UnionU& P1, ::IClassA::UnionU& P2);

void AppelZ2();
::IClassA::SequenceAny* AppelA2(const ::IClassA::SequenceAny& P1, ::IClassA::SequenceAny& P2);
::IClassA::SequenceBoolean* AppelB2(const ::IClassA::SequenceBoolean& P1, ::IClassA::SequenceBoolean& P2);
::IClassA::SequenceChar* AppelC2(const ::IClassA::SequenceChar& P1, ::IClassA::SequenceChar& P2);
::IClassA::SequenceDouble* AppelD2(const ::IClassA::SequenceDouble& P1, ::IClassA::SequenceDouble& P2);
::IClassA::SequenceFixed* AppelE2(const ::IClassA::SequenceFixed& P1, ::IClassA::SequenceFixed& P2);
::IClassA::SequenceFloat* AppelF2(const ::IClassA::SequenceFloat& P1, ::IClassA::SequenceFloat& P2);
::IClassA::SequenceLong* AppelG2(const ::IClassA::SequenceLong& P1, ::IClassA::SequenceLong& P2);
::IClassA::SequenceLongLong* AppelH2(const ::IClassA::SequenceLongLong& P1, ::IClassA::SequenceLongLong& P2);
::IClassA::SequenceLongDouble* AppelI2(const ::IClassA::SequenceLongDouble& P1, ::IClassA::SequenceLongDouble& P2);
::IClassA::SequenceObject* AppelJ2(const ::IClassA::SequenceObject& P1, ::IClassA::SequenceObject& P2);
::IClassA::SequenceOctet* AppelK2(const ::IClassA::SequenceOctet& P1, ::IClassA::SequenceOctet& P2);
::IClassA::SequenceShort* AppelL2(const ::IClassA::SequenceShort& P1, ::IClassA::SequenceShort& P2);
::IClassA::SequenceString* AppelM2(const ::IClassA::SequenceString& P1, ::IClassA::SequenceString& P2);
::IClassA::SequenceUnsignedLong* AppelN2(const ::IClassA::SequenceUnsignedLong& P1, ::IClassA::SequenceUnsignedLong& P2);
::IClassA::SequenceUnsignedLongLong* AppelO2(const ::IClassA::SequenceUnsignedLongLong& P1, ::IClassA::SequenceUnsignedLongLong& P2);
::IClassA::SequenceUnsignedShort* AppelP2(const ::IClassA::SequenceUnsignedShort& P1, ::IClassA::SequenceUnsignedShort& P2);
::IClassA::SequenceWChar* AppelQ2(const ::IClassA::SequenceWChar& P1, ::IClassA::SequenceWChar& P2);
::IClassA::SequenceWString* AppelR2(const ::IClassA::SequenceWString& P1, ::IClassA::SequenceWString& P2);
::IClassA::SequenceEnu* AppelS2(const ::IClassA::SequenceEnu& P1, ::IClassA::SequenceEnu& P2);
::IClassA::SequenceIClassB* AppelT2(const ::IClassA::SequenceIClassB& P1, ::IClassA::SequenceIClassB& P2);
::IClassA::SequenceStructS* AppelU2(const ::IClassA::SequenceStructS& P1, ::IClassA::SequenceStructS& P2);
::IClassA::SequenceUnionU* AppelV2(const ::IClassA::SequenceUnionU& P1, ::IClassA::SequenceUnionU& P2);

CClassA();
~CClassA();
};

class CVTypeA : virtual public OBV_VTypeA
/***************************************/
{
private :
/*******/
CORBA::Any* _ChampBisA1;
CORBA::Boolean _ChampBisB1;
CORBA::Char _ChampBisC1;
CORBA::Double _ChampBisD1;
FixedTmpl< 6,2 > _ChampBisE1;
CORBA::Float _ChampBisF1;
CORBA::Long _ChampBisG1;
CORBA::LongLong _ChampBisH1;
CORBA::LongDouble _ChampBisI1;
CORBA::Object_ptr _ChampBisJ1;
CORBA::Octet _ChampBisK1;
CORBA::Short _ChampBisL1;
char* _ChampBisM1;
CORBA::ULong _ChampBisN1;
CORBA::ULongLong _ChampBisO1;
CORBA::UShort _ChampBisP1;
CORBA::WChar _ChampBisQ1;
CORBA::WChar* _ChampBisR1;
::Enu _ChampBisS1;
::IClassB_ptr _ChampBisT1;
::IClassA::StructS* _ChampBisU1;
::IClassA::UnionU* _ChampBisV1;

::IClassA::SequenceAny* _ChampBisA2;
::IClassA::SequenceBoolean* _ChampBisB2;
::IClassA::SequenceChar* _ChampBisC2;
::IClassA::SequenceDouble* _ChampBisD2;
::IClassA::SequenceFixed* _ChampBisE2;
::IClassA::SequenceFloat* _ChampBisF2;
::IClassA::SequenceLong* _ChampBisG2;
::IClassA::SequenceLongLong* _ChampBisH2;
::IClassA::SequenceLongDouble* _ChampBisI2;
::IClassA::SequenceObject* _ChampBisJ2;
::IClassA::SequenceOctet* _ChampBisK2;
::IClassA::SequenceShort* _ChampBisL2;
::IClassA::SequenceString* _ChampBisM2;
::IClassA::SequenceUnsignedLong* _ChampBisN2;
::IClassA::SequenceUnsignedLongLong* _ChampBisO2;
::IClassA::SequenceUnsignedShort* _ChampBisP2;
::IClassA::SequenceWChar* _ChampBisQ2;
::IClassA::SequenceWString* _ChampBisR2;
::IClassA::SequenceEnu* _ChampBisS2;
::IClassA::SequenceIClassB* _ChampBisT2;
::IClassA::SequenceStructS* _ChampBisU2;
::IClassA::SequenceUnionU* _ChampBisV2;

CORBA::ULong Compteur;

public :
/******/ void AppelBisZ1();
CORBA::Any* AppelBisA1(const CORBA::Any& P1, CORBA::Any& P2);
CORBA::Boolean AppelBisB1(CORBA::Boolean P1, CORBA::Boolean& P2);
CORBA::Char AppelBisC1(CORBA::Char P1, CORBA::Char& P2);
CORBA::Double AppelBisD1(CORBA::Double P1, CORBA::Double& P2);
FixedTmpl< 6,2 > AppelBisE1(FixedTmpl< 6,2 > P1, FixedTmpl< 6,2 >& P2);
CORBA::Float AppelBisF1(CORBA::Float P1, CORBA::Float& P2);
CORBA::Long AppelBisG1(CORBA::Long P1, CORBA::Long& P2);
CORBA::LongLong AppelBisH1(CORBA::LongLong P1, CORBA::LongLong& P2);
CORBA::LongDouble AppelBisI1(CORBA::LongDouble P1, CORBA::LongDouble& P2);
CORBA::Object_ptr AppelBisJ1(CORBA::Object_ptr P1, CORBA::Object_ptr& P2);
CORBA::Octet AppelBisK1(CORBA::Octet P1, CORBA::Octet& P2);
CORBA::Short AppelBisL1(CORBA::Short P1, CORBA::Short& P2);
char* AppelBisM1(const char* P1, char*& P2);
CORBA::ULong AppelBisN1(CORBA::ULong P1, CORBA::ULong& P2);
CORBA::ULongLong AppelBisO1(CORBA::ULongLong P1, CORBA::ULongLong& P2);
CORBA::UShort AppelBisP1(CORBA::UShort P1, CORBA::UShort& P2);
CORBA::WChar AppelBisQ1(CORBA::WChar P1, CORBA::WChar& P2);
CORBA::WChar* AppelBisR1(const CORBA::WChar* P1, CORBA::WChar*& P2);
::Enu AppelBisS1(::Enu P1, ::Enu& P2);
::IClassB_ptr AppelBisT1(::IClassB_ptr P1, ::IClassB_ptr& P2);
::IClassA::StructS* AppelBisU1(const ::IClassA::StructS& P1, ::IClassA::StructS& P2);
::IClassA::UnionU* AppelBisV1(const ::IClassA::UnionU& P1, ::IClassA::UnionU& P2);

void AppelBisZ2();
::IClassA::SequenceAny* AppelBisA2(const ::IClassA::SequenceAny& P1, ::IClassA::SequenceAny& P2);
::IClassA::SequenceBoolean* AppelBisB2(const ::IClassA::SequenceBoolean& P1, ::IClassA::SequenceBoolean& P2);
::IClassA::SequenceChar* AppelBisC2(const ::IClassA::SequenceChar& P1, ::IClassA::SequenceChar& P2);
::IClassA::SequenceDouble* AppelBisD2(const ::IClassA::SequenceDouble& P1, ::IClassA::SequenceDouble& P2);
::IClassA::SequenceFixed* AppelBisE2(const ::IClassA::SequenceFixed& P1, ::IClassA::SequenceFixed& P2);
::IClassA::SequenceFloat* AppelBisF2(const ::IClassA::SequenceFloat& P1, ::IClassA::SequenceFloat& P2);
::IClassA::SequenceLong* AppelBisG2(const ::IClassA::SequenceLong& P1, ::IClassA::SequenceLong& P2);
::IClassA::SequenceLongLong* AppelBisH2(const ::IClassA::SequenceLongLong& P1, ::IClassA::SequenceLongLong& P2);
::IClassA::SequenceLongDouble* AppelBisI2(const ::IClassA::SequenceLongDouble& P1, ::IClassA::SequenceLongDouble& P2);
::IClassA::SequenceObject* AppelBisJ2(const ::IClassA::SequenceObject& P1, ::IClassA::SequenceObject& P2);
::IClassA::SequenceOctet* AppelBisK2(const ::IClassA::SequenceOctet& P1, ::IClassA::SequenceOctet& P2);
::IClassA::SequenceShort* AppelBisL2(const ::IClassA::SequenceShort& P1, ::IClassA::SequenceShort& P2);
::IClassA::SequenceString* AppelBisM2(const ::IClassA::SequenceString& P1, ::IClassA::SequenceString& P2);
::IClassA::SequenceUnsignedLong* AppelBisN2(const ::IClassA::SequenceUnsignedLong& P1, ::IClassA::SequenceUnsignedLong& P2);
::IClassA::SequenceUnsignedLongLong* AppelBisO2(const ::IClassA::SequenceUnsignedLongLong& P1, ::IClassA::SequenceUnsignedLongLong& P2);
::IClassA::SequenceUnsignedShort* AppelBisP2(const ::IClassA::SequenceUnsignedShort& P1, ::IClassA::SequenceUnsignedShort& P2);
::IClassA::SequenceWChar* AppelBisQ2(const ::IClassA::SequenceWChar& P1, ::IClassA::SequenceWChar& P2);
::IClassA::SequenceWString* AppelBisR2(const ::IClassA::SequenceWString& P1, ::IClassA::SequenceWString& P2);
::IClassA::SequenceEnu* AppelBisS2(const ::IClassA::SequenceEnu& P1, ::IClassA::SequenceEnu& P2);
::IClassA::SequenceIClassB* AppelBisT2(const ::IClassA::SequenceIClassB& P1, ::IClassA::SequenceIClassB& P2);
::IClassA::SequenceStructS* AppelBisU2(const ::IClassA::SequenceStructS& P1, ::IClassA::SequenceStructS& P2);
::IClassA::SequenceUnionU* AppelBisV2(const ::IClassA::SequenceUnionU& P1, ::IClassA::SequenceUnionU& P2);

void ChampBisA1(const CORBA::Any& _p);
const CORBA::Any& ChampBisA1() const;
CORBA::Any& ChampBisA1();
void ChampBisB1(CORBA::Boolean _p);
CORBA::Boolean ChampBisB1() const;
void ChampBisC1(CORBA::Char _p);
CORBA::Char ChampBisC1() const;
void ChampBisD1(CORBA::Double _p);
CORBA::Double ChampBisD1() const;
void ChampBisE1(FixedTmpl< 6,2 > _p);
FixedTmpl< 6,2 > ChampBisE1() const;
void ChampBisF1(CORBA::Float _p);
CORBA::Float ChampBisF1() const;
void ChampBisG1(CORBA::Long _p);
CORBA::Long ChampBisG1() const;
void ChampBisH1(CORBA::LongLong _p);
CORBA::LongLong ChampBisH1() const;
void ChampBisI1(CORBA::LongDouble _p);
CORBA::LongDouble ChampBisI1() const;
void ChampBisJ1(CORBA::Object_ptr _p);
CORBA::Object_ptr ChampBisJ1() const;
void ChampBisK1(CORBA::Octet _p);
CORBA::Octet ChampBisK1() const;
void ChampBisL1(CORBA::Short _p);
CORBA::Short ChampBisL1() const;
void ChampBisM1(char *_p);
void ChampBisM1(const char *_p);
void ChampBisM1(const CORBA::String_var &_p);
const char *ChampBisM1() const;
void ChampBisN1(CORBA::ULong _p);
CORBA::ULong ChampBisN1() const;
void ChampBisO1(CORBA::ULongLong _p);
CORBA::ULongLong ChampBisO1() const;
void ChampBisP1(CORBA::UShort _p);
CORBA::UShort ChampBisP1() const;
void ChampBisQ1(CORBA::WChar _p);
CORBA::WChar ChampBisQ1() const;
void ChampBisR1(wchar_t *_p);
void ChampBisR1(const wchar_t *_p);
void ChampBisR1(const CORBA::WString_var &_p);
const wchar_t *ChampBisR1() const;
void ChampBisS1(::Enu _p);
const ::Enu& ChampBisS1() const;
::Enu& ChampBisS1();
void ChampBisT1(::IClassB_ptr _p);
::IClassB_ptr ChampBisT1() const;
void ChampBisU1(const ::IClassA::StructS& _p);
const ::IClassA::StructS& ChampBisU1() const;
::IClassA::StructS& ChampBisU1();
void ChampBisV1(const ::IClassA::UnionU& _p);
const ::IClassA::UnionU& ChampBisV1() const;
::IClassA::UnionU& ChampBisV1();

void ChampBisA2(const ::IClassA::SequenceAny& _p);
const ::IClassA::SequenceAny& ChampBisA2() const;
::IClassA::SequenceAny& ChampBisA2();
void ChampBisB2(const ::IClassA::SequenceBoolean& _p);
const ::IClassA::SequenceBoolean& ChampBisB2() const;
::IClassA::SequenceBoolean& ChampBisB2();
void ChampBisC2(const ::IClassA::SequenceChar& _p);
const ::IClassA::SequenceChar& ChampBisC2() const;
::IClassA::SequenceChar& ChampBisC2();
void ChampBisD2(const ::IClassA::SequenceDouble& _p);
const ::IClassA::SequenceDouble& ChampBisD2() const;
::IClassA::SequenceDouble& ChampBisD2();
void ChampBisE2(const ::IClassA::SequenceFixed& _p);
const ::IClassA::SequenceFixed& ChampBisE2() const;
::IClassA::SequenceFixed& ChampBisE2();
void ChampBisF2(const ::IClassA::SequenceFloat& _p);
const ::IClassA::SequenceFloat& ChampBisF2() const;
::IClassA::SequenceFloat& ChampBisF2();
void ChampBisG2(const ::IClassA::SequenceLong& _p);
const ::IClassA::SequenceLong& ChampBisG2() const;
::IClassA::SequenceLong& ChampBisG2();
void ChampBisH2(const ::IClassA::SequenceLongLong& _p);
const ::IClassA::SequenceLongLong& ChampBisH2() const;
::IClassA::SequenceLongLong& ChampBisH2();
void ChampBisI2(const ::IClassA::SequenceLongDouble& _p);
const ::IClassA::SequenceLongDouble& ChampBisI2() const;
::IClassA::SequenceLongDouble& ChampBisI2();
void ChampBisJ2(const ::IClassA::SequenceObject& _p);
const ::IClassA::SequenceObject& ChampBisJ2() const;
::IClassA::SequenceObject& ChampBisJ2();
void ChampBisK2(const ::IClassA::SequenceOctet& _p);
const ::IClassA::SequenceOctet& ChampBisK2() const;
::IClassA::SequenceOctet& ChampBisK2();
void ChampBisL2(const ::IClassA::SequenceShort& _p);
const ::IClassA::SequenceShort& ChampBisL2() const;
::IClassA::SequenceShort& ChampBisL2();
void ChampBisM2(const ::IClassA::SequenceString& _p);
const ::IClassA::SequenceString& ChampBisM2() const;
::IClassA::SequenceString& ChampBisM2();
void ChampBisN2(const ::IClassA::SequenceUnsignedLong& _p);
const ::IClassA::SequenceUnsignedLong& ChampBisN2() const;
::IClassA::SequenceUnsignedLong& ChampBisN2();
void ChampBisO2(const ::IClassA::SequenceUnsignedLongLong& _p);
const ::IClassA::SequenceUnsignedLongLong& ChampBisO2() const;
::IClassA::SequenceUnsignedLongLong& ChampBisO2();
void ChampBisP2(const ::IClassA::SequenceUnsignedShort& _p);
const ::IClassA::SequenceUnsignedShort& ChampBisP2() const;
::IClassA::SequenceUnsignedShort& ChampBisP2();
void ChampBisQ2(const ::IClassA::SequenceWChar& _p);
const ::IClassA::SequenceWChar& ChampBisQ2() const;
::IClassA::SequenceWChar& ChampBisQ2();
void ChampBisR2(const ::IClassA::SequenceWString& _p);
const ::IClassA::SequenceWString& ChampBisR2() const;
::IClassA::SequenceWString& ChampBisR2();
void ChampBisS2(const ::IClassA::SequenceEnu& _p);
const ::IClassA::SequenceEnu& ChampBisS2() const;
::IClassA::SequenceEnu& ChampBisS2();
void ChampBisT2(const ::IClassA::SequenceIClassB& _p);
const ::IClassA::SequenceIClassB& ChampBisT2() const;
::IClassA::SequenceIClassB& ChampBisT2();
void ChampBisU2(const ::IClassA::SequenceStructS& _p);
const ::IClassA::SequenceStructS& ChampBisU2() const;
::IClassA::SequenceStructS& ChampBisU2();
void ChampBisV2(const ::IClassA::SequenceUnionU& _p);
const ::IClassA::SequenceUnionU& ChampBisV2() const;
::IClassA::SequenceUnionU& ChampBisV2();

void _add_ref();
void _remove_ref();
CORBA::ULong _refcount_value();
CVTypeA();
~CVTypeA();
};

class FVTypeA : virtual public VTypeA_init
/****************************************/
{
public :
/******/
VTypeA *Constructeur();
};
#include "classab_srv.h"

static CORBA::ORB *pOrb=NULL;
static PortableServer::POA *pPoa=NULL;
static PortableServer::ObjectId *pObjectIdA=NULL;
static PortableServer::ObjectId *pObjectIdB=NULL;
static CClassA *pClassAGlobal=NULL;
static CClassB *pClassBGlobal=NULL;

CORBA::Short CClassB::A()
/***********************/
{
return(_A);
}

void CClassB::A(CORBA::Short value)
/*********************************/
{
_A=value;
}

CClassB::CClassB()
/****************/
{
_A=100;
}

CClassB::~CClassB()
/*****************/
{
}

CORBA::Any* CClassA::ChampA1()
/****************************/
{
return(_ChampA1);
}

void CClassA::ChampA1(const CORBA::Any& value)
/********************************************/
{
_ChampA1=new CORBA::Any(value);
}

CORBA::Boolean CClassA::ChampB1()
/*******************************/
{
return(_ChampB1);
}

void CClassA::ChampB1(CORBA::Boolean value)
/*****************************************/
{
_ChampB1=value;
}

CORBA::Char CClassA::ChampC1()
/****************************/
{
return(_ChampC1);
}

void CClassA::ChampC1(CORBA::Char value)
/**************************************/
{
_ChampC1=value;
}

CORBA::Double CClassA::ChampD1()
/******************************/
{
return(_ChampD1);
}

void CClassA::ChampD1(CORBA::Double value)
/****************************************/
{
_ChampD1=value;
}

FixedTmpl< 6,2 > CClassA::ChampE1()
/*********************************/
{
return(_ChampE1);
}

void CClassA::ChampE1(FixedTmpl< 6,2 > value)
/*******************************************/
{
_ChampE1=*(new Fixed(value));
}

CORBA::Float CClassA::ChampF1()
/*****************************/
{
return(_ChampF1);
}

void CClassA::ChampF1(CORBA::Float value)
/***************************************/
{
_ChampF1=value;
}

CORBA::Long CClassA::ChampG1()
/****************************/
{
return(_ChampG1);
}

void CClassA::ChampG1(CORBA::Long value)
/**************************************/
{
_ChampG1=value;
}

CORBA::LongLong CClassA::ChampH1()
/********************************/
{
return(_ChampH1);
}

void CClassA::ChampH1(CORBA::LongLong value)
/******************************************/
{
_ChampH1=value;
}

CORBA::LongDouble CClassA::ChampI1()
/**********************************/
{
return(_ChampI1);
}

void CClassA::ChampI1(CORBA::LongDouble value)
/********************************************/
{
_ChampI1=value;
}

CORBA::Object_ptr CClassA::ChampJ1()
/**********************************/
{
return(_ChampJ1);
}

void CClassA::ChampJ1(CORBA::Object_ptr value)
/********************************************/
{
_ChampJ1=value;
CORBA::Object::_duplicate(_ChampJ1);
}

CORBA::Octet CClassA::ChampK1()
/*****************************/
{
return(_ChampK1);
}

void CClassA::ChampK1(CORBA::Octet value)
/***************************************/
{
_ChampK1=value;
}

CORBA::Short CClassA::ChampL1()
/*****************************/
{
return(_ChampL1);
}

void CClassA::ChampL1(CORBA::Short value)
/***************************************/
{
_ChampL1=value;
}

char* CClassA::ChampM1()
/**********************/
{
return(_ChampM1);
}

void CClassA::ChampM1(const char* value)
/**************************************/
{
_ChampM1=CORBA::string_dup((CORBA::Char *)value);
}

CORBA::ULong CClassA::ChampN1()
/*****************************/
{
return(_ChampN1);
}

void CClassA::ChampN1(CORBA::ULong value)
/***************************************/
{
_ChampN1=value;
}

CORBA::ULongLong CClassA::ChampO1()
/*********************************/
{
return(_ChampO1);
}

void CClassA::ChampO1(CORBA::ULongLong value)
/*******************************************/
{
_ChampO1=value;
}

CORBA::UShort CClassA::ChampP1()
/******************************/
{
return(_ChampP1);
}

void CClassA::ChampP1(CORBA::UShort value)
/****************************************/
{
_ChampP1=value;
}

CORBA::WChar CClassA::ChampQ1()
/*****************************/
{
return(_ChampQ1);
}

void CClassA::ChampQ1(CORBA::WChar value)
/***************************************/
{
_ChampQ1=value;
}

CORBA::WChar* CClassA::ChampR1()
/******************************/
{
return(_ChampR1);
}

void CClassA::ChampR1(const CORBA::WChar* value)
/**********************************************/
{
_ChampR1=CORBA::wstring_dup((CORBA::WChar *)value);
}

::Enu CClassA::ChampS1()
/**********************/
{
return(_ChampS1);
}

void CClassA::ChampS1(::Enu value)
/********************************/
{
_ChampS1=value;
}
::IClassB_ptr CClassA::ChampT1()
/******************************/
{
return(_ChampT1);
}

void CClassA::ChampT1(::IClassB_ptr value)
/****************************************/
{
_ChampT1=value;
::IClassB::_duplicate(_ChampT1);
}

::IClassA::StructS* CClassA::ChampU1()
/************************************/
{
return(_ChampU1);
}

void CClassA::ChampU1(const ::IClassA::StructS& value)
/****************************************************/
{
_ChampU1=new ::IClassA::S(value);
}

::IClassA::UnionU* CClassA::ChampV1()
/***********************************/
{
return(_ChampV1);
}

void CClassA::ChampV1(const ::IClassA::UnionU& value)
/***************************************************/
{
_ChampV1=new ::IClassA::U(value);
}

::IClassA::SequenceAny* CClassA::ChampA2()
/****************************************/
{
return(_ChampA2);
}

void CClassA::ChampA2(const ::IClassA::SequenceAny& value)
/********************************************************/
{
_ChampA2=new ::IClassA::SequenceAny(value);
}

::IClassA::SequenceBoolean* CClassA::ChampB2()
/********************************************/
{
return(_ChampB2);
}

void CClassA::ChampB2(const ::IClassA::SequenceBoolean& value)
/************************************************************/
{
_ChampB2=new ::IClassA::SequenceBoolean(value);
}

::IClassA::SequenceChar* CClassA::ChampC2()
/*****************************************/
{
return(_ChampC2);
}

void CClassA::ChampC2(const ::IClassA::SequenceChar& value)
/*********************************************************/
{
_ChampC2=new ::IClassA::SequenceChar(value);
}

::IClassA::SequenceDouble* CClassA::ChampD2()
/*******************************************/
{
return(_ChampD2);
}

void CClassA::ChampD2(const ::IClassA::SequenceDouble& value)
/***********************************************************/
{
_ChampD2=new ::IClassA::SequenceDouble(value);
}

::IClassA::SequenceFixed* CClassA::ChampE2()
/******************************************/
{
return(_ChampE2);
}

void CClassA::ChampE2(const ::IClassA::SequenceFixed& value)
/**********************************************************/
{
_ChampE2=new ::IClassA::SequenceFixed(value);
}

::IClassA::SequenceFloat* CClassA::ChampF2()
/******************************************/
{
return(_ChampF2);
}

void CClassA::ChampF2(const ::IClassA::SequenceFloat& value)
/**********************************************************/
{
_ChampF2=new ::IClassA::SequenceFloat(value);
}

::IClassA::SequenceLong* CClassA::ChampG2()
/*****************************************/
{
return(_ChampG2);
}

void CClassA::ChampG2(const ::IClassA::SequenceLong& value)
/*********************************************************/
{
_ChampG2=new ::IClassA::SequenceLong(value);
}

::IClassA::SequenceLongLong* CClassA::ChampH2()
/*********************************************/
{
return(_ChampH2);
}

void CClassA::ChampH2(const ::IClassA::SequenceLongLong& value)
/*************************************************************/
{
_ChampH2=new ::IClassA::SequenceLongLong(value);
}

::IClassA::SequenceLongDouble* CClassA::ChampI2()
/***********************************************/
{
return(_ChampI2);
}

void CClassA::ChampI2(const ::IClassA::SequenceLongDouble& value)
/***************************************************************/
{
_ChampI2=new ::IClassA::SequenceLongDouble(value);
}

::IClassA::SequenceObject* CClassA::ChampJ2()
/*******************************************/
{
return(_ChampJ2);
}

void CClassA::ChampJ2(const ::IClassA::SequenceObject& value)
/***********************************************************/
{
_ChampJ2=new ::IClassA::SequenceObject(value);
}

::IClassA::SequenceOctet* CClassA::ChampK2()
/******************************************/
{
return(_ChampK2);
}

void CClassA::ChampK2(const ::IClassA::SequenceOctet& value)
/**********************************************************/
{
_ChampK2=new ::IClassA::SequenceOctet(value);
}

::IClassA::SequenceShort* CClassA::ChampL2()
/******************************************/
{
return(_ChampL2);
}

void CClassA::ChampL2(const ::IClassA::SequenceShort& value)
/**********************************************************/
{
_ChampL2=new ::IClassA::SequenceShort(value);
}

::IClassA::SequenceString* CClassA::ChampM2()
/*******************************************/
{
return(_ChampM2);
}

void CClassA::ChampM2(const ::IClassA::SequenceString& value)
/***********************************************************/
{
_ChampM2=new ::IClassA::SequenceString(value);
}

::IClassA::SequenceUnsignedLong* CClassA::ChampN2()
/*************************************************/
{
return(_ChampN2);
}

void CClassA::ChampN2(const ::IClassA::SequenceUnsignedLong& value)
/*****************************************************************/
{
_ChampN2=new ::IClassA::SequenceUnsignedLong(value);
}

::IClassA::SequenceUnsignedLongLong* CClassA::ChampO2()
/*****************************************************/
{
return(_ChampO2);
}

void CClassA::ChampO2(const ::IClassA::SequenceUnsignedLongLong& value)
/*********************************************************************/
{
_ChampO2=new ::IClassA::SequenceUnsignedLongLong(value);
}

::IClassA::SequenceUnsignedShort* CClassA::ChampP2()
/**************************************************/
{
return(_ChampP2);
}

void CClassA::ChampP2(const ::IClassA::SequenceUnsignedShort& value)
/******************************************************************/
{
_ChampP2=new ::IClassA::SequenceUnsignedShort(value);
}

::IClassA::SequenceWChar* CClassA::ChampQ2()
/******************************************/
{
return(_ChampQ2);
}

void CClassA::ChampQ2(const ::IClassA::SequenceWChar& value)
/**********************************************************/
{
_ChampQ2=new ::IClassA::SequenceWChar(value);
}

::IClassA::SequenceWString* CClassA::ChampR2()
/********************************************/
{
return(_ChampR2);
}

void CClassA::ChampR2(const ::IClassA::SequenceWString& value)
/************************************************************/
{
_ChampR2=new ::IClassA::SequenceWString(value);
}

::IClassA::SequenceEnu* CClassA::ChampS2()
/****************************************/
{
return(_ChampS2);
}

void CClassA::ChampS2(const ::IClassA::SequenceEnu& value)
/********************************************************/
{
_ChampS2=new ::IClassA::SequenceEnu(value);
}

::IClassA::SequenceIClassB* CClassA::ChampT2()
/********************************************/
{
return(_ChampT2);
}

void CClassA::ChampT2(const ::IClassA::SequenceIClassB& value)
/************************************************************/
{
_ChampT2=new ::IClassA::SequenceIClassB(value);
}

::IClassA::SequenceStructS* CClassA::ChampU2()
/********************************************/
{
return(_ChampU2);
}

void CClassA::ChampU2(const ::IClassA::SequenceStructS& value)
/************************************************************/
{
_ChampU2=new ::IClassA::SequenceStructS(value);
}

::IClassA::SequenceUnionU* CClassA::ChampV2()
/*******************************************/
{
return(_ChampV2);
}

void CClassA::ChampV2(const ::IClassA::SequenceUnionU& value)
/***********************************************************/
{
_ChampV2=new ::IClassA::SequenceUnionU(value);
}

void CClassA::AppelZ1()
/*********************/
{
}

CORBA::Any* CClassA::AppelA1(const CORBA::Any& P1, CORBA::Any& P2)
/****************************************************************/
{
P2=*(new CORBA::Any(P1));
return(_ChampA1);
}

CORBA::Boolean CClassA::AppelB1(CORBA::Boolean P1, CORBA::Boolean& P2)
/********************************************************************/
{
P2=P1;
return(_ChampB1);
}

CORBA::Char CClassA::AppelC1(CORBA::Char P1, CORBA::Char& P2)
/***********************************************************/
{
P2=P1;
return(_ChampC1);
}

CORBA::Double CClassA::AppelD1(CORBA::Double P1, CORBA::Double& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampD1);
}

FixedTmpl< 6,2 > CClassA::AppelE1(FixedTmpl< 6,2 > P1, FixedTmpl< 6,2 >& P2)
/**************************************************************************/
{
P2=*(new FixedTmpl< 6,2 >(P1));
return(_ChampE1);
}

CORBA::Float CClassA::AppelF1(CORBA::Float P1, CORBA::Float& P2)
/**************************************************************/
{
P2=P1;
return(_ChampF1);
}

CORBA::Long CClassA::AppelG1(CORBA::Long P1, CORBA::Long& P2)
/***********************************************************/
{
P2=P1;
return(_ChampG1);
}

CORBA::LongLong CClassA::AppelH1(CORBA::LongLong P1, CORBA::LongLong& P2)
/***********************************************************************/
{
P2=P1;
return(_ChampH1);
}

CORBA::LongDouble CClassA::AppelI1(CORBA::LongDouble P1, CORBA::LongDouble& P2)
/*****************************************************************************/
{
P2=P1;
return(_ChampI1);
}

CORBA::Object_ptr CClassA::AppelJ1(CORBA::Object_ptr P1, CORBA::Object_ptr& P2)
/*****************************************************************************/
{
P2=P1;
CORBA::Object::_duplicate(P2);
return(_ChampJ1);
}

CORBA::Octet CClassA::AppelK1(CORBA::Octet P1, CORBA::Octet& P2)
/**************************************************************/
{
P2=P1;
return(_ChampK1);
}

CORBA::Short CClassA::AppelL1(CORBA::Short P1, CORBA::Short& P2)
/**************************************************************/
{
P2=P1;
return(_ChampL1);
}

char* CClassA::AppelM1(const char* P1, char*& P2)
/***********************************************/
{
P2=CO
RBA::string_dup((CORBA::Char *)P1);
return(_ChampM1);
}

CORBA::ULong CClassA::AppelN1(CORBA::ULong P1, CORBA::ULong& P2)
/**************************************************************/
{
P2=P1;
return(_ChampN1);
}

CORBA::ULongLong CClassA::AppelO1(CORBA::ULongLong P1, CORBA::ULongLong& P2)
/**************************************************************************/
{
P2=P1;
return(_ChampO1);
}

CORBA::UShort CClassA::AppelP1(CORBA::UShort P1, CORBA::UShort& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampP1);
}

CORBA::WChar CClassA::AppelQ1(CORBA::WChar P1, CORBA::WChar& P2)
/**************************************************************/
{
P2=P1;
return(_ChampQ1);
}

CORBA::WChar* CClassA::AppelR1(const CORBA::WChar* P1, CORBA::WChar*& P2)
/***********************************************************************/
{
P2=CORBA::wstring_dup((CORBA::WChar *)P1);
return(_ChampR1);
}

::Enu CClassA::AppelS1(::Enu P1, ::Enu& P2)
/*****************************************/
{
P2=P1;
return(_ChampS1);
}

::IClassB_ptr CClassA::AppelT1(::IClassB_ptr P1, ::IClassB_ptr& P2)
/*****************************************************************/
{
P2=P1;
::IClassB::_duplicate(P2);
return(_ChampT1);
}

::IClassA::StructS* CClassA::AppelU1(const ::IClassA::StructS& P1, ::IClassA::StructS& P2)
/****************************************************************************************/
{
P2=*(new ::IClassA::StructS(P1));
return(_ChampU1);
}

::IClassA::UnionU* CClassA::AppelV1(const ::IClassA::UnionU& P1, ::IClassA::UnionU& P2)
/*************************************************************************************/
{
P2=*(new ::IClassA::UnionU(P1));
return(_ChampV1);
}

void CClassA::AppelZ2()
/*********************/
{
}

::IClassA::SequenceAny* CClassA::AppelA2(const ::IClassA::SequenceAny& P1, ::IClassA::SequenceAny& P2)
/****************************************************************************************************/
{
P2=*(new ::IClassA::SequenceAny(P1));
return(_ChampA2);
}

::IClassA::SequenceBoolean* CClassA::AppelB2(const ::IClassA::SequenceBoolean& P1, ::IClassA::SequenceBoolean& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceBoolean(P1));
return(_ChampB2);
}

::IClassA::SequenceChar* CClassA::AppelC2(const ::IClassA::SequenceChar& P1, ::IClassA::SequenceChar& P2)
/*******************************************************************************************************/
{
P2=*(new ::IClassA::SequenceChar(P1));
return(_ChampC2);
}

::IClassA::SequenceDouble* CClassA::AppelD2(const ::IClassA::SequenceDouble& P1, ::IClassA::SequenceDouble& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceDouble(P1));
return(_ChampD2);
}

::IClassA::SequenceFixed* CClassA::AppelE2(const ::IClassA::SequenceFixed& P1, ::IClassA::SequenceFixed& P2)
/**********************************************************************************************************/
{
P2=*(new ::IClassA::SequenceFixed(P1));
return(_ChampE2);
}

::IClassA::SequenceFloat* CClassA::AppelF2(const ::IClassA::SequenceFloat& P1, ::IClassA::SequenceFloat& P2)
/**********************************************************************************************************/

{
P2=*(new ::IClassA::SequenceFloat(P1));
return(_ChampF2);
}

::IClassA::SequenceLong* CClassA::AppelG2(const ::IClassA::SequenceLong& P1, ::IClassA::SequenceLong& P2)
/*******************************************************************************************************/
{
P2=*(new ::IClassA::SequenceLong(P1));
return(_ChampG2);
}

::IClassA::SequenceLongLong* CClassA::AppelH2(const ::IClassA::SequenceLongLong& P1, ::IClassA::SequenceLongLong& P2)
/*******************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceLongLong(P1));
return(_ChampH2);
}

::IClassA::SequenceLongDouble* CClassA::AppelI2(const ::IClassA::SequenceLongDouble& P1, ::IClassA::SequenceLongDouble& P2)
/*************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceLongDouble(P1));
return(_ChampI2);
}

::IClassA::SequenceObject* CClassA::AppelJ2(const ::IClassA::SequenceObject& P1, ::IClassA::SequenceObject& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceObject(P1));
return(_ChampJ2);
}

::IClassA::SequenceOctet* CClassA::AppelK2(const ::IClassA::SequenceOctet& P1, ::IClassA::SequenceOctet& P2)
/**********************************************************************************************************/
{
P2=*(new ::IClassA::SequenceOctet(P1));
return(_ChampK2);
}

::IClassA::SequenceShort* CClassA::AppelL2(const ::IClassA::SequenceShort& P1, ::IClassA::SequenceShort& P2)
/**********************************************************************************************************/
{
P2=*(new ::IClassA::SequenceShort(P1));
return(_ChampL2);
}

::IClassA::SequenceString* CClassA::AppelM2(const ::IClassA::SequenceString& P1, ::IClassA::SequenceString& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceString(P1));
return(_ChampM2);
}

::IClassA::SequenceUnsignedLong* CClassA::AppelN2(const ::IClassA::SequenceUnsignedLong& P1, ::IClassA::SequenceUnsignedLong& P2)
/*******************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnsignedLong(P1));
return(_ChampN2);
}

::IClassA::SequenceUnsignedLongLong* CClassA::AppelO2(const ::IClassA::SequenceUnsignedLongLong& P1, ::IClassA::SequenceUnsignedLongLong& P2)
/*******************************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnsignedLongLong(P1));
return(_ChampO2);
}

::IClassA::SequenceUnsignedShort* CClassA::AppelP2(const ::IClassA::SequenceUnsignedShort& P1, ::IClassA::SequenceUnsignedShort& P2)
/**********************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnsignedShort(P1));
return(_ChampP2);
}

::IClassA::SequenceWChar* CClassA::AppelQ2(const ::IClassA::SequenceWChar& P1, ::IClassA::SequenceWChar& P2)
/**********************************************************************************************************/
{
P2=*(new ::IClassA::SequenceWChar(P1));
return(_ChampQ2);
}

::IClassA::SequenceWString* CClassA::AppelR2(const ::IClassA::SequenceWString& P1, ::IClassA::SequenceWString& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceWString(P1));
return(_ChampR2);
}

::IClassA::SequenceEnu* CClassA::AppelS2(const ::IClassA::SequenceEnu& P1, ::IClassA::SequenceEnu& P2)
/****************************************************************************************************/
{
P2=*(new ::IClassA::SequenceEnu(P1));
return(_ChampS2);
}

::IClassA::SequenceIClassB* CClassA::AppelT2(const ::IClassA::SequenceIClassB& P1, ::IClassA::SequenceIClassB& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceIClassB(P1));
return(_ChampT2);
}

::IClassA::SequenceStructS* CClassA::AppelU2(const ::IClassA::SequenceStructS& P1, ::IClassA::SequenceStructS& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceStructS(P1));
return(_ChampU2);
}

::IClassA::SequenceUnionU* CClassA::AppelV2(const ::IClassA::SequenceUnionU& P1, ::IClassA::SequenceUnionU& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnionU(P1));
return(_ChampV2);
}

CClassA::CClassA()
/****************/
{
CORBA::Any::from_string *FromString;
CClassB *pClassB;
CORBA::ULong i;
CORBA::Any BufferAny[3];
CORBA::Boolean BufferBoolean[3];
CORBA::Char BufferChar[4];
CORBA::Double BufferDouble[3];
FixedTmpl<6,2> BufferFixed[3];
CORBA::Float BufferFloat[3];
CORBA::Long BufferLong[3];
CORBA::LongLong BufferLongLong[3];
CORBA::LongDouble BufferLongDouble[3];
CORBA::Object *BufferObject[3];
CORBA::Octet BufferOctet[6];
CORBA::Short BufferShort[3];
CORBA::ULong BufferUnsignedLong[3];
CORBA::ULongLong BufferUnsignedLongLong[3];
CORBA::UShort BufferUnsignedShort[3];
CORBA::WChar BufferWChar[4];
::Enu BufferEnu[3];
IClassB *BufferClassB[3];
CORBA::Char *BufferString[3];
CORBA::WChar *BufferWString[3];
::IClassA::StructS BufferStructS[3];
::IClassA::UnionU BufferUnionU[3];

_ChampA1=new CORBA::Any();
FromString=new CORBA::Any::from_string("coucou",6);
*_ChampA1<<=*FromString;
delete FromString;
_ChampB1=TRUE;
_ChampC1=(CORBA::Char)65;
_ChampD1=(CORBA::Double)2.3;
_ChampE1=*(new Fixed((CORBA::Double)3.4));
_ChampF1=(CORBA::Float)4.5;
_ChampG1=(CORBA::Long)3;
_ChampH1=(CORBA::LongLong)4;
_ChampI1=(CORBA::LongDouble)5.6;
pClassB=new CClassB();
_ChampJ1=pClassB->_this();
_ChampK1=(CORBA::Octet)66;
_ChampL1=(CORBA::Short)5;
_ChampM1=*(new CORBA::String_var((CORBA::Char *)"coucou"));
_ChampN1=(CORBA::ULong)6;
_ChampO1=(CORBA::ULongLong)7;
_ChampP1=(CORBA::UShort)8;
_ChampQ1=(CORBA::WChar)67;
_ChampR1=*(new CORBA::WString_var((CORBA::WChar *)L"coucou"));
_ChampS1=(::Enu)0;
pClassB=new CClassB();
_ChampT1=::IClassB::_narrow(pClassB->_this());
_ChampU1=new ::IClassA::S();
_ChampU1->ChampS1=*(new CORBA::Any());
FromString=new CORBA::Any::from_string("coucou",6);
_ChampU1->ChampS1<<=*FromString;
delete FromString;
_ChampU1->ChampS2=TRUE;
_ChampU1->ChampS3=(CORBA::Char)65;
_ChampU1->ChampS4=(CORBA::Double)2.3;
_ChampU1->ChampS5=*(new Fixed((CORBA::Double)3.4));
_ChampU1->ChampS6=(CORBA::Float)4.5;
_ChampU1->ChampS7=(CORBA::Long)3;
_ChampU1->ChampS8=(CORBA::LongLong)4;
_ChampU1->ChampS9=(CORBA::LongDouble)5.6;
pClassB=new CClassB();
_ChampU1->ChampS10=pClassB->_this();
_ChampU1->ChampS11=(CORBA::Octet)66;
_ChampU1->ChampS12=(CORBA::Short)5;
_ChampU1->ChampS13=(CORBA::Char *)"coucou";
_ChampU1->ChampS14=(CORBA::ULong)6;
_ChampU1->ChampS15=(CORBA::ULongLong)7;
_ChampU1->ChampS16=(CORBA::UShort)8;
_ChampU1->ChampS17=(CORBA::WChar)67;
_ChampU1->ChampS18=(CORBA::WChar *)L"coucou";
_ChampU1->ChampS19=(::Enu)0;
pClassB=new CClassB();
_ChampU1->ChampS20=::IClassB::_narrow(pClassB->_this());
_ChampV1=new ::IClassA::U();
_ChampV1->ChampU2(TRUE);

FromString=new CORBA::Any::from_string("coucou 1",8);
BufferAny[0]<<=*FromString;
delete FromString;
FromString=new CORBA::Any::from_string("coucou 2",8);
BufferAny[1]<<=*FromString;
delete FromString;
FromString=new CORBA::Any::from_string("coucou 3",8);
BufferAny[2]<<=*FromString;
delete FromString;
_ChampA2=new ::IClassA::SequenceAny(3,3,BufferAny);
BufferBoolean[0]=TRUE;
BufferBoolean[1]=FALSE;
BufferBoolean[2]=TRUE;
_ChampB2=new ::IClassA::SequenceBoolean(3,3,BufferBoolean);
BufferChar[0]=(CORBA::Char)65;
BufferChar[1]=(CORBA::Char)66;
BufferChar[2]=(CORBA::Char)67;
BufferChar[3]=(CORBA::Char)0;
_ChampC2=new ::IClassA::SequenceChar(4,4,BufferChar);
BufferDouble[0]=(CORBA::Double)2.3;
BufferDouble[1]=(CORBA::Double)2.4;
BufferDouble[2]=(CORBA::Double)2.5;
_ChampD2=new ::IClassA::SequenceDouble(3,3,BufferDouble);
BufferFixed[0]=*(new Fixed((CORBA::Double)3.4));
BufferFixed[1]=*(new Fixed((CORBA::Double)3.5));
BufferFixed[2]=*(new Fixed((CORBA::Double)3.6));
_ChampE2=new ::IClassA::SequenceFixed(3,3,BufferFixed);
BufferFloat[0]=(CORBA::Float)4.5;
BufferFloat[1]=(CORBA::Float)4.6;
BufferFloat[2]=(CORBA::Float)4.7;
_ChampF2=new ::IClassA::SequenceFloat(3,3,BufferFloat);
BufferLong[0]=(CORBA::Long)3;
BufferLong[1]=(CORBA::Long)4;
BufferLong[2]=(CORBA::Long)5;
_ChampG2=new ::IClassA::SequenceLong(3,3,BufferLong);
BufferLongLong[0]=(CORBA::LongLong)4;
BufferLongLong[1]=(CORBA::LongLong)5;
BufferLongLong[2]=(CORBA::LongLong)6;
_ChampH2=new ::IClassA::SequenceLongLong(3,3,BufferLongLong);
BufferLongDouble[0]=(CORBA::LongDouble)5.6;
BufferLongDouble[1]=(CORBA::LongDouble)5.7;
BufferLongDouble[2]=(CORBA::LongDouble)5.8;
_ChampI2=new ::IClassA::SequenceLongDouble(3,3,BufferLongDouble);
pClassB=new CClassB();
pClassB->A(100);
BufferObject[0]=pClassB->_this();
pClassB=new CClassB();pClassB->A(101);
BufferObject[1]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(102);
BufferObject[2]=pClassB->_this();
_ChampJ2=new ::IClassA::SequenceObject(3,3,BufferObject);
BufferOctet[0]=(CORBA::Octet)66;
BufferOctet[1]=(CORBA::Octet)0;
BufferOctet[2]=(CORBA::Octet)67;
BufferOctet[3]=(CORBA::Octet)0;
BufferOctet[4]=(CORBA::Octet)68;
BufferOctet[5]=(CORBA::Octet)0;
_ChampK2=new ::IClassA::SequenceOctet(6,6,BufferOctet);
BufferShort[0]=(CORBA::Short)5;
BufferShort[1]=(CORBA::Short)6;
BufferShort[2]=(CORBA::Short)7;
_ChampL2=new ::IClassA::SequenceShort(3,3,BufferShort);
BufferString[0]=(CORBA::Char *)"coucou 1";
BufferString[1]=(CORBA::Char *)"coucou 2";
BufferString[2]=(CORBA::Char *)"coucou 3";
_ChampM2=new ::IClassA::SequenceString(3,3,BufferString);
BufferUnsignedLong[0]=(CORBA::ULong)6;
BufferUnsignedLong[1]=(CORBA::ULong)7;
BufferUnsignedLong[2]=(CORBA::ULong)8;
_ChampN2=new ::IClassA::SequenceUnsignedLong(3,3,BufferUnsignedLong);
BufferUnsignedLongLong[0]=(CORBA::ULongLong)7;
BufferUnsignedLongLong[1]=(CORBA::ULongLong)8;
BufferUnsignedLongLong[2]=(CORBA::ULongLong)9;
_ChampO2=new ::IClassA::SequenceUnsignedLongLong(3,3,BufferUnsignedLongLong);
BufferUnsignedShort[0]=(CORBA::UShort)8;
BufferUnsignedShort[1]=(CORBA::UShort)9;
BufferUnsignedShort[2]=(CORBA::UShort)10;
_ChampP2=new ::IClassA::SequenceUnsignedShort(3,3,BufferUnsignedShort);
BufferWChar[0]=(CORBA::WChar)67;
BufferWChar[1]=(CORBA::WChar)68;
BufferWChar[2]=(CORBA::WChar)69;
BufferWChar[3]=(CORBA::WChar)0;
_ChampQ2=new ::IClassA::SequenceWChar(4,4,BufferWChar);
BufferWString[0]=(CORBA::WChar *)L"coucou 1";
BufferWString[1]=(CORBA::WChar *)L"coucou 2";
BufferWString[2]=(CORBA::WChar *)L"coucou 3";
_ChampR2=new ::IClassA::SequenceWString(3,3,BufferWString);
BufferEnu[0]=(::Enu)0;
BufferEnu[1]=(::Enu)1;
BufferEnu[2]=(::Enu)2;
_ChampS2=new ::IClassA::SequenceEnu(3,3,BufferEnu);
pClassB=new CClassB();
pClassB->A(100);
BufferClassB[0]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(101);
BufferClassB[1]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(102);
BufferClassB[2]=pClassB->_this();
_ChampT2=new ::IClassA::SequenceIClassB(3,3,BufferClassB);
for (i=0;i<3;i++) _ChampU2=new ::IClassA::SequenceStructS(3,3,BufferStructS);
for (i=0;i<3;i++) _ChampV2=new ::IClassA::SequenceUnionU(3,3,BufferUnionU);
}

CClassA::~CClassA()
/*****************/
{
delete _ChampA1;
delete _ChampJ1;
delete _ChampT1;
delete _ChampU1;
delete _ChampV1;

delete _ChampA2;
delete _ChampB2;
delete _ChampC2;
delete _ChampD2;
delete _ChampE2;
delete _ChampF2;
delete _ChampG2;
delete _ChampH2;
delete _ChampI2;
delete _ChampJ2;
delete _ChampK2;
delete _ChampL2;
delete _ChampM2;
delete _ChampN2;
delete _ChampO2;
delete _ChampP2;
delete _ChampQ2;
delete _ChampR2;
delete _ChampS2;
delete _ChampT2;
delete _ChampU2;
delete _ChampV2;
}

void CVTypeA::ChampBisA1(const CORBA::Any& _p)
/********************************************/
{
_ChampBisA1=new CORBA::Any(_p);
}

const CORBA::Any& CVTypeA::ChampBisA1() const
/*******************************************/
{
return((const CORBA::Any &)*_ChampBisA1);
}

CORBA::Any& CVTypeA::ChampBisA1()
/*******************************/
{
return((CORBA::Any &)*_ChampBisA1);
}

void CVTypeA::ChampBisB1(CORBA::Boolean _p)
/*****************************************/
{
_ChampBisB1=_p;
}

CORBA::Boolean CVTypeA::ChampBisB1() const
/****************************************/
{
return(_ChampBisB1);
}

void CVTypeA::ChampBisC1(CORBA::Char _p)
/**************************************/
{
_ChampBisC1=_p;
}

CORBA::Char CVTypeA::ChampBisC1() const
/*************************************/
{
return(_ChampBisC1);
}

void CVTypeA::ChampBisD1(CORBA::Double _p)
/****************************************/
{
_ChampBisD1=_p;
}

CORBA::Double CVTypeA::ChampBisD1() const
/***************************************/
{
return(_ChampBisD1);
}

void CVTypeA::ChampBisE1(FixedTmpl< 6,2 > _p)
/*******************************************/
{
_ChampBisE1=*(new Fixed(_p));
}

FixedTmpl< 6,2 > CVTypeA::ChampBisE1() const
/******************************************/
{
return(_ChampBisE1);
}

void CVTypeA::ChampBisF1(CORBA::Float _p)
/***************************************/
{
_ChampBisF1=_p;
}

CORBA::Float CVTypeA::ChampBisF1() const
/**************************************/
{
return(_ChampBisF1);
}

void CVTypeA::ChampBisG1(CORBA::Long _p)
/**************************************/
{
_ChampBisG1=_p;
}

CORBA::Long CVTypeA::ChampBisG1() const
/*************************************/
{
return(_ChampBisG1);
}

void CVTypeA::ChampBisH1(CORBA::LongLong _p)
/******************************************/
{
_ChampBisH1=_p;
}

CORBA::LongLong CVTypeA::ChampBisH1() const
/*****************************************/
{
return(_ChampBisH1);
}

void CVTypeA::ChampBisI1(CORBA::LongDouble _p)
/********************************************/
{
_ChampBisI1=_p;
}

CORBA::LongDouble CVTypeA::ChampBisI1() const
/*******************************************/
{
return(_ChampBisI1);
}

void CVTypeA::ChampBisJ1(CORBA::Object_ptr _p)
/********************************************/
{
_ChampBisJ1=_p;
CORBA::Object::_duplicate(_ChampBisJ1);
}

CORBA::Object_ptr CVTypeA::ChampBisJ1() const
/*******************************************/
{
return(_ChampBisJ1);
}

void CVTypeA::ChampBisK1(CORBA::Octet _p)
/***************************************/
{
_ChampBisK1=_p;
}

CORBA::Octet CVTypeA::ChampBisK1() const
/**************************************/
{
return(_ChampBisK1);
}

void CVTypeA::ChampBisL1(CORBA::Short _p)
/***************************************/
{
_ChampBisL1=_p;
}

CORBA::Short CVTypeA::ChampBisL1() const
/**************************************/
{
return(_ChampBisL1);
}

void CVTypeA::ChampBisM1(char *_p)
/********************************/
{
_ChampBisM1=CORBA::string_dup((CORBA::Char *)_p);
}

void CVTypeA::ChampBisM1(const char *_p)
/**************************************/
{
_ChampBisM1=CORBA::string_dup((CORBA::Char *)_p);
}

void CVTypeA::ChampBisM1(const CORBA::String_var &_p)
/***************************************************/
{
_ChampBisM1=CORBA::string_dup((CORBA::Char *)_p.in());
}

const char *CVTypeA::ChampBisM1() const
/*************************************/
{
return(_ChampBisM1);
}

void CVTypeA::ChampBisN1(CORBA::ULong _p)
/***************************************/
{
_ChampBisN1=_p;
}

CORBA::ULong CVTypeA::ChampBisN1() const
/**************************************/
{
return(_ChampBisN1);
}

void CVTypeA::ChampBisO1(CORBA::ULongLong _p)
/*******************************************/
{
_ChampBisO1=_p;
}

CORBA::ULongLong CVTypeA::ChampBisO1() const
/******************************************/
{
return(_ChampBisO1);
}

void CVTypeA::ChampBisP1(CORBA::UShort _p)
/****************************************/
{
_ChampBisP1=_p;
}

CORBA::UShort CVTypeA::ChampBisP1() const
/***************************************/
{
return(_ChampBisP1);
}

void CVTypeA::ChampBisQ1(CORBA::WChar _p)
/***************************************/
{
_ChampBisQ1=_p;
}

CORBA::WChar CVTypeA::ChampBisQ1() const
/**************************************/
{
return(_ChampBisQ1);
}

void CVTypeA::ChampBisR1(wchar_t *_p)
/***********************************/
{
_ChampBisR1=CORBA::wstring_dup((CORBA::WChar *)_p);
}

void CVTypeA::ChampBisR1(const wchar_t *_p)
/*****************************************/
{
_ChampBisR1=CORBA::wstring_dup((CORBA::WChar *)_p);
}

void CVTypeA::ChampBisR1(const CORBA::WString_var &_p)
/****************************************************/
{
_ChampBisR1=CORBA::wstring_dup((CORBA::WChar *)_p.in());
}

const wchar_t *CVTypeA::ChampBisR1() const
/****************************************/
{
return(_ChampBisR1);
}

void CVTypeA::ChampBisS1(::Enu _p)
/********************************/
{
_ChampBisS1=_p;
}

const ::Enu& CVTypeA::ChampBisS1() const
/**************************************/
{
return(_ChampBisS1);
}

::Enu& CVTypeA::ChampBisS1()
/**************************/
{
return(_ChampBisS1);
}

void CVTypeA::ChampBisT1(::IClassB_ptr _p)
/****************************************/
{
_ChampBisT1=_p;
::IClassB::_duplicate(_ChampBisT1);
}

::IClassB_ptr CVTypeA::ChampBisT1() const
/***************************************/
{
return(_ChampBisT1);
}

void CVTypeA::ChampBisU1(const ::IClassA::StructS& _p)
/****************************************************/
{
_ChampBisU1=new ::IClassA::S(_p);
}

const ::IClassA::StructS& CVTypeA::ChampBisU1() const
/***************************************************/
{
return(*_ChampBisU1);
}

::IClassA::StructS& CVTypeA::ChampBisU1()
/***************************************/
{
return(*_ChampBisU1);
}

void CVTypeA::ChampBisV1(const ::IClassA::UnionU& _p)
/***************************************************/
{
_ChampBisV1=new ::IClassA::U(_p);
}

const ::IClassA::UnionU& CVTypeA::ChampBisV1() const
/**************************************************/
{
return(*_ChampBisV1);
}

::IClassA::UnionU& CVTypeA::ChampBisV1()
/**************************************/
{
return(*_ChampBisV1);
}

void CVTypeA::ChampBisA2(const ::IClassA::SequenceAny& _p)
/********************************************************/
{
_ChampBisA2=new ::IClassA::SequenceAny(_p);
}

const ::IClassA::SequenceAny& CVTypeA::ChampBisA2() const
/*******************************************************/
{
return(*_ChampBisA2);
}

::IClassA::SequenceAny& CVTypeA::ChampBisA2()
/*******************************************/
{
return(*_ChampBisA2);
}

void CVTypeA::ChampBisB2(const ::IClassA::SequenceBoolean& _p)
/************************************************************/
{
_ChampBisB2=new ::IClassA::SequenceBoolean(_p);
}

const ::IClassA::SequenceBoolean& CVTypeA::ChampBisB2() const
/***********************************************************/
{
return(*_ChampBisB2);
}

::IClassA::SequenceBoolean& CVTypeA::ChampBisB2()
/***********************************************/
{
return(*_ChampBisB2);
}

void CVTypeA::ChampBisC2(const ::IClassA::SequenceChar& _p)
/*********************************************************/
{
_ChampBisC2=new ::IClassA::SequenceChar(_p);
}

const ::IClassA::SequenceChar& CVTypeA::ChampBisC2() const
/********************************************************/
{
return(*_ChampBisC2);
}

::IClassA::SequenceChar& CVTypeA::ChampBisC2()
/********************************************/
{
return(*_ChampBisC2);
}

void CVTypeA::ChampBisD2(const ::IClassA::SequenceDouble& _p)
/***********************************************************/
{
_ChampBisD2=new ::IClassA::SequenceDouble(_p);
}

const ::IClassA::SequenceDouble& CVTypeA::ChampBisD2() const
/**********************************************************/
{
return(*_ChampBisD2);
}

::IClassA::SequenceDouble& CVTypeA::ChampBisD2()
/**********************************************/
{
return(*_ChampBisD2);
}

void CVTypeA::ChampBisE2(const ::IClassA::SequenceFixed& _p)
/**********************************************************/
{
_ChampBisE2=new ::IClassA::SequenceFixed(_p);
}

const ::IClassA::SequenceFixed& CVTypeA::ChampBisE2() const
/*********************************************************/
{
return(*_ChampBisE2);
}

::IClassA::SequenceFixed& CVTypeA::ChampBisE2()
/*********************************************/
{
return(*_ChampBisE2);
}

void CVTypeA::ChampBisF2(const ::IClassA::SequenceFloat& _p)
/**********************************************************/
{
_ChampBisF2=new ::IClassA::SequenceFloat(_p);
}

const ::IClassA::SequenceFloat& CVTypeA::ChampBisF2() const
/*********************************************************/
{
return(*_ChampBisF2);
}

::IClassA::SequenceFloat& CVTypeA::ChampBisF2()
/*********************************************/
{
return(*_ChampBisF2);
}

void CVTypeA::ChampBisG2(const ::IClassA::SequenceLong& _p)
/*********************************************************/
{
_ChampBisG2=new ::IClassA::SequenceLong(_p);
}

const ::IClassA::SequenceLong& CVTypeA::ChampBisG2() const
/********************************************************/
{
return(*_ChampBisG2);
}

::IClassA::SequenceLong& CVTypeA::ChampBisG2()
/********************************************/
{
return(*_ChampBisG2);
}

void CVTypeA::ChampBisH2(const ::IClassA::SequenceLongLong& _p)
/*************************************************************/
{
_ChampBisH2=new ::IClassA::SequenceLongLong(_p);
}

const ::IClassA::SequenceLongLong& CVTypeA::ChampBisH2() const
/************************************************************/
{
return(*_ChampBisH2);
}

::IClassA::SequenceLongLong& CVTypeA::ChampBisH2()
/************************************************/
{
return(*_ChampBisH2);
}

void CVTypeA::ChampBisI2(const ::IClassA::SequenceLongDouble& _p)
/***************************************************************/
{
_ChampBisI2=new ::IClassA::SequenceLongDouble(_p);
}

const ::IClassA::SequenceLongDouble& CVTypeA::ChampBisI2() const
/**************************************************************/
{
return(*_ChampBisI2);
}

::IClassA::SequenceLongDouble& CVTypeA::ChampBisI2()
/**************************************************/
{
return(*_ChampBisI2);
}

void CVTypeA::ChampBisJ2(const ::IClassA::SequenceObject& _p)
/***********************************************************/
{
_ChampBisJ2=new ::IClassA::SequenceObject(_p);
}
const ::IClassA::SequenceObject& CVTypeA::ChampBisJ2() const
/**********************************************************/
{
return(*_ChampBisJ2);
}

::IClassA::SequenceObject& CVTypeA::ChampBisJ2()
/**********************************************/
{
return(*_ChampBisJ2);
}

void CVTypeA::ChampBisK2(const ::IClassA::SequenceOctet& _p)
/**********************************************************/
{
_ChampBisK2=new ::IClassA::SequenceOctet(_p);
}

const ::IClassA::SequenceOctet& CVTypeA::ChampBisK2() const
/*********************************************************/
{
return(*_ChampBisK2);
}

::IClassA::SequenceOctet& CVTypeA::ChampBisK2()
/*********************************************/
{
return(*_ChampBisK2);
}

void CVTypeA::ChampBisL2(const ::IClassA::SequenceShort& _p)
/**********************************************************/
{
_ChampBisL2=new ::IClassA::SequenceShort(_p);
}

const ::IClassA::SequenceShort& CVTypeA::ChampBisL2() const
/*********************************************************/
{
return(*_ChampBisL2);
}

::IClassA::SequenceShort& CVTypeA::ChampBisL2()
/*********************************************/
{
return(*_ChampBisL2);
}

void CVTypeA::ChampBisM2(const ::IClassA::SequenceString& _p)
/***********************************************************/
{
_ChampBisM2=new ::IClassA::SequenceString(_p);
}

const ::IClassA::SequenceString& CVTypeA::ChampBisM2() const
/**********************************************************/
{
return(*_ChampBisM2);
}

::IClassA::SequenceString& CVTypeA::ChampBisM2()
/**********************************************/
{
return(*_ChampBisM2);
}

void CVTypeA::ChampBisN2(const ::IClassA::SequenceUnsignedLong& _p)
/*****************************************************************/
{
_ChampBisN2=new ::IClassA::SequenceUnsignedLong(_p);
}

const ::IClassA::SequenceUnsignedLong& CVTypeA::ChampBisN2() const
/****************************************************************/
{
return(*_ChampBisN2);
}

::IClassA::SequenceUnsignedLong& CVTypeA::ChampBisN2()
/****************************************************/
{
return(*_ChampBisN2);
}

void CVTypeA::ChampBisO2(const ::IClassA::SequenceUnsignedLongLong& _p)
/*********************************************************************/
{
_ChampBisO2=new ::IClassA::SequenceUnsignedLongLong(_p);
}

const ::IClassA::SequenceUnsignedLongLong& CVTypeA::ChampBisO2() const
/********************************************************************/
{
return(*_ChampBisO2);
}

::IClassA::SequenceUnsignedLongLong& CVTypeA::ChampBisO2()
/********************************************************/
{
return(*_ChampBisO2);
}

void CVTypeA::ChampBisP2(const ::IClassA::SequenceUnsignedShort& _p)
/******************************************************************/
{
_ChampBisP2=new ::IClassA::SequenceUnsignedShort(_p);
}

const ::IClassA::SequenceUnsignedShort& CVTypeA::ChampBisP2() const
/*****************************************************************/
{
return(*_ChampBisP2);
}

::IClassA::SequenceUnsignedShort& CVTypeA::ChampBisP2()
/*****************************************************/
{
return(*_ChampBisP2);
}

void CVTypeA::ChampBisQ2(const ::IClassA::SequenceWChar& _p)
/**********************************************************/
{
_ChampBisQ2=new ::IClassA::SequenceWChar(_p);
}

const ::IClassA::SequenceWChar& CVTypeA::ChampBisQ2() const
/*********************************************************/
{
return(*_ChampBisQ2);
}

::IClassA::SequenceWChar& CVTypeA::ChampBisQ2()
/*********************************************/
{
return(*_ChampBisQ2);
}

void CVTypeA::ChampBisR2(const ::IClassA::SequenceWString& _p)
/************************************************************/
{
_ChampBisR2=new ::IClassA::SequenceWString(_p);

}

const ::IClassA::SequenceWString& CVTypeA::ChampBisR2() const
/***********************************************************/
{
return(*_ChampBisR2);
}

::IClassA::SequenceWString& CVTypeA::ChampBisR2()
/***********************************************/
{
return(*_ChampBisR2);
}

void CVTypeA::ChampBisS2(const ::IClassA::SequenceEnu& _p)
/********************************************************/
{
_ChampBisS2=new ::IClassA::SequenceEnu(_p);
}

const ::IClassA::SequenceEnu& CVTypeA::ChampBisS2() const
/*******************************************************/
{
return(*_ChampBisS2);
}

::IClassA::SequenceEnu& CVTypeA::ChampBisS2()
/*******************************************/
{
return(*_ChampBisS2);
}

void CVTypeA::ChampBisT2(const ::IClassA::SequenceIClassB& _p)
/************************************************************/
{
_ChampBisT2=new ::IClassA::SequenceIClassB(_p);
}

const ::IClassA::SequenceIClassB& CVTypeA::ChampBisT2() const
/***********************************************************/
{
return(*_ChampBisT2);
}

::IClassA::SequenceIClassB& CVTypeA::ChampBisT2()
/***********************************************/
{
return(*_ChampBisT2);
}

void CVTypeA::ChampBisU2(const ::IClassA::SequenceStructS& _p)
/************************************************************/
{
_ChampBisU2=new ::IClassA::SequenceStructS(_p);
}

const ::IClassA::SequenceStructS& CVTypeA::ChampBisU2() const
/***********************************************************/
{
return(*_ChampBisU2);
}

::IClassA::SequenceStructS& CVTypeA::ChampBisU2()
/***********************************************/
{
return(*_ChampBisU2);
}

void CVTypeA::ChampBisV2(const ::IClassA::SequenceUnionU& _p)
/***********************************************************/
{
_ChampBisV2=new ::IClassA::SequenceUnionU(_p);
}

const ::IClassA::SequenceUnionU& CVTypeA::ChampBisV2() const
/**********************************************************/
{
return(*_ChampBisV2);
}

::IClassA::SequenceUnionU& CVTypeA::ChampBisV2()
/**********************************************/
{
return(*_ChampBisV2);
}

void CVTypeA::AppelBisZ1()
/************************/
{
}

CORBA::Any* CVTypeA::AppelBisA1(const CORBA::Any& P1, CORBA::Any& P2)
/*******************************************************************/
{
P2=*(new CORBA::Any(P1));
return(_ChampBisA1);
}

CORBA::Boolean CVTypeA::AppelBisB1(CORBA::Boolean P1, CORBA::Boolean& P2)
/***********************************************************************/
{
P2=P1;
return(_ChampBisB1);
}

CORBA::Char CVTypeA::AppelBisC1(CORBA::Char P1, CORBA::Char& P2)
/**************************************************************/
{
P2=P1;
return(_ChampBisC1);
}

CORBA::Double CVTypeA::AppelBisD1(CORBA::Double P1, CORBA::Double& P2)
/********************************************************************/
{
P2=P1;
return(_ChampBisD1);
}

FixedTmpl< 6,2 > CVTypeA::AppelBisE1(FixedTmpl< 6,2 > P1, FixedTmpl< 6,2 >& P2)
/*****************************************************************************/
{
P2=*(new Fixed(P1));
return(_ChampBisE1);
}

CORBA::Float CVTypeA::AppelBisF1(CORBA::Float P1, CORBA::Float& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampBisF1);
}

CORBA::Long CVTypeA::AppelBisG1(CORBA::Long P1, CORBA::Long& P2)
/**************************************************************/
{
P2=P1;
return(_ChampBisG1);
}

CORBA::LongLong CVTypeA::AppelBisH1(CORBA::LongLong P1, CORBA::LongLong& P2)
/**************************************************************************/
{
P2=P1;
return(_ChampBisH1);
}

CORBA::LongDouble CVTypeA::AppelBisI1(CORBA::LongDouble P1, CORBA::LongDouble& P2)
/********************************************************************************/
{
P2=P1;
return(_ChampBisI1);
}

CORBA::Object_ptr CVTypeA::AppelBisJ1(CORBA::Object_ptr P1, CORBA::Object_ptr& P2)
/********************************************************************************/
{
P2=P1;
CORBA::Object::_duplicate(P2);
return(_ChampBisJ1);
}

CORBA::Octet CVTypeA::AppelBisK1(CORBA::Octet P1, CORBA::Octet& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampBisK1);
}

CORBA::Short CVTypeA::AppelBisL1(CORBA::Short P1, CORBA::Short& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampBisL1);
}

char* CVTypeA::AppelBisM1(const char* P1, char*& P2)
/**************************************************/
{
P2=CORBA::string_dup((CORBA::Char *)P1);
return(_ChampBisM1);
}

CORBA::ULong CVTypeA::AppelBisN1(CORBA::ULong P1, CORBA::ULong& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampBisN1);
}

CORBA::ULongLong CVTypeA::AppelBisO1(CORBA::ULongLong P1, CORBA::ULongLong& P2)
/*****************************************************************************/
{
P2=P1;
return(_ChampBisO1);
}

CORBA::UShort CVTypeA::AppelBisP1(CORBA::UShort P1, CORBA::UShort& P2)
/********************************************************************/
{
P2=P1;
return(_ChampBisP1);
}

CORBA::WChar CVTypeA::AppelBisQ1(CORBA::WChar P1, CORBA::WChar& P2)
/*****************************************************************/
{
P2=P1;
return(_ChampBisQ1);
}

CORBA::WChar* CVTypeA::AppelBisR1(const CORBA::WChar* P1, CORBA::WChar*& P2)
/**************************************************************************/
{
P2=CORBA::wstring_dup((CORBA::WChar *)P1);
return(_ChampBisR1);
}

::Enu CVTypeA::AppelBisS1(::Enu P1, ::Enu& P2)
/********************************************/
{
P2=P1;
return(_ChampBisS1);
}

::IClassB_ptr CVTypeA::AppelBisT1(::IClassB_ptr P1, ::IClassB_ptr& P2)
/********************************************************************/
{
P2=P1;
::IClassB::_duplicate(P2);
return(_ChampBisT1);
}

::IClassA::StructS* CVTypeA::AppelBisU1(const ::IClassA::StructS& P1, ::IClassA::StructS& P2)
/*******************************************************************************************/
{
P2=*(new ::IClassA::StructS(P1));
return(_ChampBisU1);
}

::IClassA::UnionU* CVTypeA::AppelBisV1(const ::IClassA::UnionU& P1, ::IClassA::UnionU& P2)
/****************************************************************************************/
{
P2=*(new ::IClassA::UnionU(P1));
return(_ChampBisV1);
}

void CVTypeA::AppelBisZ2()
/************************/
{
}

::IClassA::SequenceAny* CVTypeA::AppelBisA2(const ::IClassA::SequenceAny& P1, ::IClassA::SequenceAny& P2)
/*******************************************************************************************************/
{
P2=*(new ::IClassA::SequenceAny(P1));
return(_ChampBisA2);
}

::IClassA::SequenceBoolean* CVTypeA::AppelBisB2(const ::IClassA::SequenceBoolean& P1, ::IClassA::SequenceBoolean& P2)
/*******************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceBoolean(P1));
return(_ChampBisB2);
}

::IClassA::SequenceChar* CVTypeA::AppelBisC2(const ::IClassA::SequenceChar& P1, ::IClassA::SequenceChar& P2)
/**********************************************************************************************************/
{
P2=*(new ::IClassA::SequenceChar(P1));
return(_ChampBisC2);
}

::IClassA::SequenceDouble* CVTypeA::AppelBisD2(const ::IClassA::SequenceDouble& P1, ::IClassA::SequenceDouble& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceDouble(P1));
return(_ChampBisD2);
}

::IClassA::SequenceFixed* CVTypeA::AppelBisE2(const ::IClassA::SequenceFixed& P1, ::IClassA::SequenceFixed& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceFixed(P1));
return(_ChampBisE2);
}

::IClassA::SequenceFloat* CVTypeA::AppelBisF2(const ::IClassA::SequenceFloat& P1, ::IClassA::SequenceFloat& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceFloat(P1));
return(_ChampBisF2);
}

::IClassA::SequenceLong* CVTypeA::AppelBisG2(const ::IClassA::SequenceLong& P1, ::IClassA::SequenceLong& P2)
/**********************************************************************************************************/
{
P2=*(new ::IClassA::SequenceLong(P1));
return(_ChampBisG2);
}

::IClassA::SequenceLongLong* CVTypeA::AppelBisH2(const ::IClassA::SequenceLongLong& P1, ::IClassA::SequenceLongLong& P2)
/**********************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceLongLong(P1));
return(_ChampBisH2);
}

::IClassA::SequenceLongDouble* CVTypeA::AppelBisI2(const ::IClassA::SequenceLongDouble& P1, ::IClassA::SequenceLongDouble& P2)
/****************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceLongDouble(P1));
return(_ChampBisI2);
}

::IClassA::SequenceObject* CVTypeA::AppelBisJ2(const ::IClassA::SequenceObject& P1, ::IClassA::SequenceObject& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceObject(P1));
return(_ChampBisJ2);
}

::IClassA::SequenceOctet* CVTypeA::AppelBisK2(const ::IClassA::SequenceOctet& P1, ::IClassA::SequenceOctet& P2)
/*************************************************************************************************************/
{
P2=*(new IClassA::SequenceOctet(P1));
return(_ChampBisK2);
}

::IClassA::SequenceShort* CVTypeA::AppelBisL2(const ::IClassA::SequenceShort& P1, ::IClassA::SequenceShort& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceShort(P1));
return(_ChampBisL2);
}

::IClassA::SequenceString* CVTypeA::AppelBisM2(const ::IClassA::SequenceString& P1, ::IClassA::SequenceString& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceString(P1));
return(_ChampBisM2);
}

::IClassA::SequenceUnsignedLong* CVTypeA::AppelBisN2(const ::IClassA::SequenceUnsignedLong& P1, ::IClassA::SequenceUnsignedLong& P2)
/**********************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnsignedLong(P1));
return(_ChampBisN2);
}

::IClassA::SequenceUnsignedLongLong* CVTypeA::AppelBisO2(const ::IClassA::SequenceUnsignedLongLong& P1, ::IClassA::SequenceUnsignedLongLong& P2)
/**********************************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnsignedLongLong(P1));
return(_ChampBisO2);
}

::IClassA::SequenceUnsignedShort* CVTypeA::AppelBisP2(const ::IClassA::SequenceUnsignedShort& P1, ::IClassA::SequenceUnsignedShort& P2)
/*************************************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnsignedShort(P1));
return(_ChampBisP2)
}

::IClassA::SequenceWChar* CVTypeA::AppelBisQ2(const ::IClassA::SequenceWChar& P1, ::IClassA::SequenceWChar& P2)
/*************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceWChar(P1));
return(_ChampBisQ2);
}

::IClassA::SequenceWString* CVTypeA::AppelBisR2(const ::IClassA::SequenceWString& P1, ::IClassA::SequenceWString& P2)
/*******************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceWString(P1));
return(_ChampBisR2);
}

::IClassA::SequenceEnu* CVTypeA::AppelBisS2(const ::IClassA::SequenceEnu& P1, ::IClassA::SequenceEnu& P2)
/*******************************************************************************************************/
{
P2=*(new ::IClassA::SequenceEnu(P1));
return(_ChampBisS2);
}

::IClassA::SequenceIClassB* CVTypeA::AppelBisT2(const ::IClassA::SequenceIClassB& P1, ::IClassA::SequenceIClassB& P2)
/*******************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceIClassB(P1));
return(_ChampBisT2);
}

::IClassA::SequenceStructS* CVTypeA::AppelBisU2(const ::IClassA::SequenceStructS& P1, ::IClassA::SequenceStructS& P2)
/*******************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceStructS(P1));
return(_ChampBisU2);
}

::IClassA::SequenceUnionU* CVTypeA::AppelBisV2(const ::IClassA::SequenceUnionU& P1, ::IClassA::SequenceUnionU& P2)
/****************************************************************************************************************/
{
P2=*(new ::IClassA::SequenceUnionU(P1));
return(_ChampBisV2);
}

void CVTypeA::_add_ref()
/**********************/
{
Compteur++;
}

void CVTypeA::_remove_ref()
/*************************/
{
Compteur--;
}

CORBA::ULong CVTypeA::_refcount_value()
/*************************************/
{
return(Compteur);
}

CVTypeA::CVTypeA()
/****************/
{
CORBA::Any::from_string *FromString;
CClassB *pClassB;
CORBA::ULong i;
CORBA::Any BufferAny[3];
CORBA::Boolean BufferBoolean[3];
CORBA::Char BufferChar[4];
CORBA::Double BufferDouble[3];
FixedTmpl<6,2> BufferFixed[3];
CORBA::Float BufferFloat[3];
CORBA::Long BufferLong[3];
CORBA::LongLong BufferLongLong[3];
CORBA::LongDouble BufferLongDouble[3];
CORBA::Object *BufferObject[3];
CORBA::Octet BufferOctet[6];
CORBA::Short BufferShort[3];
CORBA::ULong BufferUnsignedLong[3];
CORBA::ULongLong BufferUnsignedLongLong[3];
CORBA::UShort BufferUnsignedShort[3];
CORBA::WChar BufferWChar[4];
::Enu BufferEnu[3];
IClassB *BufferClassB[3];
CORBA::Char *BufferString[3];
CORBA::WChar *BufferWString[3];
::IClassA::StructS BufferStructS[3];
::IClassA::UnionU BufferUnionU[3];

_ChampBisA1=new CORBA::Any();
FromString=new CORBA::Any::from_string((CORBA::Char *)"coucou",6);
*_ChampBisA1<<=*FromString;
delete FromString;
_ChampBisB1=TRUE;
_ChampBisC1=(CORBA::Char)65;
_ChampBisD1=(CORBA::Double)2.3;
_ChampBisE1=*(new Fixed((CORBA::Double)3.4));
_ChampBisF1=(CORBA::Float)4.5;
_ChampBisG1=(CORBA::Long)3;
_ChampBisH1=(CORBA::LongLong)4;
_ChampBisI1=(CORBA::LongDouble)5.6;
pClassB=new CClassB();
_ChampBisJ1=pClassB->_this();
_ChampBisK1=(CORBA::Octet)66;
_ChampBisL1=(CORBA::Short)5;
_ChampBisM1=(CORBA::Char *)"coucou";
_ChampBisN1=(CORBA::ULong)6;
_ChampBisO1=(CORBA::ULongLong)7;
_ChampBisP1=(CORBA::UShort)8;
_ChampBisQ1=(CORBA::WChar)67;
_ChampBisR1=(CORBA::WChar *)L"coucou";
_ChampBisS1=(::Enu)0;
pClassB=new ::CClassB();
_ChampBisT1=::IClassB::_narrow(pClassB->_this());
_ChampBisU1=new ::IClassA::S();
_ChampBisU1->ChampS1=*(new CORBA::Any());
FromString=new CORBA::Any::from_string((CORBA::Char *)"coucou",6);
_ChampBisU1->ChampS1<<=*FromString;
delete FromString;
_ChampBisU1->ChampS2=TRUE;
_ChampBisU1->ChampS3=(CORBA::Char)65;
_ChampBisU1->ChampS4=(CORBA::Double)2.3;
_ChampBisU1->ChampS5=*(new Fixed((CORBA::Double)3.4));
_ChampBisU1->ChampS6=(CORBA::Float)4.5;
_ChampBisU1->ChampS7=(CORBA::Long)3;
_ChampBisU1->ChampS8=(CORBA::LongLong)4;
_ChampBisU1->ChampS9=(CORBA::LongDouble)5.6;
pClassB=new CClassB();
_ChampBisU1->ChampS10=pClassB->_this();
_ChampBisU1->ChampS11=(CORBA::Octet)66;
_ChampBisU1->ChampS12=(CORBA::Short)5;
_ChampBisU1->ChampS13=(CORBA::Char *)"coucou";
_ChampBisU1->ChampS14=(CORBA::ULong)6;
_ChampBisU1->ChampS15=(CORBA::ULongLong)7;
_ChampBisU1->ChampS16=(CORBA::UShort)8;
_ChampBisU1->ChampS17=(CORBA::WChar)67;
_ChampBisU1->ChampS18=(CORBA::WChar *)L"coucou";
_ChampBisU1->ChampS19=(::Enu)0;
pClassB=new ::CClassB();
_ChampBisU1->ChampS20=pClassB->_this();
_ChampBisV1=new ::IClassA::U();
_ChampBisV1->ChampU2(TRUE);

FromString=new CORBA::Any::from_string((CORBA::Char *)"coucou 1",8);
BufferAny[0]<<=*FromString;
delete FromString;
FromString=new CORBA::Any::from_string((CORBA::Char *)"coucou 2",8);
BufferAny[1]<<=*FromString;
delete FromString;
FromString=new CORBA::Any::from_string((CORBA::Char *)"coucou 3",8);
BufferAny[2]<<=*FromString;
delete FromString;
_ChampBisA2=new ::IClassA::SequenceAny(3,3,BufferAny);
BufferBoolean[0]=TRUE;
BufferBoolean[1]=FALSE;
BufferBoolean[2]=TRUE;
_ChampBisB2=new ::IClassA::SequenceBoolean(3,3,BufferBoolean);
BufferChar[0]=(CORBA::Char)65;
BufferChar[1]=(CORBA::Char)66;
BufferChar[2]=(CORBA::Char)67;
BufferChar[3]=(CORBA::Char)0;
_ChampBisC2=new ::IClassA::SequenceChar(4,4,BufferChar);
BufferDouble[0]=(CORBA::Double)2.3;
BufferDouble[1]=(CORBA::Double)2.4;
BufferDouble[2]=(CORBA::Double)2.5;
_ChampBisD2=new ::IClassA::SequenceDouble(3,3,BufferDouble);
BufferFixed[0]=*(new Fixed((CORBA::Double)3.4));
BufferFixed[1]=*(new Fixed((CORBA::Double)3.5));
BufferFixed[2]=*(new Fixed((CORBA::Double)3.6));
_ChampBisE2=new ::IClassA::SequenceFixed(3,3,BufferFixed);
BufferFloat[0]=(CORBA::Float)4.5;
BufferFloat[1]=(CORBA::Float)4.6;
BufferFloat[2]=(CORBA::Float)4.7;
_ChampBisF2=new ::IClassA::SequenceFloat(3,3,BufferFloat);
BufferLong[0]=(CORBA::Long)3;
BufferLong[1]=(CORBA::Long)4;
BufferLong[2]=(CORBA::Long)5;
_ChampBisG2=new ::IClassA::SequenceLong(3,3,BufferLong);
BufferLongLong[0]=(CORBA::LongLong)4;
BufferLongLong[1]=(CORBA::LongLong)5;
BufferLongLong[2]=(CORBA::LongLong)6;
_ChampBisH2=new ::IClassA::SequenceLongLong(3,3,BufferLongLong);
BufferLongDouble[0]=(CORBA::LongDouble)5.6;
BufferLongDouble[1]=(CORBA::LongDouble)5.7;
BufferLongDouble[2]=(CORBA::LongDouble)5.8;
_ChampBisI2=new ::IClassA::SequenceLongDouble(3,3,BufferLongDouble);
pClassB=new CClassB();
pClassB->A(100);
BufferObject[0]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(101);
BufferObject[1]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(102);
BufferObject[2]=pClassB->_this();
_ChampBisJ2=new ::IClassA::SequenceObject(3,3,BufferObject);
BufferOctet[0]=(CORBA::Octet)66;
BufferOctet[1]=(CORBA::Octet)0;
BufferOctet[2]=(CORBA::Octet)67;
BufferOctet[3]=(CORBA::Octet)0;
BufferOctet[4]=(CORBA::Octet)68;
BufferOctet[5]=(CORBA::Octet)0;
_ChampBisK2=new ::IClassA::SequenceOctet(6,6,BufferOctet);
BufferShort[0]=(CORBA::Short)5;
BufferShort[1]=(CORBA::Short)6;
BufferShort[2]=(CORBA::Short)7;
_ChampBisL2=new ::IClassA::SequenceShort(3,3,BufferShort);
BufferString[0]=(CORBA::Char *)"coucou 1";
BufferString[1]=(CORBA::Char *)"coucou 2";
BufferString[2]=(CORBA::Char *)"coucou 3";
_ChampBisM2=new ::IClassA::SequenceString(3,3,BufferString);
BufferUnsignedLong[0]=(CORBA::ULong)6;
BufferUnsignedLong[1]=(CORBA::ULong)7;
BufferUnsignedLong[2]=(CORBA::ULong)8;
_ChampBisN2=new ::IClassA::SequenceUnsignedLong(3,3,BufferUnsignedLong);
BufferUnsignedLongLong[0]=(CORBA::ULongLong)7;
BufferUnsignedLongLong[1]=(CORBA::ULongLong)8;
BufferUnsignedLongLong[2]=(CORBA::ULongLong)9;
_ChampBisO2=new ::IClassA::SequenceUnsignedLongLong(3,3,BufferUnsignedLongLong);
BufferUnsignedShort[0]=(CORBA::UShort)8;
BufferUnsignedShort[1]=(CORBA::UShort)9;
BufferUnsignedShort[2]=(CORBA::UShort)10;
_ChampBisP2=new ::IClassA::SequenceUnsignedShort(3,3,BufferUnsignedShort);
BufferWChar[0]=(CORBA::WChar)67;
BufferWChar[1]=(CORBA::WChar)68;
BufferWChar[2]=(CORBA::WChar)69;
BufferWChar[3]=(CORBA::WChar)0;
_ChampBisQ2=new ::IClassA::SequenceWChar(4,4,BufferWChar);
BufferWString[0]=(CORBA::WChar *)L"coucou 1";
BufferWString[1]=(CORBA::WChar *)L"coucou 2";
BufferWString[2]=(CORBA::WChar *)L"coucou 3";
_ChampBisR2=new ::IClassA::SequenceWString(3,3,BufferWString);
BufferEnu[0]=(::Enu)0;
BufferEnu[1]=(::Enu)1;
BufferEnu[2]=(::Enu)2;
_ChampBisS2=new ::IClassA::SequenceEnu(3,3,BufferEnu);
pClassB=new CClassB();
pClassB->A(100);
BufferClassB[0]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(101);
BufferClassB[1]=pClassB->_this();
pClassB=new CClassB();
pClassB->A(102);
BufferClassB[2]=pClassB->_this();
_ChampBisT2=new ::IClassA::SequenceIClassB(3,3,BufferClassB);
for (i=0;i<3;i++) _ChampBisU2=new ::IClassA::SequenceStructS(3,3,BufferStructS);
for (i=0;i<3;i++) _ChampBisV2=new ::IClassA::SequenceUnionU(3,3,BufferUnionU);
Compteur=0;
}

CVTypeA::~CVTypeA()
/*****************/
{
delete _ChampBisA1;
delete _ChampBisJ1;
delete _ChampBisT1;
delete _ChampBisU1;
delete _ChampBisV1;

delete _ChampBisA2;
delete _ChampBisB2;
delete _ChampBisC2;
delete _ChampBisD2;
delete _ChampBisE2;
delete _ChampBisF2;
delete _ChampBisG2;
delete _ChampBisH2;
delete _ChampBisI2;
delete _ChampBisJ2;
delete _ChampBisK2;
delete _ChampBisL2;
delete _ChampBisM2;
delete _ChampBisN2;
delete _ChampBisO2;
delete _ChampBisP2;
delete _ChampBisQ2;
delete _ChampBisR2;
delete _ChampBisS2;
delete _ChampBisT2;
delete _ChampBisU2;
delete _ChampBisV2;
}

VTypeA *FVTypeA::Constructeur()
/*****************************/
{
CVTypeA *pCVTypeA;

pCVypeA=new CVTypeA();
return((VTypeA *)pCVTypeA);
}

extern "C" __declspec( dllexport ) CORBA::ValueBase *VTypeA_Constructeur(void)
/****************************************************************************/
{
CVTypeA *pCVTypeA;
CORBA::ValueBase *pValueBase;

pCVTypeA=new CVTypeA();
pValueBase=pCVTypeA;
return(pValueBase);
}

extern "C" __declspec( dllexport ) CORBA::Boolean mico_module_init(const char *Version)
/*************************************************************************************/
{
int argc;
char *argv[2];
CORBA::Object *pObjet;

argc=1; argv[0]="classab";
argv[1]=NULL;
pOrb=CORBA::ORB_init(argc,argv,"mico-local-orb");
if (!pOrb) pObjet=pOrb->resolve_initial_references("RootPOA");
if (!pObjet)

Poa=PortableServer::POA::_narrow(pObjet);
if (!pPoa)

try catch (CORBA::Exception& e) return(TRUE);
}

extern "C" __declspec( dllexport ) void mico_module_exit(void)
/************************************************************/
{
try catch (CORBA::Exception& e) }
#ifndef ModuleClassAB
#define ModuleClassAB 1

const short CA=1+2*3/1<<1>>1;
const double CB=1.0+2.0*3.1/1.0;

enum Enu
interface IClassB
interface IClassA
valuetype VTypeA #endif
Source Composant "Exemple De l'emploi d'Up ! Corba" Version 1.0.0;

ImporterModule
/************/
Prive :
/*****/
Procedure EcrireStructS(L:Caractere, S:StructS)
/*********************************************/
Variable
Debut
Si S.ChampS1!=Nul Alors Sinon Fin Si
Ecran.Ecrire(L+".ChampS2="+Caractere(S.ChampS2));
Ecran.Ecrire(L+".ChampS3="+Caractere(S.ChampS3));
Ecran.Ecrire(L+".ChampS4="+Caractere(S.ChampS4));
Ecran.Ecrire(L+".ChampS5="+Caractere(S.ChampS5));
Ecran.Ecrire(L+".ChampS6="+Caractere(S.ChampS6));
Ecran.Ecrire(L+".ChampS7="+Caractere(S.ChampS7));
Ecran.Ecrire(L+".ChampS8="+Caractere(S.ChampS8));
Ecran.Ecrire(L+".ChampS9="+Caractere(S.ChampS9));
B=IClassB(S.ChampS10);
Si B!=Nul Alors Sinon Fin Si
Ecran.Ecrire(L+".ChampS11="+Caractere(S.ChampS11));
Ecran.Ecrire(L+".ChampS12="+Caractere(S.ChampS12));
Si S.ChampS13!=Nul Alors Sinon Fin Si
Ecran.Ecrire(L+".ChampS14="+Caractere(S.ChampS14));
Ecran.Ecrire(L+".ChampS15="+Caractere(S.ChampS15));
Ecran.Ecrire(L+".ChampS16="+Caractere(S.ChampS16));
Ecran.Ecrire(L+".ChampS17="+Caractere(S.ChampS17));
Ecran.Ecrire(L+".ChampS18="+S.ChampS18);
Ecran.Ecrire(L+".ChampS19="+Caractere(Enu(S.ChampS19)));
Si S.ChampS20!=Nul Alors Sinon Fin Si
Fin Procedure

Procedure EcrireUnionU(L:Caractere, U:UnionU)
/*******************************************/
Variable
Debut
Selon U.U Faire Fin Selon
Fin Procedure

Procedure EcrireTableau(L:Caractere, T:Tableau[?] De Nul Ou Objet)
/****************************************************************/
Variable
Debut
Pour I=T.BorneMin JusquA T.BorneMax Faire Fin Pour
Fin Procedure

Principal
/*******/
Variable