Issues for Mailing list of the Lightweight Services Finalization Task Force
To comment on any of these issues, send email to lwservices-ftf@omg.org. (Please include the issue number in the Subject: header, thusly: [Issue ###].) To submit a new issue, send email to issues@omg.org.
List of issues (green=resolved, yellow=pending Board vote, red=unresolved)
Issue 7063: Non normative IDL needs to be defined for Lightweight Services submission
Issue 7063: Non normative IDL needs to be defined for Lightweight Services submission (lwservices-ftf)
Click here for this issue's archive.
Source: MITRE (Mr. Kevin Richardson, kwrich(at)mitre.org)
Nature: Uncategorized Issue
Severity:
Summary:
The LW Services errata includes the following text
" For convenience, in this specification, only the operations which are
not disabled are shown in the informative IDL descriptions of these
services. "
However as of now this IDL has not been defined and incorporated into
the specification. This annex needs to be created.
Resolution: see below
Revised Text: Resolution:
Add Annex A with subsections defining Lightweight Service IDL with preprocessor defines to delineate Lightweight Service subset functionality.
Revised Text:
---- Added Annex A to specification as follows:
Annex A
(non-normative)
OMG IDL
The following sections contains the complete OMG IDL for the Lightweight Services. The IDL specifications in the full service specifications continue to be the normative definition for each interface. Operations that are termed disabled in Lightweight Services implementations may raise either BAD_OPERATION or NO_IMPLEMENT exceptions when they are invoked. This flexibility allows the lightweight services to avoid extra overhead in the service implementation skeletons and removes any requirement for clients to test explicitly for disabled operations. In cases where the operations is termed
optional, NO_IMPLEMENT is preferred over BAD_OPERATION. However, the Lightweight Service implementer may use BAD_OPERATION for the optional interfaces to meet the constraints of their embedded system.
A.1 OMG IDL for Lightweight Naming Service
//File: CosNaming.idl
//The only module of the Naming Service
#ifndef _COS_NAMING_IDL_
#define _COS_NAMING_IDL_
#ifdef _PRE_3_0_COMPILER_
# pragma prefix "omg.org"
#endif
module CosNaming
{
# ifndef _PRE_3_0_COMPILER_
typeprefix "omg.org";
# endif // _PRE_3_0_COMPILER_
typedef string Istring;
struct NameComponent {
Istring id;
Istring kind;
};
typedef sequence <NameComponent> Name;
#ifndef LIGHTWEIGHT_SERVICE
enum BindingType {nobject, ncontext};
struct Binding {
Name binding_name;
BindingType binding_type;
};
typedef sequence <Binding> BindingList;
interface BindingIterator;
#endif
interface NamingContext {
enum NotFoundReason { missing_node,
not_context,
not_object};
exception NotFound { NotFoundReason why;
Name rest_of_name;};
exception CannotProceed { NamingContext cxt;
Name rest_of_name;};
exception InvalidName{};
exception AlreadyBound {};
exception NotEmpty{};
void bind(in Name n, in Object obj)
raises( NotFound,
CannotProceed,
InvalidName,
AlreadyBound);
void rebind(in Name n, in Object obj)
raises( NotFound,
CannotProceed,
InvalidName);
#ifndef LIGHTWEIGHT_SERVICE
void bind_context( in Name n, in NamingContext nc)
raises( NotFound,
CannotProceed,
InvalidName,
AlreadyBound);
void rebind_context(in Name n, in NamingContext nc)
raises( NotFound,
CannotProceed,
InvalidName);
#endif
Object resolve (in Name n)
raises( NotFound,
CannotProceed,
InvalidName);
void unbind(in Name n)
raises( NotFound,
CannotProceed,
InvalidName);
#ifndef LIGHTWEIGHT_SERVICE
NamingContext new_context();
#endif
NamingContext bind_new_context(in Name n)
raises( NotFound,
AlreadyBound,
CannotProceed,
InvalidName);
void destroy( )
raises(NotEmpty);
#ifndef LIGHTWEIGHT_SERVICE
void list ( in unsigned long how_many,
out BindingList bl,
out BindingIterator bi);
#endif
};
#ifndef LIGHTWEIGHT_SERVICE
interface BindingIterator {
boolean next_one(out Binding b);
boolean next_n( in unsigned long how_many,
out BindingList bl);
void destroy();
};
interface NamingContextExt: NamingContext {
typedef string StringName;
typedef string Address;
typedef string URLString;
StringName to_string(in Name n)
raises(InvalidName);
Name to_name(in StringName sn)
raises(InvalidName);
exception InvalidAddress {};
URLString to_url(in Address addr, in StringName sn)
raises(InvalidAddress, InvalidName);
Object resolve_str(in StringName sn)
raises( NotFound,
CannotProceed,
InvalidName,
AlreadyBound);
NamingContext resolve_context (in Name n)
raises( NotFound,
CannotProceed,
InvalidName);
};
#endif
};
#endif /* ifndef _COS_NAMING_IDL_ */
A.2 OMG IDL for Lightweight Event Service
A.2.1 LightweightCosEventChannelAdmin.idl
//File: CosEventChannelAdmin.idl
//Part of the Event Service
#ifndef _COS_EVENT_CHANNEL_ADMIN_IDL_
#define _COS_EVENT_CHANNEL_ADMIN_IDL_
#ifdef _PRE_3_0_COMPILER_
# pragma prefix "omg.org"
#else
typeprefix "omg.org";
#endif
#include <CosEventComm.idl>
module CosEventChannelAdmin {
exception AlreadyConnected {};
exception TypeError {};
interface ProxyPushConsumer: CosEventComm::PushConsumer {
void connect_push_supplier(
in CosEventComm::PushSupplier push_supplier)
raises(AlreadyConnected);
};
#ifndef LIGHTWEIGHT_SERVICE
interface ProxyPullSupplier: CosEventComm::PullSupplier {
void connect_pull_consumer(
in CosEventComm::PullConsumer pull_consumer)
raises(AlreadyConnected);
};
interface ProxyPullConsumer: CosEventComm::PullConsumer {
void connect_pull_supplier(
in CosEventComm::PullSupplier pull_supplier)
raises(AlreadyConnected,TypeError);
};
#endif
interface ProxyPushSupplier: CosEventComm::PushSupplier {
void connect_push_consumer(
in CosEventComm::PushConsumer push_consumer)
raises(AlreadyConnected, TypeError);
};
interface ConsumerAdmin {
ProxyPushSupplier obtain_push_supplier();
#ifndef LIGHTWEIGHT_SERVICE
ProxyPullSupplier obtain_pull_supplier();
#endif
};
interface SupplierAdmin {
ProxyPushConsumer obtain_push_consumer();
#ifndef LIGHTWEIGHT_SERVICE
ProxyPullConsumer obtain_pull_consumer();
#endif
};
interface EventChannel {
ConsumerAdmin for_consumers();
SupplierAdmin for_suppliers();
void destroy();
};
};
#endif /* ifndef _COS_EVENT_CHANNEL_ADMIN_IDL_ */
A.2.2 LightweightCosEventComm.idl
//File: CosEventComm.idl
//Part of the Event Service
#ifndef _COS_EVENT_COMM_IDL_
#define _COS_EVENT_COMM_IDL_
#ifdef _PRE_3_0_COMPILER_
# pragma prefix "omg.org"
#else
typeprefix "omg.org";
#endif
module CosEventComm {
exception Disconnected{};
interface PushConsumer {
void push (in any data) raises(Disconnected);
void disconnect_push_consumer();
};
interface PushSupplier {
void disconnect_push_supplier();
};
#ifndef LIGHTWEIGHT_SERVICE
interface PullSupplier {
any pull () raises(Disconnected);
any try_pull (out boolean has_event)
raises(Disconnected);
void disconnect_pull_supplier();
};
interface PullConsumer {
void disconnect_pull_consumer();
};
#endif
};
#endif /* ifndef _COS_EVENT_COMM_IDL_ */
A.3 OMG IDL for Lightweight Time Service
//Enhanced View of Time, v1.0 - OMG IDL Summary File
//Object Management Group, Inc.
//
//Copyright 1999, Objective Interface Systems, Inc.
//Copyright 2001, Object Management Group, Inc.
//The companies listed above have granted to the Object Management Group, Inc.
//(OMG) a nonexclusive, royalty-free, paid up, worldwide license to copy and
//distribute this document and to modify this document and distribute copies of
//the modified version. Each of the copyright holders listed above has agreed
//that no person shall be deemed to have infringed the copyright in the included
//material of any such copyright holder by reason of having used the
//specification set forth herein or having conformed any computer software to
//the specification.
//
//This file contains OMG IDL from the Enhanced View of Time, v1.0 specification.
//OMG regularly publishes a summary file that contains all the "code" parts of
//an OMG formal document. Every formal document line that is IDL, PIDL, or
//language code is included in the summary file. The reason for such a listing
//is to give readers an electronic version of the "code" so that they can
//extract pieces of it. Readers might want to test an example, include it in
//their own code, or use it for documentation purposes. Having the code lines
//available electronically means there is less likelihood of a transcription
//error.
//File: CosClockService.idl
#ifndef _CosClockService_IDL_
#define _CosClockService_IDL_
// This module comprises the COS Clock service
#include <TimeBase.idl>
#include <CosPropertyService.idl>
#ifdef _PRE_3_0_COMPILER_
# pragma prefix "omg.org"
#else
typeprefix "omg.org";
#endif
module CosClockService
{
interface Clock;
module ClockProperty
{
// the minimum set of properties to be supported for a clock
typedef unsigned long Resolution; // units = nanoseconds
typedef short Precision; // ceiling of log_2(seconds signified by least
// significant bit of time readout)
typedef unsigned short Width; // no. of bits in readout - usually <= 64
typedef string Stability_Description;
typedef short Coordination;
const Coordination Uncoordinated = 0; // only static characterization
// is available
#ifndef LIGHTWEIGHT_SERVICE
const Coordination Coordinated = 1; // measured against another
// source
const Coordination Faulty = 2; // e.g., there is a bit stuck
// the following are only applicable for coordinated clocks
struct Offset
{
long long measured; // units = 100 nanoseconds
long long deliberate; // units = 100 nanoseconds
};
typedef short Measurement;
const Measurement Not_Determined = 0; // has not been measured
const Measurement Discontinuous = 1; // e.g., one clock is paused
const Measurement Available = 2; // has been measured
typedef float Hz;
struct Skew
{
Measurement available;
Hz measured; // only meaningful if available = Available - in Hz
Hz deliberate; // in Hz
};
typedef float HzPerSec;
struct Drift
{
Measurement available;
HzPerSec measured; // meaningful if available = Available
// in Hz/sec
HzPerSec deliberate; // in Hz/sec
};
#endif
typedef short TimeScale;
const TimeScale Unknown = -1;
const TimeScale TAI = 0; // International Atomic Time
const TimeScale UT0 = 1; // diurnal day
const TimeScale UT1 = 2; // + polar wander
const TimeScale UTC = 3; // TAI + leap seconds
const TimeScale TT = 4; // terrestrial time
const TimeScale TDB = 5; // Barycentric Dynamical Time
const TimeScale TCG = 6; // Geocentric Coordinate Time
const TimeScale TCB = 7; // Barycentric Coordinate Time
const TimeScale Sidereal = 8; // hour angle of vernal equinox
const TimeScale Local = 9; // UTC + time zone
const TimeScale GPS = 10; // Global Positioning System
const TimeScale Other = 0x7fff; // e.g. mission
#ifndef LIGHTWEIGHT_SERVICE
typedef short Stratum;
const Stratum unspecified = 0;
const Stratum primary_reference = 1;
const Stratum secondary_reference_base = 2;
typedef Clock CoordinationSource; // what clock is coordinating with
#endif
typedef string Comments;
};
exception TimeUnavailable {};
// the basic clock interface
interface Clock // a source of time readings
{
readonly attribute CosPropertyService::PropertySet properties;
readonly attribute TimeBase::TimeT current_time
getRaises(TimeUnavailable);
};
#ifndef LIGHTWEIGHT_SERVICE
enum TimeComparison
{
TCEqualTo,
TCLessThan,
TCGreaterThan,
TCIndeterminate
};
enum ComparisonType
{
IntervalC,
MidC
};
enum OverlapType
{
OTContainer,
OTContained,
OTOverlap,
OTNoOverlap
};
valuetype TimeSpan;
// replaces UTO from CosTime
valuetype UTC
{
factory init(in TimeBase::UtcT from);
factory compose(in TimeBase::TimeT time,
in unsigned long inacclo,
in unsigned short inacchi,
in TimeBase::TdfT tdf);
public TimeBase::TimeT time;
public unsigned long inacclo;
public unsigned short inacchi;
public TimeBase::TdfT tdf;
TimeBase::InaccuracyT inaccuracy();
TimeBase::UtcT utc_time();
TimeComparison compare_time(in ComparisonType comparison_type,
in UTC with_utc);
TimeSpan interval();
};
// replaces TIO from CosTime
valuetype TimeSpan
{
factory init (in TimeBase::IntervalT from);
factory compose(in TimeBase::TimeT lower_bound,
in TimeBase::TimeT upper_bound);
public TimeBase::TimeT lower_bound;
public TimeBase::TimeT upper_bound;
TimeBase::IntervalT time_interval();
OverlapType spans (
in UTC time,
out TimeSpan overlap
);
OverlapType overlaps (
in TimeSpan other,
out TimeSpan overlap
);
UTC time ();
};
// replaces TimeService from CosTime
interface UtcTimeService : Clock
{
UTC universal_time() raises(TimeUnavailable);
UTC secure_universal_time() raises(TimeUnavailable);
UTC absolute_time(in UTC with_offset) raises(TimeUnavailable);
};
#endif
#if !defined(LIGHTWEIGHT_SERVICE) || defined(LWTIME_HAS_SUPPORT_OF_MULTIPLE_CLOCKS)
// alternative to Trader service (e.g., for embedded systems)
interface ClockCatalog
{
struct ClockEntry
{
Clock subject;
string name;
};
typedef sequence<ClockEntry> ClockEntries;
exception UnknownEntry {};
ClockEntry get_entry(in string with_name) raises (UnknownEntry);
ClockEntries available_entries();
void register(in ClockEntry entry);
void delete_entry(in string with_name) raises (UnknownEntry);
};
#endif
// a controllable clock
interface ControlledClock: Clock
{
exception NotSupported {};
void set(in TimeBase::TimeT to) raises (NotSupported);
void set_rate(in float ratio) raises (NotSupported);
void pause() raises (NotSupported);
void resume() raises (NotSupported);
void terminate() raises (NotSupported);
};
#ifndef LIGHTWEIGHT_SERVICE
// useful for building user synchronized clocks
interface SynchronizeBase : Clock
{
struct SyncReading
{
TimeBase::TimeT local_send;
TimeBase::TimeT local_receive;
TimeBase::TimeT remote_reading;
};
SyncReading synchronize_poll(in Clock with_master);
};
interface SynchronizedClock;
exception UnableToSynchronize
{
TimeBase::InaccuracyT minimum_error;
};
// allows definition of a new clock that uses the underlying hardware source
// of the existing clock but adjusts to synchronize with a master clock
interface Synchronizable : SynchronizeBase
{
const TimeBase::TimeT Forever = 0xFFFFFFFFFFFFFFFF;
SynchronizedClock new_slave
(in Clock to_master,
in TimeBase::InaccuracyT to_within,
// synchronization envelope
in short retry_limit,
// if unable to attain accuracy
in TimeBase::TimeT minimum_delay_between_syncs,
// limits network traffic,
// Forever precludes auto resync
in CosPropertyService::Properties properties
// if null list, then inherit
// properties of self
) raises (UnableToSynchronize);
};
// able to explicitly control synchronization
interface SynchronizedClock : Clock
{
void resynch_now() raises (UnableToSynchronize);
};
#endif
#if !defined(LIGHTWEIGHT_SERVICE) || defined(LWTIME_HAS_SUPPORT_OF_PERIODIC_EXECUTION_CONTROL)
module PeriodicExecution
{
// (conceptually abstract) base for objects that can be invoked periodically
interface Periodic
{
boolean do_work(in any params);
// return FALSE terminates periodic execution
};
// control object for periodic execution
interface Controller
{
exception TimePast {};
void start
(in TimeBase::TimeT period,
in TimeBase::TimeT with_offset,
in unsigned long execution_limit, // 0 = no limit
in any params);
void start_at
(in TimeBase::TimeT period,
in TimeBase::TimeT at_time,
in unsigned long execution_limit, // 0 = no limit
in any params) raises (TimePast);
void pause();
void resume();
void resume_at(in TimeBase::TimeT at_time) raises(TimePast);
void terminate();
unsigned long executions();
};
// factory clock for periodic execution
interface Executor : Clock
{
Controller enable_periodic_execution(in Periodic on);
};
#endif // LWTIME_HAS_SUPPORT_OF_PERIODIC_EXECUTION_CONTROL
};
};
#endif // _CosClockService_IDL__
Actions taken:
March 4, 2004: received issue
March 8, 2005: closed issue