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

classab_srv.h - En-tête de source C++

classab_srv.cpp - Source C++

#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++)
{
BufferStructS[i].ChampS1=*(new CORBA::Any());
FromString=new CORBA::Any::from_string((CORBA::Char *)"coucou",6);
BufferStructS[i].ChampS1<<=*FromString;
delete FromString;
BufferStructS[i].ChampS2=TRUE;
BufferStructS[i].ChampS3=(CORBA::Char)65;
BufferStructS[i].ChampS4=(CORBA::Double)2.3;
BufferStructS[i].ChampS5=*(new Fixed((CORBA::Double)3.4));
BufferStructS[i].ChampS6=(CORBA::Float)4.5;
BufferStructS[i].ChampS7=(CORBA::Long)3;
BufferStructS[i].ChampS8=(CORBA::LongLong)4;
BufferStructS[i].ChampS9=(CORBA::LongDouble)5.6;
pClassB=new CClassB();
BufferStructS[i].ChampS10=pClassB->_this();
BufferStructS[i].ChampS11=(CORBA::Octet)66;
BufferStructS[i].ChampS12=(CORBA::Short)5;
BufferStructS[i].ChampS13=(CORBA::Char *)"coucou";
BufferStructS[i].ChampS14=(CORBA::ULong)6;
BufferStructS[i].ChampS15=(CORBA::ULongLong)7;
BufferStructS[i].ChampS16=(CORBA::UShort)8;
BufferStructS[i].ChampS17=(CORBA::WChar)67;
BufferStructS[i].ChampS18=(CORBA::WChar *)L"coucou";
BufferStructS[i].ChampS19=(::Enu)0;
pClassB=new CClassB();
BufferStructS[i].ChampS20=pClassB->_this();
}
_ChampU2=new ::IClassA::SequenceStructS(3,3,BufferStructS);
for (i=0;i<3;i++)
{
BufferUnionU[i].ChampU2(TRUE);
}
_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++)
{
BufferStructS[i].ChampS1=*(new CORBA::Any());
FromString=new CORBA::Any::from_string(::IClassB::_narrow("coucou",6);
BufferStructS[i].ChampS1<<=*FromString;
delete FromString;
BufferStructS[i].ChampS2=TRUE;
BufferStructS[i].ChampS3=(CORBA::Char)65;
BufferStructS[i].ChampS4=(CORBA::Double)2.3;
BufferStructS[i].ChampS5=*(new Fixed((CORBA::Double)3.4));
BufferStructS[i].ChampS6=(CORBA::Float)4.5;
BufferStructS[i].ChampS7=(CORBA::Long)3;
BufferStructS[i].ChampS8=(CORBA::LongLong)4;
BufferStructS[i].ChampS9=(CORBA::LongDouble)5.6;
pClassB=new CClassB();
BufferStructS[i].ChampS10=pClassB->_this();
BufferStructS[i].ChampS11=(CORBA::Octet)66;
BufferStructS[i].ChampS12=(CORBA::Short)5;
BufferStructS[i].ChampS13=(CORBA::Char *)"coucou";
BufferStructS[i].ChampS14=(CORBA::ULong)6;
BufferStructS[i].ChampS15=(CORBA::ULongLong)7;
BufferStructS[i].ChampS16=(CORBA::UShort)8;
BufferStructS[i].ChampS17=(CORBA::WChar)67;
BufferStructS[i].ChampS18=(CORBA::WChar *)L"coucou";
BufferStructS[i].ChampS19=(::Enu)0;
pClassB=new ::CClassB();
BufferStructS[i].ChampS20=pClassB->_this();
}
_ChampBisU2=new ::IClassA::SequenceStructS(3,3,BufferStructS);
for (i=0;i<3;i++)
{
BufferUnionU[i].ChampU2(TRUE);
}
_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)
return(FALSE);
pObjet=pOrb->resolve_initial_references("RootPOA");
if (!pObjet)
return(FALSE);

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

return(FALSE);
try
{
pClassAGlobal=new CClassA();
if (!pClassAGlobal)
return(FALSE);
::IClassA::_duplicate(pClassAGlobal->_this());
pObjectIdA=pPoa->activate_object(pClassAGlobal);
pClassBGlobal=new CClassB();
if (!pClassBGlobal)
return(FALSE);
::IClassB::_duplicate(pClassBGlobal->_this());
pObjectIdB=pPoa->activate_object(pClassBGlobal);
}
catch (CORBA::Exception& e)
{
return(FALSE);
}
return(TRUE);
}

extern "C" __declspec( dllexport ) void mico_module_exit(void)
/************************************************************/
{
try
{
pPoa->deactivate_object(*pObjectIdA);
pPoa->deactivate_object(*pObjectIdB);
}
catch (CORBA::Exception& e)
{
return;
}
}

classab - Interface Definition Language

#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
{
Enu1,
Enu2,
Enu3
};

interface IClassB
{
attribute short A;
};

interface IClassA
{
typedef struct S
{
any ChampS1;
boolean ChampS2;
char ChampS3;
double ChampS4;
fixed<6,2> ChampS5;
float ChampS6;
long ChampS7;
long long ChampS8;
long double ChampS9;
Object ChampS10;
octet ChampS11;
short ChampS12;
string ChampS13;
unsigned long ChampS14;
unsigned long long ChampS15;
unsigned short ChampS16;
wchar ChampS17;
wstring ChampS18;
Enu ChampS19;
IClassB ChampS20;
} structS;

typedef union U switch (short)
{
case 1 : any ChampU1;
case 2 : boolean ChampU2;
case 3 : char ChampU3;
case 4 : double ChampU4;
case 5 : fixed<6,2> ChampU5;
case 6 : float ChampU6;
case 7 : long ChampU7;
case 8 : long long ChampU8;
case 9 : long double ChampU9;
case 10 : Object ChampU10;
case 11 : octet ChampU11;
case 12 : short ChampU12;
case 13 : string ChampU13;
case 14 : unsigned long ChampU14;
case 15 : unsigned long long ChampU15;
case 16 : unsigned short ChampU16;
case 17 : wchar ChampU17;
case 18 : wstring ChampU18;
case 19 : Enu ChampU19;
case 20 : IClassB ChampU20;
} UnionU;

typedef sequence<any> SequenceAny;
typedef sequence<boolean> SequenceBoolean;
typedef sequence<char> SequenceChar;
typedef sequence<double> Sequencedouble;
typedef sequence<fixed<6,2> > SequenceFixed;
typedef sequence<float> SequenceFloat;
typedef sequence<long> SequenceLong;
typedef sequence<long long> SequenceLongLong;
typedef sequence<long double> SequenceLongdouble;
typedef sequence<Object> SequenceObject;
typedef sequence<octet> SequenceOctet;
typedef sequence<short> Sequenceshort;
typedef sequence<string> SequenceString;
typedef sequence<unsigned long> SequenceUnsignedLong;
typedef sequence<unsigned long long> SequenceUnsignedLongLong;
typedef sequence<unsigned short> SequenceUnsignedshort;
typedef sequence<wchar> SequenceWChar;
typedef sequence<wstring> SequenceWString;
typedef sequence<::Enu> SequenceEnu;
typedef sequence<IClassB> SequenceIClassB;
typedef sequence<::IClassA::structS> SequencestructS;
typedef sequence<::IClassA::UnionU> SequenceUnionU;

attribute any ChampA1;
attribute boolean ChampB1;
attribute char ChampC1;
attribute double ChampD1;
attribute fixed<6,2> ChampE1;
attribute float ChampF1;
attribute long ChampG1;
attribute long long ChampH1;
attribute long double ChampI1;
attribute Object ChampJ1;
attribute octet ChampK1;
attribute short ChampL1;
attribute string ChampM1;
attribute unsigned long ChampN1;
attribute unsigned long long ChampO1;
attribute unsigned short ChampP1;
attribute wchar ChampQ1;
attribute wstring ChampR1;
attribute ::Enu ChampS1;
attribute IClassB ChampT1;
attribute ::IClassA::structS ChampU1;
attribute ::IClassA::UnionU ChampV1;

attribute SequenceAny ChampA2;
attribute SequenceBoolean ChampB2;
attribute SequenceChar ChampC2;
attribute Sequencedouble ChampD2;
attribute SequenceFixed ChampE2;
attribute SequenceFloat ChampF2;
attribute SequenceLong ChampG2;
attribute SequenceLongLong ChampH2;
attribute SequenceLongdouble ChampI2;
attribute SequenceObject ChampJ2;
attribute SequenceOctet ChampK2;
attribute Sequenceshort ChampL2;
attribute SequenceString ChampM2;
attribute SequenceUnsignedLong ChampN2;
attribute SequenceUnsignedLongLong ChampO2;
attribute SequenceUnsignedshort ChampP2;
attribute SequenceWChar ChampQ2;
attribute SequenceWString ChampR2;
attribute SequenceEnu ChampS2;
attribute SequenceIClassB ChampT2;
attribute SequencestructS ChampU2;
attribute SequenceUnionU ChampV2;

void AppelZ1();
any AppelA1(in any P1, inout any P2);
boolean AppelB1(in boolean P1, inout boolean P2);
char AppelC1(in char P1, inout char P2);
double AppelD1(in double P1, inout double P2);
fixed<6,2> AppelE1(in fixed<6,2> P1, inout fixed<6,2> P2);
float AppelF1(in float P1, inout float P2);
long AppelG1(in long P1, inout long P2);
long long AppelH1(in long long P1, inout long long P2);
long double AppelI1(in long double P1, inout long double P2);
Object AppelJ1(in Object P1, inout Object P2);
octet AppelK1(in octet P1, inout octet P2);
short AppelL1(in short P1, inout short P2);
string AppelM1(in string P1, inout string P2);
unsigned long AppelN1(in unsigned long P1, inout unsigned long P2);
unsigned long long AppelO1(in unsigned long long P1, inout unsigned long long P2);
unsigned short AppelP1(in unsigned short P1, inout unsigned short P2);
wchar AppelQ1(in wchar P1, inout wchar P2);
wstring AppelR1(in wstring P1, inout wstring P2);
Enu AppelS1(in Enu P1, inout Enu P2);
IClassB AppelT1(in IClassB P1, inout IClassB P2);
IClassA::structS AppelU1(in IClassA::structS P1, inout IClassA::structS P2);
IClassA::UnionU AppelV1(in IClassA::UnionU P1, inout IClassA::UnionU P2);

void AppelZ2();
IClassA::SequenceAny AppelA2(in IClassA::SequenceAny P1, inout IClassA::SequenceAny P2);
IClassA::SequenceBoolean AppelB2(in IClassA::SequenceBoolean P1, inout IClassA::SequenceBoolean P2);
IClassA::SequenceChar AppelC2(in IClassA::SequenceChar P1, inout IClassA::SequenceChar P2);
IClassA::Sequencedouble AppelD2(in IClassA::Sequencedouble P1, inout IClassA::Sequencedouble P2);
IClassA::SequenceFixed AppelE2(in IClassA::SequenceFixed P1, inout IClassA::SequenceFixed P2);
IClassA::SequenceFloat AppelF2(in IClassA::SequenceFloat P1, inout IClassA::SequenceFloat P2);
IClassA::SequenceLong AppelG2(in IClassA::SequenceLong P1, inout IClassA::SequenceLong P2);
IClassA::SequenceLongLong AppelH2(in IClassA::SequenceLongLong P1, inout IClassA::SequenceLongLong P2);
IClassA::SequenceLongdouble AppelI2(in IClassA::SequenceLongdouble P1, inout IClassA::SequenceLongdouble P2);
IClassA::SequenceObject AppelJ2(in IClassA::SequenceObject P1, inout IClassA::SequenceObject P2);
IClassA::SequenceOctet AppelK2(in IClassA::SequenceOctet P1, inout IClassA::SequenceOctet P2);
IClassA::Sequenceshort AppelL2(in IClassA::Sequenceshort P1, inout IClassA::Sequenceshort P2);
IClassA::SequenceString AppelM2(in IClassA::SequenceString P1, inout IClassA::SequenceString P2);
IClassA::SequenceUnsignedLong AppelN2(in IClassA::SequenceUnsignedLong P1, inout IClassA::SequenceUnsignedLong P2);
IClassA::SequenceUnsignedLongLong AppelO2(in IClassA::SequenceUnsignedLongLong P1, inout IClassA::SequenceUnsignedLongLong P2);
IClassA::SequenceUnsignedshort AppelP2(in IClassA::SequenceUnsignedshort P1, inout IClassA::SequenceUnsignedshort P2);
IClassA::SequenceWChar AppelQ2(in IClassA::SequenceWChar P1, inout IClassA::SequenceWChar P2);
IClassA::SequenceWString AppelR2(in IClassA::SequenceWString P1, inout IClassA::SequenceWString P2);
IClassA::SequenceEnu AppelS2(in IClassA::SequenceEnu P1, inout IClassA::SequenceEnu P2);
IClassA::SequenceIClassB AppelT2(in IClassA::SequenceIClassB P1, inout IClassA::SequenceIClassB P2);
IClassA::SequencestructS AppelU2(in IClassA::SequencestructS P1, inout IClassA::SequencestructS P2);
IClassA::SequenceUnionU AppelV2(in IClassA::SequenceUnionU P1, inout IClassA::SequenceUnionU P2);
};


valuetype VTypeA
{
public any ChampBisA1;
public boolean ChampBisB1;
public char ChampBisC1;
public double ChampBisD1;
public fixed<6,2> ChampBisE1;
public float ChampBisF1;
public long ChampBisG1;
public long long ChampBisH1;
public long double ChampBisI1;
public Object ChampBisJ1;
public octet ChampBisK1;
public short ChampBisL1;
public string ChampBisM1;
public unsigned long ChampBisN1;
public unsigned long long ChampBisO1;
public unsigned short ChampBisP1;
public wchar ChampBisQ1;
public wstring ChampBisR1;
public Enu ChampBisS1;
public IClassB ChampBisT1;
public ::IClassA::structS ChampBisU1;
public ::IClassA::UnionU ChampBisV1;

public ::IClassA::SequenceAny ChampBisA2;
public ::IClassA::SequenceBoolean ChampBisB2;
public ::IClassA::SequenceChar ChampBisC2;
public ::IClassA::Sequencedouble ChampBisD2;
public ::IClassA::SequenceFixed ChampBisE2;
public ::IClassA::SequenceFloat ChampBisF2;
public ::IClassA::SequenceLong ChampBisG2;
public ::IClassA::SequenceLongLong ChampBisH2;
public ::IClassA::SequenceLongdouble ChampBisI2;
public ::IClassA::SequenceObject ChampBisJ2;
public ::IClassA::SequenceOctet ChampBisK2;
public ::IClassA::Sequenceshort ChampBisL2;
public ::IClassA::SequenceString ChampBisM2;
public ::IClassA::SequenceUnsignedLong ChampBisN2;
public ::IClassA::SequenceUnsignedLongLong ChampBisO2;
public ::IClassA::SequenceUnsignedshort ChampBisP2;
public ::IClassA::SequenceWChar ChampBisQ2;
public ::IClassA::SequenceWString ChampBisR2;
public ::IClassA::SequenceEnu ChampBisS2;
public ::IClassA::SequenceIClassB ChampBisT2;
public ::IClassA::SequencestructS ChampBisU2;
public ::IClassA::SequenceUnionU ChampBisV2;

void AppelBisZ1();
any AppelBisA1(in any P1, inout any P2);
boolean AppelBisB1(in boolean P1, inout boolean P2);
char AppelBisC1(in char P1, inout char P2);
double AppelBisD1(in double P1, inout double P2);
fixed<6,2> AppelBisE1(in fixed<6,2> P1, inout fixed<6,2> P2);
float AppelBisF1(in float P1, inout float P2);
long AppelBisG1(in long P1, inout long P2);
long long AppelBisH1(in long long P1, inout long long P2);
long double AppelBisI1(in long double P1, inout long double P2);
Object AppelBisJ1(in Object P1, inout Object P2);
octet AppelBisK1(in octet P1, inout octet P2);
short AppelBisL1(in short P1, inout short P2);
string AppelBisM1(in string P1, inout string P2);
unsigned long AppelBisN1(in unsigned long P1, inout unsigned long P2);
unsigned long long AppelBisO1(in unsigned long long P1, inout unsigned long long P2);
unsigned short AppelBisP1(in unsigned short P1, inout unsigned short P2);
wchar AppelBisQ1(in wchar P1, inout wchar P2);
wstring AppelBisR1(in wstring P1, inout wstring P2);
Enu AppelBisS1(in Enu P1, inout Enu P2);
IClassB AppelBisT1(in IClassB P1, inout IClassB P2);
::IClassA::structS AppelBisU1(in ::IClassA::structS P1, inout ::IClassA::structS P2);
::IClassA::UnionU AppelBisV1(in ::IClassA::UnionU P1, inout ::IClassA::UnionU P2);

void AppelBisZ2();
::IClassA::SequenceAny AppelBisA2(in ::IClassA::SequenceAny P1, inout ::IClassA::SequenceAny P2);
::IClassA::SequenceBoolean AppelBisB2(in ::IClassA::SequenceBoolean P1, inout ::IClassA::SequenceBoolean P2);
::IClassA::SequenceChar AppelBisC2(in ::IClassA::SequenceChar P1, inout ::IClassA::SequenceChar P2);
::IClassA::Sequencedouble AppelBisD2(in ::IClassA::Sequencedouble P1, inout ::IClassA::Sequencedouble P2);
::IClassA::SequenceFixed AppelBisE2(in ::IClassA::SequenceFixed P1, inout ::IClassA::SequenceFixed P2);
::IClassA::SequenceFloat AppelBisF2(in ::IClassA::SequenceFloat P1, inout ::IClassA::SequenceFloat P2);
::IClassA::SequenceLong AppelBisG2(in ::IClassA::SequenceLong P1, inout ::IClassA::SequenceLong P2);
::IClassA::SequenceLongLong AppelBisH2(in ::IClassA::SequenceLongLong P1, inout ::IClassA::SequenceLongLong P2);
::IClassA::SequenceLongdouble AppelBisI2(in ::IClassA::SequenceLongdouble P1, inout ::IClassA::SequenceLongdouble P2);
::IClassA::SequenceObject AppelBisJ2(in ::IClassA::SequenceObject P1, inout ::IClassA::SequenceObject P2);
::IClassA::SequenceOctet AppelBisK2(in ::IClassA::SequenceOctet P1, inout ::IClassA::SequenceOctet P2);
::IClassA::Sequenceshort AppelBisL2(in ::IClassA::Sequenceshort P1, inout ::IClassA::Sequenceshort P2);
::IClassA::SequenceString AppelBisM2(in ::IClassA::SequenceString P1, inout ::IClassA::SequenceString P2);
::IClassA::SequenceUnsignedLong AppelBisN2(in ::IClassA::SequenceUnsignedLong P1, inout ::IClassA::SequenceUnsignedLong P2);
::IClassA::SequenceUnsignedLongLong AppelBisO2(in ::IClassA::SequenceUnsignedLongLong P1, inout ::IClassA::SequenceUnsignedLongLong P2);
::IClassA::SequenceUnsignedshort AppelBisP2(in ::IClassA::SequenceUnsignedshort P1, inout ::IClassA::SequenceUnsignedshort P2);
::IClassA::SequenceWChar AppelBisQ2(in ::IClassA::SequenceWChar P1, inout ::IClassA::SequenceWChar P2);
::IClassA::SequenceWString AppelBisR2(in ::IClassA::SequenceWString P1, inout ::IClassA::SequenceWString P2);
::IClassA::SequenceEnu AppelBisS2(in ::IClassA::SequenceEnu P1, inout ::IClassA::SequenceEnu P2);
::IClassA::SequenceIClassB AppelBisT2(in ::IClassA::SequenceIClassB P1, inout ::IClassA::SequenceIClassB P2);
::IClassA::SequencestructS AppelBisU2(in ::IClassA::SequencestructS P1, inout ::IClassA::SequencestructS P2);
::IClassA::SequenceUnionU AppelBisV2(in ::IClassA::SequenceUnionU P1, inout ::IClassA::SequenceUnionU P2);

factory constructeur();
};
#endif


Source du composant client.upl

Source Composant "Exemple De l'emploi d'Up ! Corba" Version 4.0.0;

ImporterModule
/************/
ClassB(<classab>, ImporterDefinitions);

Prive :
/*****/
Procedure EcrireStructS(L:Caractere, S:StructS)
/*********************************************/
Variable
B:Nul Ou IClassB;

Debut
Si S.ChampS1!=Nul Alors
Ecran.Ecrire(L+".ChampS1="+Caractere(S.ChampS1));
Sinon
Ecran.Ecrire(L+".ChampS1=Nul");
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
Ecran.Ecrire(L+".ChampS10="+Caractere(B.A));
Sinon
Ecran.Ecrire(L+".ChampS10=Nul");
Fin Si
Ecran.Ecrire(L+".ChampS11="+Caractere(S.ChampS11));
Ecran.Ecrire(L+".ChampS12="+Caractere(S.ChampS12));
Si S.ChampS13!=Nul Alors
Ecran.Ecrire(L+".ChampS13="+S.ChampS13);
Sinon
Ecran.Ecrire(L+".ChampS13=Nul");
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
Ecran.Ecrire(L+".ChampS20="+Caractere(S.ChampS20.A));
Sinon
Ecran.Ecrire(L+".ChampS20=Nul");
Fin Si
Fin Procedure

Procedure EcrireUnionU(L:Caractere, U:UnionU)
/*******************************************/
Variable
B:Nul Ou IClassB;

Debut
Selon U.U Faire
Cas Pour Enumere2_1 Faire
Si U.U.Cas1.ChampU1!=Nul Alors
Ecran.Ecrire(L+".ChampU1="+Caractere(U.U.Cas1.ChampU1));
Sinon
Ecran.Ecrire(L+".ChampU1=Nul");
Fin Si
Fin Cas
Cas Pour Enumere2_2 Faire
Ecran.Ecrire(L+".ChampU2="+Caractere(U.U.Cas2.ChampU2));
Fin Cas
Cas Pour Enumere2_3 Faire
Ecran.Ecrire(L+".ChampU3="+Caractere(U.U.Cas3.ChampU3));
Fin Cas
Cas Pour Enumere2_4 Faire
Ecran.Ecrire(L+".ChampU4="+Caractere(U.U.Cas4.ChampU4));
Fin Cas
Cas Pour Enumere2_5 Faire
Ecran.Ecrire(L+".ChampU5="+Caractere(U.U.Cas5.ChampU5));
Fin Cas
Cas Pour Enumere2_6 Faire
Ecran.Ecrire(L+".ChampU6="+Caractere(U.U.Cas6.ChampU6));
Fin Cas
Cas Pour Enumere2_7 Faire
Ecran.Ecrire(L+".ChampU7="+Caractere(U.U.Cas7.ChampU7));
Fin Cas
Cas Pour Enumere2_8 Faire
Ecran.Ecrire(L+".ChampU8="+Caractere(U.U.Cas8.ChampU8));
Fin Cas
Cas Pour Enumere2_9 Faire
Ecran.Ecrire(L+".ChampU9="+Caractere(U.U.Cas9.ChampU9));
Fin Cas
Cas Pour Enumere2_10 Faire
B=IClassB(U.U.Cas10.ChampU10);
Si B!=Nul Alors
Ecran.Ecrire(L+".ChampU10="+Caractere(B.A));
Sinon
Ecran.Ecrire(L+".ChampU10=Nul");
Fin Si
Fin Cas
Cas Pour Enumere2_11 Faire
Ecran.Ecrire(L+".ChampU11="+Caractere(U.U.Cas11.ChampU11));
Fin Cas
Cas Pour Enumere2_12 Faire
Ecran.Ecrire(L+".ChampU12="+Caractere(U.U.Cas12.ChampU12));
Fin Cas
Cas Pour Enumere2_13 Faire
Si U.U.Cas13.ChampU13!=Nul Alors
Ecran.Ecrire(L+".ChampU13="+U.U.Cas13.ChampU13);
Sinon
Ecran.Ecrire(L+".ChampU13=Nul");
Fin Si
Fin Cas
Cas Pour Enumere2_14 Faire
Ecran.Ecrire(L+".ChampU14="+Caractere(U.U.Cas14.ChampU14));
Fin Cas
Cas Pour Enumere2_15 Faire
Ecran.Ecrire(L+".ChampU15="+Caractere(U.U.Cas15.ChampU15));
Fin Cas
Cas Pour Enumere2_16 Faire
Ecran.Ecrire(L+".ChampU16="+Caractere(U.U.Cas16.ChampU16));
Fin Cas
Cas Pour Enumere2_17 Faire
Ecran.Ecrire(L+".ChampU17="+Caractere(U.U.Cas17.ChampU17));
Fin Cas
Cas Pour Enumere2_18 Faire
Ecran.Ecrire(L+".ChampU18="+U.U.Cas18.ChampU18);
Fin Cas
Cas Pour Enumere2_19 Faire
Ecran.Ecrire(L+".ChampU19="+Caractere(Enu(U.U.Cas19.ChampU19)));
Fin Cas
Cas Pour Enumere2_20 Faire
Si U.U.Cas20.ChampU20!=Nul Alors
Ecran.Ecrire(L+".ChampU20="+Caractere(U.U.Cas20.ChampU20.A));
Sinon
Ecran.Ecrire(L+".ChampU20=Nul");
Fin Si
Fin Cas
Fin Selon
Fin Procedure

Procedure EcrireTableau(L:Caractere, T:Tableau[?] De Nul Ou Objet)
/****************************************************************/
Variable
I:Entier;
S:Nul Ou StructS;
U:Nul Ou UnionU;

Debut
Pour I=T.BorneMin JusquA T.BorneMax Faire
Selon T[I].EstInstanceDe Faire
Cas Pour Enumere Faire
Ecran.Ecrire(L+"["+Caractere(I)+"]="+Caractere(Enumere(T[I])));
Fin Cas

Cas Pour Entier Faire
Ecran.Ecrire(L+"["+Caractere(I)+"]="+Caractere(Entier(T[I])));
Fin Cas

Cas Pour Reel Faire
Ecran.Ecrire(L+"["+Caractere(I)+"]="+Caractere(Reel(T[I])));
Fin Cas

Cas Pour Caractere Faire
Ecran.Ecrire(L+"["+Caractere(I)+"]="+Caractere(T[I]));
Fin Cas

Cas Pour IClassB Faire
Ecran.Ecrire(L+"["+Caractere(I)+"]="+Caractere(IClassB(T[I]).A));
Fin Cas

Cas Pour StructS Faire
EcrireStructS(L+"["+Caractere(I)+"]",StructS(T[I]));
Fin Cas

Cas Pour UnionU Faire
EcrireUnionU(L+"["+Caractere(I)+"]",UnionU(T[I]));
Fin Cas
Fin Selon
Fin Pour
Fin Procedure

Principal
/*******/
Variable
A : Nul Ou IClassA;
B : Nul Ou IClassB;
B2 : Nul Ou IClassB;
V : Nul Ou VTypeA;
C : Booleen;
D : Entier;
E : Reel;
F : Caractere;
G : Nul Ou Objet;
H : Enu;
S : StructS;
S2 : Nul Ou StructS;
U : UnionU;
U2 : Nul Ou UnionU;
TA1 : Tableau[3] De Nul Ou Objet;
TA2 : Tableau[3] De Nul Ou Objet;
TB1 : Tableau[3] De Nul Ou Booleen;
TB2 : Tableau[3] De Nul Ou Booleen;
TC1 : Caractere;
TC2 : Caractere;
TD1 : Tableau[3] De Nul Ou Reel;
TD2 : Tableau[3] De Nul Ou Reel;
TE1 : Tableau[3] De Nul Ou Reel;
TE2 : Tableau[3] De Nul Ou Reel;
TF1 : Tableau[3] De Nul Ou Reel;
TF2 : Tableau[3] De Nul Ou Reel;
TG1 : Tableau[3] De Nul Ou Entier;
TG2 : Tableau[3] De Nul Ou Entier;
TH1 : Tableau[3] De Nul Ou Entier;
TH2 : Tableau[3] De Nul Ou Entier;
TI1 : Tableau[3] De Nul Ou Reel;
TI2 : Tableau[3] De Nul Ou Reel;
TJ1 : Tableau[3] De Nul Ou Objet;
TJ2 : Tableau[3] De Nul Ou Objet;
TK1 : Binaire;
TK2 : Binaire;
TL1 : Tableau[3] De Nul Ou Entier;
TL2 : Tableau[3] De Nul Ou Entier;
TM1 : Tableau[3] De Nul Ou Caractere;
TM2 : Tableau[3] De Nul Ou Caractere;
TN1 : Tableau[3] De Nul Ou Entier;
TN2 : Tableau[3] De Nul Ou Entier;
TO1 : Tableau[3] De Nul Ou Entier;
TO2 : Tableau[3] De Nul Ou Entier;
TP1 : Tableau[3] De Nul Ou Entier;
TP2 : Tableau[3] De Nul Ou Entier;
TQ1 : Caractere;
TQ2 : Caractere;
TR1 : Tableau[3] De Nul Ou Caractere;
TR2 : Tableau[3] De Nul Ou Caractere;
TS1 : Tableau[3] De Nul Ou Enu;
TS2 : Tableau[3] De Nul Ou Enu;
TT1 : Tableau[3] De Nul Ou IClassB;
TT2 : Tableau[3] De Nul Ou IClassB;
TU1 : Tableau[3] De Nul Ou StructS;
TU2 : Tableau[3] De Nul Ou StructS;
TV1 : Tableau[3] De Nul Ou UnionU;
TV2 : Tableau[3] De Nul Ou UnionU;
I : Entier;