How to use com.meidusa.amoeba.sqljep.function

  public static Comparable<?> compareTo(Comparable<?> param1,Comparable<?> param2) throws ParseException{
    if (param1 instanceof Comparative) {
      Comparative other = (Comparative) param1;
      boolean result = other.intersect(Comparative.Equivalent,
          param2, ComparativeComparator.comparator);
      return (result);
    } else {
      return (ComparativeComparator.compareTo(param1, param2) == 0);
    }
  }
}

public boolean intersect(int function,Comparable other,Comparator comparator){
  return Intersector.intersect(function,other,this.comparison,this.getValue(),comparator);
}
public String toString(){

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return addDate(comparables[0],comparables[1]);
  }
}

public Comparable<?> getResult(Comparable<?>... comparables) throws ParseException {
  if (comparables[0] != null && comparables[0] instanceof String) {
    return hash((String) comparables[0]);
  }
  return _unknown;
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return and(comparables[0], comparables[1]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return upper(comparables[0]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return replace(comparables[0],comparables[1],comparables[2]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    if(comparables.length == 2){
      return substr(comparables[0],comparables[1]);
    }else{
      return substr(comparables[0],comparables[1],comparables[2]);
    }
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return ceil(comparables[0]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return nvl(comparables[0],comparables[1]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    // TODO Auto-generated method stub
    return or(comparables[0],comparables[1]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return like(comparables[0], comparables[1]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return lpad(comparables[0],comparables[1],comparables[2]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return trim(comparables[0]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return initcap(comparables[0]);
  }
}

@SuppressWarnings("unchecked")
public boolean intersect(Comparative other, Comparator comparator) {
  for(Comparative source :list){
    if(source.intersect(other, comparator)){
      return true;
    }
  }
  return false;
}

public static boolean intersect(Comparable<?> param1,Comparable<?> param2){
  int function1 = Comparative.Equivalent;
  int function2 = Comparative.Equivalent;
  return Intersector.intersect(function1,param1,function2,param2,ComparativeComparator.comparator);
}
 

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return add(comparables[0], comparables[1]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return microsecond(comparables[0]);
  }
}

  public Comparable<?> getResult(Comparable<?>... comparables)
      throws ParseException {
    return mul(comparables[0],comparables[1]);
  }
}