Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Logback: the reliable, generic, fast and flexible logging framework. Copyright (C) 1999-2011, QOS.ch. All rights reserved. This program and the accompanying materials are dual-licensed under either the terms of the Eclipse Public License v1.0 as published by the Eclipse Foundation or (per the licensee's choosing) under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation.
 
 package ch.qos.logback.core.joran.spi;
 
 import java.util.List;

A pattern is used to designate XML elements in a document.

For more information see http://logback.qos.ch/manual/onJoran.html#pattern

Author(s):
Ceki Gülcü
 
 public class Pattern {
 
   // contains String instances
 
 
   public Pattern() {
   }
 
   public Pattern(List<Stringlist) {
     .addAll(list);
   }

  
Build a pattern from a string. Note that "/x" is considered equivalent to "x" and to "x/"
 
   public Pattern(String p) {
     this();
 
     if (p == null) {
       return;
     }
 
     int lastIndex = 0;
 
     // System.out.println("p is "+ p);
     while (true) {
       int k = p.indexOf('/'lastIndex);
 
       // System.out.println("k is "+ k);
       if (k == -1) {
         String lastPart = p.substring(lastIndex);
         if (lastPart != null && lastPart.length() > 0) {
           .add(p.substring(lastIndex));
         }
         break;
       } else {
         String c = p.substring(lastIndexk);
 
         if (c.length() > 0) {
           .add(c);
         }
 
         lastIndex = k + 1;
       }
     }
 
     // System.out.println(components);
   }
 
   public List<StringgetCopyOfPartList() {
     return new ArrayList<String>();
   }
   
   public Object clone() {
     Pattern p = new Pattern();
     p.partList.addAll(this.);
     return p;
   }
 
   public void push(String s) {
     .add(s);
   }
 
   public int size() {
     return .size();
   }
 
   public String get(int i) {
     return (String.get(i);
  }
  public void pop() {
    if (!.isEmpty()) {
      .remove(.size() - 1);
    }
  }
  public String peekLast() {
    if (!.isEmpty()) {
      int size = .size();
      return (String.get(size - 1);
    } else {
      return null;
    }
  }

  
Returns the number of "tail" components that this pattern has in common with the pattern p passed as parameter. By "tail" components we mean the components at the end of the pattern.
  public int getTailMatchLength(Pattern p) {
    if (p == null) {
      return 0;
    }
    int lSize = this..size();
    int rSize = p.partList.size();
    // no match possible for empty sets
    if ((lSize == 0) || (rSize == 0)) {
      return 0;
    }
    int minLen = (lSize <= rSize) ? lSize : rSize;
    int match = 0;
    // loop from the end to the front
    for (int i = 1; i <= minLeni++) {
      String l = (Stringthis..get(lSize - i);
      String r = (Stringp.partList.get(rSize - i);
      if (equalityCheck(lr)) {
        match++;
      } else {
        break;
      }
    }
    return match;
  }
  public boolean isContained(Pattern p) {
    if(p == null) {
      return false;
    }
    String lStr = this.toString();
    return lStr.contains(p.toString());
  }
  
  
  
Returns the number of "prefix" components that this pattern has in common with the pattern p passed as parameter. By "prefix" components we mean the components at the beginning of the pattern.
  public int getPrefixMatchLength(Pattern p) {
    if (p == null) {
      return 0;
    }
    int lSize = this..size();
    int rSize = p.partList.size();
    // no match possible for empty sets
    if ((lSize == 0) || (rSize == 0)) {
      return 0;
    }
    int minLen = (lSize <= rSize) ? lSize : rSize;
    int match = 0;
    for (int i = 0; i < minLeni++) {
      String l = (Stringthis..get(i);
      String r = (Stringp.partList.get(i);
      if (equalityCheck(lr)) {
        match++;
      } else {
        break;
      }
    }
    return match;
  }
  private boolean equalityCheck(String xString y) {
    return x.equalsIgnoreCase(y);
  }
  public boolean equals(Object o) {
    if ((o == null) || !(o instanceof Pattern)) {
      return false;
    }
    Pattern r = (Patterno;
    if (r.size() != size()) {
      return false;
    }
    int len = size();
    for (int i = 0; i < leni++) {
      if (!equalityCheck(get(i), r.get(i))) {
        return false;
      }
    }
    // if everything matches, then the two patterns are equal
    return true;
  }
  public int hashCode() {
    int hc = 0;
    int len = size();
    for (int i = 0; i < leni++) {
      // make Pattern comparisons case insensitive
      // http://jira.qos.ch/browse/LBCORE-76
      hc ^= get(i).toLowerCase().hashCode();
    }
    return hc;
  }
  public String toString() {
    StringBuilder result = new StringBuilder();
    for (String current : ) {
      result.append("[").append(current).append("]");
    }
    return result.toString();
  }
New to GrepCode? Check out our FAQ X