X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=auth%2Fauth-core%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Faaf%2Fauth%2Frserv%2FMatch.java;h=8f47126fb32685ca5b63f1728b4b6c5adba98050;hb=refs%2Fchanges%2F24%2F97124%2F3;hp=599e45b2ceeca4e4630247f7d9df0ea19162f186;hpb=bdce7667a6e272e2fa32e298d957a0d9090c5bc9;p=aaf%2Fauthz.git

diff --git a/auth/auth-core/src/main/java/org/onap/aaf/auth/rserv/Match.java b/auth/auth-core/src/main/java/org/onap/aaf/auth/rserv/Match.java
index 599e45b2..8f47126f 100644
--- a/auth/auth-core/src/main/java/org/onap/aaf/auth/rserv/Match.java
+++ b/auth/auth-core/src/main/java/org/onap/aaf/auth/rserv/Match.java
@@ -7,9 +7,9 @@
  * 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.
@@ -27,9 +27,9 @@ import java.util.Set;
 
 /**
  * This path matching algorithm avoids using split strings during the critical transactional run-time.  By pre-analyzing the
- * content at "set Param" time, and storing data in an array-index model which presumably is done once and at the beginning, 
+ * content at "set Param" time, and storing data in an array-index model which presumably is done once and at the beginning,
  * we can match in much less time when it actually counts.
- * 
+ *
  * @author Jonathan
  *
  */
@@ -39,14 +39,14 @@ public class Match {
     private Integer vars[];
     private boolean wildcard;
 
-    
+
     /*
      * These two methods are pairs of searching performance for variables Spark Style.
      * setParams evaluates the target path, and sets a HashMap that will return an Integer.
      * the Keys are both :key and key so that there will be no string operations during
      * a transaction
-     * 
-     * For the Integer, if the High Order is 0, then it is just one value.  If High Order >0, then it is 
+     *
+     * For the Integer, if the High Order is 0, then it is just one value.  If High Order >0, then it is
      * a multi-field option, i.e. ending with a wild-card.
      */
     public Match(String path) {
@@ -56,7 +56,7 @@ public class Match {
             String[] pa = path.split("/");
             values = new byte[pa.length][];
             vars = new Integer[pa.length];
-            
+
             int val = 0;
             String key;
             for (int i=0;i<pa.length && !wildcard;++i) {
@@ -69,7 +69,7 @@ public class Match {
                         val = i;
                         key = pa[i];
                     }
-                    params.put(key,val); //put in :key 
+                    params.put(key,val); //put in :key
                     params.put(key.substring(1,key.length()), val); // put in just key, better than adding a missing one, like Spark
                     // values[i]=null; // null stands for Variable
                     vars[i]=val;
@@ -96,14 +96,14 @@ public class Match {
     /*
      * This is the second of the param evaluation functions.  First, we look up to see if there is
      * any reference by key in the params Map created by the above.
-     * 
+     *
      * The resulting Integer, if not null, is split high/low order into start and end.
      * We evaluate the string for '/', rather than splitting into  String[] to avoid the time/mem needed
-     * We traverse to the proper field number for slash, evaluate the end (whether wild card or no), 
-     * and return the substring.  
-     * 
+     * We traverse to the proper field number for slash, evaluate the end (whether wild card or no),
+     * and return the substring.
+     *
      * The result is something less than .003 milliseconds per evaluation
-     * 
+     *
      */
     public String param(String path,String key) {
         Integer val = params.get(key); // :key or key
@@ -116,7 +116,7 @@ public class Match {
                 idx = path.indexOf('/',idx+1);
                 if (idx<0)break;
             }
-            if (i==start) { 
+            if (i==start) {
                 ++idx;
                 if (end==0) {
                     end = path.indexOf('/',idx);
@@ -131,7 +131,7 @@ public class Match {
         }
         return null;
     }
-    
+
     public boolean match(String path) {
         if (path==null|| path.length()==0 || "/".equals(path) ) {
             if (values==null)return true;
@@ -140,7 +140,7 @@ public class Match {
                 case 1: return values[0].length==0;
                 default: return false;
             }
-        }            
+        }
         boolean rv = true;
         byte[] pabytes = path.getBytes();
         int field=0;
@@ -169,7 +169,7 @@ public class Match {
                         ++j;
                     }
                 }
-                
+
                 if (k==lastByte && pabytes[k-1]!='/')++field;
                 if (k>i)i=k-1; // if we've incremented, have to accommodate the outer for loop incrementing as well
                 fieldMatched = false; // reset
@@ -183,10 +183,10 @@ public class Match {
                     }
                     rv = fieldMatched && ++field<lastField;
                     // reset
-                    fieldMatched = false; 
+                    fieldMatched = false;
                     fieldIdx = 0;
                 } else if (values[field].length==0) {
-                    // double slash in path, but content in field.  We check specially here to avoid 
+                    // double slash in path, but content in field.  We check specially here to avoid
                     // Array out of bounds issues.
                     rv = false;
                 } else {
@@ -204,7 +204,7 @@ public class Match {
         if (field!=lastField || pabytes.length!=lastByte) rv = false; // have we matched all the fields and all the bytes?
         return rv;
     }
-    
+
     public Set<String> getParamNames() {
         return params.keySet();
     }