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.impl.application;
 
 import java.net.URI;
 import java.util.List;
 import java.util.Map;

Author(s):
Paul.Sandoz@Sun.Com
 
 public final class WebApplicationContext implements UriRuleContextExtendedUriInfo {
     public static final String HTTP_METHOD_MATCH_RESOURCE = "com.sun.jersey.MATCH_RESOURCE";
 
     private final WebApplicationImpl app;
 
     private final boolean isTraceEnabled;
 
     private ContainerRequest request;
 
     private ContainerResponse response;
 
 
             ContainerRequest requestContainerResponse response) {
         this. = app;
         this. = app.isTracingEnabled();
         this. = request;
         this. = response;
         this. = .;
 
         if (isTracingEnabled()) {
             getProperties().put(TraceInformation.class.getName(),
                     new TraceInformation(this));
         }
    }
        final URI base = .getBaseUri();
        if (u.isAbsolute()) {
            // TODO check if base is a base of u
            URI r = base.relativize(u);
            if (r == u) {
                throw new ContainerException("The URI " + u + " is not relative to the base URI " + base);
            }
        } else {
            u = UriBuilder.fromUri(base).
                    path(u.getRawPath()).
                    replaceQuery(u.getRawQuery()).
                    fragment(u.getRawFragment()).
                    build();
        }
        final ContainerRequest _request = new ContainerRequest(,
                ,
                baseu,
                new InBoundHeaders(), new ByteArrayInputStream(new byte[0]));
        _request.setSecurityContext(.getSecurityContext());
        // Propagate security context
        final ContainerResponse _response = new ContainerResponse(,
                _requestnull);
        return new WebApplicationContext(,
                _request,
                _response);
    }
        return ;
    }
    // HttpContext
    @Override
    public HttpRequestContext getRequest() {
        return ;
    }
    @Override
    public HttpResponseContext getResponse() {
        return ;
    }
    @Override
    public ExtendedUriInfo getUriInfo() {
        return this;
    }
    @Override
    public Map<StringObjectgetProperties() {
        return .getProperties();
    }
    // Traceable
    @Override
    public boolean isTracingEnabled() {
        return ;
    }
    @Override
    public void trace(String message) {
        if (!isTracingEnabled())
            return;
        .trace(message);
    }
    // UriMatchResultContext
    private MatchResult matchResult;
    @Override
    public MatchResult getMatchResult() {
        return ;
    }
    @Override
    public void setMatchResult(MatchResult matchResult) {
        this. = matchResult;
    }
    // UriRuleContext
    private final LinkedList<Objectresources = new LinkedList<Object>();
    private final LinkedList<MatchResultmatchResults = new LinkedList<MatchResult>();
    private final LinkedList<Stringpaths = new LinkedList<String>();
    private final LinkedList<UriTemplatetemplates = new LinkedList<UriTemplate>();
    private AbstractResourceMethod arm;
    @Override
        return ;
    }
    @Override
    public void setContainerRequest(ContainerRequest request) {
        this. = request;
        this..setContainerRequest(request);
    }
    @Override
        return ;
    }
    @Override
    public void setContainerResponse(ContainerResponse response) {
        this. = response;
    }
    @Override
        if (filters.isEmpty())
            return;
        if ( == .)
             = new LinkedList<ContainerResponseFilter>();
        for (ContainerResponseFilter f : filters) {
            .add(0, f);
        }
    }
    @Override
    public Object getResource(Class resourceClass) {
        return .getResourceComponentProvider(resourceClass).getInstance(this);
    }
    @Override
    public UriRules<UriRulegetRules(Class resourceClass) {
        return .getUriRules(resourceClass);
    }
    @Override
    public void pushMatch(UriTemplate templateList<Stringnames) {
        .addFirst(template);
        if ( == null) {
             = new MultivaluedMapImpl();
        }
        int i = 1;
        for (String name : names) {
            final String value = .group(i++);
            .addFirst(namevalue);
            if ( != null) {
                .addFirst(
                        UriComponent.decode(name..),
                        UriComponent.decode(value..));
            }
        }
    }
    @Override
    public void pushResource(Object resource) {
        .addFirst(resource);
    }
    @Override
    public void pushMethod(AbstractResourceMethod arm) {
        this. = arm;
    }
    @Override
    public void pushRightHandPathLength(int rhpathlen) {
        final String ep = .getPath(false);
        .addFirst(ep.substring(0,
                ep.length() - rhpathlen));
    }
    // UriInfo, defer to HttpRequestContext
    @Override
    public URI getBaseUri() {
        return .getBaseUri();
    }
    @Override
    public UriBuilder getBaseUriBuilder() {
        return .getBaseUriBuilder();
    }
    @Override
    public URI getAbsolutePath() {
        return .getAbsolutePath();
    }
    @Override
        return .getAbsolutePathBuilder();
    }
    @Override
    public URI getRequestUri() {
        return .getRequestUri();
    }
    @Override
    public UriBuilder getRequestUriBuilder() {
        return .getRequestUriBuilder();
    }
    @Override
    public String getPath() {
        return .getPath(true);
    }
    @Override
    public String getPath(boolean decode) {
        return .getPath(decode);
    }
    @Override
    public List<PathSegmentgetPathSegments() {
        return .getPathSegments(true);
    }
    @Override
    public List<PathSegmentgetPathSegments(boolean decode) {
        return .getPathSegments(decode);
    }
    @Override
        return .getQueryParameters(true);
    }
    @Override
    public MultivaluedMap<StringStringgetQueryParameters(boolean decode) {
        return .getQueryParameters(decode);
    }
    // UriInfo, matching specific functionality
    @Override
        return getPathParameters(true);
    }
    @Override
    public MultivaluedMap<StringStringgetPathParameters(boolean decode) {
        if (decode) {
            if ( != null) {
                return ;
            }
             = new MultivaluedMapImpl();
            for (Map.Entry<StringList<String>> e : .entrySet()) {
                List<Stringl = new ArrayList<String>();
                for (String v : e.getValue()) {
                    l.add(UriComponent.decode(v..));
                }
                .put(
                        UriComponent.decode(e.getKey(), ..),
                        l);
            }
            return ;
        } else {
            return ;
        }
    }
    @Override
    public List<StringgetMatchedURIs() {
        return getMatchedURIs(true);
    }
    @Override
    public List<StringgetMatchedURIs(boolean decode) {
        List<Stringresult;
        if (decode) {
            result = new ArrayList<String>(.size());
            for (String path : ) {
                result.add(UriComponent.decode(
                    path,
                    ..));
            }
        } else {
            result = ;
        }
        return Collections.unmodifiableList(result);
    }
    @Override
    public List<ObjectgetMatchedResources() {
        return ;
    }
    // ExtendedUriInfo
    @Override
        return ;
    }
    @Override
    public Throwable getMappedThrowable() {
        return .getMappedThrowable();
    }
    @Override
    public List<MatchResultgetMatchedResults() {
        return ;
    }
    @Override
    public List<UriTemplategetMatchedTemplates() {
        return ;
    }
    @Override
    public List<PathSegmentgetPathSegments(String name) {
        return getPathSegments(nametrue);
    }
    @Override
    public List<PathSegmentgetPathSegments(String nameboolean decode) {
        int[] bounds = getPathParameterBounds(name);
        if (bounds != null) {
            String path = .getLast().group();
            // Work out how many path segments are up to the start
            // and end position of the matching path parameter value
            // This assumes that the path always starts with a '/'
            int segmentsStart = 0;
            for (int x = 0; x < bounds[0]; x++) {
                if (path.charAt(x) == '/') {
                    segmentsStart++;
                }
            }
            int segmentsEnd = segmentsStart;
            for (int x = bounds[0]; x < bounds[1]; x++) {
                if (path.charAt(x) == '/') {
                    segmentsEnd++;
                }
            }
            return getPathSegments(decode).subList(segmentsStart - 1, segmentsEnd);
        } else
            return Collections.emptyList();
    }
    private int[] getPathParameterBounds(String name) {
        Iterator<UriTemplateiTemplate = .iterator();
        Iterator<MatchResultiMatchResult = .iterator();
        while (iTemplate.hasNext()) {
            MatchResult mr = iMatchResult.next();
            // Find the index of path parameter
            int pIndex = getLastPathParameterIndex(nameiTemplate.next());
            if (pIndex != -1) {
                int pathLength = mr.group().length();
                int segmentIndex = mr.end(pIndex + 1);
                int groupLength = segmentIndex - mr.start(pIndex + 1);
                // Find the absolute position of the end of the
                // capturing group in the request path
                while (iMatchResult.hasNext()) {
                    mr = iMatchResult.next();
                    segmentIndex += mr.group().length() - pathLength;
                    pathLength = mr.group().length();
                }
                int[] bounds = {segmentIndex - groupLengthsegmentIndex};
                return bounds;
            }
        }
        return null;
    }
    private int getLastPathParameterIndex(String nameUriTemplate t) {
        int i = 0;
        int pIndex = -1;
        for (String parameterName : t.getTemplateVariables()) {
            if (parameterName.equals(name)) {
                pIndex = i;
            }
            i++;
        }
        return pIndex;
    }
New to GrepCode? Check out our FAQ X