Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * http://glassfish.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 package com.sun.jersey.server.wadl.generators;
 
 
 import java.net.URI;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
This com.sun.jersey.server.wadl.WadlGenerator generates a grammar based on the referenced elements. This is a template class designed to be overridden by specific implementations, for example XML Schema and JSON Schema Created on: Sept 17, 2012

Author(s):
Gerard Davison
Version:
$Id: AbstractWadlGeneratorGrammarGenerator.java $
 
 public abstract class AbstractWadlGeneratorGrammarGenerator<T> implements WadlGenerator {
 
     
     // Wrapper interfaces so I can treat dispirate types the same
     // when processing them later
     //
 
     protected static interface HasType
     {
         public Class getPrimaryClass();
         public Type getType();
         public MediaType getMediaType();
     }
 
     protected static interface WantsName<T>
     {
        

Returns:
does this object need an element or a type
        public boolean isElement();
        public void setName( T name );
    }

    

Parameters:
param parameter.
Returns:
An adapter for Parameter
    protected static HasType parameter(final Parameter paramfinal MediaType mt)
    {
        return new HasType() {
            public Class getPrimaryClass() {
                return param.getParameterClass();
            }
            public Type getType() {
                return param.getParameterType();
            }
            
            public MediaType getMediaType() {
                return mt;
            }
        };
    }
    protected class Pair {
        public Pair(HasType hasTypeWantsName wantsName) {
            this. = hasType;
            this. = wantsName;
        }
        public HasType hasType;
        public WantsName wantsName;
    }
    // Static final fields
    private static final Logger LOGGER = Logger.getLoggerAbstractWadlGeneratorGrammarGenerator.class.getName() );
    public static final java.util.Set<ClassSPECIAL_GENERIC_TYPES =
            new HashSet<Class>()
            {{
                add(JResponse.class);
                add(List.class);
            }};
    // Instance fields
    // The generator we are decorating
    private WadlGenerator _delegate;
    // Any SeeAlso references
    protected Set<Class_seeAlso;
    // A matched list of Parm, Parameter to list the relavent
    // entity objects that we might like to transform.
    protected List<Pair_hasTypeWantsName;
    
    // The root of this application
    protected URI _root;
    // The uri of this WADL
    protected URI _wadl;
    
    
    // The type of the resolved element
    protected Class<T> _resolvedType;
    protected AbstractWadlGeneratorGrammarGenerator(WadlGenerator delegateClass<T> resolvedType) {
         = delegate;
         = resolvedType;
    }
    // =============== House keeping methods ================================
    public void setWadlGeneratorDelegateWadlGenerator delegate ) {
         = delegate;
    }
        return .getRequiredJaxbContextPath();
    }
    public void init() throws Exception {
        .init();
        //
         = new HashSet<Class>();
        // A matched list of Parm, Parameter to list the relavent
        // entity objects that we might like to transform.
         = new ArrayList<Pair>();
    }
    // ================ filter actions =======================
    
    

Parameters:
type
Returns:
Whether we want to acceptMediaType this element, for example the grammar generator wouldn't necessarily want to selector for JAX-B or vice versa.
    public abstract boolean acceptMediaType(MediaType type);
    
    
    
    // =============== Application Creation ================================


    
    public Application createApplication(UriInfo requestInfo) {
        if (requestInfo!=null) {
             = requestInfo.getBaseUri();
             = requestInfo.getRequestUri();
        }
        
        return .createApplication(requestInfo);
    }

    
    public Method createMethodAbstractResource ar,
                                AbstractResourceMethod arm ) {
        return .createMethodararm );
    }

    
    public Request createRequestAbstractResource ar,
                                  AbstractResourceMethod arm ) {
        return .createRequestararm );
    }

    
    public Param createParamAbstractResource ar,
                              AbstractMethod amParameter p ) {
        final Param param = .createParamaramp );
        // If the paramter is an entity we probably want to convert this to XML
        //
        if (p.getSource() == ..) {
            .addnew Pair(
                    parameter(p.), createParmWantsName(param)));
        }
        return param;
    }

    
            AbstractResource arAbstractResourceMethod armMediaType mt ) {
        final Representation rt = .createRequestRepresentationararmmt );
        for (Parameter p : arm.getParameters()) {
            if (p.getSource() == ..) {
                if (acceptMediaType(mt)) {
                    .addnew Pair(
                            parameter(pmt), createRepresentationWantsName(rt)));
                }
            }
        }
        return rt;
    }

    

Parameters:
ar abstract resource
path resources path
Returns:
resource
See also:
com.sun.jersey.server.wadl.WadlGenerator.createResource(com.sun.jersey.api.model.AbstractResource,java.lang.String)
    public Resource createResourceAbstractResource arString path ) {
        Class cls = ar.getResourceClass();
        XmlSeeAlso seeAlso = (XmlSeeAlso)cls.getAnnotationXmlSeeAlso.class );
        if ( seeAlso !=null ) {
            Collections.addAll(seeAlso.value());
        }
        return .createResourcearpath );
    }

    
    public Resources createResources() {
        return .createResources();
    }

    
                                          final AbstractResourceMethod arm) {
        final List<Responseresponses = .createResponses(ararm );
        if (responses!=null) {
            for(Response response : responses) {
                for (final Representation representation : response.getRepresentation()) {
                    // Process each representation
                    // Check first that we have a media type and that it is supported
                    if (representation.getMediaType()!=null && acceptMediaType(MediaType.valueOf(representation.getMediaType()))) {
                        
                        HasType hasType = new HasType()  {
                            @Override
                            public Class getPrimaryClass() {
                                return arm.getReturnType();
                            }
                            public Type getType() {
                                return arm.getGenericReturnType();
                            }
                            
                            public MediaType getMediaType() {
                                return MediaType.valueOf(representation.getMediaType());
                            }
                        };
                        
                        .add(new Pair(
                                hasType,
                                createRepresentationWantsName(representation)));
                    }
                }
            }
        }
        return responses;
    }
    // ================ methods for post build actions =======================
        // Invoke previous generator so we can overide if required
        //
        
        
        
        // Right now lets generate some external metadata
        Map<StringApplicationDescription.ExternalGrammarextraFiles =
                new HashMap<StringApplicationDescription.ExternalGrammar>();
        // Build the model as required
        Resolver resolver = buildModelAndSchemas(extraFiles);
        // Pass onto the next delegate
        previous.map.putAll(extraFiles);
        if (resolver!=null) {
            previous.addResolver(resolver);
        }
        return previous;
    }

    
Build the the external schema files and generate a suitable resolver

Parameters:
extraFiles
    protected abstract Resolver buildModelAndSchemas(Map<StringExternalGrammarextraFiles);
    @Override
    public void attachTypes(ApplicationDescription introspector) {
        // Chain
        .attachTypes(introspector);
        
        // If we managed to get an introspector then lets go back an update the parameters
        if (introspector!=null) {
            int i = .size();
            nextItem : for ( int j = 0; j < ij++ ) {
                Pair pair = .getj );
                WantsName nextToProcess = pair.wantsName;
                
                // If we have to resolve a type rather than an element
                // then we can't do this yet
                //
                
                if (!nextToProcess.isElement()) {
                    // This is only a problem for param types; but these are 
                    // nearly always basic a scalar types, out of scope of
                    // the current modifications to resolve this issue
                    .info("Type references are not supported as yet");
                }
                
                //
                
                HasType nextType = pair.hasType;
                // There is a method on the RI version that works with just
                // the class name; but using the introspector for the moment
                // as it leads to cleaner code
                Class<?> parameterClass = nextType.getPrimaryClass();
                // Fix those specific generic types
                if (.contains(parameterClass)) {
                    Type type = nextType.getType();
                    if (ParameterizedType.class.isAssignableFrom(type.getClass()) &&
                            Class.class.isAssignableFrom(((ParameterizedType)type).getActualTypeArguments()[0].getClass())) {
                        parameterClass = (Class) ((ParameterizedType)type).getActualTypeArguments()[0];
                    } else {
                        // Works around JERSEY-830
                        .info("Couldn't find grammar element due to nested parameterized type " + type);
                        return;
                    }
                }
                T name = introspector.resolve(parameterClassnextType.getMediaType(), );
                if ( name !=null ) {
                    nextToProcess.setName(name);
                } else  {
                    .info("Couldn't find grammar element for class " + parameterClass.getName());
                }
            }
        }
    }
    
    // ================ methods for creating wants name actions ===============
    
    protected abstract WantsName<T> createParmWantsName(final Param param);
    protected abstract WantsName<T> createRepresentationWantsName(final Representation rt);
 
    
New to GrepCode? Check out our FAQ X