ROSE DEFINITIONS IMPLICIT TAGS ::=
BEGIN
OPERATION ::= CLASS
{
&ArgumentType OPTIONAL,
&argumentTypeOptional BOOLEAN OPTIONAL,
&returnResult BOOLEAN DEFAULT TRUE,
&ResultType OPTIONAL,
&resultTypeOptional BOOLEAN OPTIONAL,
&Errors ERROR OPTIONAL,
&Linked OPERATION OPTIONAL,
&synchronous BOOLEAN DEFAULT FALSE,
&idempotent BOOLEAN DEFAULT FALSE,
&alwaysReturns BOOLEAN DEFAULT TRUE,
&InvokePriority Priority OPTIONAL,
&ResultPriority Priority OPTIONAL,
&operationCode Code UNIQUE OPTIONAL
}
WITH SYNTAX
{
[ARGUMENT &ArgumentType [OPTIONAL &argumentTypeOptional]]
[RESULT &ResultType [OPTIONAL &resultTypeOptional]]
[RETURN RESULT &returnResult]
[ERRORS &Errors]
[LINKED &Linked]
[SYNCHRONOUS &synchronous]
[IDEMPOTENT &idempotent]
[ALWAYS RESPONDS &alwaysReturns]
[INVOKE PRIORITY &InvokePriority]
[RESULT-PRIORITY &ResultPriority]
[CODE &operationCode]
}
ERROR ::= CLASS
{
&ParameterType OPTIONAL,
¶meterTypeOptional BOOLEAN OPTIONAL,
&ErrorPriority Priority OPTIONAL,
&errorCode Code UNIQUE OPTIONAL
}
WITH SYNTAX
{
[PARAMETER &ParameterType [OPTIONAL ¶meterTypeOptional]]
[PRIORITY &ErrorPriority]
[CODE &errorCode]
}
OPERATION-PACKAGE ::= CLASS
{
&Both OPERATION OPTIONAL,
&Consumer OPERATION OPTIONAL,
&Supplier OPERATION OPTIONAL,
&id OBJECT IDENTIFIER UNIQUE OPTIONAL
}
WITH SYNTAX
{
[OPERATIONS &Both]
[CONSUMER INVOKES &Supplier]
[SUPPLIER INVOKES &Consumer]
[ID &id]
}
CONNECTION-PACKAGE ::= CLASS
{
&bind OPERATION DEFAULT emptyBind,
&unbind OPERATION DEFAULT emptyUnbind,
&responderCanUnbind BOOLEAN DEFAULT FALSE,
&unbindCanFail BOOLEAN DEFAULT FALSE,
&id OBJECT IDENTIFIER UNIQUE OPTIONAL
}
WITH SYNTAX
{
[BIND &bind]
[UNBIND &unbind]
[RESPONDER UNBIND &responderCanUnbind]
[FAILURE TO UNBIND &unbindCanFail]
[ID &id]
}
CONTRACT ::= CLASS
{
&connection CONNECTION-PACKAGE OPTIONAL,
&OperationsOf OPERATION-PACKAGE OPTIONAL,
&InitiatorConsumerOf OPERATION-PACKAGE OPTIONAL,
&InitiatorSupplierOf OPERATION-PACKAGE OPTIONAL,
&id OBJECT IDENTIFIER UNIQUE OPTIONAL
}
WITH SYNTAX
{
[CONNECTION &connection]
[OPERATIONS OF &OperationsOf]
[INITIATOR CONSUMER OF &InitiatorConsumerOf]
[RESPONDER CONSUMER OF &InitiatorSupplierOf]
[ID &id]
}
ROS-OBJECT-CLASS ::= CLASS
{
&Is ROS-OBJECT-CLASS OPTIONAL,
&Initiates CONTRACT OPTIONAL,
&Responds CONTRACT OPTIONAL,
&InitiatesAndResponds CONTRACT OPTIONAL,
&id OBJECT IDENTIFIER UNIQUE
}
WITH SYNTAX
{
[IS &Is]
[BOTH &InitiatesAndResponds]
[INITIATES &Initiates]
[RESPONDS &Responds]
ID &id
}
Code ::= CHOICE
{
local INTEGER,
global OBJECT IDENTIFIER
}
Priority ::= INTEGER (0..MAX)
ROS {InvokeId:InvokeIdSet,OPERATION:Invokable,OPERATION:Returnable} ::= CHOICE
{
invoke [1] Invoke {{InvokeIdSet}, {Invokable}},
returnResult [2] ReturnResult {{Returnable}},
returnError [3] ReturnError {{Errors{{Returnable}}}},
reject [4] Reject
}
(CONSTRAINED BY {-- must conform to the above definition --}
! RejectProblem : general-unrecognizedPDU)
Invoke {InvokeId:InvokeIdSet, OPERATION:Operations} ::= SEQUENCE
{
invokeId InvokeId (InvokeIdSet)
(CONSTRAINED BY {-- must be unambiguous --}
! RejectProblem : invoke-duplicateInvocation),
linkedId CHOICE {
present [0] IMPLICIT present < InvokeId,
absent [1] IMPLICIT NULL
}
(CONSTRAINED BY {-- must identify an outstanding operation --}
! RejectProblem : invoke-unrecognizedLinkedId)
(CONSTRAINED BY {-- which has one or more linked operations--}
! RejectProblem : invoke-linkedResponseUnexpected)
OPTIONAL,
opcode OPERATION.&operationCode
({Operations}
! RejectProblem : invoke-unrecognizedOperation),
argument OPERATION.&ArgumentType
({Operations} {@opcode}
! RejectProblem : invoke-mistypedArgument)
OPTIONAL
}
(CONSTRAINED BY {-- must conform to the above definition --}
! RejectProblem : general-mistypedPDU)
(
WITH COMPONENTS
{...,
linkedId ABSENT
}
| WITH COMPONENTS
{...,
linkedId PRESENT,
opcode
(CONSTRAINED BY {-- must be in the &Linked field of the associated operation --
}
! RejectProblem : invoke-unexpectedLinkedOperation)
}
)
ReturnResult {OPERATION:Operations}::= SEQUENCE
{
invokeId InvokeId
(CONSTRAINED BY {-- must be that for an outstanding operation --}
! RejectProblem:returnResult-unrecognizedInvocation)
(CONSTRAINED BY {-- which returns a result --}
! RejectProblem:returnResult-resultResponseUnexpected),
result SEQUENCE
{
opcode OPERATION.&operationCode
({Operations})(CONSTRAINED BY {-- identified by invokeId --}
! RejectProblem:returnResult-unrecognizedInvocation),
result OPERATION.&ResultType ({Operations} {@.opcode}
! RejectProblem:returnResult-mistypedResult)
}
OPTIONAL
}
(CONSTRAINED BY {-- must conform to the above definition --
}
! RejectProblem:general-mistypedPDU)
ReturnError {ERROR:Errors} ::= SEQUENCE
{
invokeId InvokeId
(CONSTRAINED BY {-- must be that for an outstanding operation --
}
! RejectProblem : returnError-unrecognizedInvocation)
(CONSTRAINED BY {-- which returns an error --
}
! RejectProblem : returnError-errorResponseUnexpected),
errcode ERROR.&errorCode
({Errors}
! RejectProblem : returnError-unrecognizedError)
(CONSTRAINED BY {-- must be in the &Errors field of the associated operation --
}
! RejectProblem : returnError-unexpectedError),
parameter ERROR.&ParameterType
({Errors}{@errcode}
! RejectProblem : returnError-mistypedParameter) OPTIONAL
}
(CONSTRAINED BY {-- must conform to the above definition --
}
! RejectProblem : general-mistypedPDU)
Reject ::= SEQUENCE
{
invokeId InvokeId,
problem CHOICE
{
general [0] GeneralProblem,
invoke [1] InvokeProblem,
returnResult [2] ReturnResultProblem,
returnError [3] ReturnErrorProblem
}
}
(CONSTRAINED BY {-- must conform to the above definition --
}
! RejectProblem : general-mistypedPDU)
GeneralProblem ::= INTEGER
{
unrecognizedPDU (0),
mistypedPDU (1),
badlyStructuredPDU (2)
}
InvokeProblem ::= INTEGER
{
duplicateInvocation (0),
unrecognizedOperation (1),
mistypedArgument (2),
resourceLimitation (3),
releaseInProgress (4),
unrecognizedLinkedId (5),
linkedResponseUnexpected (6),
unexpectedLinkedOperation (7)
}
ReturnResultProblem ::= INTEGER
{
unrecognizedInvocation (0),
resultResponseUnexpected (1),
mistypedResult (2)
}
ReturnErrorProblem ::= INTEGER
{
unrecognizedInvocation (0),
errorResponseUnexpected (1),
unrecognizedError (2),
unexpectedError (3),
mistypedParameter (4)
}
RejectProblem ::= INTEGER
{
general-unrecognizedPDU (0),
general-mistypedPDU (1),
general-badlyStructuredPDU (2),
invoke-duplicateInvocation (10),
invoke-unrecognizedOperation (11),
invoke-mistypedArgument (12),
invoke-resourceLimitation (13),
invoke-releaseInProgress (14),
invoke-unrecognizedLinkedId (15),
invoke-linkedResponseUnexpected (16),
invoke-unexpectedLinkedOperation (17),
returnResult-unrecognizedInvocation (20),
returnResult-resultResponseUnexpected (21),
returnResult-mistypedResult (22),
returnError-unrecognizedInvocation (30),
returnError-errorResponseUnexpected (31),
returnError-unrecognizedError (32),
returnError-unexpectedError (33),
returnError-mistypedParameter (34)
}
InvokeId ::= CHOICE
{
present INTEGER,
absent NULL
}
noInvokeId InvokeId ::= absent:NULL
NoInvokeId InvokeId ::= {noInvokeId}
Errors {OPERATION:Operations} ERROR ::= {Operations.&Errors}
Bind {OPERATION:operation} ::= CHOICE
{
bind-invoke [16] OPERATION.&ArgumentType({operation}),
bind-result [17] OPERATION.&ResultType ({operation}),
bind-error [18] OPERATION.&Errors.&ParameterType ({operation})
}
Unbind {OPERATION:operation} ::= CHOICE
{
unbind-invoke [19] OPERATION.&ArgumentType({operation}),
unbind-result [20] OPERATION.&ResultType ({operation}),
unbind-error [21] OPERATION.&Errors.&ParameterType ({operation})
}
emptyBind OPERATION ::= {ERRORS {refuse} SYNCHRONOUS TRUE}
emptyUnbind OPERATION ::= { SYNCHRONOUS TRUE }
refuse ERROR ::= {CODE local:-1}
no-op OPERATION ::=
{
IDEMPOTENT TRUE
ALWAYS RESPONDS FALSE
CODE local:-1
}
Forward {OPERATION:OperationSet} OPERATION ::=
{
OperationSet |
OperationSet.&Linked.&Linked |
OperationSet.&Linked.&Linked.&Linked.&Linked
}
Reverse {OPERATION:OperationSet} OPERATION ::=
{Forward{{OperationSet.&Linked}}}
ConsumerPerforms {OPERATION-PACKAGE:package} OPERATION ::=
{
Forward{{package.&Consumer}} |
Forward{{package.&Both}} |
Reverse{{package.&Supplier}} |
Reverse{{package.&Both}}
}
SupplierPerforms {OPERATION-PACKAGE:package} OPERATION ::=
{
Forward{{package.&Supplier}} |
Forward{{package.&Both}} |
Reverse{{package.&Consumer}} |
Reverse{{package.&Both}}
}
AllOperations {OPERATION-PACKAGE:package} OPERATION ::=
{
ConsumerPerforms {package} |
SupplierPerforms {package}
}
recode {OPERATION:operation, Code:code} OPERATION ::=
{
ARGUMENT operation.&ArgumentType
OPTIONAL operation.&argumentTypeOptional
RESULT operation.&ResultType
OPTIONAL operation.&resultTypeOptional
RETURN RESULT operation.&returnResult
ERRORS {operation.&Errors}
LINKED {operation.&Linked}
SYNCHRONOUS operation.&synchronous
ALWAYS RESPONDS operation.&alwaysReturns
INVOKE PRIORITY {operation.&InvokePriority}
RESULT-PRIORITY {operation.&ResultPriority}
CODE code
}
switch {OPERATION-PACKAGE:package, OBJECT IDENTIFIER:id} OPERATION-PACKAGE ::=
{
OPERATIONS {package.&Both}
CONSUMER INVOKES {package.&Consumer}
SUPPLIER INVOKES {package.&Supplier}
ID id
}
combine {OPERATION-PACKAGE:ConsumerConsumes,OPERATION-PACKAGE:ConsumerSupplies,
OPERATION-PACKAGE:base
} OPERATION-PACKAGE ::=
{
OPERATIONS {ConsumerConsumes.&Both | ConsumerSupplies.&Both}
CONSUMER INVOKES {ConsumerConsumes.&Consumer | ConsumerSupplies.&Supplier}
SUPPLIER INVOKES {ConsumerConsumes.&Supplier | ConsumerSupplies.&Consumer}
ID base.&id
}
ROS-SingleAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS
{{InvokeIdSet}, {AllOperations{package}}, {AllOperations{package}}}
ROS-ConsumerAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS
{{InvokeIdSet}, {ConsumerPerforms{package}}, {SupplierPerforms{package}}}
ROS-SupplierAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS
{{InvokeIdSet}, {SupplierPerforms{package}}, {ConsumerPerforms{package}}}
probe OPERATION ::=
{
ARGUMENT SEQUENCE
{
invokeId [0] InvokeId
}
RESULT ENUMERATED{running(0), finished(1), unknown(2), ...}
IDEMPOTENT TRUE
CODE local:-2
}
acknowledge OPERATION ::=
{
ARGUMENT InvokeId
RESULT ENUMERATED{acknowledged(0), unknown(1), ...}
IDEMPOTENT TRUE
CODE local:-3
}
ProbeAndAcknowledge OPERATION ::= {probe | acknowledge}
cancel OPERATION ::=
{
ARGUMENT InvokeId
ERRORS {cancelFailed}
IDEMPOTENT TRUE
CODE local:-4
}
cancelFailed ERROR ::=
{
PARAMETER SET
{
problem [0] CancelProblem,
operation [1] InvokeId
}
CODE local:-2
}
CancelProblem ::= ENUMERATED
{unknownOperation(0), tooLate(1), operationNotCancellable(2), ...}
cancelled ERROR ::= {CODE local:-3}
END -- end of useful definitions.
