Transcript Corba

Corba
Overzicht
Corba referenties
Belangrijkste:
CORBA: Integrating Diverse Applications Within
Distributed Heterogeneous Environments (Steve
Vinoski)
(http://www.cs.wustl.edu/~schmidt/corbapapers.html)
A Detailed Comparison of CORBA, DCOM and
Java/RMI (Gopalan Suresh Raj)
(http//wwww.execpc.com/~gopalan/misc/compare.ht
ml)
Corba Sites
De referentie is http://www.corba.org/ vooral:
http://www.omg.org/technology/corba/corba3releaseinfo.htm
Een autoriteit is:
http://www.cs.wustl.edu/~schmidt/corba.html
Voor de linux gemeenschap:
http://linas.org/linux/corba.html
Een goede tutorial is
http://www.dcl.hpi.uni-potsdam.de/LV/ccm04/
En "off the road"
http://www.corbamtb.com/
Corba Bedoeling
• Op een hoog niveau van abstractie de
nodige voorzieningen treffen voor
gedistribueerde programmering
• De Object Request Broker verzorgt
transparantie van plaats, activatie en
communicatie
OMG: Object Managing Group
• Opgericht in 1989, momenteel > 800 leden.
• Object Management Architecture (OMA)
omvat als kern CORBA
• Object Model
– encapsulatie, vaste identiteit, interfaces
• Reference Model
• interface categorieën
Corba Vijf Onderdelen
•
•
•
•
•
Orb kern
Interface Definition Language
Dynamic Invocation Interface
Interface Repository
Object Adapters
Corba Versus RPC
• RPC laat toe om ingewikkelde
datastructuren over het netwerk te verdelen
• RPC ondersteunt de distributie van C++
objecten niet expliciet
• Programmeurs moeten dit dus zelf
implementeren
Corba Versus RPC
• Dit is moeilijk vanwege de verborgen pointers
naar virtuele functietabellen
• De toepassing hoeft ook de klassen niet echt te
kennen
• We hebben een methode nodig om de objecten
over het net te distribueren
• Inpakken en uitpakken leidt tot problemen met
encapsulatie en gebruik van bibliotheken
Corba Versus RMI
• RMI lost verschillende problemen van RPC op
– Het object blijft aan de serverkant functioneren
– Slechts een stub reist over het netwerk
– De klasse blijft voor de client een abstracte entiteit
waarover slechts een minimum bekend hoeft te zijn
• RMI is enkel Java
• Het hergebruiken van bestaande code is
problematisch (enkel mogelijk via de native code
interface van Java)
Corba Versus CGI e.a.
• De Common Gateway Interface laat toe om code
aan de serverkant (website) uit te voeren in
opdracht van een client (browser)
–
–
–
–
–
De programmeertaal is niet vastgelegd
De parameters worden gespecificeerd via de URL
Cfr asp
Dit is niet object georienteerd en loopt over HTTP
HTTP is toestandsloos, er is dus geen sprake van een
verbinding (kan omzeild worden)
Corba Voordelen
• Ondersteuning van legacy code in C, C++,
COBOL, SMALLTALK, …
• Java ondersteuning
• Onafhankelijkheid van een specifieke softwareboer
• Schaalbaarheid naar het aantal gebruikers toe
• Ondersteuning van een groot aantal platformen
• Een Object Georienteerd ontwikkelingsparadigma
• Veiligheid
CORBA en DCOM
• DCOM is de Microsoft oplossing voor dit
probleem
• Distributed Component Object Model
– COM (Component Object Model) geeft toegang tot alle
onderdelen van de MS applicaties
– DCOM laat toe deze applicaties over het netwerk te
raadplegen
– Probleem: 1 vendor. DCOM-CORBA bridges zijn
nodig voor andere gebruikers (vb LINUX)
Een voorbeeld
TimeServer
•
•
$
•
1 struct, 1 interface
time.idl
idl time.idl
time.hh:
struct TimeOfDay {
short hour;
short minute;
short second;
};
– #include bij client
• timeC.cc
– stub voor client
• timeS.hh, timeS.cc
Interface Time {
TimeOfDay get_gmt();
};
– #include en skeleton voor server
Server code
#include <time.h>
#include <iostream.h>
#include “timeS.hh”
class Time_impl : public virtual POA_Time {
public : virtual TimeOfDay get_gmt() throw(CORBA::SystemException);
};
TimeOfDay Time_impl::getgmt() throw(CORBA::SystemException)
{ time_t time_now = time(0);
struct tm * time_p = gmtime(&time_now);
TimeOfDay tod;
tod.hour = time_p->tm_hour;tod.minute = time_p->tm_min;
tod.second = time_p->tm_sec;
return tod;
}
Server code
int main(int argc, char * argv[]) {
try{ CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
CORBA::Object_var obj =
orb->resolve_initial_references(“RootPOA”);
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj);
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
Time_impl time_servant;
Time_var tm = time_servant._this();
CORBA::String_var str = orb->object_to_string(tm);
cout << str << endl;
orb->run();
} catch (const CORBA::Exception &) { cerr << “?” << endl; return 1}
return 0;}
Server compilatie e.d.
$ CC -c -I/opt/myORB/include timeC.cc
$ CC -c -I/opt/myORB/include timeS.cc
$ CC -c -I/opt/myORB/include myserver.cc
$ CC -o myserver timeC.o timeS.o myserver.o \
> -L/opt/myORB/lib -lorb
IOR:0000000000000000d4944443eafec902….
Client
#include <iostream.h>
#include <iomanip.h>
#inlcude “time.hh”
int main(int argc, char * argv[]){
try {
if (argc !=2) {cerr << “2!” << endl;throw 0;}
CORBA::ORB_var orb = CORBA::ORB_init(argc,argv);
CORBA::Object_var obj = obj->string_to_object(argv[1]);
if (CORBA::is_nil(obj) {cerr << “NIL!” << endl; throw 0;}
Time_var tm = Time::_narrow(obj);
if (CORBA::is_nil(tm) {cerr “not a Time reference!”<< endl; throw 0;}
TimeOfDay tod = tm->get_gmt();
cout << “Time is “ << tod.hour << ‘:’ << tot.minute << endl;
} catch (const CORBA::Exception &) {cerr “CORBA” << endl;return 1;}
catch (…) {return 1;}
return 0;}
Client compilatie e.d.
$ CC -c -I/opt/myORB/include timeC.cc
$ CC -c -I/opt/myORB/include myclient.cc
$ CC -o myserver timeC.o myclient.o \
> -L/opt/myORB/lib -lorb
$ ./myserver >/tmp/myserver.ref &
[1] 1729
$ ./myclient `cat /tmp/myserver.ref`
Time is 1:35
$ kill %1
[1] + Terminated
./myserver &
$
OMG IDL
Interface Definition Language
• OMG IDL is de fundamentele abstractie die
interfaces van hun implementaties scheidt.
• Er bestaan standaard afbeeldingen voor C,
C++, Smalltalk, COBOL, Ada, Java
• Er zijn onafhankelijke afbeeldingen voor
Modula 3, Perl, Tcl, Python, Dylan, Oberon,
Visual Basic, Objective-C.
• OMG IDL is zuiver declaratief: interfaces,
exceptions, datatypes. OMG IDL->IDL
COMPILATIE
• IDL->source files die met de applicatiecode
moeten gecombineerd worden (afhankelijk
van de ORB).
• Client executable en Server executable
kunnen overal lopen, kunnen in
verschillende talen geschreven zijn. De host
machines verschaffen de runtime omgeving.
• Twee gevallen: één ontwikkelingsomgeving
en gescheiden ontwikkelingsomgevingen
voor client en server.
Inhoud
•
•
•
•
OMG IDL
Lexicografie
Basis types
Gebruikerstypes
– Unions Arrays Sequenties Recursieve types
Interfaces User Exceptions Overerving
• Voorbeeld
Source Files
• Bestandsnamen: .idl
• Bestandsformaat: free-form
• Preprocessing: C++ preprocessor
–
–
–
–
–
#include
#define
#ifdef
#ifndef
#endif /* einde conditionele module */
• Definitievolgorde: definitie vóór gebruik
Basis Types
• De grootte van de types worden bewaard
door de afbeeldingen. De bereiken zijn niet
noodzakelijk behouden.
– Vb Java kent geen unsigned integers
– Vb geen 8 bit characters
• Er kunnen representatie omzettingen nodig
zijn of vertalingen nodig zijn
– little endian, big endian
– EBCDIC, ASCII
• Er zijn geen pointers, enkel referenties
Lexicografie
• Commentaar /* */ en // als in C++
• Sleutelwoorden in kleine letters, behalve
Object, TRUE en FALSE
• Namen: letter (a-z,A-Z) gevolgd door
letters, cijfers en onderlijning. Geen _
vooraan, geen onengelse letters. Hoofdletter
ongevoelig maar consistentie is verplicht.
– short aap; Aap = 0; // fout, inconsistent
– long giraffe; double Giraffe; // fout, ongevoelig
– long while; // ok maar niet verstandig
Gebruiker gefinieerde Types
• Andere namen: typedef semantiek
afhankelijk van de programmeertaal
– typedef short JaarType;
• Opsommingen : enum
– enum dag {maa,din,woe,don,vri,zat}
– gegarandeerd 32 bits
– geen gegarandeerde overeenkomst met int
Gebruikers Types
• Structuren
– C++ notatie
– struct Tijd {short uur;short minuut;};
– een struct vormt een eigen naamruimte
• Unions: altijd discriminerend:
union TelDagen switch(dag) {
case maa :
case din :
unsigned long num_serious;
case woe :
float discount;
default :
string no_sense;
}
Union idiomatic
union AgeOpt switch (boolean) {
case TRUE : unsigned short age;
};
Union not advised (overloading)
Struct InfoKind {text, numeric, none};
union Info switch (InfoKind) {
case text : string text;
case numeric : long index;
};
Arrays
• typedef Color ColorVector[10];
• typedef long IDTable[10][20];
• Always use typedef
• Geen niet gedimensioneerde tabellen
• Indexbereik is niet gespecifieerd!
Sequences
• typedef sequence<Color> Colors;
• typedef sequence<long, 100> Numbers;
– (hoogstens 100 getallen)
• typedef sequence<Numbers>;
– (lijst lijsten van hoogstens 100 getallen)
• typedef sequence<sequence<long> >;
– lijst lijsten van long, gebruikt anonieme
variabele=>niet onproblematisch, te vermijden.
Sequences/Arrays
• Matrix als een array:
Performantie!
typedef
long M[100][100];
interface MProc {
M invert(in M m);
};
• Matrix als een sequentie:
sparse
struct NZ {
unsigned short r;
unsigned short c;
long val;};
typedef sequence<NZ> M;
interface MProc {
M invert(in M m);
};
Recursieve types
• Structures:
struct Node {
long value;
sequence<Node> children;};
• Unions:
enum OpType {O_AND, O_OR, O_NOT};
enum NodeSoort {BLAD,UNAIR,BINAIR};
union Node switch(NodeSoort) {
case BLAD:
long val;
Recursieve types
case UNAIR:
struct UnaireOp {
OpType op;
sequence<Node,1> kind;
} u_op;
case BINAIR:
struct BinaireOp {
OpType op;
sequence<Node,2> kinderen;
} bin_op;
};
Recursieve Types
• In kwade en in goede tijden:
– de sequence<Node, 1> constructie maakt het
systeem type veiliger, maar voorkomt niet dat
een unaire knoop 0 kinderen heeft
– een unaire knoop kan een binaire operator
hebben
– O_AND is veiliger dan AND omdat dit in veel
programmeertalen een sleutelwoord is
• Multilevel recursie is ok, wel problemen
met mutueel recursieve structuren.
Interfaces
Interface ThermoStat {
short get_temp();
short set_temp(in short new_temp);
};
• Geen publiek deel, geen lidvelden
• Perfecte scheiding van implementatie en
interface
• de kleinste korrel in CORBA
Interface Semantiek
•
•
•
•
Interface namen zijn typenamen
Interfaces kunnen doorgegeven worden
Object referenties zijn instance pointers in C++
Object referenties kunnen buiten de adresruimte
wijzen
• Nil referenties zijn mogelijk, kunnen als een “geen
resultaat” of “geen parameter” indicatie gebruikt
worden
• IDL verzekert type overeenkomst
Operaties
•
•
•
•
Verplicht return type, eventueel void
return en parameters: nooit anonyme types
Geen overloading
Alle parameters hebben een richting
– in, out, inout
• De richting verhoogt de efficiëntie
• De richting bepaalt de veantwoordelijkheid
voor geheugenmanagement
• Constante operaties bestaan niet (CORBA
Security Service is een alternatief)
Operaties, voorbeelden
interface vbdn {
op();
// Fout
void op();
// OK
typedef unsigned long prime;
prime next_prime(in long n);
prime next_prime(in long n,out prime p); //Fout
void next_prime2(in long n, out prime p); //~OK
sequence<long> get_longs(); //Fout
SomeType read_value() const; //Fout
};
User Exceptions
•
•
•
•
Syntax ~ structures, niet genest
Vormen een namespace
Kunnen niet als dataleden gebruikt worden
Gebruik “raises” om aan te geven dat een
fout gegenereerd kan worden (verplicht)
interface Unrel { void can_fail() raises(Failed);
void can_also_fail(in long l)
raises(Failed,RangeError); }
• Geen overerving voor exceptions
Exceptions, Voorbeelden
• exception Failed {};
• exception RangeError {
unsigned long supplied;
unsigned long min_val;
unsigned long max_val;
};
• struct ErrorRep {
Object obj; RangeError exc; // Fout
}
System Exceptions: een lijst
enum completion_status {
COMPLETED_YES, COMPLETED_NO,
COMPLETED_MAYBE
};
#define SYSEX(NAME) exception NAME {\
unsigned long minor; \
completion_status completed; \
}
Attributes
interface Thermostat {
readonly attribute short temperature;
attribute short nominal_temp;
};
• Semantisch equivalent met
interface Thermostat {
short get_temperature();
short get_nominal_temp();
void set_nominal_temp();
};
Attributes
• Attributen zijn dus geen variabelen, geen
geheugentoekenning
• Problemen met attributen:
– geen raises-clausule toegelaten
– terugvallen op system exceptions is
twijfelachtig, het minor attribuut is niet
noodzakelijk bewaard door de ORB
• Beperk het gebruik in elk geval tot
read_only, of gebruik ze niet
Interface versus Implementatie
• Overerving in IDL betreft enkel de
interface!
• Implementatie kan via
– C++ implementatie overerving
– delegatie in dezelfde adresruimte
– totaal gescheiden implementatie in dezelfde
adresruimte
– delegatie over adresruimtegrens
– gescheiden implementatie in verschillende
adresruimten
Herdefinitie en Regels
• Constanten, types en excepties mogen
opnieuw gedefinieerd worden in de ervende
interface (verwarrend, te vermijden)
• Attributen en operaties mogen niet opnieuw
gedefinieerd worden
• Overloading is ook in de ervende klasse niet
toegestaan
• Meervoudige overerving is toegelaten, (mits
de namen niet dubbel voorkomen!) met
minder problemen dan C++ (interface)
Meervoudige overerving,
voorbeelden
Interface Sensor {…};
interface Thermometer : Sensor {… };
interface Hygrometer : Sensor { … };
interface HygroTherm : Thermometer, Hygrometer
{… };
• Dit is in orde, op voorwaarde dat Thermometer en
Hygrometer geen namen voor attributen of
operaties delen (types zijn toegelaten!)
• De vraag of van “Sensor” één of twee exemplaren
aanwezig zijn in HygroTherm is een
implementatiekwestie.
Corba Voorbeeld Van Toepassing
http://www.ebi.ac.uk/xembl/
http://corba.ebi.ac.uk/
http://industry.ebi.ac.uk/applab/
http://corba.ebi.ac.uk/EMBL_embl.html
Naming Service
IDLs for the CORBA Server
Een reference
Een IDL voorbeeld
Verder Voorbeeld
Voorbeeld: climatisatiesysteem
Zie bijlagen
•
•
•
•
•
Afbeelding IDL naar C++
Intuïtief, gemakkelijk te gebruiken
Aanvoelen als normale C++ programmatuur
Typeveilig
Efficiënt in geheugengebruik en cycly
OK voor verschillende geheugenarchitecturen
• Reentrant, goed voor thread toepassingen
• Plaatsonafhankelijkheid
• Beste compromis, met voorrang voor
efficiëntie over gebruiksgemak
Enige regels
• Identifiers blijven normaal behouden
– if -> _cxx_if
• Modules worden “namespaces”
• De CORBA module: “namespace” in C++,
bevat standaard IDL types en interfaces
• Basis types zijn beschikbaar voor
overloading, behalve Boolean, Octet, Wchar
• (w)strings worden op (W)char * afgebeeld.
Allocatie moet gebeuren met speciale
functies
Afbeeldingstabel
Overdraagbare geheugenallocatie
namespace CORBA {
// do not use new[] en delete[]
static char * string_alloc(Ulong len);
static char * string_dup(const char *);
static void string_free(char *);
static WChar * wstring_alloc(Ulong len);
static WChar * wstring_dup(const WChar *);
static void wstring_free(WChar *);
//…
}
Types van variabele lengte
• Voor types van variabele lengte zijn er twee
mogelijkheden:
– raw: doe als programmeur alle geheugenbeheer
zelf. Dit is de oude C-programmeerstijl, met
een onderscheid tussen types van variabele en
vaste lengte.
– Gebruik slimme pointer types, _var, die de
deallocatie van het geheugen voor u doen. Vaste
en variabele lengte krijgen een uniforme
behandeling.
_var types
• Voorbeeld
– Schrijf een C-functie die een string van een I/O
apparaat leest en teruggeeft als resultaat. De
lengte van de string is niet beperkt, en kan niet
bepaald worden op voorhand.
• Oplossingen
–
–
–
–
static buffer
static pointer naar dynamisch geheugen
geheugen meegegeven door de oproeper
een pointer naar dynamisch geheugen als
return
_var types
• Van elke klasse van variabele grootte wordt
een basis C++ type (raw) en een wrapper
klasse gedefinieerd (automatisch):
_var types, voorbeeld
class String_var {
public:
String_var();
// s = 0
String_var(char * p); // s = p, zal string_free uitvoeren op p
String_var(const char * p); // s = string_dup(p), free op s
String_var(const String_var & s);//deep copy
~String_var(); //destructor, voert string_free(s) uit
String_var operator=(char * p); // s = p,
String_var operator=(const char * p); // s = string_dup(p)
String_var operator=(const String_var & s);//deep copy
_var types, class String_var
operator char *(); // conversie tot char *
operator const char *() const; // conversie tot const char *
/* voorbeeld
CORBA::String_var s;
s = get_string(); // string_alloc, s eigenaar
size_t len = strlen(s); // Ok, conversie
*/
operator char * &(); // vb in void update(char * &);(realloc)
char & operator[](ULong);
char operator[](ULong) const; // gebruik een_string[3]
Valkuilen in String_var
CORBA::String_var s1(“Hall”); // slecht in non ANSI C++
CORBA::String_var s2 = “Hall”; // idem!
CORBA::String_var s3;
s3 = “Hall”; // idem, nu met toekenningsoperator
oplossingen:
CORBA::String_var s1((const char *) “Hall”);
CORBA::String_var s2 =(CORBA::string_dup(“Hall”));
CORBA::String_var s3;
s3 = (const char *) “Hall”;
een toekenning aan een pointer geeft een wijzer naar
inwendig geheugen in de string, let dus op met
char * p = s1;
Performantie bij lees toegang
void print_string(CORBA::String_var s)
{
cout << “String is \”” << s << “\”” << endl;
}
// gaat tot 10 functie-oproepen, inclusief new en delete
void print_string(const char * s)
{
cout << “String is \”” << s << “\”” << endl;
}
// gebruikt automatische conversie, met inline code
Voorbeeld: Climakontrole
• Thermometers en thermostaten in een eigen
netwerk
• Uitgerust met geheugen dat kan uitgelezen
worden via meegeleverde software
• Centrale controle via een monitor op het
bedrijfsnetwerk
Thermometers
• Asset
– uniek nummer, vast aan het toestel, is het adres
binnen het eigen netwerk
• Model
– bepaalt karakteristiek, string, read-only
• Location
– de plaats waar de thermometer staat, wordt
ingesteld
Thermostaten
• Hebben de eigenschappen van
thermometers
• Worden even uniek genummerd via de asset
• Laten het instellen van de gewenste
temperatuur binnen bepaalde grenzen toe
De monitor
• Lijst van de toestellen
• Relatief (delta) instellen van de gewenste
temperaturen voor de termostaten
– bij een instelling buiten de grenzen blijft de
oorspronkelijke instelling behouden, de
thermostaat genereert een foutboodschap
IDL
• Thermometer
– Gebruik van typedef voor de attributen
– Gebruik van (readonly) attributen
• Thermostaat
– Gebruik van functies
– Definitie van de exception “BadTemp”
• de struct BtData helpt omdat een exception niet als
veld van een struct kan gebruikt worden
IDL
• Controller
– Gebruik van een polymorfe lijst van
thermometers
– Definitie van een operatie change op een lijst
van thermostaten
– Specifieke foutmelding via een lijst (Echange)
– een find operatie via een lijst van
zoekopdrachten, overloading via een enum
Definitie van een client voor het
climasysteem
• De mapping voor de clients is uitgebreid
• Voor eenvoudige clients is mits het gebruik
van _var klassen veel complexiteit
verborgen
• Geheugenbeheer gebeurt ongeveer
automatisch
• Bekijk het voorbeeld
Globale structuur
• Try-catch blok in main
– return van generische CORBA::Exception
– return via willekeurige, niet opgevangen
Exceptions
• Belangrijk via main terug te keren, niet via
exit.
Include Files
• <iostream.h>…
• ccs.hh
– resultaat van de idl compiler
– naamgeving is niet gestandaardiseerd
• oplossing via conditionele compilatie
• via parameters voor de compiler
Helper functies: toesteldetails
• Maak een “ostream inserter” voor
CCS::Thermometer_ptr variabelen
– dit laat meteen _var variabelen toe
(automatische typeconversie)
• Controle op is_nil voor de pointer
• Dynamische typecontrole via _narrow
– maakt een kopie indien mogelijk!
– maakt een gedifferentieerde afdruk mogelijk
IDL: Error Exception informatie
• Wordt straks bewust gebruikt
• Het BtData type laat een ostream-inserter
toe
• EChange is een lijst, wordt ook via een
ostream inserter afgedrukt
• De functie set_temp probeert een nieuwe
temperatuur op een thermostaat in te stellen
Main
• Initialisatie
– argc en argv worden doorgegeven aan
CORBA::orb_init. Deze zal de strings in argv
onderzoeken naar parameters -ORB… die als
parameters voor de orb geïnterpreteerd worden,
en uit de lijst verdwijnen
– ‘orb’ is een pseudo-referentie, gespecifieerd in
de CORBA module via PIDL (Pseudo-IDL)
Main
• Initialisatie, vervolg
– de client verwacht de object referentie op de
commandolijn (primitieve methode, wordt later
vervangen door dynamische bootstrap)
– eerst wordt de string omgezet naar een object
referentie (is_nil duidt enkel op een nilreferentie op de commandolijn)
– vervolgens wordt het object via _narrow
dynamisch geconverteerd naar het gewenste
type
Main
• Elke interactie met de ORB kan fouten
opleveren. Deze worden door de hoofdlus
opgevangen
– bijvoorbeeld: een syntax fout in de objectreferentie-string
• Interactie met de server
– is transparant via de object referenties
– gebruikt voortdurent _var par’s voor de
variabelen van wisselende grootte
De Server
• Een servant voor elk CORBA object
– controller
– elk toestel
– transient: bij het afsluiten wordt alle informatie
(instellingen, assets, modellen, locaties, ...)
vergeten
– de verzameling toestellen ligt vast, wordt niet
door de clienten beïnvloed
Instrument Controle via de eigen
API
• ICP: Intstrument Controle Protocol
#ifndef _ICP_H
#define _ICP_H
extern “C” {
int ICP_online(unsigned long id); // voegtoe
int ICP_offline(unsigned long id); // verwijder
int ICP_get(unsigned long id, const char * attr,
void * value, size_t len);
int ICP_set(unsigned long id, const char * attr,
const void * value);
};}
#endif
The Thermometer Servant Class
Class Thermometer_impl : public virtual POA_CCS::Thermometer
{ //...
public :
virtual CCS::ModelType model() throw(CORBA::SystemEx…
virtual CCS::AssetType asset_num() throw(CORBA::System…
virtual CCS::TempType temperature() throw(CORBA::Syste…
virtual CCS::LocType location() throw(CORBA::SystemExc…
virtual void location(const char ¨loc) throw(CORBA::System…
};
The Thermometer Extended
Thermometer_impl(CCS::AssetType, const char * loc);
virtual ~Thermometer_impl();
static Controller_impl * m_ctrl;
protected:
CCS::AssetType m_anum;
private:
CCS::ModelType get_model();
CCS::TempType get_temp();
CCS::LocType get_loc();
void set_loc(const char *);
Thermometer_impl(const Thermometer_impl &);
void operator=(const Thermometer_impl &);
Implementatie, voorbeelden
CCS::ModelType Thermometer_impl::get_model() {
char buf[32];
assert(ICP_get(m_anum,”model”,buf,sizeof(buf)) == 0);
return CORBA::string_dup(buf);
}
CCS::TempType Thermometer_impl::get_temp() {
short temp;
assert(ICP_get(m_anum,”temperature”,&temp,sizeof(temp))==0);
return temp;
}
IDL Operaties, voorbeelden
CCS::ModelType Thermometer_impl::model()
throw(CORBA::SystemException) {
return get_model();
}
CCS::LocType Thermometer_impl::location()
throw(CORBA::SystemException){
return get_loc();
}
Voorbeelden van toepassingen
• Hierarchisch controlesysteem voor grote
structuren (bruggen, torens, …)
• Grid computing http://www.globus.org/ en
http://www.globus.org/cog/documentation/p
apers/corba-cog.pdf
• …