/*
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2019 Ericsson Telecom AB
//
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
///////////////////////////////////////////////////////////////////////////////
//
//  File:               Remote_Operations_Generic_ROS_PDUs.asn
//  Rev:                R2B
//  Updated:            2010-05-20
//  Prodnr:             CNL 113 369
//  Contact:            http://ttcn.ericsson.se
//  Reference:          ITU-T X.880
*/ 
-- Module Remote-Operations-Generic-ROS-PDUs (X.880:07/1994)
Remote-Operations-Generic-ROS-PDUs {joint-iso-itu-t remote-operations(4)
  generic-ROS-PDUs(6) version1(0)} DEFINITIONS IMPLICIT TAGS ::=
BEGIN

-- exports everything
IMPORTS
  OPERATION, ERROR
    FROM Remote-Operations-Information-Objects {joint-iso-itu-t
      remote-operations(4) informationObjects(5) version2(1)};

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

  -- the following fields are needed for ASN.1 decoding
  -- please do not modify them
  
--  invoke-help        [5]  Invoke-help{{InvokeIdSet}, {Invokable}},
--  returnResult-help  [6]  ReturnResult-help{{Returnable}},
--  returnError-help   [7]  ReturnError-help{{Errors  {{Returnable}}}}

  
}
(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] EXPLICIT 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)
 })

-- the following type is for ASN.1 decoding purposes
-- please do not modify it

Invoke-help{InvokeId:InvokeIdSet, OPERATION:Operations} ::= SEQUENCE {
  invokeId
    InvokeId(InvokeIdSet)
      (CONSTRAINED BY {-- must be unambiguous -- } !
       RejectProblem:invoke-duplicateInvocation),
  linkedId 
    CHOICE {present  [0] EXPLICIT 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 ANY 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)

-- the following type is for ASN.1 decoding purposes
-- please do not modify it

ReturnResult-help{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 
			  	ANY
    } 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 -- ErrorParameterType{{Errors}}
    ERROR.&ParameterType
      ({Errors}{@errcode} !RejectProblem:returnError-mistypedParameter)
      OPTIONAL
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)


-- the following type is for ASN.1 decoding purposes
-- please do not modify it

ReturnError-help{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 
  	ANY OPTIONAL
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)


Reject ::= SEQUENCE {
  invokeId  InvokeId,
  problem	ProblemType
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)
}

ProblemType ::=     CHOICE {
	general       [0]  GeneralProblem,
    invoke        [1]  InvokeProblem,
    returnResult  [2]  ReturnResultProblem,
    returnError   [3]  ReturnErrorProblem
}


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
}

--PresentInvokeId InvokeId ::= {present:1..65536}  TR HL89739
PresentInvokeId InvokeId ::= { WITH COMPONENTS { ..., present (1..65536) } }

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})
}

END -- end of generic ROS PDU definitions



