content: package org.apache.solr.request.compare;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.log4j.Logger;
  import org.apache.solr.request.join.HigoJoinSort;
  
  import com.alimama.mdrill.utils.EncodeUtils;
  
  public class UniqTypeNum {
      private static Logger LOG = Logger.getLogger(UniqTypeNum.class);
  
  	static HashMap<String,SortType> typeMap=new HashMap<String, SortType>();
  	static{
  		typeMap.put("index",  new SortType(0,SortTypeEnum.index));
  		typeMap.put("countall", new SortType(1,SortTypeEnum.countall));
  		typeMap.put("count", new SortType(2,SortTypeEnum.count));
  		typeMap.put("dist", new SortType(3,SortTypeEnum.dist));
  		typeMap.put("sum", new SortType(4,SortTypeEnum.sum));
  		typeMap.put("max", new SortType(5,SortTypeEnum.max));
  		typeMap.put("min", new SortType(6,SortTypeEnum.min));
  		typeMap.put("avg", new SortType(7,SortTypeEnum.avg));
  		typeMap.put("column",new SortType(8,SortTypeEnum.column));
  		typeMap.put("joincolumn",new SortType(9,SortTypeEnum.joincolumn));
  	}
  	
  	
  	
  	public static enum SortTypeEnum{
  		none,index,countall,count,dist,sum,max,min,avg,column,joincolumn
  	}
  	public static SortType parseType(String type,String fl,String[] groupby,HigoJoinSort[] joinSort)
  	{
  		int start=groupby.length;
  		for(HigoJoinSort s:joinSort)
  		{
  			if(s.getIndex()>=0)
  			{
  				start+=s.getIndex();
  				SortType rtn=typeMap.get("joincolumn");	
  				rtn.sortFieldNum=start;
  				return rtn;
  			}
  			start+=s.getoffset();
  		}
  		SortType rtn=typeMap.get(type);	
  		if(rtn==null)
  		{
  			return typeMap.get("index");
  		}
  		
  		if(rtn.typeEnum.equals(SortTypeEnum.count)&&fl.indexOf("higoempty_")>=0)
  		{
  			return typeMap.get("countall");
  		}
  		
  		
  		return rtn;
  	}
  	
  	public static class SelectDetailSort{
  		public int sortIndex;
  		public int offset;
  		public int selfOffset;
  		public String field;
  		public SelectDetailSort(int sortIndex, int offset, int selfOffset,
  				String field) {
  			this.sortIndex = sortIndex;
  			this.offset = offset;
  			this.selfOffset = selfOffset;
  			this.field = field;
  		}
  	}
  	public static SelectDetailSort parseSelectDetailType(String[] groupby,HigoJoinSort[] joinSort)
  	{
  		int start=groupby.length;
  		for(int i=0;i<joinSort.length;i++)
  		{
  			HigoJoinSort s=joinSort[i];
  			if(s.getIndex()>=0)
  			{
  				start+=s.getIndex();
  				return new SelectDetailSort(i,start, s.getIndex(), s.getSortField());
  			}
  			start+=s.getoffset();
  		}
  		
  		return null;
  	}
  	
  	public static Integer foundIndex(String[] list,String fl)
  	{
  		int rtn= foundIndex(list, fl, 0);
  //		LOG.info("####"+Arrays.toString(list)+"@"+fl+"@"+rtn);
  		return rtn;
  	}
  	
  	public static Integer foundIndex(String[] list,String fl,int def)
  	{
  		if(fl==null)
  		{
  			return def;
  		}
  		if(list!=null)
  		{
  			for(int i=0;i<list.length;i++)
  			{
  				if(fl.equals(list[i])){
  					return i;
  				}
  			}
  		}
  		return def;
  	}
  	
  	public static class SortType{
  		public int sortFieldNum=-1;
  		@Override
  		public String toString() {
  			return "SortType [sortFieldNum=" + sortFieldNum + ", typeNum="
  					+ typeNum + ", typeEnum=" + typeEnum + "]";
  		}
  		public int typeNum;
  		public SortTypeEnum typeEnum;
  		public SortType(int typeNum, SortTypeEnum typeEnum) {
  			this.typeNum = typeNum;
  			this.typeEnum = typeEnum;
  		}
  	}
  	
  	public static int compare(double value1, double value2) {
  		return value1 > value2 ? -1 : value1 < value2 ? 1 : 0;
      }
  	 public static int compare(long value1, long value2) {
  			return value1 > value2 ? -1 : value1 < value2 ? 1 : 0;
  	    }
  	 public static int compare(int value1, int value2) {
  			return value1 > value2 ? -1 : value1 < value2 ? 1 : 0;
  	    }
  
  	public static int compare(int[] a, int[] a2) {
  		int len = a.length;
  		int cmp = compare(len, a2.length);
  		if (cmp != 0) {
  			return cmp;
  		}
  
  		for (int i = 0; i < len; i++) {
  			cmp = compare(a[i], a2[i]);
  			if (cmp != 0) {
  				return cmp;
  			}
  		}
  
  		return cmp;
  	}
  	 public static int compare(String value1, String value2) {
  		 return value2.compareTo(value1);
  	 }
  	 
  	 public static int compareStrNum(String value1, String value2) {
  		 return compare(filterUnNumber(value1), filterUnNumber(value2));
  	 }
  	 
  	private static Pattern p = Pattern.compile("[^0-9]");
  
  	public static double filterUnNumber(String str) {
  		if (str == null || str.isEmpty() || str.indexOf("null") >= 0|| str.indexOf("_") >= 0) {
  			return 0d;
  		}
  
  		try {
  			return Double.parseDouble(str);
  		} catch (Throwable e) {
  			Matcher m = p.matcher(str);
  			String rtn = m.replaceAll("").trim();
  			if (rtn.isEmpty()) {
  				return 0d;
  			}
  			return Double.parseDouble(rtn);
  		}
  
  	}
  
  	
  	 public static int compareDecode(String value1, String value2) {
  			return compare(EncodeUtils.decode(value1),EncodeUtils.decode(value2));
  	    }
  	 
  	 public static int compareDecodeNum(String value1, String value2) {
  			return compareStrNum(EncodeUtils.decode(value1),EncodeUtils.decode(value2));
  	    }
  	 
  	 
  
  	
  	public static int compareDecode(String[] a, String[] a2) {
  		int len = a.length;
  		int cmp = compare(len, a2.length);
  		if (cmp != 0) {
  			return cmp;
  		}
  
  		for (int i = 0; i < len; i++) {
  			cmp = compareDecode(a[i], a2[i]);
  			if (cmp != 0) {
  				return cmp;
  			}
  		}
  
  		return cmp;
  	}
  }
  