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

Commande de compilation

• Dans le menu Project - Add Existing Item de Visual C++, il faut ajouter la bibliothèque ${UPS_HOME}/upscrb/upscrb/upsvtm_sc.lib pour que les méthodes statiques des classes soient disponibles.
• Dans le menu Project - Properties de Visual C++, il faut spécifier que l'alignement des structures est de quatre octets via l'option de compilation /ZP4.

Commande d'enregistrement des objets Corba

Commande d'exécution

Remarque

Fichiers sources

Source du module

Source du composant

Source Composant "Exemple d'emploi de l'adaptateur Corba" Version 4.0.0 RattacherA "c:/up/exemples/libf.upl";

Enumere
/*****/
Public :
A1 Dans (ValA1, ValA2, ValA3);
Prive :
B2 Dans (ValB1, ValB2);
Entrepot
/*******/
Public :
MonEntrepot;
Public :
/*****/
Type C1 Defaut
/************/
Public :
/******/
CA1 : Booleen;
CB1 : Nul Ou Booleen;
CC1 : Entier;
CD1 : Nul Ou Entier;
CE1 : Reel;
CF1 : Nul Ou Reel;
CG1 : Caractere;
CH1 : Nul Ou Caractere;
CA1V : Booleen Virtuel;
CB1V : Nul Ou Booleen Virtuel;
CC1V : Entier Virtuel;
CD1V : Nul Ou Entier Virtuel;
CE1V : Reel Virtuel;
CF1V : Nul Ou Reel Virtuel; CG1V : Caractere Virtuel;
CH1V : Nul Ou Caractere Virtuel;
Prive :
/******/
CA2 : Booleen;
CB2 : Nul Ou Booleen;
CC2 : Entier;
CD2 : Nul Ou Entier;
CE2 : Reel;
CF2 : Nul Ou Reel;
CG2 : Caractere;
CH2 : Nul Ou Caractere;
Public :
/******/
Constructeur();
Procedure Ecrire1(Prm : Nul Ou Booleen);
Procedure Ecrire2(Prm : Nul Ou Entier);
Procedure Ecrire3(Prm : Nul Ou Reel);
Procedure Ecrire3(Prm : Nul Ou Caractere);
Fin Type

Type C2 Defaut
/************/
CA1 : Entier;
Fin Type

Variable
/******/
Public :
/******/
VA1 : Booleen;
VB1 : Nul Ou Booleen;
VC1 : Entier;
VD1 : Nul Ou Entier;
VE1 : Reel;
VF1 : Nul Ou Reel;
VG1 : Caractere;
VH1 : Nul Ou Caractere;
VA1V : Booleen Virtuel;
VB1V : Nul Ou Booleen Virtuel;
VC1V : Entier Virtuel;
VD1V : Nul Ou Entier Virtuel;
VE1V : Reel Virtuel;
VF1V : Nul Ou Reel Virtuel;
VG1V : Caractere Virtuel;
VH1V : Nul Ou Caractere Virtuel;
Prive :
/******/
VA2 : Booleen;
VB2 : Nul Ou Booleen;
VC2 : Entier;
VD2 : Nul Ou Entier;
VE2 : Reel;
VF2 : Nul Ou Reel;
VG2 : Caractere;
VH2 : Nul Ou Caractere;
Exception
/*******/
Public :
/******/
E1(1, TransactionInchangee);
Prive :
/*****/
E2(2, TransactionInchangee);
Public :
Procedure C1.CA1V(P : Booleen)
/**************************/
Debut
CA2=P;
Fin Procedure

Fonction C1.CA1V() Retourner Booleen
/**********************************/
Debut
Retourner CA2;
Fin Fonction

Procedure C1.CB1V(P : Nul Ou Booleen)
/*********************************/
Debut
CB2=P;
Fin Procedure

Fonction C1.CB1V() Retourner Nul Ou Booleen
/*****************************************/
Debut
Retourner CB2;
Fin Fonction

Procedure C1.CC1V(P : Entier)
/*************************/
Debut
CC2=P;
Fin Procedure

Fonction C1.CC1V() Retourner Entier
/*********************************/
Debut
Retourner CC2;
Fin Fonction

Procedure C1.CD1V(P : Nul Ou Entier)
/********************************/
Debut
CD2=P;
Fin Procedure

Fonction C1.CD1V() Retourner Nul Ou Entier
/****************************************/
Debut
Retourner CD2;
Fin Fonction

Procedure C1.CE1V(P : Reel)
/***********************/
Debut
CE2=P;
Fin Procedure

Fonction C1.CE1V() Retourner Reel
/*******************************/
Debut
Retourner CE2;
Fin Fonction

Procedure C1.CF1V(P : Nul Ou Reel)
/******************************/
Debut
CF2=P;
Fin Procedure

Fonction C1.CF1V() Retourner Nul Ou Reel
/**************************************/
Debut
Retourner CF2;
Fin Fonction

Procedure C1.CG1V(P : Caractere)
/****************************/
Debut
CG2=P;
Fin Procedure

Fonction C1.CG1V() Retourner Caractere
/************************************/
Debut
Retourner CG2;
Fin Fonction

Procedure C1.CH1V(P : Nul Ou Caractere)
/***********************************/
Debut
CH2=P;
Fin Procedure

Fonction C1.CH1V() Retourner Nul Ou Caractere
/*******************************************/
Debut
Retourner CH2;
Fin Fonction

Procedure C1.Ecrire1(Prm : Nul Ou Booleen)
/**************************************/
Debut
Ecran.Ecrire(Prm);
Fin Procedure

Procedure C1.Ecrire2(Prm : Nul Ou Entier)
/*************************************/
Debut
Ecran.Ecrire(Prm);
Fin Procedure

Procedure C1.Ecrire3(Prm : Nul Ou Reel)
/***********************************/
Debut
Ecran.Ecrire(Prm);
Fin Procedure

Procedure C1.Ecrire3(Prm : Nul Ou Caractere)
/****************************************/
Debut
Ecran.Ecrire(Prm);
Fin Procedure

Procedure VA1V(P : Booleen)
/***********************/
Debut
VA2=P;
Fin Procedure

Fonction VA1V() Retourner Booleen
/*******************************/
Debut
Retourner VA2;
Fin Fonction

Procedure VB1V(P : Nul Ou Booleen)
/******************************/
Debut
VB2=P;
Fin Procedure

Fonction VB1V() Retourner Nul Ou Booleen
/**************************************/
Debut
Retourner VB2;
Fin Fonction

Procedure VC1V(P : Entier)
/**********************/
Debut
VC2=P;
Fin Procedure

Fonction VC1V() Retourner Entier
/******************************/
Debut
Retourner VC2;
Fin Fonction

Procedure VD1V(P : Nul Ou Entier)
/*****************************/
Debut
VD2=P;
Fin Procedure

Fonction VD1V() Retourner Nul Ou Entier
/*************************************/
Debut
Retourner VD2;
Fin Fonction

Procedure VE1V(P : Reel)
/********************/
Debut
VE2=P;
Fin Procedure

Fonction VE1V() Retourner Reel
/****************************/
Debut
Retourner VE2;
Fin Fonction

Procedure VF1V(P : Nul Ou Reel)
/***************************/
Debut
VF2=P;
Fin Procedure

Fonction VF1V() Retourner Nul Ou Reel
/***********************************/
Debut
Retourner VF2;
Fin Fonction

Procedure VG1V(P : Caractere)
/*************************/
Debut
VG2=P;
Fin Procedure

Fonction VG1V() Retourner Caractere
/*********************************/
Debut
Retourner VG2;
Fin Fonction

Procedure VH1V(P : Nul Ou Caractere)
/********************************/
Debut
VH2=P;
Fin Procedure

Fonction VH1V() Retourner Nul Ou Caractere
/****************************************/
Debut
Retourner VH2;
Fin Fonction

Procedure Appel1()
/****************/
Debut
Ecran.Ecrire("Appel1();");
Fin Procedure

Procedure Appel2(Prm1 : Booleen, Prm2 : Entier, Prm3 : Reel, Prm4 : Caractere Entree Sortie)
/**********************************************************************************/
Debut
Ecran.Ecrire(Appel2(+Caractere(Prm1)+","+Caractere(Prm2)+","+Caractere(Prm3)+","+Prm4+);");
Prm4="hello Appel2";
Fin Procedure

Fonction Appel3() Retourner Booleen
/*********************************/
Debut
Ecran.Ecrire("Appel3();");
Retourner Vrai;
Fin Fonction

Fonction Appel4(Prm1 : Booleen, Prm2 : Entier, Prm3 : Reel, Prm4 : Caractere Entree Sortie) Retourner Booleen
/***************************************************************************************************/
Debut
Ecran.Ecrire(Appel4(+Caractere(Prm1)+","+Caractere(Prm2)+","+Caractere(Prm3)+","+Prm4+);");
Prm4="hello Appel4";
Retourner Vrai;
Fin Fonction

Fonction Appel5() Retourner Entier
/********************************/
Debut
Ecran.Ecrire("Appel5();");
Retourner 10;
Fin Fonction

Fonction Appel6(Prm1 : Booleen, Prm2 : Entier, Prm3 : Reel, Prm4 : Caractere Entree Sortie) Retourner Entier
/**************************************************************************************************/
Debut
Ecran.Ecrire(Appel6(+Caractere(Prm1)+","+Caractere(Prm2)+","+Caractere(Prm3)+","+Prm4+);");
Prm4="hello Appel6";
Retourner 10;
Fin Fonction

Fonction Appel7() Retourner Reel
/******************************/
Debut
Ecran.Ecrire("Appel7();");
Retourner 11.11;
Fin Fonction

Fonction Appel8(Prm1 : Booleen, Prm2 : Entier, Prm3 : Reel, Prm4 : Caractere Entree Sortie) Retourner Reel
/************************************************************************************************/
Debut
Ecran.Ecrire(Appel8(+Caractere(Prm1)+","+Caractere(Prm2)+","+Caractere(Prm3)+","+Prm4+);");
Prm4="hello Appel8";
Retourner 11.11;
Fin Fonction

Fonction Appel9() Retourner Caractere
/***********************************/
Debut
Ecran.Ecrire("Appel9();");
Retourner "schuss";
Fin Fonction

Fonction Appel10(Prm1 : Booleen, Prm2 : Entier, Prm3 : Reel, Prm4 : Caractere Entree Sortie) Retourner Caractere
/******************************************************************************************************/
Debut
Ecran.Ecrire(Appel10(+Caractere(Prm1)+","+Caractere(Prm2)+","+Caractere(Prm3)+","+Prm4+);");
Prm4="hello Appel10";
Retourner "schuss";
Fin Fonction

Source C++

#include <CORBA.h>
#include <mico/string.h>
#include <upskrn.hh>
#include <upscrbexception.h>

using namespace std;

static CORBA::ORB *pOrb;
static CORBA::BOA *pBoa;
static CORBA::Object *pObjet;
static IUpsKrn *pIUpsKrn;
static Ilibf *pILibF;

/****************************************************************/
int main(int argc, char *argv[])
/****************************************************************/
{
IlibfC1_var VC1;
IUpsKrnCaractere_ptr C;

pOrb=CORBA::ORB_init(argc,argv,"mico-local-orb");
if (!pOrb)
return(1);
pBoa=pOrb->BOA_init(argc, argv, "mico-local-boa");
if (!pBoa)
return(1);
pObjet=pOrb->bind("IDL:IUpsKrn:1.0");
if (!pObjet)
return(1);
pIUpsKrn=IUpsKrn::_narrow(pObjet);
if (!pIUpsKrn)
return(1);
pObjet=pOrb->bind("IDL:Ilibf:1.0");
if (!pObjet)
return(1);
pILibF=Ilibf::_narrow(pObjet);
if (!pILibF)
return(1);
try
{
VC1=pILibF->C11();
VC1->CA1(TRUE);
if (VC1->CA1())
cout << "VC1.CA1=True" << endl;
else
cout << "VC1.CA1=False" << endl;
VC1->CB1(pIUpsKrn->CorbaBoolean2Booleen(TRUE));
if (pIUpsKrn->Booleen2CorbaBoolean(VC1->CB1()))
cout << "VC1.CB1=True" << endl;
else
cout << "VC1.CB1=False" << endl;
VC1->CC1(2);
cout << "VC1.CC1=" << VC1->CC1()<< endl;
VC1->CD1(pIUpsKrn->CorbaLong2Entier(2));
cout << "VC1.CD1=" << pIUpsKrn->Entier2CorbaLong(VC1->CD1())<< endl;
VC1->CE1(3.2);
cout << "VC1.CE1=" << VC1->CE1()<< endl;
VC1->CF1(pIUpsKrn->CorbaDouble2Reel(3.2));
cout << "VC1.CF1=" << pIUpsKrn->Reel2CorbaDouble(VC1->CF1())<< endl;
VC1->CG1(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VC1.CG1=" << pIUpsKrn->Caractere2CorbaString(VC1->CG1())<< endl;
VC1->CH1(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VC1.CH1=" << pIUpsKrn->Caractere2CorbaString(VC1->CH1())<< endl;

VC1->CA1V(TRUE);
if (VC1->CA1V())
cout << "VC1.CA1V=True" << endl;
else
cout << "VC1.CA1V=False" << endl;
VC1->CB1V(pIUpsKrn->CorbaBoolean2Booleen(TRUE));
if (pIUpsKrn->Booleen2CorbaBoolean(VC1->CB1V()))
cout << "VC1.CB1V=True" << endl;
else
cout << "VC1.CB1V=False" << endl;
VC1->CC1V(2);
cout << "VC1.CC1V=" << VC1->CC1V()<< endl;
VC1->CD1V(pIUpsKrn->CorbaLong2Entier(2));
cout << "VC1.CD1V=" << pIUpsKrn->Entier2CorbaLong(VC1->CD1V())<< endl;
VC1->CE1V(3.2);
cout << "VC1.CE1V=" << VC1->CE1V()<< endl;
VC1->CF1V(pIUpsKrn->CorbaDouble2Reel(3.2));
cout << "VC1.CF1V=" << pIUpsKrn->Reel2CorbaDouble(VC1->CF1V())<< endl;
VC1->CG1V(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VC1.CG1V=" << pIUpsKrn->Caractere2CorbaString(VC1->CG1V())<< endl;
VC1->CH1V(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VC1.CH1V=" << pIUpsKrn->Caractere2CorbaString(VC1->CH1V())<< endl;

VC1->Ecrire1(pIUpsKrn->CorbaBoolean2Booleen(TRUE));
VC1->Ecrire2(pIUpsKrn->CorbaLong2Entier(2));
VC1->Ecrire3(pIUpsKrn->CorbaDouble2Reel(3.2));
VC1->Ecrire32(pIUpsKrn->CorbaString2Caractere("coucou"));

pILibF->VA1(TRUE);
if (pILibF->VA1())
cout << "VA1=True" << endl;
else
cout << "VA1=False" << endl;
pILibF->VB1(pIUpsKrn->CorbaBoolean2Booleen(TRUE)); if (pIUpsKrn->Booleen2CorbaBoolean(pILibF->VB1()))
cout << "VB1=True" << endl;
else
cout << "VB1=False" << endl;
pILibF->VC1(2);
cout << "VC1=" << pILibF->VC1()<< endl;
pILibF->VD1(pIUpsKrn->CorbaLong2Entier(2));
cout << "VD1=" << pIUpsKrn->Entier2CorbaLong(pILibF->VD1())<< endl;
pILibF->VE1(3.2);
cout << "VE1=" << pILibF->VE1()<< endl;
pILibF->VF1(pIUpsKrn->CorbaDouble2Reel(3.2));
cout << "VF1=" << pIUpsKrn->Reel2CorbaDouble(pILibF->VF1())<< endl;
pILibF->VG1(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VG1=" << pIUpsKrn->Caractere2CorbaString(pILibF->VG1())<< endl;
pILibF->VH1(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VH1=" << pIUpsKrn->Caractere2CorbaString(pILibF->VH1())<< endl;

pILibF->VA1V(TRUE);
if (pILibF->VA1V())
cout << "VA1V=True" << endl;
else
cout << "VA1V=False" << endl;
pILibF->VB1V(pIUpsKrn->CorbaBoolean2Booleen(TRUE));
if (pIUpsKrn->Booleen2CorbaBoolean(pILibF->VB1V()))
cout << "VB1V=True" << endl;
else
cout << "VB1V=False" << endl;
pILibF->VC1V(2);
cout << "VC1V=" << pILibF->VC1V()<< endl;
pILibF->VD1V(pIUpsKrn->CorbaLong2Entier(2));
cout << "VD1V=" << pIUpsKrn->Entier2CorbaLong(pILibF->VD1V())<< endl;
pILibF->VE1V(3.2);
cout << "VE1V=" << pILibF->VE1V()<< endl;
pILibF->VF1V(pIUpsKrn->CorbaDouble2Reel(3.2));
cout << "VF1V=" << pIUpsKrn->Reel2CorbaDouble(pILibF->VF1V())<< endl;
pILibF->VG1V(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VG1V=" << pIUpsKrn->Caractere2CorbaString(pILibF->VG1V())<< endl;
pILibF->VH1V(pIUpsKrn->CorbaString2Caractere("coucou"));
cout << "VH1V=" << pIUpsKrn->Caractere2CorbaString(pILibF->VH1V())<< endl;

pILibF->Appel1();
C= (IUpsKrnCaractere*)pIUpsKrn->ObjetNul();
pILibF->Appel2(TRUE, 2, 3.2, C);
cout << pIUpsKrn->Caractere2CorbaString(C)<< endl;
if (pILibF->Appel3())
cout << "Appel3=True" << endl;
else
cout << "Appel3=False" << endl;
C= (IUpsKrnCaractere*)pIUpsKrn->ObjetNul();
if (pILibF->Appel4(TRUE, 2, 3.2, C))
cout << "Appel4=True" << endl;
else
cout << "Appel4=False" << endl;
cout << pIUpsKrn->Caractere2CorbaString(C)<< endl;
cout << "Appel5=" << pILibF->Appel5()<< endl;
C= (IUpsKrnCaractere*)pIUpsKrn->ObjetNul();
cout << "Appel6=" << pILibF->Appel6(TRUE,2, 3.2, C) << endl;
cout << pIUpsKrn->Caractere2CorbaString(C)<< endl;
cout << "Appel7=" << pILibF->Appel7()<< endl;
C= (IUpsKrnCaractere*)pIUpsKrn->ObjetNul();
cout << "Appel8=" << pILibF->Appel8(TRUE,2, 3.2, C) << endl;
cout << pIUpsKrn->Caractere2CorbaString(C)<< endl;
cout << "Appel9=" << pIUpsKrn->Caractere2CorbaString(pILibF->Appel9())<< endl;
C= (IUpsKrnCaractere*)pIUpsKrn->ObjetNul();
cout << "Appel10=" << pIUpsKrn->Caractere2CorbaString(pILibF->Appel10(TRUE,2, 3.2, C)) << endl;
cout << pIUpsKrn->Caractere2CorbaString(C)<< endl;
C=NULL;
}
catch (UpsCrbException *E)
{
cout << Erreur UpsKrn-0 : L'exception suivante a été envoyée dans le source '" << E->NomSourceEnErreur<< "' :" << endl;
cout << E->MessageErreur<< endl;
return(1);
}
catch (CORBA::Exception &e)
{
cout << "Erreur Mico : L'exception suivante a été envoyée :" << endl;
cout << e << endl;
return(1);
}

VC1=NULL;
C=NULL;
CORBA::release(pILibF);
pILibF=NULL;
CORBA::release(pIUpsKrn);
pIUpsKrn=NULL;
delete pBoa;
delete pOrb;
return(0);
}