path: root/lib/asn1/test/asn1_SUITE_data/ROSE.asn1

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,
    &parameterTypeOptional BOOLEAN OPTIONAL,
    &ErrorPriority Priority OPTIONAL,
    &errorCode Code UNIQUE OPTIONAL
    }
WITH SYNTAX
{
    [PARAMETER &ParameterType [OPTIONAL &parameterTypeOptional]]
    [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.