functionexpression.java

来自「用applet实现很多应用小程序」· Java 代码 · 共 1,002 行 · 第 1/3 页

    public CapFunction() { super(1); }
    public String getName() { return "CAP"; }
    public Object get(Tuple t) {
        String str = param(0).get(t).toString();
        return StringLib.capitalizeFirstOnly(str);
    }
}
//CONCAT(str1,str2,...)
class ConcatFunction extends StringFunction {
    public ConcatFunction() { super(Function.VARARGS); }
    public String getName() { return "CONCAT"; }
    public Object get(Tuple t) {
        StringBuffer sbuf = getBuffer();
        for ( int i=0; i<paramCount(); ++i ) {
            Object o = param(i).get(t);
            if ( o != null )
                sbuf.append(o.toString());
        }
        return sbuf.toString();
    }
}
//CONCAT_WS(separator,str1,str2,...)
class ConcatWsFunction extends StringFunction {
    public ConcatWsFunction() { super(Function.VARARGS); }
    public String getName() { return "CONCAT_WS"; }
    public Object get(Tuple t) {
        StringBuffer sbuf = getBuffer();
        String sep = param(0).get(t).toString();
        for ( int i=1; i<paramCount(); ++i ) {
            sbuf.append(param(i).get(t).toString());
            sbuf.append(sep);
        }
        return sbuf.toString();
    }
}
//FORMAT(X,D)
class FormatFunction extends StringFunction {
    public FormatFunction() { super(2); }
    public String getName() { return "FORMAT"; }
    public Object get(Tuple t) {
        double x = param(0).getDouble(t);
        int d = param(1).getInt(t);
        DecimalFormat df = (DecimalFormat)NumberFormat.getInstance();
        df.setMinimumFractionDigits(d);
        df.setMaximumFractionDigits(d);
        return df.format(x);
    }
}
//INSERT(str,pos,len,newstr)
class InsertFunction extends StringFunction {
    public InsertFunction() { super(4); }
    public String getName() { return "INSERT"; }
    public Object get(Tuple t) {
        String str = param(0).get(t).toString();
        int strlen = str.length();
        int pos = param(1).getInt(t);
        int len = pos+param(2).getInt(t);
        String newstr = param(1).get(t).toString();
        if ( pos < 0 || pos > strlen )
            return str;
        if ( len < 0 || len > strlen )
            return str.substring(0,pos)+newstr;
        else
            return str.substring(0,pos)+newstr+str.substring(len);
    }
}
//INSTR(str,substr)
//LEFT(str,len)
class LeftFunction extends StringFunction {
    public LeftFunction() { super(2); }
    public String getName() { return "LEFT"; }
    public Object get(Tuple t) {
        String src = param(0).get(t).toString();
        int len = param(1).getInt(t);
        return src.substring(0, len);
    }
    
}
//LENGTH(str)
class LengthFunction extends IntFunction {
    public LengthFunction() { super(1); }
    public String getName() { return "LENGTH"; }
    public int getInt(Tuple t) {
        return param(0).get(t).toString().length();
    }
}
//LOCATE(substr,str), LOCATE(substr,str,pos)
//LOWER(str) | LCASE(str)
class LowerFunction extends StringFunction {
    public LowerFunction() { super(1); }
    public String getName() { return "LOWER"; }
    public Object get(Tuple t) {
        return param(0).get(t).toString().toLowerCase();
    }
}
//LPAD(str,len,padstr)
class LPadFunction extends StringFunction {
    public LPadFunction() { super(3); }
    public String getName() { return "LPAD"; }
    public Object get(Tuple t) {
        String str = param(0).get(t).toString();
        int len = param(1).getInt(t);
        String pad = param(2).get(t).toString();
        int strlen = str.length();
        if ( strlen > len ) {
            return str.substring(0,len);
        } else if ( strlen == len ) {
            return str;
        } else {
            StringBuffer sbuf = getBuffer();
            int padlen = pad.length();
            int diff = len-strlen;
            for ( int i=0; i<diff; i+=padlen)
                sbuf.append(pad);
            if ( sbuf.length() > diff )
                sbuf.delete(diff, sbuf.length());
            sbuf.append(str);
            return sbuf.toString();
        }
    }
}
//LTRIM(str)
//MID(str,pos,len) -- same as substring
//POSITION(substr, str)
class PositionFunction extends IntFunction {
    public PositionFunction() { super(2); }
    public String getName() { return "POSITION"; }
    public int getInt(Tuple t) {
        String substr = param(0).get(t).toString();
        String src = param(1).get(t).toString();
        return src.indexOf(substr);
    } 
}
//QUOTE(str)
//REPEAT(str,count)
class RepeatFunction extends StringFunction {
    public RepeatFunction() { super(2); }
    public String getName() { return "REPEAT"; }
    public Object get(Tuple t) {
        String src = param(0).get(t).toString();
        int count = param(1).getInt(t);
        StringBuffer sbuf = new StringBuffer();
        for ( int i=0; i<count; ++i ) {
            sbuf.append(src);
        }
        return sbuf.toString();
    } 
}
//REPLACE(str,from_str,to_str)
class ReplaceFunction extends StringFunction {
    public ReplaceFunction() { super(3); }
    public String getName() { return "REPLACE"; }
    public Object get(Tuple t) {
        String src = param(0).get(t).toString();
        String from = param(1).get(t).toString();
        String to = param(2).get(t).toString();
        return src.replaceAll(from, to);
    }
    
}
//REVERSE(str)
class ReverseFunction extends StringFunction {
    public ReverseFunction() { super(1); }
    public String getName() { return "REVERSE"; }
    public Object get(Tuple t) {
        String str = param(0).get(t).toString();
        StringBuffer sbuf = getBuffer();
        for ( int i=str.length()-1; --i>=0; ) {
            sbuf.append(str.charAt(i));
        }
        return sbuf.toString();
    }
}
//RIGHT(str,len)
class RightFunction extends StringFunction {
    public RightFunction() { super(2); }
    public String getName() { return "RIGHT"; }
    public Object get(Tuple t) {
        String src = param(0).get(t).toString();
        int len = param(1).getInt(t);
        return src.substring(src.length()-len);
    }
    
}
//RPAD(str,len,padstr)
class RPadFunction extends StringFunction {
    public RPadFunction() { super(3); }
    public String getName() { return "RPAD"; }
    public Object get(Tuple t) {
        String str = param(0).get(t).toString();
        int len = param(1).getInt(t);
        String pad = param(2).get(t).toString();
        int strlen = str.length();
        if ( strlen > len ) {
            return str.substring(0,len);
        } else if ( strlen == len ) {
            return str;
        } else {
            StringBuffer sbuf = getBuffer();
            sbuf.append(str);
            int padlen = pad.length();
            int diff = len-strlen;
            for ( int i=0; i<diff; i+=padlen)
                sbuf.append(pad);
            if ( sbuf.length() > len )
                sbuf.delete(len, sbuf.length());
            return sbuf.toString();
        }
    }
}
//RTRIM(str)
//// SOUNDEX(str)
//SPACE(N)
class SpaceFunction extends StringFunction {
    public SpaceFunction() { super(1); }
    public String getName() { return "SPACE"; }
    public Object get(Tuple t) {
        int n = param(0).getInt(t);
        StringBuffer sbuf = new StringBuffer();
        for ( int i=0; i<n; ++i )
            sbuf.append(' ');
        return sbuf.toString();
    }
    
}
//SUBSTRING(str,pos), SUBSTRING(str,pos,len)
class SubstringFunction extends StringFunction {
    public SubstringFunction() { super(3); }
    public String getName() { return "SUBSTRING"; }
    public Object get(Tuple t) {
        String src = param(0).get(t).toString();
        int pos = param(1).getInt(t);
        if ( paramCount() == 3 ) {
            int len = param(2).getInt(t);
            return src.substring(pos, pos+len);
        } else {
            return src.substring(pos);
        }
    }
}
//SUBSTRING_INDEX(str,delim,count)
//TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM(remstr FROM] str)
//UPPER(str) | UCASE(str)
class UpperFunction extends StringFunction {
    public UpperFunction() { super(1); }
    public String getName() { return "UPPER"; }
    public Object get(Tuple t) {
        return param(0).get(t).toString().toUpperCase();
    }
}

// ----------------------------------------------------------------------------

//RGB(r,g,b)
class RGBFunction extends IntFunction {
    public RGBFunction() { super(3); }
    public String getName() { return "RGB"; }
    public int getInt(Tuple t) {
        int r = param(0).getInt(t);
        int g = param(1).getInt(t);
        int b = param(2).getInt(t);
        return ColorLib.rgb(r,g,b);
    }
}
//HEX(hex)
class HexFunction extends IntFunction {
    public HexFunction() { super(1); }
    public String getName() { return "RGB"; }
    public int getInt(Tuple t) {
        String hex = (String)param(0).get(t);
        return ColorLib.hex(hex);
    }
}
//RGBA(r,g,b,a)
class RGBAFunction extends IntFunction {
    public RGBAFunction() { super(4); }
    public String getName() { return "RGBA"; }
    public int getInt(Tuple t) {
        int r = param(0).getInt(t);
        int g = param(1).getInt(t);
        int b = param(2).getInt(t);
        int a = param(3).getInt(t);
        return ColorLib.rgba(r,g,b,a);
    }
}
//GRAY(v) | GRAY(v, a)
class GrayFunction extends IntFunction {
    public GrayFunction() { super(2); }
    public String getName() { return "GRAY"; }
    public int getInt(Tuple t) {
        int g = param(0).getInt(t);
        if ( paramCount() == 2 ) {
            int a = param(1).getInt(t);
            return ColorLib.gray(g, a);
        } else {
            return ColorLib.gray(g);
        }
    }
}
//HSB(h,s,b)
class HSBFunction extends IntFunction {
    public HSBFunction() { super(3); }
    public String getName() { return "HSB"; }
    public int getInt(Tuple t) {
        float h = param(0).getFloat(t);
        float s = param(1).getFloat(t);
        float b = param(2).getFloat(t);
        return ColorLib.hsb(h,s,b);
    }
}
//HSBA(h,s,b,a)
class HSBAFunction extends IntFunction {
    public HSBAFunction() { super(4); }
    public String getName() { return "HSBA"; }
    public int getInt(Tuple t) {
        float h = param(0).getFloat(t);
        float s = param(1).getFloat(t);
        float b = param(2).getFloat(t);
        float a = param(3).getFloat(t);
        return ColorLib.hsba(h,s,b,a);
    }
}
//COLORINTERP(c1, c2, f)
class ColorInterpFunction extends IntFunction {
    public ColorInterpFunction() { super(3); }
    public String getName() { return "COLORINTERP"; }
    public int getInt(Tuple t) {
        int c1 = param(0).getInt(t);
        int c2 = param(1).getInt(t);
        double f = param(2).getDouble(t);
        return ColorLib.interp(c1, c2, f);
    }
}