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.implementation.java.xml;
 
 import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
 import static org.apache.tuscany.sca.implementation.java.xml.JavaImplementationConstants.CLASS;
 import static org.apache.tuscany.sca.implementation.java.xml.JavaImplementationConstants.IMPLEMENTATION_JAVA;
 import static org.apache.tuscany.sca.implementation.java.xml.JavaImplementationConstants.IMPLEMENTATION_JAVA_QNAME;
 import static org.apache.tuscany.sca.implementation.java.xml.JavaImplementationConstants.SCA11_NS;
 
 import java.util.Map;
 
 

Version:
$Rev: 987394 $ $Date: 2010-08-20 10:37:55 +0300 (Fri, 20 Aug 2010) $
 
 
     private AssemblyFactory assemblyFactory;
     private PolicyFactory policyFactory;
     private transient InterfaceContractMapper interfaceContractMapper;
 
     public JavaImplementationProcessor(ExtensionPointRegistry registry,  StAXArtifactProcessor<?> staxProcessor) {
         FactoryExtensionPoint modelFactories = registry.getExtensionPoint(FactoryExtensionPoint.class);
         this. = modelFactories.getFactory(AssemblyFactory.class);
         this. = modelFactories.getFactory(PolicyFactory.class);
         this. = modelFactories.getFactory(JavaImplementationFactory.class);
         this. = new PolicySubjectProcessor();
         this. = (StAXArtifactProcessor<Object>)staxProcessor;
         UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class);
         this. = utilities.getUtility(InterfaceContractMapper.class);
     }

    
Report a error.

Parameters:
problems
message
model
    private void error(Monitor monitorString messageObject modelObject... messageParameters) {
        if (monitor != null) {
            Problem problem =
                monitor.createProblem(this.getClass().getName(),
                                      "impl-javaxml-validation-messages",
                                      .,
                                      model,
                                      message,
                                      (Object[])messageParameters);
            monitor.problem(problem);
        }
    }

    
Report a exception.

Parameters:
problems
message
model
    private void error(Monitor monitorString messageObject modelException ex) {
        if (monitor != null) {
            Problem problem =
                monitor.createProblem(this.getClass().getName(),
                                      "impl-javaxml-validation-messages",
                                      .,
                                      model,
                                      message,
                                      ex);
            monitor.problem(problem);
        }
    }
        // Read an <implementation.java>
        JavaImplementation javaImplementation = .createJavaImplementation();
        implType.setType(getArtifactType());
        implType.setUnresolved(true);
        javaImplementation.setExtensionType(implType);
        javaImplementation.setUnresolved(true);
        javaImplementation.setName(reader.getAttributeValue(null));
        // Read policies
        .readPolicies(javaImplementationreader);
        // read operation elements if exists or skip unto end element
        int event;
        while (reader.hasNext()) {
            event = reader.next();
            if (event ==  && .equals(reader.getName())) {
                break;
            }
        }
        return javaImplementation;
    }
    public void write(JavaImplementation javaImplementationXMLStreamWriter writerProcessorContext contextthrows ContributionWriteException,
        XMLStreamException {
        // Write an <implementation.java>
        .writePolicyAttributes(javaImplementationwriter);
        if (javaImplementation.getName() != null) {
            writer.writeAttribute(javaImplementation.getName());
        }
        writer.writeEndElement();
    }
    public void resolve(JavaImplementation javaImplementationModelResolver resolverProcessorContext context)
        throws ContributionResolveException {
        Monitor monitor = context.getMonitor();
    	try {
	        ClassReference classReference = new ClassReference(javaImplementation.getName());
	        classReference = resolver.resolveModel(ClassReference.classclassReferencecontext);
	        Class<?> javaClass = classReference.getJavaClass();
	        if (javaClass == null) {
	            error(monitor"ClassNotFoundException"resolverjavaImplementation.getName());
	            //throw new ContributionResolveException(new ClassNotFoundException(javaImplementation.getName()));
	            return;
	        }
	        javaImplementation.setJavaClass(javaClass);
	        try {
	            .createJavaImplementation(javaImplementationjavaImplementation.getJavaClass());
	        } catch (IntrospectionException e) {
	            ContributionResolveException ce = new ContributionResolveException(e);
	            error(monitor"ContributionResolveException"ce);
	            //throw ce;
	            return;
	        }
	        checkNoStaticAnnotations(monitorjavaImplementation);
	        
	        postJAXWSProcessorResolve(resolverjavaImplementationcontext);
	        
	        javaImplementation.setUnresolved(false);
	        
	        mergeComponentType(resolverjavaImplementationcontext);
	        // FIXME the introspector should always create at least one service
	        if (javaImplementation.getServices().isEmpty()) {
	            javaImplementation.getServices().add(.createService());
	        }
        } catch (Throwable e) {
            throw new ContributionResolveException("Resolving Java implementation: " + javaImplementation.getName()
                + ", "
                + e.getMessage(), e);
        } // end try
    } // end method
    private void checkNoStaticAnnotations(Monitor monitorJavaImplementation javaImplementation) {
        if (javaImplementation.getJavaClass() != null) {
            Class<?> clazz = javaImplementation.getJavaClass();
            for (Method m : clazz.getMethods()) {
                if (Modifier.isStatic(m.getModifiers())) {
                    for (Annotation a : m.getAnnotations()) {
                        if (a.annotationType().getName().startsWith("org.oasisopen.sca.annotation")) {
                            error(monitor"IllegalSCAAnnotation"javaImplementation.getName(), m.getName());
                        }
                    }
                }
            }
            for (Field f : clazz.getFields()) {
                if (Modifier.isStatic(f.getModifiers())) {
                    for (Annotation a : f.getAnnotations()) {
                        if (a.annotationType().getName().startsWith("org.oasisopen.sca.annotation")) {
                            error(monitor"IllegalSCAAnnotation"javaImplementation.getName(), f.getName());
                        }
                    }
                }
            }
        }
    }
    private JavaElementImpl getMemeber(JavaImplementation implString nameClass<?> type) {
        String setter = JavaIntrospectionHelper.toSetter(name);
        try {
            Method method = impl.getJavaClass().getDeclaredMethod(settertype);
            int mod = method.getModifiers();
            if ((Modifier.isPublic(mod) || Modifier.isProtected(mod)) && (!Modifier.isStatic(mod))) {
                return new JavaElementImpl(method, 0);
            }
        } catch (NoSuchMethodException e) {
            Field field;
            try {
                field = impl.getJavaClass().getDeclaredField(name);
                int mod = field.getModifiers();
                if ((Modifier.isPublic(mod) || Modifier.isProtected(mod)) && (!Modifier.isStatic(mod))) {
                    return new JavaElementImpl(field);
                }
            } catch (NoSuchFieldException e1) {
                // Ignore
            }
        }
        return null;
    }

    
Merge the componentType from introspection and external file

Parameters:
resolver
impl
    private void mergeComponentType(ModelResolver resolverJavaImplementation implProcessorContext context) {
        // FIXME: Need to clarify how to merge
        ComponentType componentType = getComponentType(resolverimplcontext);
        if (componentType != null && !componentType.isUnresolved()) {
            Map<StringReferencerefMap = new HashMap<StringReference>();
            for (Reference ref : impl.getReferences()) {
                refMap.put(ref.getName(), ref);
            }
            for (Reference reference : componentType.getReferences()) {
                refMap.put(reference.getName(), reference);
            }
            impl.getReferences().clear();
            impl.getReferences().addAll(refMap.values());
            // Try to match references by type
            Map<StringJavaElementImplrefMembers = impl.getReferenceMembers();
            for (Reference ref : impl.getReferences()) {
                if (ref.getInterfaceContract() != null) {
                    Interface i = ref.getInterfaceContract().getInterface();
                    if (i instanceof JavaInterface) {
                        Class<?> type = ((JavaInterface)i).getJavaClass();
                        if (!refMembers.containsKey(ref.getName())) {
                            JavaElementImpl e = getMemeber(implref.getName(), type);
                            if (e != null) {
                                refMembers.put(ref.getName(), e);
                            }
                        }
                    }
                }
            }
            Map<StringServiceserviceMap = new HashMap<StringService>();
            for (Service svc : impl.getServices()) {
                serviceMap.put(svc.getName(), svc);
            }
            for (Service service : componentType.getServices()) {
                serviceMap.put(service.getName(), service);
            }
            impl.getServices().clear();
            impl.getServices().addAll(serviceMap.values());
            Map<StringPropertypropMap = new HashMap<StringProperty>();
            for (Property prop : impl.getProperties()) {
                propMap.put(prop.getName(), prop);
            }
            for (Property property : componentType.getProperties()) {
                propMap.put(property.getName(), property);
            }
            impl.getProperties().clear();
            impl.getProperties().addAll(propMap.values());
        }
    }
    
    private void postJAXWSProcessorResolve(ModelResolver resolverJavaImplementation implProcessorContext context)
        for(Service service : impl.getServices()){
            JavaInterfaceContract javaInterfaceContract = (JavaInterfaceContract)service.getInterfaceContract();
            
            JavaInterface javaInterface = (JavaInterface)javaInterfaceContract.getInterface();
            if (javaInterface.isUnresolved()){             
                .resolve(javaInterfaceContractresolvercontext);
            }
            
            WSDLInterfaceContract wsdlInterfaceContract = (WSDLInterfaceContract)javaInterfaceContract.getNormalizedWSDLContract();
            if(wsdlInterfaceContract != null){
                // The user has explicitly associated a WSDL with the Java implementation
                // using a @WebService(wsdlLocation="...") annotation
                WSDLInterface wsdlInterface = (WSDLInterface)wsdlInterfaceContract.getInterface();
                if (wsdlInterface.isUnresolved()){
                    //WSDLDefinition resolved = resolver.resolveModel(WSDLDefinition.class, wsdlInterface.getWsdlDefinition(), context);
                    .resolve(wsdlInterfaceContractresolvercontext);
                    
                    // check that the Java and WSDL contracts are compatible
                    .checkCompatibility(wsdlInterfaceContract,
                                                               javaInterfaceContract,
                                                               .
                                                               false
                                                               false);
                    
                    // retrieve the resolved WSDL interface
                    wsdlInterface = (WSDLInterface)wsdlInterfaceContract.getInterface();
                    
                    // copy policy from the WSDL interface to the Java interface
                    javaInterface.getPolicySets().addAll(wsdlInterface.getPolicySets());
                    javaInterface.getRequiredIntents().addAll(wsdlInterface.getRequiredIntents());
                    
                    // copy policy from the WSDL interface to the component type service
                    service.getPolicySets().addAll(wsdlInterface.getPolicySets());
                    service.getRequiredIntents().addAll(wsdlInterface.getRequiredIntents());                    
                    
                    // TODO - is there anything else to be copied from the user specified WSDL?
                } 
            }
        }
    }    
    private ComponentType getComponentType(ModelResolver resolverJavaImplementation implProcessorContext context) {
        String className = impl.getJavaClass().getName();
        String componentTypeURI = className.replace('.''/') + ".componentType";
        ComponentType componentType = .createComponentType();
        componentType.setUnresolved(true);
        componentType.setURI(componentTypeURI);
        componentType = resolver.resolveModel(ComponentType.classcomponentTypecontext);
        if (!componentType.isUnresolved()) {
            return componentType;
        }
        return null;
    }
    public QName getArtifactType() {
        return ;
    }
        return JavaImplementation.class;
    }
New to GrepCode? Check out our FAQ X