| Humboldt Universität zu Berlin Institut für Informatik Lehrstuhl Systemarchitektur |
|
| CorSiCA-Homepage CorSiCA-Index |
Hier werden CORBA-Interfaces und andere Schnittstellen beschrieben, die von den einzelnen Teilprojekten einzuhalten sind.
Für die Definition von Ereignistypen, Dienstkomponenten und Diensten gibt es jeweils eine Grammatik:
IDL-Interfaces
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// corsica.idl: einige nuetzliche Typdefinitionen
//
/////////////////////////////////////////////////////////////////////////////
#ifndef CorsicaDef
#define CorsicaDef
//
// Definitionen
//
module Corsica {
typedef long Place;
typedef short Call;
typedef string Address; // Adressen werden angegeben in der Form:
// "+++"
// z.B. "+49+30+20181237"
// oder auch (?)
// "", z.B. "20181237"
typedef string Date;
typedef long Time;
typedef short ID;
typedef sequence < string > StringSeq;
typedef sequence < ID > IDSeq;
typedef sequence < Address > AddressSeq;
typedef sequence < Place > PlaceSeq;
enum Types { BOOLEAN, CHAR, SHORT, LONG, FLOAT, DOUBLE, STRING,
ENUM, TABLE };
enum Language {ENGLISH, FRENCH, GERMAN, RUSSIAN, UNKNOWN};
enum AccessRole {DESIGNER, PROVIDER, SUBSCRIBER, USER, JOINT};
union Value switch (Types) {
case BOOLEAN : boolean b;
case CHAR : char c;
case SHORT : short s;
case LONG : long l;
case FLOAT : float f;
case DOUBLE : double d;
case STRING : string str;
case ENUM : short e;
case TABLE : short siz;
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// terminal.idl: Das CorSiCA-Endgeraet
// Autor: Dirk Blaschke
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Terminal;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef TerminalDef
#define TerminalDef
//
// Definitionen
//
#include "corsica.idl"
module Corsica {
interface Terminal {
readonly attribute Address device;
// physische Endgeraetenummer, z.B. Telefonnummer
void display(in string message);
// gibt die Zeichenkette message aus
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// contracts.idl: Vertraege und ihre Verwaltung
// Autor : Tuan Nguyen Quoc
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Contract;
interface ContractManager;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef ContractsDef
#define ContractsDef
//
// Definitionen
//
#include "corsica.idl"
module Corsica {
typedef long Key;
typedef string Verifier;
interface Contract {
exception notPermitted {};
exception noSuchAttribute {};
exception badValue {};
any get (in string attrName, in Key k)
// attrName hat die Form component.attribute oder
// componente.table.attribute (liefert Sequenz) oder alias
raises (noSuchAttribute, notPermitted);
void set (in string attrName, in any value, in Key k)
// attrName hat die Form component.attribute oder
// componente.table.attribute (liefert Sequenz) oder alias
raises (noSuchAttribute, notPermitted, badValue);
};
interface ContractManager{
exception noContract {};
exception contractException { string reason; };
Contract getContract (in ID serviceID,
in ID subscriberID,
in AccessRole role,
in Verifier ver, // authentisiert die Rolle
out Key k) // wird vom Contract-Manager
// vergeben und auch dem Vertrag
// mitgeteilt
raises (noContract, contractException);
void commit (in ID serviceID,
in ID subscriberID,
in Key k,
in boolean success);
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// events.idl: IDL-Datentypen fuer die Modellierung von Eventtypen
// in CorSiCA
// Autor: Oliver Becker
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Consumer;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef EventsDef
#define EventsDef
//
// Definitionen
//
#include "corsica.idl"
module Corsica {
typedef sequence < Value > ValueSeq;
struct Event {
StringSeq hierarchy;
ValueSeq values;
};
interface Consumer {
void push ( in Call current_call, in Place input_place,
in Event ev);
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// channel.idl: der Event-Channel in CorSiCA
// Autor: Oliver Becker
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Channel;
interface ChannelFactory;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef ChannelDef
#define ChannelDef
//
// Definitionen
//
#include "corsica.idl"
#include "adapter.idl"
module Corsica {
interface Channel {
Consumer getProxyConsumer();
void connect(in Consumer component,
in PlaceSeq subscribed_places);
void destroy();
};
interface ChannelFactory {
Channel createChannel(in CallInfo adapter);
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// testInterfaces.idl: Interface fuer Testzwecke
// Autor: Long Tran Thanh
//
/////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface ReadingHistory;
interface WritingHistory;
interface Flag;
interface Monitor;
interface Test;
interface TestFactory;
};
///////////////////////////////////////////////////////////////////////////
#ifndef TestInterfacesDef
#define TestInterfacesDef
//
// Definitionen
//
//
#include "channel.idl"
module Corsica {
struct Element {
Call cl;
Place pl;
Event evt;
};
typedef sequence ElementSeq;
interface ReadingHistory {
exception inWorking {};
exception dataError {};
exception endOfProtocol {};
void gotoBegin();
// zurueck zum Anfang
short readNextEvent(in short number, out ElementSeq seq)
raises (inWorking, endOfProtocol, dataError);
// die naechsten 'number' Events lesen
// die Anzahl der tatsaechlich gelesenen Events wird
// zurueckgegeben
};
interface WritingHistory : ReadingHistory {
void writeEvent(in Element el);
};
interface Flag {
void setEndOfService();
};
interface Monitor {
readonly attribute ReadingHistory history;
void destroy();
};
interface Test : Monitor {
exception noSuchPlace {};
exception noEvent {};
exception endOfService {};
short tryNextEvent(out Element el);
// versucht, das naechste Event abzuholen
// Rueckgabewert = 1 : kein Event
// = 0 : ein Event ist da
Element nextEvent()
raises (endOfService);
// holt das naechste Event ab
// wartet so lange, bis das Event da ist
void fire();
short nextEventForPlace(in Place pl, out Element el)
raises (noSuchPlace);
// holt das naechste Event fuer den Platz 'pl' ab
void modifyEvent(in Event evt);
// modifiziert das als naechstes geschickte Event
void generateEvent(in Element el);
// generiert ein neues Event und es wird gleich geschickt
};
interface TestFactory {
exception noSuchService {};
exception error {
string reason;
};
enum TestMode {MONITOR, TEST};
// MONITOR: Dienstausfuehrung mit Protokollierung
// TEST : interaktive Dienstausfuehrung mit Protokollierung
Monitor start(in long serviceID, in long subscriberID, in TestMode mode)
raises (noSuchService, error);
// startet den Service mit dem entsprechenden Modus
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// testChannels.idl: Event-Bus fuer Testzwecke
// Autor: Long Tran Thanh
//
/////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface MonitorChannel;
interface TestChannel;
interface TestChannelFactory;
};
/////////////////////////////////////////////////////////////////////////
#ifndef TestChannelsDef
#define TestChannelsDef
//
// Definitionen
//
//
#include "testInterfaces.idl"
module Corsica {
interface MonitorChannel : Channel {
void getReferences(in WritingHistory history, in Flag ref);
};
interface TestChannel : MonitorChannel {
short tryNextEvent(out Element el);
// versucht, das naechste Event abzuholen
// Rueckgabewert = 1 : kein Event
// = 0 : ein ist da
short nextEventForPlace(in Place pl, out Element el);
void fire();
void setPushEvent(in Event evt);
};
interface TestChannelFactory {
MonitorChannel createMonitorChannel();
TestChannel createTestChannel();
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// components.idl: Komponenten und Komponenten-Fabrik
// Autor: Oliver Becker, Christian Priebe
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Component;
interface ComponentFactory;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef ComponentsDef
#define ComponentsDef
//
// Definitionen
//
#include "corsica.idl"
#include "events.idl"
module Corsica {
struct NameValuePair {
string name;
Value val;
};
typedef sequence < NameValuePair > NameValueSeq;
interface Component : Consumer {
void connectChannel( in Consumer channel,
in PlaceSeq input_places,
in PlaceSeq output_places);
};
};
//
#include "adapter.idl"
module Corsica {
interface ComponentFactory {
exception noInstance {};
exception badInits {};
Component createInstance( in NameValueSeq inits,
in CallInfo callObj )
raises (noInstance, badInits);
string isFactoryFor ();
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// context.idl: Zugriff auf IN-globale Daten
// Autor: Barbara Burkhard
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Calendar;
interface Context;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef ContextDef
#define ContextDef
//
// Definitionen
//
#include "corsica.idl"
#include "contracts.idl"
module Corsica {
struct AnnounceEntry {
long annId;
string announce;
short nrOfvars;
};
typedef sequence < AnnounceEntry > AnnounceSeq;
interface Calendar {
boolean isHoliday (in Date day);
boolean isWorkday (in Date day);
};
interface Context {
readonly attribute ContractManager ctrRepository;
readonly attribute AnnounceSeq announces;
readonly attribute Language lang;
readonly attribute Calendar ca;
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// adapter.idl: Das Adapterobjekt
// Autor: Dirk Blaschke
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface CallControl;
interface CallInfo;
interface Adapter;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef AdapterDef
#define AdapterDef
//
// Definitionen
//
#include "corsica.idl"
#include "ssp.idl"
#include "contracts.idl"
#include "components.idl"
module Corsica {
interface CallInfo {
// dieses Interface erlaubt Dienstkomponenten, unter Vorlage der
// Call-ID rufspezifische Daten zu erfragen
exception noSuchCall {};
readonly attribute Configuration service;
Address getOriginator (in Call cl)
raises (noSuchCall);
AddressSeq getParties (in Call cl)
raises (noSuchCall);
Contract getContract (in Call cl, out Key k)
raises (noSuchCall);
// Der Key k autorisiert die Komponenten beim Vertragobjekt in der Rolle USER
};
interface CallControl { // gerade in Arbeit !!!!!!
// Dieses Interface erlaubt der SSF, Rufe zu verwalten und die
// Generierung rufbezogener Ereignissnachrichten auszuloesen
exception noSuchParty {};
exception noSuchCall {};
// Operationen zum Eintragen und Streichen von Teilnehmern des Rufs.
// Der Returnwert liefert die aktuelle Anzahl der Rufteilnehmer.
Call createCall (in Address originator,
in Contract ctr, in Key k,
in ConnectionControl ssf);
void destroyCall(in Call cl)
raises (noSuchCall);
short addParty (in Call cl, in Address device)
raises (noSuchCall);
short deleteParty (in Call cl, in Address device)
raises (noSuchParty);
// Operationen zum Erzeugen rufbezogener Events
oneway void inputEvent (in Call c,
in string inp, in Address from);
oneway void annAckEvent (in Call c,
in long annID, in short lang,
in Address was_for);
oneway void connectedEvent (in Call c,
in Address with, in Time when);
oneway void disconnectedEvent (in Call c,
in Address dev, in Time when);
oneway void noAnswerEvent (in Call c, in Address dev);
oneway void busyEvent (in Call c, in Address dev);
oneway void forwardedEvent (in Call c,
in Address from, in Address to);
oneway void hookOnEvent (in Call c, in Address dev);
oneway void hookOffEvent (in Call c, in Address dev);
};
interface Adapter : CallControl, CallInfo, Component { };
interface AdapterFactory {
Adapter createAdapter (in Configuration service);
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// configure.idl : Konfigurator
// Autor: Oliver Becker, Barbara Burkhard
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface Configurator;
interface ConfiguratorAdmin;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef ConfigureDef
#define ConfigureDef
//
// Definitionen
//
#include "corsica.idl"
#include "adapter.idl"
#include "channel.idl"
module Corsica {
interface Configurator { // Konfiguration bei Eintreffen des Rufs
exception notBound {};
exception noSuchComponent {string componentName;};
exception notAvailable {}; // Strategie-abhaengig
Adapter configure (in ID serviceID,
in ID subscriberID)
raises (notBound, noSuchComponent, notAvailable);
};
interface ConfiguratorAdmin : Configurator {
// Konfiguration + Administration durch Management- und Testwerkzeuge
exception idAlreadyUsed {};
exception dontExist{};
exception noPlan {};
// ueberfluessig
// eine Testapplikation wird installiert durch Aufruf von bind()
// mit einer Test-Channel-Factory.
// Die Konfiguration des Dienstes erfolgt dann laut Konfigurations-
// strategie im Konfigurationsplan, z.B. bei Eintreffen eines Rufes.
// Adapter configure_test (in ID serviceID,
// in ID subscriberID,
// in Channel testBus)
// raises (noPlan, noSuchComponent);
void bind (in string service, in ID serviceID, in ChannelFactory fac)
raises (idAlreadyUsed, noPlan);
void unbind (in string service, in ID serviceID)
raises (notBound);
void destroy (in Adapter svc_instance)
raises (dontExist);
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// ssp.idl : Der CorSiCA-SSP
// Autor: Dirk Blaschke
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface SSPAdmin;
interface TerminalControl;
interface ConnectionControl;
interface SSP;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef SSPDef
#define SSPDef
//
// Definitionen
//
#include "corsica.idl"
#include "terminal.idl"
module Corsica {
enum DP{ O_ATTEMPT_AUTHORIZED, COLLECTED_INFO, ANALYSE_INFO,
O_ANSWER, O_MOD_CALL, O_DISCONNECT,
TERM_ATTEMPT_AUTHORIZED, T_ANSWER, T_CALLED_PARTY_BUSY};
interface SSPAdmin {
exception alreadyUsed {};
exception unknown {};
short list (out IDSeq idList);
// idList liefert die Liste aller registrierten Service-IDs,
// der Returnwert ist die Laenge der Sequenz.
void setTrigger( in DP state, in ID serviceID, in long subscriber)
raises (alreadyUsed);
void unsetTrigger( in DP state, in ID serviceID, in long subscriber)
raises (unknown);
};
interface TerminalControl {
exception notActivated {};
exception overflow {};
exception congested{};
ID activateTerminal(in Terminal me, in Address myDevice)
raises (congested);
// Endgeraet meldet sich beim SSP an ('Schalten des Telefonanschlusses')
void deactivateTerminal(in ID me, in Address myDevice)
raises (notActivated);
// Endgeraet meldet sich beim SSP ab ('Stillegen des Telefonanschlusses')
void input(in ID me, in string c)
raises (overflow);
// Eine Zeichenkette eingegeben
void hook_off(in ID me);
// Hoerer aufnehmen
void hook_on(in ID me);
// Hoerer auflegen
};
interface ConnectionControl { // Version: asynchrone Kommunikation
oneway void announceReq(in long annID, in short langID, in Address device);
// loest das Abspielen der Ansage durch die IP aus.
// Ist device=" ", wird die Ansage dem Originator vorgespielt.
oneway void inputReq( in Address device, in short length);
// fordert Input der Laenge length vom Terminal device an.
oneway void connectReq( in Address device, in Call cl);
// zeigt am Endgeraet device den Verbindungswunsch an.
oneway void disconnectReq (in Address device);
oneway void callReleased (in Call c);
// benachrichtigt den SSP ueber das Ende des IN-Rufs
oneway void charge(in Time t, in short chargeType, in Call c);
void setTriggerReq( in DP state, in ID serviceID, in long subscriber);
void unsetTriggerReq( in DP state, in ID serviceID, in long subscriber);
};
interface SSP : TerminalControl, ConnectionControl, SSPAdmin {};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDl-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Maerz 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// templates.idl : Zugriff auf die Komponenten-Templates
// Autor: Christian Priebe
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface TmplEnum;
interface TmplAttrTable;
interface TmplAttr;
interface TmplAttrEnum;
interface Template;
interface TemplateRepository;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef TemplatesDef
#define TemplatesDef
//
// Definitionen
//
#include "corsica.idl"
module Corsica {
exception notSpecified { };
exception noSuchPlace { };
typedef sequence < AccessRole > AccessRoleSeq;
typedef sequence < TmplAttr > TmplAttrSeq;
interface TmplEnum {
readonly attribute string name;
readonly attribute StringSeq values;
};
interface TmplAttr {
exception noSequence { };
readonly attribute string name;
readonly attribute string description;
readonly attribute Types type;
Value getDefaultValue ()
raises (notSpecified);
string getCondition ()
raises (notSpecified);
readonly attribute AccessRoleSeq writeAccess;
readonly attribute AccessRoleSeq readAccess;
TmplAttrTable getTable ()
raises (noSequence);
};
interface TmplAttrTable : TmplAttr { // table size attribute
readonly attribute TmplAttrSeq sequences;
};
interface TmplAttrEnum : TmplAttr {
readonly attribute TmplEnum enumType;
};
interface Template {
readonly attribute string description;
readonly attribute string name;
StringSeq getInputPlaces ();
StringSeq getOutputPlaces ();
StringSeq getInputPlaceEvents (in string place)
raises (noSuchPlace);
StringSeq getOutputPlaceEvents (in string place)
raises (noSuchPlace);
TmplAttrSeq getAttributes ();
TmplAttrSeq getSimpleAttributes (); // without sequences
TmplAttrSeq getAttrWritableBy (in AccessRole id);
TmplAttrSeq getAttrReadableBy (in AccessRole id);
};
interface TemplateRepository {
readonly attribute StringSeq templates;
Template getTemplate (in string sc)
raises (notSpecified);
};
};
#endif
/////////////////////////////////////////////////////////////////////////////
// IDL-Interfaces fuer das Projekt CorSiCA
// Corba based Simlation Concept for In Applications
// (c) Projektgruppe CorSiCA: Barbara Burkhard, Oliver Becker,
// Christian Priebe, Dirk Blaschke, Long Tran Thanh,
// Knut Conrad, Tuan Nguyen Quoc
// Mai 1998
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// channel.idl: das Configuration-Repository in CorSiCA
// Autor: Oliver Becker
//
/////////////////////////////////////////////////////////////////////////////
//
// Forward-Deklarationen
//
module Corsica {
interface ConfiguredComponent;
interface Configuration;
interface ConfigurationRepository;
};
/////////////////////////////////////////////////////////////////////////////
#ifndef ConfigRepDef
#define ConfigRepDef
//
// Definitionen
//
#include "events.idl"
#include "components.idl"
#include "templates.idl"
module Corsica {
enum Strategy { DYNAMIC_PER_CALL, STATIC_PER_CALL,
DYNAMIC_PER_SUBSCRIBER, STATIC_PER_SUBSCRIBER,
DYNAMIC_PER_SERVICE, STATIC_PER_SERVICE };
interface ConfiguredComponent {
readonly attribute Template componentTemplate;
readonly attribute PlaceSeq inputPlaceNumbers;
readonly attribute PlaceSeq outputPlaceNumbers;
readonly attribute NameValueSeq inits;
};
typedef sequence < ConfiguredComponent > ConfCompSeq;
interface Configuration {
readonly attribute string service;
readonly attribute Strategy strategy;
readonly attribute string description;
readonly attribute ConfCompSeq confComponents;
};
typedef sequence < Configuration > ConfSeq;
interface ConfigurationRepository {
exception noPlan {};
readonly attribute StringSeq availableConfigurations;
Configuration getConfiguration(in string service)
raises (noPlan);
};
};
#endif