corba overzicht. corba referenties belangrijkste: corba: integrating diverse applications within...
TRANSCRIPT
Corba
Overzicht
Corba referenties
Belangrijkste:CORBA: Integrating Diverse Applications Within
Distributed Heterogeneous Environments (Steve Vinoski)
(http://www.cs.wustl.edu/~schmidt/corba-papers.html)
A Detailed Comparison of CORBA, DCOM and Java/RMI (Gopalan Suresh Raj)
(http//wwww.execpc.com/~gopalan/misc/compare.html)
Corba SitesDe 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.htmlVoor de linux gemeenschap:http://linas.org/linux/corba.htmlEen goede tutorial ishttp://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 software-
boer• 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 voorbeeldTimeServer
• 1 struct, 1 interface• time.idl$ idl time.idl• time.hh:
– #include bij client
• timeC.cc– stub voor client
• timeS.hh, timeS.cc– #include en skeleton voor server
struct TimeOfDay { short hour; short minute; short second;};
Interface Time { TimeOfDay get_gmt();};
#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)
{
return tod;
}
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;
Server code
int main(int argc, char * argv[]) {
return 0;}
try{
} catch (const CORBA::Exception &) { cerr << “?” << endl; return 1}
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();
Server code
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[]){
return 0;}
try {
} catch (const CORBA::Exception &) {cerr “CORBA” << endl;return 1;}
catch (…) {return 1;}
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;
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 IDLInterface 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;
};
Struct InfoKind {text, numeric, none};
union Info switch (InfoKind) {
case text : string text;
case numeric : long index;
};
Union not advised (overloading)
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 typescase 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, voorbeeldeninterface vbdn {
op(); // Foutvoid op(); // OKtypedef unsigned long prime;prime next_prime(in long n);prime next_prime(in long n,out prime p); //Foutvoid next_prime2(in long n, out prime p); //~OKsequence<long> get_longs(); //FoutSomeType 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.htmlNaming ServiceIDLs for the CORBA ServerEen referenceEen IDL voorbeeldVerder 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 geheugen-
architecturen• 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 geheugenallocatienamespace 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 *
operator char * &(); // vb in void update(char * &);(realloc)
char & operator[](ULong);
char operator[](ULong) const; // gebruik een_string[3]
/* voorbeeldCORBA::String_var s;s = get_string(); // string_alloc, s eigenaarsize_t len = strlen(s); // Ok, conversie*/
Valkuilen in String_varCORBA::String_var s1(“Hall”); // slecht in non ANSI C++CORBA::String_var s2 = “Hall”; // idem!CORBA::String_var s3;s3 = “Hall”; // idem, nu met toekenningsoperatoroplossingen: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 metchar * p = s1;
Performantie bij lees toegangvoid 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 nil-referentie 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 object-
referentie-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 ExtendedThermometer_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/papers/corba-cog.pdf
• …