-- IDL module extracted from ITU-T X.780 (2001) Amend. 1 (05/2002)

/* This IDL code is meant to be stored in a file named "itut_x780.idl" located in the search path used by IDL compilers on your system. */ #ifndef ITUT_X780_IDL #define ITUT_X780_IDL #include <CosNaming.idl> #include <CosTime.idl> #include <itut_x780Const.idl> #pragma prefix "itu.int" /* Most comments in this file are formatted to be parsed by an IDL-to-HTML converter such as idldoc or orbacus hidl. */ // MODULE itut_x780 /** This module provides the fundamental capabilities for implementing network management interfaces and defines the "managed object" interface. The interfaces below are modeled after the managed object specifications found in the ITU-T CMIP specification document X.721. */ module itut_x780 { // IMPORTED TYPES // Types imported from CosNaming typedef CosNaming::Name NameType; // Types imported from CosTime typedef TimeBase::UtcT UtcT; // FORWARD DECLARATIONS AND TYPEDEFS /** International strings are strings of wide (16 bit unicode) characters. */ typedef wstring Istring; /** Istring Sets are just sets of Istrings */ typedef sequence <Istring> IstringSetType; /** Additional Text Type is often used in notifications to convey a text explanation for the notification. */ typedef Istring AdditionalTextType; /** Avalibility Type is used in a sequence to indicate the availability of a resource. Zero or more of these conditions may be indicated. */ typedef short AvailabilityStatusType; const AvailabilityStatusType inTest = 0; const AvailabilityStatusType failed = 1; const AvailabilityStatusType powerOff = 2; const AvailabilityStatusType offLine = 3; const AvailabilityStatusType offDuty = 4; const AvailabilityStatusType dependency = 5; const AvailabilityStatusType degraded = 6; const AvailabilityStatusType notInstalled = 7; const AvailabilityStatusType logFull = 8; /** Availability status is used to indicate the availability of a resource. It is represented as a sequence of integers because several of the conditions may exist at once. */ typedef sequence<AvailabilityStatusType> AvailabilityStatusSetType; /** Backed Up Status Type is used to indicate if an object has a back up. */ typedef boolean BackedUpStatusType; /** BitStrings are used to hold strings of bits. They may be of any length. */ typedef sequence<octet> BitString; /** Control Status Type is used in a sequence to indicate the control status of a resource. Zero or more of these may be indicated. */ typedef short ControlStatusType; const ControlStatusType subjectToTest = 0; const ControlStatusType partOfServicesLocked = 1; const ControlStatusType reservedForTest = 2; const ControlStatusType suspended = 3; /** Control status set is used to indicate the control status of a resource. It is represented as a sequence of integers because several of the conditions may exist at once. */ typedef sequence<ControlStatusType> ControlStatusSetType; /** Generalized time is a basic ASN.1 type. It is usually represented as a string in computing languages but it has certain, parseable formats. The 3 possible forms are: <ol><li> Local time only. "YYYYMMDDHHMMSS.fff", where the optional fff is accurate to three decimal places, <li> Universal time (UTC time) only. "YYYYMMDDHHMMSS.fffZ", and <li> Difference between local and UTC times. "YYYYMMDDHHMMSS.fff+-HHMM". </ol> The options for representing this in IDL seem to be either a string or the UtcT structure from the CORBA Time Service. UtcT makes it a little easier to compare times from different zones, but requires managed systems to know their time zones. UtcT was picked. */ typedef UtcT GeneralizedTimeType; /** External Time is generalized time. */ typedef GeneralizedTimeType ExternalTimeType; /** A sequence of names is defined as just a sequence of names. */ typedef sequence <NameType> NameSeqType; /** A set of names is definded as a sequence of names. */ typedef sequence <NameType> NameSetType; /** A managed object name is just a name */ typedef NameType MONameType; /** A sequence of managed object names is defined as just a sequence of names. */ typedef NameSeqType MONameSeqType; /** A set of managed object names is defined as just a set of names. */ typedef NameSetType MONameSetType; /** Notification IDs are long integers. */ typedef long NotifIDType; /** This defines a set of notification IDs. */ typedef sequence <long> NotifIDSetType; /** Since CORBA IDL does not provide a null type, the type NullType is defined for cases in unions in which no data type should be defined. Since char really is a data type, though, it should always be set to /0 and always ignored. */ typedef char NullType; /** Procedural Status Type is used in a sequence to indicate the procedural status of a resource. Zero or more of these may be indicated. */ typedef short ProceduralStatusType; const ProceduralStatusType initializationRequired = 0; const ProceduralStatusType notInitialized = 1; const ProceduralStatusType initializing = 2; const ProceduralStatusType reporting = 3; const ProceduralStatusType terminating = 4; /** Procedural Status Set is used to indicate the procedural status of a resource. It is represented as a sequence of integers because several of the conditions may exist at once. */ typedef sequence<ProceduralStatusType> ProceduralStatusSetType; /** ScopedName is just a string. */ typedef string ScopedNameType; /** Scoped Name Sets are simply sets of Scoped Names. */ typedef sequence <ScopedNameType> ScopedNameSetType; /** In CORBA, strings containing scoped names are used to identify object classes (actually, "interfaces"). */ typedef ScopedNameType ObjectClassType; /** Object Class Set is a set of object classes */ typedef sequence <ObjectClassType> ObjectClassSetType; /** Name Binding Modules are identified with scoped names. */ typedef ScopedNameType NameBindingType; /** StartTimeType is used to specify a time when something starts. It is often paired with a StopTimeType to control the activation of some function. */ typedef GeneralizedTimeType StartTimeType; /** String sets are sets of strings. */ typedef sequence <string> StringSetType; /** System Labels are strings used to identify systems. */ typedef string SystemLabelType; /** Unknown status is used to indicate if the status of a resource is not known. A value of true indicates the status is unknown. */ typedef boolean UnknownStatusType; // ENUMERATED TYPES /* The following state objects are used in many interfaces and parallel the state objects in CMIP standards. */ /** Administrative State is read/write. A "locked" object is usually one that may not be changed or one which is not providing service. Setting the Admininstrative State of an object to "shuttingDown" begins the shutdown process for that object. */ enum AdministrativeStateType {locked, unlocked, shuttingDown}; /** Operational State is read only. It simply reports the current capability of the object to provide service. */ enum OperationalStateType {disabled, enabled}; /** Usage state is read only. If "idle," the resource is completely unused. If "busy," the total capacity of the resource is in use. "Active" is in between. */ enum UsageStateType {idle, active, busy}; /** Delete Policy indicates if an object can be deleted and if so if any contained objects should automatically be deleted. Since objects must not be orphaned, if an object has a delete policy of "deleteOnlyIfNoContainedObjects" the object must not be deleted if it has contained objects. A value of "deleteContainedObjects" means if the object is deleted its contained objects should also be deleted. */ enum DeletePolicyType {notDeletable, deleteOnlyIfNoContainedObjects, deleteContainedObjects}; /** PerceivedSeverity reports the severity of an alarm. "Indeterminate" is used when it is not possible to assign one of the other values */ enum PerceivedSeverityType {indeterminate, critical, major, minor, warning, cleared}; /** Source Indicator is used in many notifications. It identifies whether the notification is a result of a management operation or something that occurred on the managed system. */ enum SourceIndicatorType {resourceOperation, managementOperation, unknown}; /** The standby status attribute is single-valued and read-only. The value is only meaningful when the back-up relationship role exists. If "hot standby" the resource is not providing service, but is operating in synchronism with another resource that is to be backed-up. If "cold standby" the resource is to back-up another resource, but is not synchronized with that resource. If "providing service" the back-up resource is providing service and is backing up another resource. */ enum StandbyStatusType {hotStandby, coldStandby, providingService}; /** Stop times are used to specify when some function should cease. There are normally two choices, the function runs continually (in which case no actual time is specified) or the function ends at a specified time. */ enum StopTimeChoice {specific, continual}; /** Threshold indication describes if the threshold crossed was in the up or down direction. */ enum ThresholdIndicationType {up, down}; /** TrendIndication values indicate if some observed condition is getting better, worse, or not changing. */ enum TrendIndicationType {lessSevere, noChange, moreSevere}; // STRUCTURES AND UNIONS /* The structures defined below are used to pass values that may be optionally included. For some types of values, like strings, lists, and pointers, it is easy to tell if the value is included. For others, like enumerations, numbers, and structures, it is not. */ /** AdministrativeStateTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union AdministrativeStateTypeOpt switch (boolean) { case TRUE: AdministrativeStateType value; }; /** BooleanTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union BooleanTypeOpt switch (boolean) { case TRUE: boolean value; }; /** FloatTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union FloatTypeOpt switch (boolean) { case TRUE: float value; }; /** LongTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union LongTypeOpt switch (boolean) { case TRUE: long value; }; /** OperationalStateTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union OperationalStateTypeOpt switch (boolean) { case TRUE: OperationalStateType value; }; /** ShortTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union ShortTypeOpt switch (boolean) { case TRUE: short value; }; /** TrendIndicationTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union TrendIndicationTypeOpt switch (boolean) { case TRUE: TrendIndicationType value; }; /** UnsignedShortTypeOpt is an optional type. If the discriminator is the value is present, otherwise the value is null. */ union UnsignedShortTypeOpt switch (boolean) { case TRUE: unsigned short value; }; /** UsageStateTypeOpt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union UsageStateTypeOpt switch (boolean) { case TRUE: UsageStateType value; }; /** Many times interface specifications need to define standard values to be passed across the interface. Also, often the scheme used to define these values needs to be extensible as new interfaces are subclassed, so enumerations don't work well. CMIP uses OIDs, strings of numbers that are often appended, in standards. To serve this purpose, the Unique ID is used. It consists of two parts, a string containing a scoped module name, and an integer value defined as a constant within that module. These UIDs, and the ObjectClass type defined above, replace ASN.1 OIDs. It is expected that each module will contain a constant string named "moduleName" that contains the name of the module for error-free use by the programmer. A null module name will indicate a null value for the UID. <p> Code to interpret a UID might look like the following code snippet:<br> <code><pre> UIDType pc; // probable cause ... if (pc.moduleName == itut_x780::ProbableCauseConst::moduleName) //string compare switch (pc.value) { case itut_x780::ProbableCauseConst::adapterError: ... case itut_x780::ProbableCauseConst::applicationSubsystemFailure: ... case itut_x780::ProbableCauseConst::bandwidthReduced: ... } else if (pc.moduleName == MyLocal::ProbableCauseConst::moduleName) switch (pc.value) { ... } </pre></code> @member moduleName The scoped module name where values are defined. @member value The value defined as a constant within the module. */ struct UIDType { string moduleName; // module where value is defined short value; // constant within the module }; typedef sequence <UIDType> UIDSetType; /** Management Extension is a structure for flexibly reporting information. It is typically used in the Additional Information field of notifications. @see <a href="#AdditionalInformationSetType"> AdditionalInformationSetType </a> @member id identifies the type of information @member any contains the actual information, type will depend on the value of the id member. */ struct ManagementExtensionType { UIDType id; // identifies the type of info any info; // type will depend on id }; /** Additional Information is a flexible way to report information that does not fit into the structure of a notification. It contains a sequence of a structure called "Management Extension". */ typedef sequence <ManagementExtensionType> AdditionalInformationSetType; /** An Attribute Value structure is used in a notification to report the value of any attribute. The string used for the attribute's name is the same as the name of the data member in the value object defined for the object. In other words, it is the name of an attribute accessor method minus the "get" or "set". @member attributeName the name of the attribute @member value contains the value of the attribute, type will depend on the attributeName. */ struct AttributeValueType { string attributeName; any value; // type will depend on the attribute }; /** Attribute Value Sets are used to report attributes generically, in a batch mode. */ typedef sequence <AttributeValueType> AttributeSetType; /** An Attribute Value Change structure is used in a notification to report an attribute that has been changed. @see <a href="#AttributeValueType">AttributeValueType</a> @member attributeName the name of the attribute @member oldValue the old value, type will depend on the attributeName @member newValue the new value, type will depend on the attributeName. */ struct AttributeValueChangeType { string attributeName; any oldValue; // type depends on attribute any newValue; // type depends on attribute }; /** An Attribute Change Set is used to report the attributes that have been changed in an attribute value change notification. */ typedef sequence <AttributeValueChangeType> AttributeChangeSetType; /** A Correlated Notification is identified by the object that emitted the notification and the notification ID. Both are included in case the Notification IDs are not unique across objects. @member source Reference to object that emitted the correlated notification. If null, the correlated notifications are from the same source as the notification containing this data structure. @member notifIDs IDs of the correlated notifications. Notification identifiers must be chosen to be unique across all notifications from a particular managed object throughout the time that correlation is significant. */ struct CorrelatedNotificationType { NameType source; NotifIDSetType notifIDs; }; /** Correlated Notification sets are sets of Correlated Notification structures. */ typedef sequence <CorrelatedNotificationType> CorrelatedNotificationSetType; /** ProbableCause, in CMIP standards, may be either an integer or GDMO OID, a dot-notation string. The UID type is used instead. */ typedef UIDType ProbableCauseType; /** Proposed Repair Actions are sets of unique identifiers. */ typedef UIDSetType ProposedRepairActionSetType; /** Security Alarm Causes are unique identifiers. */ typedef UIDType SecurityAlarmCauseType; /** Security Alarm Detector can indicate either a mechanism or a specific object. According to X.721 a choice is made between one or the other, though it is not clear why. (Actually, X.721 adds a third choice for an AE-title which has no equivalent here.) Unless otherwise indicated, then, at most one of the members will be non-null. Two nulls may be sent if the managed system does not support this property. @member mechanism the scheme or function detecting the alarm, may be null @member obj the object detecting the alarm, may be null */ struct SecurityAlarmDetectorType { UIDType mechanism; // may be null NameType obj; // may be null }; /** Service User @member id the id of the service user @member details details about the service user, type will depend on id */ struct ServiceUserType { UIDType id; any details; // value will depend on id }; /** Service Providers share the same representation as Service Users. */ typedef ServiceUserType ServiceProviderType; /** Specific Problems are sets of unique identifiers. */ typedef UIDSetType SpecificProblemSetType; /** A Stop Time Type is used to indicate when some function should cease. In the specific case, an actual time is given. In the continual case, the function runs continually and no value is carried in this union. */ union StopTimeType switch (StopTimeChoice) { case specific: GeneralizedTimeType time; /* case continual carries NULL value */ }; /** A SuspectObject identifies an object that may be the cause of a failure. It is usually a component of a SuspectObjectList. @member objectClass Object class of the suspect object @member suspectObject Name of the suspect object @member failureProbability Optional failure responsibility probability from 1 to 100 */ struct SuspectObjectType { ObjectClassType objectClass; MONameType suspectObject; UnsignedShortTypeOpt failureProbability; }; /** Suspect Object Lists are used to identify objects that may be the cause of a failure. */ typedef sequence<SuspectObjectType> SuspectObjectSetType; /** Threshold Level Indication describes multi-level threshold crossings. Up is the only permitted choice for a counter. In ASN.1, if indication is "up", low value is optional. @member indication indicates up or down direction of crossing. @member low the low observed value. @member high the high observed value. */ struct ThresholdLevelIndType { ThresholdIndicationType indication; FloatTypeOpt low; // observed value float high; // observed value }; /** Threshold Level Ind Type Opt is an optional type. If the discriminator is true the value is present, otherwise the value is null. */ union ThresholdLevelIndTypeOpt switch (boolean) { case TRUE: ThresholdLevelIndType value; }; /** Threshold Information indicates some guage or counter attribute passed a set threshold. The structure differs from X.721 some to simplify the syntax. @member attributeID Identifies the attribute that crossed the threshold. Actually, it is an operation name on an interface minus the "get" or "set". The interface on which the operation is defined is included elsewhere in the notification as ObjectClass. A Null value indicates the entire structure is null. @member observedValue Attributes that are of type integer will be converted to floats. @member thresholdlevel This parameter is for multi-level threhsolds. Optional. @member armTime May be null(0). */ struct ThresholdInfoType { string attributeID; float observedValue; ThresholdLevelIndTypeOpt thresholdLevel; ExternalTimeType armTime; }; // EXCEPTIONS /** Application error info types are passed back in managed object exceptions. @member error A unique identifier identifying the problem. @member details A text message with additional information about the problem. */ valuetype ApplicationErrorInfoType { public UIDType error; public Istring details; }; /** Create error info types are passed back in managed object create exceptions. They extend application error info types. @member relatedObjects objects that have some relationship to the object to be created that somehow prevented the creation. @member attributeList the values that would have been assigned to the created object. These may hold some key to why the object could not be created. */ valuetype CreateErrorInfoType : ApplicationErrorInfoType { public MONameSetType relatedObjects; public AttributeSetType attributeList; }; /** Delete error info types are passed back in managed object delete exceptions. They extend application error info types. @member relatedObjects objects that have some relationship to the object to be deleted that somehow prevented the deletion. @member attributeList the attribute values assigned to the object to be deleted. These may hold some key to why the object could not be deleted. */ valuetype DeleteErrorInfoType : ApplicationErrorInfoType { public MONameSetType relatedObjects; public AttributeSetType attributeList; }; /** A package error info type is a special create error. It will be passed back in a managed object create exception as a create error. If the UID error code matches the package error info type, the client application may narrow the value type from create error info type to package error info type to access the additional information. @member packages the list of requested packages that conflicted or could not be supported. */ valuetype PackageErrorInfoType : CreateErrorInfoType { public StringSetType packages; }; /** Application error exceptions may be raised on any managed object operation to identify a problem preventing the operation from being completed. */ exception ApplicationError { ApplicationErrorInfoType info; }; /** Create error exceptions may be raised on any managed object create operation to identify a problem preventing the object from being completed. */ exception CreateError { CreateErrorInfoType info; }; /** Delete error exceptions may be raised by a managed object in response to an attempt to delete the object. They may also be raised by the terminator service. */ exception DeleteError { DeleteErrorInfoType info; }; /** Invalid length exceptions are raised when an invalid length is supplied on an operation invocation. */ exception InvalidLength { long length; }; /** Invalid string exceptions are raised when an invalid string is supplied on an operation invocation. */ exception InvalidString {}; const string administrativeStatePackage = "itut_x744d1::administrativeStatePackage"; const string createDeleteNotificationsPackage = "itut_x744d1::createDeleteNotificationsPackage"; const string stateChangeNotificationPackage = "itut_x744d1::stateChangeNotificationPackage"; exception NOadministrativeStatePackage {}; // VALUE TYPES /** Bit string value types are used to represent bit strings with associated semantic tags representing the bit string positions. */ valuetype BitStringValue { /** The state of a bit string is kept in a data member of type BitString (sequence of octets). The first octed is the count of unused bits in the last octed. */ public BitString bitStringVal; /** This initializer shall set all bit positions to '0' */ factory initValue (in unsigned long number_of_bits); /** This initializer shall create a new BitStringValue with the same length and value as the supplied BitString. */ factory InitFromBitString (in BitString desiredValue); // local operations /** This local operation returns 0 or 1 for the bit value at the specified position. If the position requested is beyond the length of the bit string an invalid length exception shall be raised. */ short getBit (in unsigned long position) raises (InvalidLength); /** This local operation is used to set the value of the bit at the requested position. If the position requested is beyond the length of the bit string an invalid length exception shall be raised. If the new_bit_value is 0, the bit shall be set to 0, otherwise it shall be set to 1. */ void setBit (in unsigned long position, in short new_bit_value) raises (InvalidLength); /** This local operation returns the number of bits in the bit string. Since the first octet contains the number of unused bits in the last octet, and the last octet may contain unused bits, the value returned is (NumberOfOctets 2)*8 + (8 firstOctetVal) */ unsigned long length (); /** This local operation returns the value of a bit string as a character string. Each bit of value 0 shall be represented as a '0' character, and each bit of value 1 shall be represented as a '1' character. A 'B' character shall be appended to the end of the string ("1001011B"). string asString (); /** This local operation sets the value of the bit string given a character string. Each '0' character in the string is converted to a bit of value 0, and each '1' character is converted to a 1. If the string has any characters other than '0', '1', or a terminating 'B', the InvalidString exception shall be raised. */ void setFromString (in string string_value) raises (InvalidString); }; // MANAGED OBJECT INTERFACE /** This valuetype object contains members for each of the attributes accessible on this interface. */ valuetype ManagedObjectValueType { public NameType name; public ObjectClassType objectClass; public StringSetType packages; public SourceIndicatorType creationSource; public DeletePolicyType deletePolicy; }; /** The Managed Object interface is intended to be the base interface from which all other managed object interfaces inherit. It is a central place to specify basic functions which all managed objects are expected to support. */ interface ManagedObject { /** This method returns the fully-qualified name for the object. This method is used rather than having a "get*ID" method defined for each interface, as is done in CMIP specifications. This will ensure that objects have only a single operation to retrieve names when they are sub-classed. <p> The response is a sequence of name component structures, starting with the name assigned to the "local root" naming context under which this object is contained. The client may find the superiors of this object by removing components from the tail end of this sequence and performing a resolve operation on the first part of the name. */ NameType nameGet() raises (ApplicationError); /** This method returns the scoped name of the most-specific class of the interface (e.g. "EquipmentR1"). */ ObjectClassType objectClassGet() raises (ApplicationError); /** This method returns a list of all the conditional packages supported by this instance. */ StringSetType packagesGet () raises (ApplicationError); /** This method returns an indication of how the object was created. */ SourceIndicatorType creationSourceGet() raises (ApplicationError); /** This method returns a value indicating if the object may be deleted and if it may, if all contained objects are automatically deleted. */ DeletePolicyType deletePolicyGet () raises (ApplicationError); /** This method may be used to generically get all of the attributes supported by an instance. Each interface is expected to sub-class the Managed Object value type and add the other attributes supported by that interface. The managed object must return a value object of that type. The client must then narrow the reference to access all the attributes. <p> The client may also submit a list of names indicating the attributes it wishes to receive. These names must match the member names in the value object. For members not on the list, and for members that are part of packages that are not supported, the server may return any value but it should be as short as possible. The server also returns the list of attributes, which may be shorter due to exclusion of attributes in unsupported packages. The client must regard the value of any member not in the list as garbage. <p> A null attribute names list indicates that all supported attributes are to be returned. The server must return the actual list. */ ManagedObjectValueType attributesGet ( inout StringSetType attributeNames) raises (ApplicationError); /** This method destroys the object. It is used to simply release any resources associated with the managed object. It does not check for contained objects or remove name bindings from the naming tree. <p> The intent of this operation is to allow support services to destroy the managed object. <p><b> NOTE: Direct invocation of this operation from a managing system could corrupt the naming tree and is recommended only under extraordinary circumstances. Clients wishing to delete an object should instead use the terminator service. </b> */ void destroy() raises (ApplicationError, DeleteError); }; // end of ManagedObject interface // MANAGED OBJECT FACTORY INTERFACE /** This interface defines the generic managed object factory interface. All Managed Object factories should inherit from this interface. <p> In addition to providing the means for creating objects by management operation, the factories are assumed to take responsibility for maintaining the integrity of the naming tree by creating name bindings for the objects they create. <p> Currently, this interface is null. It is included, however, as a placeholder for capabilities that must be supported by all managed object factories. */ interface ManagedObjectFactory { }; // end of ManagedObjectFactory interface // SYSTEM INTERFACE /** This valuetype is used to retrieve multiple attributes. */ valuetype SystemValueType : truncatable ManagedObjectValueType { public OperationalStateType operationalState; // GET public UsageStateType usageState; // GET public AdministrativeStateType administrativeState; // GET-REPLACE // administrativeStatePackage }; // valuetype SystemValueType /** The System managed object class is used to represent a set of hardware and software that forms an autonomous whole capable of performing information processing and/or information transfer. The entire specification of the sequence of name bindings to be used in constructing the distinguished name for a System managed object is outside the scope of this Recommendation. Name bindings to the Recommendation M.3120 Managed Element managed object class is supplied. Examples of names for systems are specified in Recommendation X.720. NOTE - This definition does not correspond to real open system but corresponds to real systems in Recommendation X.200. An instance of this managed object class may be used as the superior in naming managed objects representing either information processing and or information transfer resources contained within this instance. Note that this does not have the Supported Features attribute defined in Recommendation X.721, since the CORBA interface does not define negotiable Functional Units. */ interface System : ManagedObject { /** Operational State, Usage State and Administrative State are described in Recommendation X.731 */ OperationalStateType operationalStateGet () raises (ApplicationError); UsageStateType usageStateGet () raises (ApplicationError); /** PRESENT IF an instance supports it. */ AdministrativeStateType administrativeStateGet () raises (ApplicationError, NOadministrativeStatePackage); void administrativeStateSet in AdministrativeStateType administrativeState) raises (ApplicationError, NOadministrativeStatePackage); CONDITIONAL_NOTIFICATION( Notifications, objectCreation, createDeleteNotificationsPackage) CONDITIONAL_NOTIFICATION( Notifications, objectDeletion, createDeleteNotificationsPackage) CONDITIONAL_NOTIFICATION( Notifications, stateChange, stateChangeNotificationPackage) }; // interface System // SYSTEM FACTORY INTERFACE /** Factory for System */ interface SystemFactory : ManagedObjectFactory { ManagedObject create (in NameBindingType nameBinding, in MONameType superior, in string reqID, // auto naming if empty string out MONameType name, in AdministrativeStateType administrativeState // GET-REPLACE // administrativeStatePackage ) raises (ApplicationError, CreateError); }; // interface SystemFactory // SUBSYSTEM INTERFACE /** This valuetype is used to retrieve multiple attributes. */ valuetype SubsystemValueType : truncatable SystemValueType { }; // valuetype SubsystemValueType /** The Subsystem managed object class may be used as a common containment point for managed objects in a system that relate to the operation of a given layer. The choice of structuring within a system is dependent on what structure the system designer wishes to present externally for management purposes. This managed object class represents a portion of a system where components are named independently of the components of other subsystems. */ interface Subsystem : System { }; // interface Subsystem // SUBSYSTEM FACTORY INTERFACE /** Factory for Subsystem */ interface SubsystemFactory : ManagedObjectFactory { ManagedObject create (in NameBindingType nameBinding, in MONameType superior, in string reqID, // auto naming if empty string out MONameType name, in AdministrativeStateType administrativeState // GET-REPLACE // administrativeStatePackage ) raises (ApplicationError, CreateError); }; // interface SubsystemFactory // NOTIFICATIONS INTERFACE /** This interface contains the definitions of notifications emitted by many managed objects. <p> The use of "typed" notifications is done here so that the notifications can be documented in IDL and to support typed notifications for those manager and managing systems that wish to use them. Note that the OMG's Notification Service supports both structured and typed notifications. It is not clear if implementations of the Notification Service will support translation between them. It is expected that the implementation agreement between the managing and managed system will specify the use of structured or typed notifications. <p> Notification users wishing to use typed notifications need only support the interfaces below. Notification publishers and subscribers wishing to use structured notifications based on the operations defined below should follow these rules for constructing and reading the notification structure: <ul><li> The domain_type string in the fixed header of the structure should be set to "telecommunications". <li> The event_type string in the fixed header of the structure should be set to the scoped name of the operation. For example, for the Attribute Value Change notification defined below this field would be "itut_x780::Notifications::attributeValueChange". <li> The event_name string in the fixed header of the structure is not used by this framework. It can be set to null or used for other purposes. <li> Optional header fields may be included to support features like Quality of Service as appropriate. <li> Each parameter in the operation should be placed in a name-value pair in the filterable body portion of the notification. The fd_name string of this pair shall be set to the name of the parameter and the type placed in the associated fd_value will be the type specified for the parameter. For example, each of the notifications defined below has a parameter named "eventTime" that is an "ExternalTimeType." This parameter would be placed in the filterable data portion of the event. The fd_name string of this pair would be set to "eventTime" and fd_value would contain an ExternalTimeType value. <li> The remainder of the body of the notification (the unfilterable part) should be null. </ul> Unfortunately, typed notifications are mapped to notification structures differently, so if one system wants to use typed notifications and the other structured, the structured notification user must be aware of how the CORBA Notification Service translates typed notifications to structured notifications. See the specification for details. In short, however, each of the parameters in the operations below will be converted into a name-value pair in the filterable data protion of the structured notification. Also, the event_type field in the fixed header of the structured notification will be set to the special value "%TYPED" and the domain_type field will be an empty string. Finally, a name-value pair will be added as the first element in the filterable data portion of the notification with the name "operation". The value associated with this name will be a string with the value set to the scoped name of the operation used to emit the notification (e.g. itut_x780::Notifications::attributeValueChange). <p> Also, structured notification publishers may exclude notification parameters that are marked "optional" or are of an optional type (a type name ending in "TypeOpt." This should be done for efficiency. This will, however, preclude the automatic conversion of structured notifications to typed, so managers must be capable of accepting structured notifications. (They do not strictly have to support typed notifications, but if managed systems emit typed notifications managers should accept them rather than translations because it will be more efficient.) If an "optional" parameter is included in a notification, the "optional" type (discriminated union) must be used. <p> Parameters named "operation" should be avoided in notification operations to support the use of typed notifications. While the notification channel should be able to differentiate the real parameter from the one added based on their positions in the filterable data list, it could have an impact on filtering as the default filtering language does not have a way to differentiate parameters based on position. <p> Because the scoped operation name is placed in either the type_name string (when structured notifications are used) or a filterable body name-value pair with the name "operation" (when typed notifications are used), there is no "event type" parameter explicitly included in any of the notification data structures. */ interface Notifications { /** An Attribute Value Change notification is used to report changes to the attributes of an object such as addition or deletion of members to one or more set-valued attributes and replacement of the value of one or more attributes. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. param sourceIndicator Cause of event. Optional. Use "unknown" if not supported. @param attributeChanges Changed attributes */ void attributeValueChange ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SourceIndicatorType sourceIndicator, in AttributeChangeSetType attributeChanges ); /** A Communications Alarm notification is used to report when an object detects a communications error. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param probableCause @param specificProblems Optional. Zero length sequence indicates absence of this parameter. @param perceivedSeverity @param backedUpStatus "True" if backed up @param backUpObject Will be null if backedUpStatus is "false" @param trendIndication Optional. See type for details. @param thresholdInfo Optional. See type for details. @param stateChangeDefinition Optional. Zero length sequence indicates absence of this parameter. @param monitoredAttributes Optional. Zero length sequence indicates absence of this parameter. @param proposedRepairActions Optional. Zero length sequence indicates absence of this parameter. @param alarmEffectOnService True if alarm is service effecting. @param alarmingResumed True if alarming was just resumed, possibly resulting in delayed reporting of an alarm @param suspectObjectList Objects possibly involved in failure. */ void communicationsAlarm ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in ProbableCauseType probableCause, in SpecificProblemSetType specificProblems, in PerceivedSeverityType perceivedSeverity, in BooleanTypeOpt backedUpStatus, in NameType backUpObject, in TrendIndicationTypeOpt trendIndication, in ThresholdInfoType thresholdInfo, in AttributeChangeSetType stateChangeDefinition, in AttributeSetType monitoredAttributes, in ProposedRepairActionSetType proposedRepairActions, in BooleanTypeOpt alarmEffectOnService, in BooleanTypeOpt alarmingResumed, in SuspectObjectSetType suspectObjectList ); /** An Environmental Alarm notification is used to report a problem in the environment. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param probableCause @param specificProblems Optional. Zero length sequence indicates absence of this parameter. @param perceivedSeverity @param backedUpStatus "True" if backed up @param backUpObject Will be null if backedUpStatus is "false" @param trendIndication Optional. See type for details. @param thresholdInfo Optional. See type for details. @param stateChangeDefinition Optional. Zero length sequence indicates absence of this parameter. @param monitoredAttributes Optional. Zero length sequence indicates absence of this parameter. @param proposedRepairActions Optional. Zero length sequence indicates absence of this parameter. @param alarmEffectOnService True if alarm is service effecting. @param alarmingResumed True if alarming was just resumed, possibly resulting in delayed reporting of an alarm @param suspectObjectList Objects possibly involved in failure. */ void environmentalAlarm ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in ProbableCauseType probableCause, in SpecificProblemSetType specificProblems, in PerceivedSeverityType perceivedSeverity, in BooleanTypeOpt backedUpStatus, in NameType backUpObject, in TrendIndicationTypeOpt trendIndication, in ThresholdInfoType thresholdInfo, in AttributeChangeSetType stateChangeDefinition, in AttributeSetType monitoredAttributes, in ProposedRepairActionSetType proposedRepairActions, in BooleanTypeOpt alarmEffectOnService, in BooleanTypeOpt alarmingResumed, in SuspectObjectSetType suspectObjectList ); /** An Equipment Alarm notification is used to report a failure in the equipment. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param probableCause @param specificProblems Optional. Zero length sequence indicates absence of this parameter. @param perceivedSeverity @param backedUpStatus "True" if backed up @param backUpObject Will be null if backedUpStatus is "false" @param trendIndication Optional. See type for details. @param thresholdInfo Optional. See type for details. @param stateChangeDefinition Optional. Zero length sequence indicates absence of this parameter. @param monitoredAttributes Optional. Zero length sequence indicates absence of this parameter. @param proposedRepairActions Optional. Zero length sequence indicates absence of this parameter. @param alarmEffectOnService True if alarm is service effecting. @param alarmingResumed True if alarming was just resumed, possibly resulting in delayed reporting of an alarm @param suspectObjectList Objects possibly involved in failure. */ void equipmentAlarm ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in ProbableCauseType probableCause, in SpecificProblemSetType specificProblems, in PerceivedSeverityType perceivedSeverity, in BooleanTypeOpt backedUpStatus, in NameType backUpObject, in TrendIndicationTypeOpt trendIndication, in ThresholdInfoType thresholdInfo, in AttributeChangeSetType stateChangeDefinition, in AttributeSetType monitoredAttributes, in ProposedRepairActionSetType proposedRepairActions, in BooleanTypeOpt alarmEffectOnService, in BooleanTypeOpt alarmingResumed, in SuspectObjectSetType suspectObjectList ); /** An Integrity Violation notification is used to report that a potential interruption in information flow has occurred such that information may have been illegally modified, inserted or deleted. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param securityAlarmCause @param securityAlarmSeverity Clears allowed? X.721 appears to restrict the "cleared" value on this alarm but clears should be allowed. @param securityAlarmDetector @param serviceUser @param serviceProvider */ void integrityViolation ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SecurityAlarmCauseType securityAlarmCause, in PerceivedSeverityType securityAlarmSeverity, in SecurityAlarmDetectorType securityAlarmDetector, in ServiceUserType serviceUser, in ServiceProviderType serviceProvider ); /** An Object Creation notification is used to report the creation of a managed object to another open system. Note that the source field should be set to the created object, not the factory. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param sourceIndicator Cause of event. Optional. Use "unknown" if not supported. @param attributeSet Attribute values. Optional. Zero length sequence indicates absence of this parameter. */ void objectCreation ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SourceIndicatorType sourceIndicator, in AttributeSetType attributeList ); /** An Object Deletion notification is used to report the deletion of a managed object. Note that the source field should be set to the object being deleted. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param sourceIndicator Cause of event. Optional. Use "unknown" if not supported. @param attributeSet Attribute values. Optional. Zero length sequence indicates absence of this parameter. */ void objectDeletion ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SourceIndicatorType sourceIndicator, in AttributeSetType attributeList ); /** An Operational Violation notification is used to report that the provision of the requested service was not possible due to the unavailability, malfunction or incorrect invocation of the service. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param securityAlarmCause @param securityAlarmSeverity Clears allowed? X.721 appears to restrict the "cleared" value on this alarm but clears should be allowed. @param securityAlarmDetector @param serviceUser @param serviceProvider */ void operationalViolation ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SecurityAlarmCauseType securityAlarmCause, in PerceivedSeverityType securityAlarmSeverity, in SecurityAlarmDetectorType securityAlarmDetector, in ServiceUserType serviceUser, in ServiceProviderType serviceProvider ); /** A Physical Violation notification is used to report that a physical resource has been violated in a way that indicates a potential security attack. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param securityAlarmCause @param securityAlarmSeverity Clears allowed? X.721 appears to restrict the "cleared" value on this alarm but clears should be allowed. @param securityAlarmDetector @param serviceUser @param serviceProvider */ void physicalViolation ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SecurityAlarmCauseType securityAlarmCause, in PerceivedSeverityType securityAlarmSeverity, in SecurityAlarmDetectorType securityAlarmDetector, in ServiceUserType serviceUser, in ServiceProviderType serviceProvider ); /** A Processing Error Alarm notification is used to report a processing failure in a managed object. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param probableCause @param specificProblems Optional. Zero length sequence indicates absence of this parameter. @param perceivedSeverity @param backedUpStatus "True" if backed up @param backUpObject Will be null if backedUpStatus is "false" @param trendIndication Optional. See type for details. @param thresholdInfo Optional. See type for details. @param stateChangeDefinition Optional. Zero length sequence indicates absence of this parameter. @param monitoredAttributes Optional. Zero length sequence indicates absence of this parameter. @param proposedRepairActions Optional. Zero length sequence indicates absence of this parameter. @param alarmEffectOnService True if alarm is service effecting. @param alarmingResumed True if alarming was just resumed, possibly resulting in delayed reporting of an alarm @param suspectObjectList Objects possibly involved in failure. */ void processingErrorAlarm ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in ProbableCauseType probableCause, in SpecificProblemSetType specificProblems, in PerceivedSeverityType perceivedSeverity, in BooleanTypeOpt backedUpStatus, in NameType backUpObject, in TrendIndicationTypeOpt trendIndication, in ThresholdInfoType thresholdInfo, in AttributeChangeSetType stateChangeDefinition, in AttributeSetType monitoredAttributes, in ProposedRepairActionSetType proposedRepairActions, in BooleanTypeOpt alarmEffectOnService, in BooleanTypeOpt alarmingResumed, in SuspectObjectSetType suspectObjectList ); /** A Quality of Service Alarm notification is used to report a failure in the quality of service of the managed object. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param probableCause @param specificProblems Optional. Zero length sequence indicates absence of this parameter. @param perceivedSeverity @param backedUpStatus "True" if backed up @param backUpObject Will be null if backedUpStatus is "false" @param trendIndication Optional. See type for details. @param thresholdInfo Optional. See type for details. @param stateChangeDefinition Optional. Zero length sequence indicates absence of this parameter. @param monitoredAttributes Optional. Zero length sequence indicates absence of this parameter. @param proposedRepairActions Optional. Zero length sequence indicates absence of this parameter. @param alarmEffectOnService True if alarm is service effecting. @param alarmingResumed True if alarming was just resumed, possibly resulting in delayed reporting of an alarm @param suspectObjectList Objects possibly involved in failure. */ void qualityOfServiceAlarm ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in ProbableCauseType probableCause, in SpecificProblemSetType specificProblems, in PerceivedSeverityType perceivedSeverity, in BooleanTypeOpt backedUpStatus, in NameType backUpObject, in TrendIndicationTypeOpt trendIndication, in ThresholdInfoType thresholdInfo, in AttributeChangeSetType stateChangeDefinition, in AttributeSetType monitoredAttributes, in ProposedRepairActionSetType proposedRepairActions, in BooleanTypeOpt alarmEffectOnService, in BooleanTypeOpt alarmingResumed, in SuspectObjectSetType suspectObjectList ); /** A Relationship Change notification is used to report the change in the value of one or more relationship attributes of a managed object, that result through either internal operation of the managed object or via management operation. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param sourceIndicator Cause of event. Optional. Use "unknown" if not supported. @param relationshipChanges Changed relationship attributes */ void relationshipChange ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SourceIndicatorType sourceIndicator, in AttributeChangeSetType relationshipChanges ); /** A Security Violation notification is used to report that a security attack has been detected by a security service or mechanism. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param securityAlarmCause @param securityAlarmSeverity Clears allowed? X.721 appears to restrict the "cleared" value on this alarm but clears should be allowed. @param securityAlarmDetector @param serviceUser @param serviceProvider */ void securityViolation ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SecurityAlarmCauseType securityAlarmCause, in PerceivedSeverityType securityAlarmSeverity, in SecurityAlarmDetectorType securityAlarmDetector, in ServiceUserType serviceUser, in ServiceProviderType serviceProvider ); /** A State Change notification is used to report the change in the the value of one or more state attributes of a managed object, that result through either internal operation of the managed object or via management operation. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param sourceIndicator Cause of event. Optional. Use "unknown" if not supported. @param stateChanges Changed state attributes. */ void stateChange ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SourceIndicatorType sourceIndicator, in AttributeChangeSetType stateChanges ); /** A Time Domain Violation notification is used to report that an event has occurred at an unexpected or prohibited time. @param eventTime Managed system's current time. @param source Object emitting notification. @param sourceClass Actual class of source object. @param notificationIdentifier A unique identifier for this notification. Must be unique for an object instance. (Optional in X.721 but not here. See text for discussion of possible implications) @param correlatedNotifications List of correlated notifications. Optional. Zero length sequence indicates absence of this parameter. @param additionalText Text message. Optional. Zero length string indicates absence of this parameter. @param additionalInfo Optional. Zero length sequence indicates absence of this parameter. @param securityAlarmCause @param securityAlarmSeverity Clears allowed? X.721 appears to restrict the "cleared" value on this alarm but clears should be allowed. @param securityAlarmDetector @param serviceUser @param serviceProvider */ void timeDomainViolation ( in ExternalTimeType eventTime, in NameType source, in ObjectClassType sourceClass, in NotifIDType notificationIdentifier, in CorrelatedNotificationSetType correlatedNotifications, in AdditionalTextType additionalText, in AdditionalInformationSetType additionalInfo, in SecurityAlarmCauseType securityAlarmCause, in PerceivedSeverityType securityAlarmSeverity, in SecurityAlarmDetectorType securityAlarmDetector, in ServiceUserType serviceUser, in ServiceProviderType serviceProvider ); /** These constants define the names of the notifications declared above and are provided to help reduce errors. */ const string attributeValueChangeTypeName = "itut_x780::Notifications::attributeValueChange"; const string communicationsAlarmTypeName = "itut_x780::Notifications::communicationsAlarm"; const string environmentalAlarmTypeName = "itut_x780::Notifications::environmentalAlarm"; const string equipmentAlarmTypeName = "itut_x780::Notifications::equipmentAlarm"; const string integrityViolationTypeName = "itut_x780::Notifications::integrityViolation"; const string objectCreationTypeName = "itut_x780::Notifications::objectCreation"; const string objectDeletionTypeName = "itut_x780::Notifications::objectDeletion"; const string operationalViolationTypeName = "itut_x780::Notifications::operationalViolation"; const string physicalViolationTypeName = "itut_x780::Notifications::physicalViolation"; const string processingErrorAlarmTypeName = "itut_x780::Notifications::processingErrorAlarm"; const string qualityOfServiceAlarmTypeName = "itut_x780::Notifications::qualityOfServiceAlarm"; const string relationshipChangeTypeName = "itut_x780::Notifications::relationshipChange"; const string securityViolationTypeName = "itut_x780::Notifications::securityViolation"; const string stateChangeTypeName = "itut_x780::Notifications::stateChange"; const string timeDomainViolationTypeName = "itut_x780::Notifications::timeDomainViolation"; /** These constants define the names of the parameters used in the notifications declared above and are provided to help reduce errors. */ const string additionalInfoName = "additionalInfo"; const string additionalTextName = "additionalText"; const string alarmEffectOnServiceName = "alarmEffectOnService"; const string alarmingResumedName = "alarmingResumed"; const string attributeChangesName = "attributeChanges"; const string attributeListName = "attributeList"; const string backedUpStatusName = "backedUpStatus"; const string backUpObjectName = "backUpObject"; const string correlatedNotificationsName = "correlatedNotifications"; const string eventTimeName = "eventTime"; const string monitoredAttributesName = "monitoredAttributes"; const string notificationIdentifierName = "notificationIdentifier"; const string perceivedSeverityName = "perceivedSeverity"; const string probableCauseName = "probableCause"; const string proposedRepairActionsName = "proposedRepairActions"; const string relationshipChangesName = "relationshipChanges"; const string securityAlarmCauseName = "securityAlarmCause"; const string securityAlarmDetectorName = "securityAlarmDetector"; const string securityAlarmSeverityName = "securityAlarmSeverity"; const string serviceProviderName = "serviceProvider"; const string serviceUserName = "serviceUser"; const string sourceName = "source"; const string sourceClassName = "sourceClass"; const string sourceIndicatorName = "sourceIndicator"; const string specificProblemsName = "specificProblems"; const string stateChangeDefinitionName = "stateChangeDefinition"; const string stateChangesName = "stateChanges"; const string suspectObjectListName = "suspectObjectList"; const string thresholdInfoName = "thresholdInfo"; const string trendIndicationName = "trendIndication"; }; // end of Notifications interface // NAME BINDINGS /** This name binding is used to name the System object relative to the local root. That is, enable it to be the top-most managed object on a system. */ module System { const string superiorClass = ""; const boolean superiorSubclassesAllowed = FALSE; const string subordinateClass = "itut_x780::System"; const boolean subordinateSubclassesAllowed = TRUE; const boolean managerCreatesAllowed = FALSE; const DeletePolicyType deletePolicy = itut_x780::deleteOnlyIfNoContainedObjects; const string kind = "System"; }; // module System /** This name binding is used to name the Subsystem object relative to a Subsystem object. */ module Subsystem_Subsystem { const string superiorClass = "itut_x780::Subsystem"; const boolean superiorSubclassesAllowed = TRUE; const string subordinateClass = "itut_x780::Subsystem"; const boolean subordinateSubclassesAllowed = TRUE; const boolean managerCreatesAllowed = TRUE; const DeletePolicyType deletePolicy = itut_x780::deleteOnlyIfNoContainedObjects; const string kind = "Subsystem"; }; // module Subsystem_System /** This name binding is used to name the Subsystem object relative to a System object. */ module Subsystem_System { const string superiorClass = "itut_x780::System"; const boolean superiorSubclassesAllowed = TRUE; const string subordinateClass = "itut_x780::Subsystem"; const boolean subordinateSubclassesAllowed = TRUE; const boolean managerCreatesAllowed = TRUE; const DeletePolicyType deletePolicy = itut_x780::deleteOnlyIfNoContainedObjects; const string kind = "Subsystem"; }; // module Subsystem_System }; // end of itut_x780 module // MACROS /* The following macros are provided for quickly and concisely defining the notifications to be supported by an object. Example usage (within an interface): MANDATORY_NOTIFICATION(itut_x780::Notifications, objectCreation); CONDITIONAL_NOTIFICATION(itut_x780::Notifications, stateChange, statePackage); The macros simply expand into nothing, as CORBA IDL doesn't really have anything for them to expand into that makes sense. Eventually, these may be changed to expand into IDL supporting the CORBA Component Model. */ #undef MANDATORY_NOTIFICATION #define MANDATORY_NOTIFICATION(InterfaceName, NotificationName) #undef CONDITIONAL_NOTIFICATION #define CONDITIONAL_NOTIFICATION(InterfaceName, NotificationName, PackageName) #endif // end of ifndef itut_x780_IDL