1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.tuscany.sca.interfacedef;
/**
* The InterfaceContractMapper is responsible to match interfaces
*
* @version $Rev$ $Date$
*/
public interface InterfaceContractMapper {
/**
* Check the compatibility of the source and the target interface contracts.
* <p>
* A wire may only connect a source to a target if the target implements an
* interface that is compatible with the interface required by the source.
* The source and the target are compatible if: <p/>
* <ol>
* <li>the source interface and the target interface MUST either both be
* remotable or they are both local
* <li>the methods on the target interface MUST be the same as or be a
* superset of the methods in the interface specified on the source
* <li>compatibility for the individual method is defined as compatibility
* of the signature, that is method name, input types, and output types MUST
* BE the same.
* <li>the order of the input and output types also MUST BE the same.
* <li>the set of Faults and Exceptions expected by the source MUST BE the
* same or be a superset of those specified by the service.
* <li>other specified attributes of the two interfaces MUST match,
* including Scope and Callback interface
* </ol>
* <p/>
* <p>
* This relationship implies that the source contract is a subset of the target
* contract - ie all the operations of the source must be present in the target, but
* the target can in principle contain additional operations not present in the
* source
* </p>
* <p>
* Please note this test is not symmetric: the success of isCompatible(A, B)
* does NOT imply isCompatible(B, A)
*
* @param source The source interface contract
* @param target The target interface contract
* @return true if the source contract can be supported by the target
* contract
*/
boolean isCompatible(InterfaceContract source, InterfaceContract target);
/**
* Check that two interface contracts are equal. The contracts are equal if the two contracts have the
* same set of operations, with each operation having the same signature.
* @param source - the source contract
* @param target - the target contract
* @return
*/
boolean isEqual(InterfaceContract source, InterfaceContract target);
/**
* Check that two interfaces are equal. The interfaces are equal if the two interfaces have the
* same set of operations, with each operation having the same signature.
* @param source an interface
* @param target a second interface
* @return true if the two interfaces are equal, otherwise return false
*/
public boolean isEqual(Interface source, Interface target);
/**
* @param source
* @param target
* @param ignoreCallback
* @param silent
* @return
* @throws IncompatibleInterfaceContractException
*/
boolean checkCompatibility(InterfaceContract source,
InterfaceContract target,
boolean ignoreCallback,
boolean silent) throws IncompatibleInterfaceContractException;
/**
* Test if the source data type is compatible with the target data type. The
* compatibility is defined as follows.
* <ul>
* <li>source's logical type is either the same or subtype of the target's
* logical type
* </ul>
* For example, if the source type is a SDO Customer and the target type is
* a JAXB Customer and both Customer are generated from the same XSD type.
*
* @param source The source data type
* @param target The target data type
* @return
*/
boolean isCompatible(DataType<?> source, DataType<?> target, boolean remotable);
/**
* Check if source operation is compatible with the target operation
*
* @param source The source operation
* @param target The target operation
* @return true if the source operation is compatible with the target
* operation
*/
boolean isCompatible(Operation source, Operation target, boolean remotable);
/**
* @param source
* @param target
* @return
*/
boolean isCompatible(Interface source, Interface target);
/**
* Map the source operation to a compatible operation in the target
* interface
*
* @param target The target interface
* @param source The source operation
* @return A compatible operation
*/
Operation map(Interface target, Operation source);
}
|
