path: root/lib/asn1/test/asn1_SUITE_data/Remote-Operations-Useful-Definitions.asn1

Remote-Operations-Useful-Definitions {joint-iso-itu-t remote-operations(4) useful-definitions(7) version2(1)}
DEFINITIONS IMPLICIT TAGS ::=
BEGIN

-- exports everything

IMPORTS

   OPERATION, ERROR, OPERATION-PACKAGE, Code
    FROM Remote-Operations-Information-Objects
   {joint-iso-itu-t remote-operations(4) informationObjects(5) version1(0)} 
   InvokeId, ROS{} 
    FROM Remote-Operations-Generic-ROS-PDUs 
   {joint-iso-itu-t remote-operations(4) generic-ROS-PDUs(6) version1(0)};


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.