View Javadoc

1   /* 
2    * Copyright (c) 2007, Fraunhofer-Gesellschaft
3    * All rights reserved.
4    * 
5    * Redistribution and use in source and binary forms, with or without
6    * modification, are permitted provided that the following conditions are
7    * met:
8    * 
9    * (1) Redistributions of source code must retain the above copyright
10   *     notice, this list of conditions and the disclaimer at the end.
11   *     Redistributions in binary form must reproduce the above copyright
12   *     notice, this list of conditions and the following disclaimer in
13   *     the documentation and/or other materials provided with the
14   *     distribution.
15   * 
16   * (2) Neither the name of Fraunhofer nor the names of its
17   *     contributors may be used to endorse or promote products derived
18   *     from this software without specific prior written permission.
19   * 
20   * DISCLAIMER
21   * 
22   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33   *  
34   */
35  package org.ogf.graap.wsag.interpreter;
36  
37  import org.ogf.graap.wsag.interpreter.expr.AllExpression;
38  import org.ogf.schemas.graap.wsAgreement.AgreementTemplateType;
39  import org.ogf.schemas.graap.wsAgreement.AgreementType;
40  import org.ogf.schemas.graap.wsAgreement.GuaranteeTermType;
41  import org.ogf.schemas.graap.wsAgreement.ServiceDescriptionTermType;
42  import org.ogf.schemas.graap.wsAgreement.ServicePropertiesType;
43  import org.ogf.schemas.graap.wsAgreement.ServiceReferenceType;
44  import org.ogf.schemas.graap.wsAgreement.TermTreeType;
45  import org.ogf.schemas.graap.wsAgreement.TermType;
46  
47  /**
48   * The agreement interpreter evaluates the agreement language in the agreement terms property and checks
49   * whether or not the agreement is valid with respect to term composition.
50   * 
51   * @author Oliver Waeldrich
52   * 
53   */
54  public class AgreementInterpreter
55  {
56      /**
57       * Evaluates the term composition in the given template and returns the template if the terms in the
58       * template are valid with respect to term composition. Otherwise an exception is thrown.
59       * 
60       * @param template
61       *            the template to evaluate
62       * @return the valid template
63       * @throws InterpreterException
64       *             error during term processing
65       */
66      public AgreementTemplateType process( AgreementTemplateType template ) throws InterpreterException
67      {
68          return (AgreementTemplateType) interpretAgreementType( template );
69      }
70  
71      /**
72       * Evaluates the term composition in the given agreement and returns the agreement object if the terms are
73       * valid with respect to term composition.
74       * 
75       * @param agreement
76       *            the agreement to evaluate
77       * @return the valid agreement
78       * @throws InterpreterException
79       *             error during term processing
80       */
81      public AgreementType process( AgreementType agreement ) throws InterpreterException
82      {
83          return interpretAgreementType( agreement );
84      }
85  
86      private AgreementType interpretAgreementType( AgreementType toProcess ) throws InterpreterException
87      {
88  
89          toProcess = (AgreementType) toProcess.copy();
90  
91          AllExpression all = new AllExpression( toProcess.getTerms().getAll() );
92  
93          //
94          // interpret the all expression
95          //
96          TermType[] terms = all.interpret( new InterpreterContext() );
97  
98          TermTreeType processed = TermTreeType.Factory.newInstance();
99          processed.addNewAll();
100 
101         for ( int i = 0; i < terms.length; i++ )
102         {
103             if ( terms[i] instanceof ServiceDescriptionTermType )
104             {
105                 processed.getAll().addNewServiceDescriptionTerm().set( terms[i] );
106             }
107             if ( terms[i] instanceof GuaranteeTermType )
108             {
109                 processed.getAll().addNewGuaranteeTerm().set( terms[i] );
110             }
111             if ( terms[i] instanceof ServicePropertiesType )
112             {
113                 processed.getAll().addNewServiceProperties().set( terms[i] );
114             }
115             if ( terms[i] instanceof ServiceReferenceType )
116             {
117                 processed.getAll().addNewServiceReference().set( terms[i] );
118             }
119         }
120 
121         //
122         // reinitialize the term tree
123         //
124         toProcess.setTerms( processed );
125 
126         return toProcess;
127     }
128 }