📄 rose94.txt

📁 Ecma-285-source_files:CSTAIII协议的ASN.1描述
💻 TXT
字号:
Remote-Operations-Information-Objects {joint-iso-itu-t remote-operations(4) informationObjects(5) version1(0)}
DEFINITIONS ::=
BEGIN
-- exports everything
IMPORTS emptyBind, emptyUnbind FROM Remote-Operations-Useful-Definitions{joint-iso-itu-t remote-operations(4) useful-definitions(7) version1(0)};
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,
	&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]
	[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)
END -- end of Information Object specifications
      

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) version1(0)}; 
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-unrecognisedPDU)
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-unrecognisedLinkedId) 
					(CONSTRAINED BY {-- which has one or more linked operations--}
					! RejectProblem : invoke-linkedResponseUnexpected) 
						OPTIONAL,
	opcode	OPERATION.&operationCode
					({Operations}
					! RejectProblem : invoke-unrecognisedOperation), 
	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-unrecognisedInvocation) 
					(CONSTRAINED BY {-- which returns a result --}
					! RejectProblem : returnResult-resultResponseUnexpected),
	result	SEQUENCE
	{
	opcode	OPERATION.&operationCode
					({Operations})(CONSTRAINED BY {-- identified by invokeId --}
					! RejectProblem : returnResult-unrecognisedInvocation),
	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-unrecognisedInvocation) 
					(CONSTRAINED BY {-- which returns an error --}
					! RejectProblem : returnError-errorResponseUnexpected),
	errcode	ERROR.&errorCode
				 	({Errors}
					! RejectProblem : returnError-unrecognisedError) 
					(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
{
	unrecognisedPDU (0),
	mistypedPDU (1),
	badlyStructuredPDU (2)
}
InvokeProblem ::= INTEGER
{
	duplicateInvocation (0),
	unrecognisedOperation (1),
	mistypedArgument (2),
	resourceLimitation (3),
	releaseInProgress (4),
	unrecognisedLinkedId (5),
	linkedResponseUnexpected (6),
	unexpectedLinkedOperation (7)
}
ReturnResultProblem ::= INTEGER
{
	unrecognisedInvocation (0),
	resultResponseUnexpected (1),
	mistypedResult (2)
}
ReturnErrorProblem ::= INTEGER
{
	unrecognisedInvocation (0),
	errorResponseUnexpected (1),
	unrecognisedError (2),
	unexpectedError (3),
	mistypedParameter (4)
}
RejectProblem ::= INTEGER
{
	general-unrecognisedPDU (0),
	general-mistypedPDU (1),
	general-badlyStructuredPDU (2),
	invoke-duplicateInvocation (10),
	invoke-unrecognisedOperation (11),
	invoke-mistypedArgument (12),
	invoke-resourceLimitation (13),
	invoke-releaseInProgress (14),
	invoke-unrecognisedLinkedId (15),
	invoke-linkedResponseUnexpected (16),
	invoke-unexpectedLinkedOperation (17),
	returnResult-unrecognisedInvocation (20),
	returnResult-resultResponseUnexpected (21),
	returnResult-mistypedResult (22),
	returnError-unrecognisedInvocation (30),
	returnError-errorResponseUnexpected (31),
	returnError-unrecognisedError (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})
}
END -- end of generic ROS PDU definitions
     

Remote-Operations-Useful-Definitions {joint-iso-itu-t remote-operations(4) useful-definitions(7) version1(0)}
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 ::=
{
	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.&Supplier}
	SUPPLIER INVOKES	{package.&Consumer}
	ID			id
}
combine {OPERATION-PACKAGE:ConsumerConsumes, OPERATION-PACKAGE:ConsumerSupplies, OPERATION-PACKAGE:base} OPERATION-PACKAGE ::= 
{
	OPERATIONS		{ConsumerConsumes.&Both | ConsumerSupplies.&Both}
	CONSUMER INVOKES	{ConsumerConsumes.&Supplier | ConsumerSupplies.&Consumer}
	SUPPLIER INVOKES	{ConsumerConsumes.&Consumer | ConsumerSupplies.&Supplier}
	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}}}
END -- end of useful definitions.
💿 文件大小 67 K
👤 上传用户 wangdatouay
📂 所属分类其他书籍
🏷️ 相关标签

#source_files #CSTAIII #Ecma #285
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -