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.sling.samples.pathbasedrtp;
 
 
Map a path prefix to a (1-based) index in the path components
 
 class Mapping {
     private final Logger log = LoggerFactory.getLogger(getClass());
     
     String path;
     final String fixedNodeType;
     final Pattern nodeTypeExpr;
     int resourceTypeIndex;
     public static final String DEFAULT_NODE_TYPE = "nt:unstructured";
     
     Mapping(String definition) {
         final String [] parts = definition.trim().split(":");
         if(parts.length < 2) {
             throw new IllegalArgumentException("Illegal definition'" + definition + "'");
         }
         
          = parts[0];
         try {
              = Integer.parseInt(parts[1]);
         } catch(Exception e) {
             .warn("Invalid path index in Mapping {}"definition);
         }
 
         // Parse the definition: two parts means default nodetype,
         // more than two means fixed nodetype or regexp.
         // Nodetypes can contain : which is our separator - not fun.
         if(parts.length > 2) {
             final StringBuilder sb = new StringBuilder();
             for(int i=2; i < parts.lengthi++) {
                 sb.append(parts[i]);
                 if(i < parts.length - 1) {
                     sb.append(":");
                 }
             }
             
             String expr = sb.toString();
             if(expr.startsWith("(") && expr.endsWith(")")) {
                 // Definition in brackets -> regexp
                  = null;
                 expr = expr.substring(1);
                 expr = expr.substring(0, expr.length() - 1);
                  = Pattern.compile(expr);
             } else {
                 // No brackets -> fixed node type
                  = expr;
                  = null;
             }
         } else {
              = ;
              = null;
         }
         
         .debug(toString());
     }
     
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder();
         sb.append("Mapping: path=");
         sb.append();
         sb.append(", resource type index=");
         sb.append();
         if( != null) {
             sb.append(", node type=");
             sb.append();
         } else {
             sb.append(", node type regexp=");
             sb.append();
         }
         return sb.toString();
     }
     
     String getResourceType(String nodePathString nodeType) {
         String result = null;
        if(!=null && nodePath.startsWith() && nodeTypeMatches(nodeType)) {
            final String [] paths = nodePath.split("/");
            if(paths.length >= +1) {
                result = paths[];
            }
        }
        return result;
    }
    
    private boolean nodeTypeMatches(String nodeType) {
        if( != null) {
            return .equals(nodeType);
        } else if( == null) {
            throw new IllegalStateException("Neither fixedNodeType nor nodeTypeExpr supplied in " + this);
        }
        return .matcher(nodeType).matches();
        
    }
New to GrepCode? Check out our FAQ X