MetaJolie

Inclusion code:

List of Available Interfaces

MetaJolieInterface

Interface documentation:

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 }