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 package org.ogf.graap.wsag.interpreter.expr;
36
37 import java.util.Vector;
38
39 import org.ogf.graap.wsag.interpreter.IExpression;
40 import org.ogf.graap.wsag.interpreter.InterpreterContext;
41 import org.ogf.graap.wsag.interpreter.InterpreterException;
42 import org.ogf.schemas.graap.wsAgreement.TermCompositorType;
43 import org.ogf.schemas.graap.wsAgreement.TermType;
44
45
46
47
48
49
50
51
52
53
54
55
56
57 public abstract class AbstractExpression implements IExpression
58 {
59
60 private TermCompositorType expression;
61
62 private Vector<TermType> result;
63
64
65
66
67
68
69
70 public AbstractExpression( TermCompositorType term )
71 {
72 this.expression = term;
73 }
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88 protected abstract TermType[] interpret( TermType[] terms, InterpreterContext context )
89 throws InterpreterException;
90
91
92
93
94 public TermType[] interpret( InterpreterContext context ) throws InterpreterException
95 {
96 result = new Vector<TermType>();
97
98
99
100
101 interpretAllExpression( expression.getAllArray(), context );
102 interpretExactlyOneExpression( expression.getExactlyOneArray(), context );
103 interpretOneOrMoreExpression( expression.getOneOrMoreArray(), context );
104
105
106
107
108 interpretTerms( expression.getServiceDescriptionTermArray(), context );
109 interpretTerms( expression.getGuaranteeTermArray(), context );
110 interpretTerms( expression.getServicePropertiesArray(), context );
111 interpretTerms( expression.getServiceReferenceArray(), context );
112
113
114
115
116 TermType[] interpretedTerms = (TermType[]) result.toArray( new TermType[result.size()] );
117
118 return interpret( interpretedTerms, context );
119 }
120
121 private void interpretAllExpression( TermCompositorType[] compositor, InterpreterContext context )
122 throws InterpreterException
123 {
124
125 for ( int i = 0; i < compositor.length; i++ )
126 {
127 AllExpression allExpression = new AllExpression( compositor[i] );
128 TermType[] interpretionResult = allExpression.interpret( context );
129 for ( int j = 0; j < interpretionResult.length; j++ )
130 {
131 result.add( interpretionResult[j] );
132 }
133 }
134
135 }
136
137 private void interpretExactlyOneExpression( TermCompositorType[] compositor, InterpreterContext context )
138 throws InterpreterException
139 {
140
141 for ( int i = 0; i < compositor.length; i++ )
142 {
143 ExactlyOneExpression allExpression = new ExactlyOneExpression( compositor[i] );
144 TermType[] interpretionResult = allExpression.interpret( context );
145
146 if ( interpretionResult.length != 1 )
147 {
148 throw new InterpreterException(
149 "ExaclyOne expression returned interpretation result unequal 1." );
150 }
151
152 result.add( interpretionResult[0] );
153 }
154
155 }
156
157 private void interpretOneOrMoreExpression( TermCompositorType[] compositor, InterpreterContext context )
158 throws InterpreterException
159 {
160
161 for ( int i = 0; i < compositor.length; i++ )
162 {
163 OneOrMoreExpression oneOrMoreExpression = new OneOrMoreExpression( compositor[i] );
164 TermType[] interpretionResult = oneOrMoreExpression.interpret( context );
165
166 if ( interpretionResult.length == 0 )
167 {
168 throw new InterpreterException( "OneOrMore expression returned no interpretation result." );
169 }
170
171 for ( int j = 0; j < interpretionResult.length; j++ )
172 {
173 result.add( interpretionResult[j] );
174 }
175 }
176
177 }
178
179 private void interpretTerms( TermType[] terms, InterpreterContext context ) throws InterpreterException
180 {
181
182 for ( int i = 0; i < terms.length; i++ )
183 {
184 TermExpression oneOrMoreExpression = new TermExpression( terms[i] );
185 TermType[] interpretionResult = oneOrMoreExpression.interpret( context );
186
187 for ( int j = 0; j < interpretionResult.length; j++ )
188 {
189 result.add( interpretionResult[j] );
190 }
191 }
192
193 }
194 }