MetaJolie

Inclusion code:

Service Deployment

Port Name

Location

Protocol

Interfaces

MetaJolie documentation:

MetaJolie

-

-

MetaJolieInterface

List of Available Interfaces

MetaJolieInterface

Interface documentation:

Operation Name

Input Type

Output Type

Faults

getInputPortMetaData

GetInputPortMetaDataRequest

GetInputPortMetaDataResponse

ParserException( ParserExceptionType ) InputPortMetaDataFault( undefined ) SemanticException( SemanticExceptionType )

getMetaData

GetMetaDataRequest

GetMetaDataResponse

ParserException( ParserExceptionType ) SemanticException( SemanticExceptionType )

messageTypeCast

MessageTypeCastRequest

MessageTypeCastResponse

TypeMismatch( undefined )

checkNativeType

CheckNativeTypeRequest

CheckNativeTypeResponse

Operation Description

getInputPortMetaData

Operation documentation:

Invocation template:

getInputPortMetaData@MetaJolie( request )( response )

Request type

Type: GetInputPortMetaDataRequest

type GetInputPortMetaDataRequest: void {
.filename: string
.name?: Name
}

GetInputPortMetaDataRequest : void

  • filename : string : the filename where the service definition is

  • name : void : the absolute name to give to the resource. in this operation only .domain will be used. default .domain = "".

Response type

Type: GetInputPortMetaDataResponse

type GetInputPortMetaDataResponse: void {
.input*: Port
}

GetInputPortMetaDataResponse : void

  • input : void : the full description of each input port of the service definition

Possible faults thrown

Fault ParserException with type ParserExceptionType

Fault-handling install template:

install ( ParserException => /* error-handling code */ )
type ParserExceptionType: void {
.line: int
.sourceName: string
.message: string
}

Fault InputPortMetaDataFault with type undefined

Fault-handling install template:

install ( InputPortMetaDataFault => /* error-handling code */ )

Fault SemanticException with type SemanticExceptionType

Fault-handling install template:

install ( SemanticException => /* error-handling code */ )
type SemanticExceptionType: void {
.error*: void {
.line: int
.sourceName: string
.message: string
}
}

getMetaData

Operation documentation:

Invocation template:

getMetaData@MetaJolie( request )( response )

Request type

Type: GetMetaDataRequest

type GetMetaDataRequest: void {
.filename: string
.name: Name
}

GetMetaDataRequest : void

  • filename : string : the filename where the service definition is

  • name : void : the name and the domain name to give to the service

Response type

Type: GetMetaDataResponse

type GetMetaDataResponse: void {
.output*: Port
.input*: Port
.interfaces*: Interface
.types*: Type
.service: Service
.embeddedServices*: void {
.servicepath: string
.type: string
.portId: string
}
}

GetMetaDataResponse : void

  • output : void : the definitions of all the output ports

  • input : void : the definitions of all the input ports

  • interfaces : void : the definitions of all the interfaces

  • types : void : the definitions of all the types

  • service : void : the definition of the service

  • embeddedServices : void : the definitions of all the embedded services

    • servicepath : string : path where the service can be found

    • type : string : type of the embedded service

    • portId : string : target output port where the embedded service is bound

Possible faults thrown

Fault ParserException with type ParserExceptionType

Fault-handling install template:

install ( ParserException => /* error-handling code */ )
type ParserExceptionType: void {
.line: int
.sourceName: string
.message: string
}

Fault SemanticException with type SemanticExceptionType

Fault-handling install template:

install ( SemanticException => /* error-handling code */ )
type SemanticExceptionType: void {
.error*: void {
.line: int
.sourceName: string
.message: string
}
}

messageTypeCast

Operation documentation:

Invocation template:

messageTypeCast@MetaJolie( request )( response )

Request type

Type: MessageTypeCastRequest

type MessageTypeCastRequest: void {
.types: void {
.types*: Type
.messageTypeName: Name
}
.message: undefined
}

MessageTypeCastRequest : void

  • types : void : the types to use for casting the message

    • types : void : list of all the required types

    • messageTypeName : void : starting type to user for casting

  • message : any : the message to be cast

Response type

Type: MessageTypeCastResponse

type MessageTypeCastResponse: void {
.message: undefined
}

MessageTypeCastResponse : void

  • message : any : casted message

Possible faults thrown

Fault TypeMismatch with type undefined

Fault-handling install template:

install ( TypeMismatch => /* error-handling code */ )

checkNativeType

Operation documentation:

Invocation template:

checkNativeType@MetaJolie( request )( response )

Request type

Type: CheckNativeTypeRequest

type CheckNativeTypeRequest: void {
.type_name: string
}

CheckNativeTypeRequest : void

  • type_name : string : the type name to check it is native

Response type

Type: CheckNativeTypeResponse

type CheckNativeTypeResponse: void {
.result: bool
}

CheckNativeTypeResponse : void

  • result : bool

Subtypes

Name

type Name: void { .registry?: string .domain?: string .name: string }

Port

type Port: void { .protocol: string .interfaces*: Interface .name: Name .location: any }

Interface

type Interface: void { .types*: Type .operations*: Operation .name: Name }

Type

type Type: void { .root_type: NativeType .sub_type*: SubType .name: Name }

NativeType

type NativeType: void { .string_type?: bool .void_type?: bool .raw_type?: bool .int_type?: bool .any_type?: bool .link?: void { .domain?: string .name: string } .bool_type?: bool .double_type?: bool .long_type?: bool }

SubType

type SubType: void { .type_inline?: Type .name: string .cardinality: Cardinality .type_link?: Name }

Cardinality

type Cardinality: void { .min: int .max?: int .infinite?: int }

Operation

type Operation: void { .operation_name: string .output?: Name .input: Name .documentation?: any .fault*: Fault }

Fault

type Fault: void { .type_name?: Name .name: Name }

Service

type Service: void { .output*: Name .input*: void { .domain: string .name: string } .name: Name }