Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2011 JBoss, by Red Hat, Inc
   *
   * Licensed 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.jboss.errai.enterprise.rebind;
 
 import java.util.List;
 import java.util.Map;
 
 
 import  org.jboss.errai.codegen.Cast;
 import  org.jboss.errai.codegen.Context;
 import  org.jboss.errai.codegen.DefParameters;
 import  org.jboss.errai.codegen.Parameter;
 import  org.jboss.errai.codegen.Statement;
 import  org.jboss.errai.codegen.meta.MetaClass;
 import  org.jboss.errai.codegen.meta.MetaClassFactory;
 import  org.jboss.errai.codegen.meta.MetaMethod;
 import  org.jboss.errai.codegen.meta.MetaParameter;
 import  org.jboss.errai.codegen.util.Stmt;
Represents parameters of a JAX-RS resource method.

Author(s):
Christian Sadilek <csadilek@redhat.com>
 
   // path param examples which are matched by this regex: /{isbn}/aaa{param}bbb/{name}-{zip}/aaa{param:b+}/{many:.*}
   // leading and trailing white spaces are tolerated
   // see http://docs.jboss.org/resteasy/docs/2.3.4.Final/userguide/html_single/index.html#_PathParam
   private static final Pattern PATH_PARAM_PATTERN =
       Pattern.compile("(\\{\\s*)(\\w[\\w.-]*)(:\\s*([^{}][^{}]*))*(\\s*\\})");
 
   private Statement entityParameter;
   private Map<Class<? extends Annotation>, MultivaluedMap<String, Statement>> parameters;
 
   public static JaxrsResourceMethodParameters fromMethod(MetaMethod method) {
     List<Parameter> defParams = DefParameters.from(method).getParameters();
     return fromMethod(methoddefParams);
   }
 
   public static JaxrsResourceMethodParameters fromMethod(MetaMethod methodString parameterArrayVarName) {
     List<Statement> params = new ArrayList<Statement>();
     Parameter[] defParms = DefParameters.from(method).getParameters().toArray(new Parameter[0]);
     for (int i = 0; i < defParms.length; i++) {
       final MetaClass type = defParms[i].getType().asBoxed();
       final Statement s = Cast.to(type, Stmt.loadVariable(parameterArrayVarNamei));
       params.add(new Statement() {
         @Override
         public String generate(Context context) {
           return s.generate(context);
         }
 
         @Override
         public MetaClass getType() {
           return type;
         }
       });
     }
 
     return fromMethod(methodparams);
   }
 
   public static JaxrsResourceMethodParameters fromMethod(MetaMethod methodList<? extends Statement> parameterValues) {
     int i = 0;
     for (MetaParameter param : method.getParameters()) {
 
       Statement paramValue = parameterValues.get(i++);
       Annotation a = param.getAnnotation(PathParam.class);
       if (a != null) {
         params.add(PathParam.class, ((PathParama).value(), paramValue);
      }
      else if ((a = param.getAnnotation(QueryParam.class)) != null) {
        params.add(QueryParam.class, ((QueryParama).value(), paramValue);
      }
      else if ((a = param.getAnnotation(HeaderParam.class)) != null) {
        params.add(HeaderParam.class, ((HeaderParama).value(), paramValue);
      }
      else if ((a = param.getAnnotation(MatrixParam.class)) != null) {
        params.add(MatrixParam.class, ((MatrixParama).value(), paramValue);
      }
      else if ((a = param.getAnnotation(FormParam.class)) != null) {
        params.add(FormParam.class, ((FormParama).value(), paramValue);
      }
      else if ((a = param.getAnnotation(CookieParam.class)) != null) {
        params.add(CookieParam.class, ((CookieParama).value(), paramValue);
      }
      else {
        params.setEntityParameter(paramValuemethod);
      }
    }
    return params;
  }
  private void add(Class<? extends AnnotationtypeString name, Statement value) {
    if ( == null)
       = new HashMap<Class<? extends Annotation>, MultivaluedMap<String, Statement>>();
    MultivaluedMap<String, Statement> params = .get(type);
    if (params == null) {
      .put(typeparams = new MultivaluedMapImpl<String, Statement>());
    }
    params.add(namevalue);
  }
  public MultivaluedMap<String, Statement> getPathParameters() {
    return .get(PathParam.class);
  }
  public Statement getPathParameter(String name) {
    final Statement param = getParameterByName(PathParam.classname);
    if (param == null)
      throw new RuntimeException("No @PathParam found with name:" + name);
    if (MetaClassFactory.get(PathSegment.class).equals(param.getType())) {
      return new Statement() {
        @Override
        public String generate(Context context) {
          if (param instanceof Parameter) {
            return Stmt.castTo(PathSegmentImpl.class, Stmt.loadVariable(((Parameter) param).getName()))
              .invoke("getEncodedPathWithParameters").generate(context);
          }
          else {
            return Stmt.castTo(PathSegmentImpl.classparam).invoke("getEncodedPathWithParameters").generate(context);
          }
        }
        @Override
        public MetaClass getType() {
          return MetaClassFactory.get(String.class);
        }
      };
    }
    return param;
  }
  public MultivaluedMap<String, Statement> getQueryParameters() {
    return get(QueryParam.class);
  }
  public List<Statement> getQueryParameters(String name) {
    return getQueryParameters().get(name);
  }
  public MultivaluedMap<String, Statement> getHeaderParameters() {
    return get(HeaderParam.class);
  }
  public List<Statement> getHeaderParameters(String name) {
    return getHeaderParameters().get(name);
  }
  public MultivaluedMap<String, Statement> getMatrixParameters() {
    return get(MatrixParam.class);
  }
  public Statement getMatrixParameter(String name) {
    return getParameterByName(MatrixParam.classname);
  }
  public MultivaluedMap<String, Statement> getFormParameters() {
    return get(FormParam.class);
  }
  public MultivaluedMap<String, Statement> getCookieParameters() {
    return get(CookieParam.class);
  }
  public Statement getCookieParameter(String name) {
    return getParameterByName(CookieParam.classname);
  }
  public Statement getEntityParameter() {
    return ;
  }
  private void setEntityParameter(Statement entityParameter, MetaMethod method) {
    if (this. != null) {
      throw new RuntimeException("Only one non-annotated entity parameter allowed per method:" + method.getName());
    }
    this. = entityParameter;
  }
  private MultivaluedMap<String, Statement> get(Class<? extends Annotationtype) {
    if ( == null)
      return null;
    return .get(type);
  }
  private Statement getParameterByName(Class<? extends AnnotationtypeString name) {
    Statement param = null;
    if (get(type) != null) {
      List<Statement> params = get(type).get(name);
      if (params != null && !params.isEmpty()) {
        param = params.get(0);
      }
    }
    return param;
  }
  public static List<StringgetPathParameterNames(String path) {
    List<StringpathParamNames = new ArrayList<String>();
    Matcher matcher = .matcher(path);
    while (matcher.find()) {
      String id = matcher.group(2);
      String regex = matcher.group(3);
      if (id != null)
        pathParamNames.add(id + ((regex != null) ? regex : ""));
    }
    return pathParamNames;
  }
  public boolean needsEncoding(String paramName) {
    // PathSegments are encoded in PathSegmentImpl
    if ((MetaClassFactory.get(PathSegment.class).equals(getParameterByName(PathParam.classparamName).getType()))) {
      return false;
    }
      
    return true;
  }
New to GrepCode? Check out our FAQ X