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

• …