Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.impl;
 
 import java.util.List;
 
 

Version:
$Rev: 1061329 $ $Date: 2011-01-20 16:57:06 +0200 (Thu, 20 Jan 2011) $
 
     
     protected ExtensionPointRegistry registry;
     protected BuilderExtensionPoint builders;
     protected ContractBuilder contractBuilder;
     
         this. = registry;
         this. = registry.getExtensionPoint(BuilderExtensionPoint.class);
     }
     
     public boolean isCompatible(DataType sourceDataType targetboolean passByValue) {
         return isCompatible(sourcetargetpassByValuenull);   
     }
 
     public boolean isCompatible(DataType sourceDataType targetboolean passByValueAudit audit) {
         if (source == target) {
             return true;
         }
         if (!passByValue) {
             if (source == null || target == null) {
                 if (audit != null){
                     audit.append("One of either the source or target data types is null for");
                 }
                 return false;
             }
             // For local case
             return target.getPhysical().isAssignableFrom(source.getPhysical());
         } else {
             // For remote interfaces where the target is represented with WSDL 
             // the source will have been converted to WSDL so we rely on JAXB mappings
             // being the same in both cases and just compare the type names directly. 
             // TODO - is this right?
             XMLType sourceLogicalType = null;
             
             // There is some nesting of data types (when GeneratedDataType is used) so
             // dig a bit deeper to find the real data type
             if (source.getLogical() instanceof DataType<?>){
                 sourceLogicalType = (XMLType)((DataType<?>)source.getLogical()).getLogical();
             } else {
                 sourceLogicalType = (XMLType)source.getLogical();
             }
             
             XMLType targetLogicalType = null
             
             if (target.getLogical() instanceof DataType<?>){
                 targetLogicalType = (XMLType)((DataType<?>)target.getLogical()).getLogical();
             } else {
                 targetLogicalType = (XMLType)target.getLogical();
             }
             
             // The logical type seems to be null in some cases, e.g. when the 
             // argument or return type is something like a Map. 
             // TODO - check when some type give rise to a null logical type
             if (sourceLogicalType.getTypeName() == null ||
                 targetLogicalType.getTypeName() == null) {
                return true;
            }
            
            boolean match = sourceLogicalType.getTypeName().equals(targetLogicalType.getTypeName());
            
            if (!match){
                
                QName anyType = new QName("http://www.w3.org/2001/XMLSchema""anyType");
                if (sourceLogicalType.getTypeName().equals(anyType) || 
                    targetLogicalType.getTypeName().equals(anyType)){
                    // special case where a Java interface uses a generic type, e.g.
                    // public OMElement getGreetings(OMElement om)
                    // while the provided WSDL uses a specific type. So we assume
                    // that xsd:anyType matched anything
                    match = true;
                } else {
                    if (audit != null){
                        audit.append("Operation argument types source = " + 
                                     sourceLogicalType.getTypeName() + 
                                     " target = " + 
                                     targetLogicalType.getTypeName() +
                                     " don't match for");
                    }
                }
            }
            
            return match
        }
    }

    
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, both for forward and callback interfaces

Parameters:
source
target
Returns:
    public boolean isMutuallyCompatible(InterfaceContract sourceInterfaceContract target) {
        ExtensionType ext = source.getInterface().getExtensionType();
        InterfaceContract sourceContract = null;
        
        // Are the forward interfaces equal?
        if (isMutuallyCompatible(source.getInterface(), target.getInterface())) {
            // Is there a Callback interface?
            if (source.getCallbackInterface() == null && target.getCallbackInterface() == null) {
                return true;
            } else {
                if (isMutuallyCompatible(source.getCallbackInterface(), target.getCallbackInterface())) {
                    return true;
                } // end if
            } // end if
        } // end if
        return false;
    } // end method isEqual

    
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.

Parameters:
source
target
Returns:
    public boolean isMutuallyCompatible(Interface sourceInterface target) {
        if (source == target) {
            // Shortcut for performance
            return true;
        } // end if
        if (source == null || target == null) {
            return false;
        } // end if
        if (source.isDynamic() || target.isDynamic()) {
            return true;
        }
        if (source.isRemotable() != target.isRemotable()) {
            return false;
        }
        if (source.getOperations().size() != target.getOperations().size()) {
            return false;
        }
        for (Operation operation : source.getOperations()) {
            Operation targetOperation = getOperation(target.getOperations(), operation.getName());
            if (targetOperation == null) {
                return false;
            }
            if (!isCompatible(operationtargetOperation.)) {
                return false;
            }
        }
        return true;
    } // end method isEqual
    public boolean isCompatible(Operation sourceOperation targetCompatibility compatibilityType) {
        return isCompatible(sourcetargetcompatibilityTypetrue);
    }
    public boolean isCompatible(Operation sourceOperation targetCompatibility compatibilityTypeboolean byValue) {
        return isCompatible(sourcetargetcompatibilityTypetruenull);
    }
    
    public boolean isCompatible(Operation sourceOperation targetCompatibility compatibilityTypeboolean byValueAudit audit) {
        if (source == target) {
            return true;
        }
        if (source.isDynamic() || target.isDynamic()) {
            return true;
        }
        // Check name
        if (!source.getName().equals(target.getName())) {
            if (audit != null){
                audit.append("operation names are not the same source = " +
                             source.getName() + 
                             " target = " +
                             target.getName());
                audit.appendSeperator();
            }
            return false;
        }
        if (source.getInterface().isRemotable() != target.getInterface().isRemotable()) {
            if (audit != null){
                audit.append("Interfaces have different remote settings source = " +
                             source.getName() + 
                             " target = " +
                             target.getName());
                audit.appendSeperator();
            }            
            return false;
        }
        if (source.isNonBlocking() != target.isNonBlocking()) {
            if (audit != null){
                audit.append("operations one-way not the same, source = " +
                             source.isNonBlocking() + 
                             " target = " +
                             target.isNonBlocking());
                audit.appendSeperator();
            }            
            return false;
        }
        boolean passByValue = (source.getInterface().isRemotable()) && byValue;
        //        if (source.getInterface().isRemotable()) {
        //            return true;
        //        }
        // FIXME: We need to deal with wrapped<-->unwrapped conversion
        // Check output type
        List<DataTypesourceOutputType = source.getOutputType().getLogical();
        List<DataTypetargetOutputType = target.getOutputType().getLogical();
        boolean checkSourceWrapper = true;
        List<DataTypesourceInputType = source.getInputType().getLogical();
        if (source.isWrapperStyle() && source.getWrapper() != null) {
            sourceInputType = source.getWrapper().getUnwrappedInputType().getLogical();
            sourceOutputType = source.getWrapper().getUnwrappedOutputType().getLogical();
            checkSourceWrapper = false;
        }
        boolean checkTargetWrapper = true;
        List<DataTypetargetInputType = target.getInputType().getLogical();
        if (target.isWrapperStyle() && target.getWrapper() != null) {
            targetInputType = target.getWrapper().getUnwrappedInputType().getLogical();
            targetOutputType = target.getWrapper().getUnwrappedOutputType().getLogical();
            checkTargetWrapper = false;
        }
/* TODO - Why are we assuming compatibility if one side is wrapped and the other is not?
        if (checkSourceWrapper != checkTargetWrapper) {
            return true;
        }
*/
       
        if ( sourceOutputType.size() != targetOutputType.size()) {
        	  if (audit != null){
                  audit.append("different number of output types");
                  audit.appendSeperator();
              } 
              return false;
        }
               
        for ( int i=0; i < sourceOutputType.size(); i++) {
        	 if (!isCompatible(targetOutputType.get(i), sourceOutputType.get(i), passByValueaudit)) {
                 if (audit != null){
                     audit.append(" output types");
                     audit.appendSeperator();
                 } 
                 return false;
             }
        }
       
        if (sourceInputType.size() != targetInputType.size()) {
            if (audit != null){
                audit.append("different number of input types");
                audit.appendSeperator();
            } 
            return false;
        }
        int size = sourceInputType.size();
        for (int i = 0; i < sizei++) {
            if (!isCompatible(sourceInputType.get(i), targetInputType.get(i), passByValueaudit)) {
                if (audit != null){
                    audit.append(" input types");
                    audit.appendSeperator();
                } 
                return false;
            }
        }
        // Check fault types
        for (DataType targetFaultType : target.getFaultTypes()) {
            // Source fault types must be the same or superset of target fault
            // types
            boolean found = true;
            for (DataType sourceFaultType : source.getFaultTypes()) {
                found = false;
                if (isCompatible(targetFaultTypesourceFaultTypepassByValueaudit)) {
                    // Target fault type can be covered by the source fault type
                    found = true;
                    break;
                }
            }
            if (!found) {
                if (audit != null){
                    audit.append("Fault types incompatible");
                    audit.appendSeperator();
                } 
                return false;
            }
        }
        return true;
    }    
    public boolean isCompatibleByReference(Operation sourceOperation targetCompatibility compatibilityType) {
        return isCompatible(sourcetargetcompatibilityTypefalse);
    }
    public boolean isCompatibleByValue(Operation sourceOperation targetCompatibility compatibilityType) {
        return isCompatible(sourcetargetcompatibilityTypetrue);
    }
    // FIXME: How to improve the performance for the lookup
    private Operation getOperation(List<OperationoperationsString name) {
        for (Operation op : operations) {
            if (op.getName().equals(name)) {
                return op;
            }
        }
        return null;
    }
    /*
     * this variant of the checkCompatibility method is intended to supersede the one without an audit argument
     * Presence of both method variants indicates a state of partial development
     */
    public boolean checkCompatibility(InterfaceContract source,
			                          InterfaceContract target
			                          Compatibility compatibility,
			                          boolean ignoreCallback
			                          boolean silent
			                          Audit audit)
		if (source == target) {
			// Shortcut for performance
			return true;
		}
		if (source == null || target == null) {
			return false;
		}
		if (source.getInterface() == target.getInterface()) {
			return ignoreCallback
					|| isCallbackCompatible(sourcetargetsilent);
		}
		if (source.getInterface() == null || target.getInterface() == null) {
			return false;
		}
		if (source.getInterface().isDynamic()
				|| target.getInterface().isDynamic()) {
			return ignoreCallback
					|| isCallbackCompatible(sourcetargetsilent);
		}
		if (source.getInterface().isRemotable() != target.getInterface()
			if (!silent) {
				audit.append("Remotable settings do not match: "source + "," + target); // TODO see if serialization is sufficient
						"Remotable settings do not match"sourcetarget);
else {
				return false;
			}
		}
		for (Operation operation : source.getInterface().getOperations()) {
			Operation targetOperation = map(target.getInterface(), operation);
			if (targetOperation == null) {
				if (!silent) {
	                audit.append("Operation " + operation.getName()+ " not found on target"); 
	                audit.appendSeperator();
							"Operation " + operation.getName()
" not found on target"sourcetarget);
else {
					return false;
				}
			}
			if (!silent) {
				if (audit == null)
					audit = new Audit();
				if (!isCompatible(operationtargetOperation,
						.trueaudit)) {
                    audit.append("Operations called " + operation.getName()+ " are not compatible"); 
                    audit.appendSeperator();
							"Operations called " + operation.getName()
" are not compatible " + auditsource,
							target);
				}
else {
				if (!isCompatible(operationtargetOperation,
					return false;
				}
			}
		}
		return ignoreCallback || isCallbackCompatible(sourcetargetsilent);
	}
    /*
     * The old checkCompatibility operation without auditing. This just delegates to the new one for the time
     * being while there are still calls that don't provide and audit object. In the medium term when the calls have
     * been converted to sue the new opetion directly this should be removed. 
     */
    public boolean checkCompatibility(InterfaceContract source,
                                      InterfaceContract target,
                                      Compatibility compatibility,
                                      boolean ignoreCallback,
                                      boolean silent
      
        // create dummy audit object.
        Audit audit = new Audit();
        
        return checkCompatibility(source
                                  target
                                  compatibility
                                  ignoreCallback
                                  silent,
                                  audit);
    }
    
    
    protected boolean isCallbackCompatible(InterfaceContract sourceInterfaceContract targetboolean silent)
        if (source.getCallbackInterface() == null && target.getCallbackInterface() == null) {
            return true;
        }
        if (source.getCallbackInterface() == null || target.getCallbackInterface() == null) {
            if (!silent) {
                throw new IncompatibleInterfaceContractException("Callback interface doesn't match as one of the callback interfaces is null"sourcetarget);
            } else {
                return false;
            }
        }
        for (Operation operation : source.getCallbackInterface().getOperations()) {
            Operation targetOperation =
                getOperation(target.getCallbackInterface().getOperations(), operation.getName());
            if (targetOperation == null) {
                if (!silent) {
                    throw new IncompatibleInterfaceContractException("Callback operation not found on target"source,
                                                                     targetnulltargetOperation);
                } else {
                    return false;
                }
            }
            if (!source.getCallbackInterface().isRemotable()) {
                // FIXME: for remotable operation, only compare name for now
                if (!operation.equals(targetOperation)) {
                    if (!silent) {
                        throw new IncompatibleInterfaceContractException("Target callback operation is not compatible",
                                                                         sourcetargetoperationtargetOperation);
                    } else {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    public boolean isCompatibleSubset(Interface sourceInterface target) {
        if (source == target) {
            // Shortcut for performance
            return true;
        }
        if (source == null || target == null) {
            return false;
        }
        if (source.isDynamic() || target.isDynamic()) {
            return true;
        }
        if (source.isRemotable() != target.isRemotable()) {
            return false;
        }
        for (Operation operation : source.getOperations()) {
            Operation targetOperation = getOperation(target.getOperations(), operation.getName());
            if (targetOperation == null) {
                return false;
            }
            if (!isCompatible(operationtargetOperation.)) {
                return false;
            }
        }
        return true;
    }
    /*
     * the variant of isCompatibleSubset with the audit parameter is intended to supersede the other
     * -- the presence of both indicates a partial development state
     */
    public boolean isCompatibleSubset(InterfaceContract sourceInterfaceContract targetAudit audit) {
        try {
            return checkCompatibility(sourcetarget.falsefalseaudit);
        } catch (IncompatibleInterfaceContractException e) {
            return false;
        }
    }
    
    public boolean isCompatibleSubset(InterfaceContract sourceInterfaceContract target) {
        try {
            return checkCompatibility(sourcetarget.falsefalse);
        } catch (IncompatibleInterfaceContractException e) {
            return false;
        }
    }

    
    public Operation map(Interface targetOperation source) {
        // TODO: How to handle the case that source operation is dynamic?
        if (target == null || target.isDynamic()) {
            return source;
        } else if (target.isRemotable()) {
            for (Operation op : target.getOperations()) {
                if (op.getName().equals(source.getName())) {
                    return op;
                }
            }
            return null;
        } else {
            for (Operation op : target.getOperations()) {
                if (isCompatible(sourceop.)) {
                    return op;
                }
            }
            return null;
        }
    }
New to GrepCode? Check out our FAQ X