root/livinglogic.java.ul4/library/src/com/livinglogic/ul4/Utils.java @ 200:18950fd59129

Revision 200:18950fd59129, 35.1 KB (checked in by Walter Doerwald <walter@…>, 10 years ago)

Add two argument version of int().

Line 
1package com.livinglogic.ul4;
2
3import java.util.AbstractList;
4import java.util.Collection;
5import java.util.Collections;
6import java.util.Iterator;
7import java.util.LinkedList;
8import java.util.NoSuchElementException;
9import java.util.List;
10import java.util.Locale;
11import java.util.Map;
12import java.util.Vector;
13import java.util.Date;
14import java.text.SimpleDateFormat;
15import org.apache.commons.lang.StringUtils;
16import org.apache.commons.lang.StringEscapeUtils;
17
18class Range extends AbstractList
19{
20    int start;
21
22    int stop;
23
24    int step;
25
26    int length;
27
28    public Range(int start, int stop, int step)
29    {
30        if (0 == step)
31        {
32            throw new IllegalArgumentException("Step argument must be different from zero!");
33        }
34        else if (0 < step)
35        {
36            this.length = rangeLength(start, stop, step);
37        }
38        else
39        {
40            this.length = rangeLength(stop, start, -step);
41        }
42        this.start = start;
43        this.stop = stop;
44        this.step = step;
45    }
46
47    public Object get(int index)
48    {
49        if ((index < 0) || (index >= length))
50        {
51            throw new IndexOutOfBoundsException("Invalid index: " + index);
52        }
53        return new Integer(start + index * step);
54    }
55
56    protected int rangeLength(int lowerEnd, int higherEnd, int positiveStep)
57    {
58        int retVal = 0;
59        if (lowerEnd < higherEnd)
60        {
61            int diff = higherEnd - lowerEnd - 1;
62            retVal = diff/positiveStep + 1;
63        }
64        return retVal;
65    }
66
67    public int size()
68    {
69        return length;
70    }
71}
72
73class StringIterator implements Iterator
74{
75    String string;
76
77    int stringSize;
78
79    int index;
80
81    public StringIterator(String string)
82    {
83        this.string = string;
84        stringSize = string.length();
85        index = 0;
86    }
87
88    public boolean hasNext()
89    {
90        return index < stringSize;
91    }
92
93    public Object next()
94    {
95        if (index >= stringSize)
96        {
97            throw new NoSuchElementException("No more characters available!");
98        }
99        return String.valueOf(string.charAt(index++));
100    }
101
102    public void remove()
103    {
104        throw new UnsupportedOperationException("Strings don't support character removal!");
105    }
106}
107
108class MapItemIterator implements Iterator
109{
110    Iterator iterator;
111
112    public MapItemIterator(Map map)
113    {
114        iterator = map.entrySet().iterator();
115    }
116
117    public boolean hasNext()
118    {
119        return iterator.hasNext();
120    }
121
122    public Object next()
123    {
124        Vector retVal = new Vector(2);
125        Map.Entry entry = (Map.Entry)iterator.next();
126        retVal.add(entry.getKey());
127        retVal.add(entry.getValue());
128        return retVal;
129    }
130
131    public void remove()
132    {
133        iterator.remove();
134    }
135}
136
137class ZipIterator implements Iterator
138{
139    Iterator iterator1;
140    Iterator iterator2;
141    Iterator iterator3;
142
143    public ZipIterator(Iterator iterator1, Iterator iterator2)
144    {
145        this.iterator1 = iterator1;
146        this.iterator2 = iterator2;
147        this.iterator3 = null;
148    }
149
150    public ZipIterator(Iterator iterator1, Iterator iterator2, Iterator iterator3)
151    {
152        this.iterator1 = iterator1;
153        this.iterator2 = iterator2;
154        this.iterator3 = iterator3;
155    }
156
157    public boolean hasNext()
158    {
159        return iterator1.hasNext() && iterator2.hasNext() && (iterator3 == null || iterator3.hasNext());
160    }
161
162    public Object next()
163    {
164        Vector retVal = new Vector(iterator3 != null ? 3 : 2);
165        retVal.add(iterator1.next());
166        retVal.add(iterator2.next());
167        if (iterator3 != null)
168            retVal.add(iterator3.next());
169        return retVal;
170    }
171
172    public void remove()
173    {
174        iterator1.remove();
175        iterator2.remove();
176        if (iterator3 != null)
177            iterator3.remove();
178    }
179}
180
181class SequenceEnumerator implements Iterator
182{
183    Iterator sequenceIterator;
184
185    int index = 0;
186
187    public SequenceEnumerator(Iterator sequenceIterator)
188    {
189        this.sequenceIterator = sequenceIterator;
190    }
191
192    public boolean hasNext()
193    {
194        return sequenceIterator.hasNext();
195    }
196
197    public Object next()
198    {
199        Vector retVal = new Vector(2);
200        retVal.add(new Integer(index++));
201        retVal.add(sequenceIterator.next());
202        return retVal;
203    }
204
205    public void remove()
206    {
207        sequenceIterator.remove();
208    }
209}
210
211public class Utils
212{
213    protected static final Integer INTEGER_TRUE = new Integer(1);
214
215    protected static final Integer INTEGER_FALSE = new Integer(0);
216
217    public static Object neg(Integer arg)
218    {
219        return new Integer(-arg.intValue());
220    }
221
222    public static Object neg(Number arg)
223    {
224        return new Double(-arg.doubleValue());
225    }
226
227    public static Object neg(Object arg)
228    {
229        if (arg instanceof Integer)
230            return neg((Integer)arg);
231        else if (arg instanceof Number)
232            return neg((Number)arg);
233        throw new UnsupportedOperationException("Can't negate instance of " + arg.getClass() + "!");
234    }
235
236    public static Object add(Integer arg1, Integer arg2)
237    {
238        return new Integer(arg1.intValue() + arg2.intValue());
239    }
240
241    public static Object add(Number arg1, Number arg2)
242    {
243        return new Double(arg1.doubleValue() + arg2.doubleValue());
244    }
245
246    public static Object add(String arg1, String arg2)
247    {
248        return arg1 + arg2;
249    }
250
251    public static Object add(Object arg1, Object arg2)
252    {
253        if (arg1 instanceof Integer && arg2 instanceof Integer)
254            return add((Integer)arg1, (Integer)arg2);
255        else if (arg1 instanceof Number && arg2 instanceof Number)
256            return add((Number)arg1, (Number)arg2);
257        else if (arg1 instanceof String && arg2 instanceof String)
258            return add((String)arg1, (String)arg2);
259        throw new UnsupportedOperationException("Can't add instances of " + arg1.getClass() + " and " + arg2.getClass() + "!");
260    }
261
262    public static Object sub(Integer arg1, Integer arg2)
263    {
264        return new Integer(arg1.intValue() - arg2.intValue());
265    }
266
267    public static Object sub(Number arg1, Number arg2)
268    {
269        return new Double(arg1.doubleValue() - arg2.doubleValue());
270    }
271
272    public static Object sub(Object arg1, Object arg2)
273    {
274        if (arg1 instanceof Integer && arg2 instanceof Integer)
275            return sub((Integer)arg1, (Integer)arg2);
276        else if (arg1 instanceof Number && arg2 instanceof Number)
277            return sub((Number)arg1, (Number)arg2);
278        else if (arg1 instanceof String && arg2 instanceof String)
279            return sub((String)arg1, (String)arg2);
280        throw new UnsupportedOperationException("Can't subtract instances of " + arg1.getClass() + " and " + arg2.getClass() + "!");
281    }
282
283    public static Object mul(String arg1, Integer arg2)
284    {
285        return StringUtils.repeat(arg1, arg2.intValue());
286    }
287
288    public static Object mul(Integer arg1, String arg2)
289    {
290        return StringUtils.repeat(arg2, arg1.intValue());
291    }
292
293    public static Object mul(Integer arg1, Integer arg2)
294    {
295        return new Integer(arg1.intValue() * arg2.intValue());
296    }
297
298    public static Object mul(Number arg1, Number arg2)
299    {
300        return new Double(arg1.doubleValue() * arg2.doubleValue());
301    }
302
303    public static Object mul(Object arg1, Object arg2)
304    {
305        if (arg1 instanceof String && arg2 instanceof Integer)
306            return mul((String)arg1, (Integer)arg2);
307        if (arg1 instanceof Integer && arg2 instanceof String)
308            return mul((Integer)arg1, (String)arg2);
309        if (arg1 instanceof Integer && arg2 instanceof Integer)
310            return mul((Integer)arg1, (Integer)arg2);
311        if (arg1 instanceof Number && arg2 instanceof Number)
312            return mul((Number)arg1, (Number)arg2);
313        throw new UnsupportedOperationException("Can't multiply instances of " + arg1.getClass() + " and " + arg2.getClass() + "!");
314    }
315
316    public static Object truediv(Number arg1, Number arg2)
317    {
318        return new Double(arg1.doubleValue() / arg2.doubleValue());
319    }
320
321    public static Object truediv(Object arg1, Object arg2)
322    {
323        throw new UnsupportedOperationException("Can't divide instances of " + arg1.getClass() + " and " + arg2.getClass() + "!");
324    }
325
326    public static Object floordiv(Integer arg1, Integer arg2)
327    {
328        return new Integer(arg1.intValue() / arg2.intValue());
329    }
330
331    public static Object floordiv(Number arg1, Number arg2)
332    {
333        return new Double((int)(arg1.doubleValue() / arg2.doubleValue()));
334    }
335
336    public static Object floordiv(Object arg1, Object arg2)
337    {
338        throw new UnsupportedOperationException("Can't divide instances of " + arg1.getClass() + " and " + arg2.getClass() + "!");
339    }
340
341    public static Object mod(Integer arg1, Integer arg2)
342    {
343        return new Integer(arg1.intValue() % arg2.intValue());
344    }
345
346    public static Object mod(Object arg1, Object arg2)
347    {
348        if (arg1 instanceof Integer && arg2 instanceof Integer)
349            return mod((Integer)arg1, (Integer)arg2);
350        else if (arg1 instanceof Color && arg2 instanceof Color)
351            return ((Color)arg1).blend((Color)arg2);
352        throw new UnsupportedOperationException("Can't apply the modulo operator to instances of " + arg1.getClass() + " and " + arg2.getClass() + "!");
353    }
354
355    public static Object getItem(String arg1, Integer arg2)
356    {
357        int index = arg2.intValue();
358        if (0 > index)
359        {
360            index += arg1.length();
361        }
362        return arg1.substring(index, index + 1);
363    }
364
365    public static Object getItem(List arg1, Integer arg2)
366    {
367        int index = arg2.intValue();
368        if (0 > index)
369        {
370            index += arg1.size();
371        }
372        return arg1.get(index);
373    }
374
375    public static Object getItem(Color arg1, Integer arg2)
376    {
377        int index = arg2.intValue();
378        switch (index)
379        {
380            case 0:
381                return new Integer(arg1.getR());
382            case 1:
383                return new Integer(arg1.getG());
384            case 2:
385                return new Integer(arg1.getB());
386            case 3:
387                return new Integer(arg1.getA());
388            default:
389                throw new ArrayIndexOutOfBoundsException();
390        }
391    }
392
393    public static Object getItem(Map arg1, Object arg2)
394    {
395        Object result = arg1.get(arg2);
396
397        if ((result == null) && !arg1.containsKey(arg2))
398            throw new KeyException(arg2);
399        return result;
400    }
401
402    public static Object getItem(Object arg1, Object arg2)
403    {
404        if (arg1 instanceof String && arg2 instanceof Integer)
405            return getItem((String)arg1, (Integer)arg2);
406        else if (arg1 instanceof List && arg2 instanceof Integer)
407            return getItem((List)arg1, (Integer)arg2);
408        else if (arg1 instanceof Color && arg2 instanceof Integer)
409            return getItem((Color)arg1, (Integer)arg2);
410        else if (arg1 instanceof Map)
411            return getItem((Map)arg1, arg2);
412        throw new UnsupportedOperationException("Instance of " + arg1.getClass() + " does not support getitem with argument of type " + arg2.getClass() + "!");
413    }
414
415    private static int getSliceStartPos(int sequenceSize, Integer virtualPos)
416    {
417        int retVal;
418        if (null == virtualPos)
419        {
420            retVal = 0;
421        }
422        else
423        {
424            retVal = virtualPos.intValue();
425            if (0 > retVal)
426            {
427                retVal += sequenceSize;
428            }
429            if (0 > retVal)
430            {
431                retVal = 0;
432            }
433            else if (sequenceSize < retVal)
434            {
435                retVal = sequenceSize;
436            }
437        }
438        return retVal;
439    }
440
441    private static int getSliceEndPos(int sequenceSize, Integer virtualPos)
442    {
443        int retVal;
444        if (null == virtualPos)
445        {
446            retVal = sequenceSize;
447        }
448        else
449        {
450            retVal = virtualPos.intValue();
451            if (0 > retVal)
452            {
453                retVal += sequenceSize;
454            }
455            if (0 > retVal)
456            {
457                retVal = 0;
458            }
459            else if (sequenceSize < retVal)
460            {
461                retVal = sequenceSize;
462            }
463        }
464        return retVal;
465    }
466
467    public static Object getSlice(List arg1, Integer arg2, Integer arg3)
468    {
469        int size = arg1.size();
470        int start = getSliceStartPos(size, arg2);
471        int end = getSliceEndPos(size, arg3);
472        if (end < start)
473            end = start;
474        return arg1.subList(start, end);
475    }
476
477    public static Object getSlice(String arg1, Integer arg2, Integer arg3)
478    {
479        int size = arg1.length();
480        int start = getSliceStartPos(size, arg2);
481        int end = getSliceEndPos(size, arg3);
482        if (end < start)
483            end = start;
484        return StringUtils.substring(arg1, start, end);
485    }
486
487    public static Object getSlice(Object arg1, Object arg2, Object arg3)
488    {
489        if (arg1 instanceof List)
490            return getSlice((List)arg1, (Integer)arg2, (Integer)arg3);
491        else if (arg1 instanceof String)
492            return getSlice((String)arg1, (Integer)arg2, (Integer)arg3);
493        throw new UnsupportedOperationException("Instance of " + arg1.getClass() + " does not support getslice with arguments of type " + arg2.getClass() + " and " + arg3.getClass() + "!");
494    }
495
496    public static boolean getBool(Boolean obj)
497    {
498        return obj.booleanValue();
499    }
500
501    public static boolean getBool(String obj)
502    {
503        return (obj.length() > 0);
504    }
505
506    public static boolean getBool(Integer obj)
507    {
508        return (obj.intValue() != 0);
509    }
510
511    public static boolean getBool(Long obj)
512    {
513        return (obj.longValue() != 0);
514    }
515
516    public static boolean getBool(Double obj)
517    {
518        return (obj.doubleValue() != 0.);
519    }
520
521    public static boolean getBool(Date obj)
522    {
523        return true;
524    }
525
526    public static boolean getBool(Collection obj)
527    {
528        return !obj.isEmpty();
529    }
530
531    public static boolean getBool(Map obj)
532    {
533        return !obj.isEmpty();
534    }
535
536    public static boolean getBool(Object obj)
537    {
538        if (null == obj)
539            return false;
540        else if (obj instanceof Boolean)
541            return getBool((Boolean)obj);
542        else if (obj instanceof String)
543            return getBool((String)obj);
544        else if (obj instanceof Integer)
545            return getBool((Integer)obj);
546        else if (obj instanceof Long)
547            return getBool((Long)obj);
548        else if (obj instanceof Double)
549            return getBool((Double)obj);
550        else if (obj instanceof Date)
551            return getBool((Date)obj);
552        else if (obj instanceof Collection)
553            return getBool((Collection)obj);
554        else if (obj instanceof Map)
555            return getBool((Map)obj);
556        return true;
557    }
558
559    public static boolean lt(Object obj1, Object obj2)
560    {
561        if (null != obj1)
562        {
563            if (null != obj2)
564                return ((Comparable)obj1).compareTo(obj2) < 0;
565        }
566        else if (null == obj2)
567            return false;
568        throw new RuntimeException("Can't compare object to null!");
569    }
570
571    public static boolean le(Object obj1, Object obj2)
572    {
573        if (null != obj1)
574        {
575            if (null != obj2)
576                return ((Comparable)obj1).compareTo(obj2) <= 0;
577        }
578        else if (null == obj2)
579            return true;
580        throw new RuntimeException("Can't compare object to null!");
581    }
582
583    public static boolean contains(String obj, String container)
584    {
585        return container.indexOf(obj) >= 0;
586    }
587
588    public static boolean contains(Object obj, Collection container)
589    {
590        return container.contains(obj);
591    }
592
593    public static boolean contains(Object obj, Map container)
594    {
595        return container.containsKey(obj);
596    }
597
598    public static boolean contains(Object obj, Object container)
599    {
600        if (container instanceof String)
601            return contains(obj, (String)container);
602        else if (container instanceof Collection)
603            return contains(obj, (Collection)container);
604        else if (container instanceof Map)
605            return contains(obj, (Map)container);
606        throw new RuntimeException("Can't determine presence for instance of " + obj.getClass() + " in container instance of class " + container.getClass() + "!");
607    }
608
609    public static String xmlescape(Object obj)
610    {
611        if (obj == null)
612            return "";
613
614        String str = obj.toString();
615        int length = str.length();
616        StringBuffer sb = new StringBuffer((int)(1.2 * length));
617        for (int offset = 0; offset < length; offset++)
618        {
619            char c = str.charAt(offset);
620            switch (c)
621            {
622                case '<':
623                    sb.append("&lt;");
624                    break;
625                case '>':
626                    sb.append("&gt;");
627                    break;
628                case '&':
629                    sb.append("&amp;");
630                    break;
631                case '\'':
632                    sb.append("&#39;");
633                    break;
634                case '"':
635                    sb.append("&quot;");
636                    break;
637                case '\t':
638                    sb.append(c);
639                    break;
640                case '\n':
641                    sb.append(c);
642                    break;
643                case '\r':
644                    sb.append(c);
645                    break;
646                case '\u0085':
647                    sb.append(c);
648                    break;
649                default:
650                    if ((('\u0020' <= c) && (c <= '\u007e')) || ('\u00A0' <= c))
651                        sb.append(c);
652                    else
653                        sb.append("&#").append((int)c).append(';');
654                    break;
655            }
656        }
657        return sb.toString();
658    }
659
660    public static String csv(Object obj)
661    {
662        if (obj == null)
663            return "";
664        if (!(obj instanceof String))
665            obj = repr(obj);
666        return StringEscapeUtils.escapeCsv((String)obj);
667    }
668
669    public static Object toInteger(String obj)
670    {
671        return Integer.valueOf(obj);
672    }
673
674    public static Object toInteger(Integer obj)
675    {
676        return obj;
677    }
678
679    public static Object toInteger(Long obj)
680    {
681        return obj;
682    }
683
684    public static Object toInteger(Number obj)
685    {
686        return new Integer(obj.intValue());
687    }
688
689    public static Object toInteger(Boolean obj)
690    {
691        return obj.booleanValue() ? INTEGER_TRUE : INTEGER_FALSE;
692    }
693
694    public static Object toInteger(Object obj)
695    {
696        if (obj instanceof String)
697            return toInteger((String)obj);
698        else if (obj instanceof Integer)
699            return toInteger((Integer)obj);
700        else if (obj instanceof Long)
701            return toInteger((Long)obj);
702        else if (obj instanceof Number)
703            return toInteger((Number)obj);
704        else if (obj instanceof Boolean)
705            return toInteger((Boolean)obj);
706        throw new UnsupportedOperationException("Can't convert instance of " + obj.getClass() + " to an integer!");
707    }
708
709    public static Object toInteger(String obj1, Integer obj2)
710    {
711        return Integer.valueOf(obj1, obj2.intValue());
712    }
713
714    public static Object toInteger(Object obj1, Object obj2)
715    {
716        if (obj1 instanceof String && obj2 instanceof Integer)
717        {
718            return toInteger((String)obj1, (Integer)obj2);
719        }
720        throw new UnsupportedOperationException("Can't convert instance of " + obj1.getClass() + " to an integer using " + obj2.getClass() + " as base!");
721    }
722
723    public static String repr(Object obj)
724    {
725        if (obj == null)
726            return "None";
727        else if (obj instanceof Boolean)
728            return ((Boolean)obj).booleanValue() ? "True" : "False";
729        else if (obj instanceof Integer)
730            return String.valueOf(((Integer)obj).intValue());
731        else if (obj instanceof Long)
732            return String.valueOf(((Long)obj).longValue());
733        else if (obj instanceof Double)
734            return String.valueOf(((Double)obj).doubleValue());
735        else if (obj instanceof String)
736            return new StringBuffer()
737                .append("\"")
738                .append(StringEscapeUtils.escapeJava(((String)obj)))
739                .append("\"")
740                .toString();
741        else if (obj instanceof Date)
742            return isoformat((Date)obj);
743        else if (obj instanceof Color)
744            return ((Color)obj).repr();
745        else if (obj instanceof Collection)
746        {
747            StringBuffer sb = new StringBuffer();
748            sb.append("[");
749            boolean first = true;
750            for (Iterator iter = ((Collection)obj).iterator(); iter.hasNext();)
751            {
752                if (first)
753                    first = false;
754                else
755                    sb.append(", ");
756                sb.append(repr(iter.next()));
757            }
758            sb.append("]");
759            return sb.toString();
760        }
761        else if (obj instanceof Map)
762        {
763            StringBuffer sb = new StringBuffer();
764            sb.append("{");
765            boolean first = true;
766            for (Iterator iter = ((Map)obj).entrySet().iterator(); iter.hasNext();)
767            {
768                if (first)
769                    first = false;
770                else
771                    sb.append(", ");
772                Map.Entry entry = (Map.Entry)iter.next();
773                sb.append(repr(entry.getKey()));
774                sb.append(": ");
775                sb.append(repr(entry.getValue()));
776            }
777            sb.append("}");
778            return sb.toString();
779        }
780        return null;
781    }
782   
783    public static String json(Object obj)
784    {
785        if (obj == null)
786            return "null";
787        else if (obj instanceof Boolean)
788            return ((Boolean)obj).booleanValue() ? "true" : "false";
789        else if (obj instanceof Integer)
790            return String.valueOf(((Integer)obj).intValue());
791        else if (obj instanceof Long)
792            return String.valueOf(((Long)obj).longValue());
793        else if (obj instanceof Double)
794            return String.valueOf(((Double)obj).doubleValue());
795        else if (obj instanceof String)
796            return new StringBuffer()
797                .append("\"")
798                .append(StringEscapeUtils.escapeJavaScript(((String)obj)))
799                .append("\"")
800                .toString();
801        else if (obj instanceof Date)
802            return json(isoformat((Date)obj));
803        else if (obj instanceof Collection)
804        {
805            StringBuffer sb = new StringBuffer();
806            sb.append("[");
807            boolean first = true;
808            for (Iterator iter = ((Collection)obj).iterator(); iter.hasNext();)
809            {
810                if (first)
811                    first = false;
812                else
813                    sb.append(", ");
814                sb.append(json(iter.next()));
815            }
816            sb.append("]");
817            return sb.toString();
818        }
819        else if (obj instanceof Map)
820        {
821            StringBuffer sb = new StringBuffer();
822            sb.append("{");
823            boolean first = true;
824            for (Iterator iter = ((Map)obj).entrySet().iterator(); iter.hasNext();)
825            {
826                if (first)
827                    first = false;
828                else
829                    sb.append(", ");
830                Map.Entry entry = (Map.Entry)iter.next();
831                sb.append(json(entry.getKey()));
832                sb.append(": ");
833                sb.append(json(entry.getValue()));
834            }
835            sb.append("}");
836            return sb.toString();
837        }
838        return null;
839    }
840   
841    public static Object length(String obj)
842    {
843        return new Integer(obj.length());
844    }
845
846    public static Object length(Collection obj)
847    {
848        return new Integer(obj.size());
849    }
850
851    public static Object length(Map obj)
852    {
853        return new Integer(obj.size());
854    }
855
856    public static Object length(Object obj)
857    {
858        if (obj instanceof String)
859            return length((String)obj);
860        else if (obj instanceof Collection)
861            return length((Collection)obj);
862        else if (obj instanceof Map)
863            return length((Map)obj);
864        throw new UnsupportedOperationException("Can't determine length for instance of " + obj.getClass() + "!");
865    }
866
867    public static Iterator iterator(String obj)
868    {
869        return new StringIterator(obj);
870    }
871
872    public static Iterator iterator(Collection obj)
873    {
874        return obj.iterator();
875    }
876
877    public static Iterator iterator(Map obj)
878    {
879        return obj.keySet().iterator();
880    }
881
882    public static Iterator iterator(Object obj)
883    {
884        if (obj instanceof String)
885            return iterator((String)obj);
886        else if (obj instanceof Collection)
887            return iterator((Collection)obj);
888        else if (obj instanceof Map)
889            return iterator((Map)obj);
890        else if (obj instanceof Iterator)
891            return (Iterator)obj;
892        throw new UnsupportedOperationException("Can't iterate instance of " + obj.getClass() + "!");
893    }
894
895    public static Object enumerate(Object obj)
896    {
897        return new SequenceEnumerator(iterator(obj));
898    }
899
900    public static Object chr(Integer obj)
901    {
902        int intValue = obj.intValue();
903        char charValue = (char)intValue;
904        if (intValue != (int)charValue)
905        {
906            throw new IndexOutOfBoundsException("Code point " + intValue + " is invalid!");
907        }
908        return String.valueOf(charValue);
909    }
910
911    public static Object chr(Object obj)
912    {
913        if (obj instanceof Integer)
914            return chr((Integer)obj);
915        throw new UnsupportedOperationException("Instance of " + obj.getClass() + " is no valid unicode codepoint!");
916    }
917
918    public static Object ord(String obj)
919    {
920        if (1 != obj.length())
921        {
922            throw new IllegalArgumentException("String " + obj + " contains more than one unicode character!");
923        }
924        return new Integer((int)obj.charAt(0));
925    }
926
927    public static Object ord(Object obj)
928    {
929        if (obj instanceof String)
930            return chr((String)obj);
931        throw new UnsupportedOperationException("Can't determine unicode code point for instance of " + obj.getClass() + "!");
932    }
933
934    public static Object hex(Integer obj)
935    {
936        return "0x" + Integer.toHexString(obj.intValue());
937    }
938
939    public static Object hex(Object obj)
940    {
941        if (obj instanceof Integer)
942            return hex((Integer)obj);
943        throw new UnsupportedOperationException("Instance of " + obj.getClass() + " can't be represented as a hexadecimal string!");
944    }
945
946    public static Object oct(Integer obj)
947    {
948        return "0o" + Integer.toOctalString(obj.intValue());
949    }
950
951    public static Object oct(Object obj)
952    {
953        if (obj instanceof Integer)
954            return oct((Integer)obj);
955        throw new UnsupportedOperationException("Instance of " + obj.getClass() + " can't be represented as an octal string!");
956    }
957
958    public static Object bin(Integer obj)
959    {
960        return "0b" + Integer.toBinaryString(obj.intValue());
961    }
962
963    public static Object bin(Object obj)
964    {
965        if (obj instanceof Integer)
966            return chr((Integer)obj);
967        throw new UnsupportedOperationException("Instance of " + obj.getClass() + " can't be represented as a binary string!");
968    }
969
970    public static Object sorted(String obj)
971    {
972        Vector retVal;
973        int length = obj.length();
974        retVal = new Vector(obj.length());
975        for (int i = 0; i < length; i++)
976        {
977            retVal.add(String.valueOf(obj.charAt(i)));
978        }
979        Collections.sort(retVal);
980        return retVal;
981    }
982
983    public static Object sorted(Collection obj)
984    {
985        Vector retVal = new Vector(obj);
986        Collections.sort(retVal);
987        return retVal;
988    }
989
990    public static Object sorted(Map obj)
991    {
992        Vector retVal = new Vector(obj.keySet());
993        Collections.sort(retVal);
994        return retVal;
995    }
996
997    public static Object sorted(Object obj)
998    {
999        if (obj instanceof String)
1000            return sorted((String)obj);
1001        else if (obj instanceof Collection)
1002            return sorted((Collection)obj);
1003        else if (obj instanceof Map)
1004            return sorted((Map)obj);
1005        throw new RuntimeException("Can't sort instance of " + obj.getClass() + "!");
1006    }
1007
1008    public static Object range(Integer obj)
1009    {
1010        return new Range(0, obj.intValue(), 1);
1011    }
1012
1013    public static Object range(Object obj)
1014    {
1015        if (obj instanceof Integer)
1016            return range((Integer)obj);
1017        throw new UnsupportedOperationException("Can't build a range for parameter: instance of " + obj.getClass() + "!");
1018    }
1019
1020    public static Object range(Integer obj1, Integer obj2)
1021    {
1022        return new Range(obj1.intValue(), obj2.intValue(), 1);
1023    }
1024
1025    public static Object range(Object obj1, Object obj2)
1026    {
1027        if (obj1 instanceof Integer && obj2 instanceof Integer)
1028            return range((Integer)obj1, (Integer)obj2);
1029        throw new UnsupportedOperationException("Can't build a range for parameters: instances of " + obj1.getClass() + " and " + obj2.getClass() + "!");
1030    }
1031
1032    public static Object range(Integer obj1, Integer obj2, Integer obj3)
1033    {
1034        return new Range(obj1.intValue(), obj2.intValue(), obj3.intValue());
1035    }
1036
1037    public static Object range(Object obj1, Object obj2, Object obj3)
1038    {
1039        if (obj1 instanceof Integer && obj2 instanceof Integer && obj3 instanceof Integer)
1040            return range((Integer)obj1, (Integer)obj2, (Integer)obj3);
1041        throw new UnsupportedOperationException("Can't build a range for parameters: instances of " + obj1.getClass() + " and " + obj2.getClass() + " and " + obj3.getClass() + "!");
1042    }
1043
1044    public static Object zip(Object obj1, Object obj2)
1045    {
1046        return new ZipIterator(iterator(obj1), iterator(obj2));
1047    }
1048
1049    public static Object zip(Object obj1, Object obj2, Object obj3)
1050    {
1051        return new ZipIterator(iterator(obj1), iterator(obj2), iterator(obj3));
1052    }
1053
1054    public static Object split(String obj1, String obj2)
1055    {
1056        LinkedList retVal = new LinkedList();
1057        int length = obj1.length();
1058        int delimLength = obj2.length();
1059        int pos1 = 0;
1060        int pos2;
1061        while (pos1 < length)
1062        {
1063            while ((pos1 < length) && obj1.startsWith(obj2, pos1))
1064            {
1065                if (0 == pos1)
1066                {
1067                    retVal.add("");
1068                }
1069                pos1 += delimLength;
1070                retVal.add("");
1071            }
1072            if (pos1 < length)
1073            {
1074                pos2 = pos1 + 1;
1075                if (!retVal.isEmpty())
1076                {
1077                    retVal.removeLast();
1078                }
1079                while ((pos2 < length) && !obj1.startsWith(obj2, pos2))
1080                {
1081                    pos2++;
1082                }
1083                retVal.add(obj1.substring(pos1, pos2));
1084                pos1 = pos2;
1085            }
1086        }
1087        return retVal;
1088    }
1089
1090    public static Object split(Object obj)
1091    {
1092        if (obj instanceof String)
1093            return StringUtils.split((String)obj);
1094        throw new UnsupportedOperationException("Can't split instance of " + obj.getClass() + "!");
1095    }
1096
1097    public static Object split(Object obj1, Object obj2)
1098    {
1099        if ((obj1 instanceof String) && (obj2 instanceof String))
1100            return split((String)obj1, (String)obj2);
1101        throw new UnsupportedOperationException("Can't split instance of " + obj1.getClass() + " with delimiter instance of " + obj2.getClass() + "!");
1102    }
1103
1104    public static Object strip(Object obj)
1105    {
1106        if (obj instanceof String)
1107            return StringUtils.strip((String)obj);
1108        throw new UnsupportedOperationException("Can't strip instance of " + obj.getClass() + "!");
1109    }
1110
1111    public static Object lstrip(Object obj)
1112    {
1113        if (obj instanceof String)
1114            return StringUtils.stripStart((String)obj, null);
1115        throw new UnsupportedOperationException("Can't lstrip instance of " + obj.getClass() + "!");
1116    }
1117
1118    public static Object rstrip(Object obj)
1119    {
1120        if (obj instanceof String)
1121            return StringUtils.stripEnd((String)obj, null);
1122        throw new UnsupportedOperationException("Can't rstrip instance of " + obj.getClass() + "!");
1123    }
1124
1125    public static Object upper(String obj)
1126    {
1127        return obj.toUpperCase();
1128    }
1129
1130    public static Object upper(Object obj)
1131    {
1132        if (obj instanceof String)
1133            return upper((String)obj);
1134        throw new UnsupportedOperationException("Can't convert an instance of " + obj.getClass() + " to upper case!");
1135    }
1136
1137    public static Object lower(String obj)
1138    {
1139        return obj.toLowerCase();
1140    }
1141
1142    public static Object lower(Object obj)
1143    {
1144        if (obj instanceof String)
1145            return lower((String)obj);
1146        throw new UnsupportedOperationException("Can't convert an instance of " + obj.getClass() + " to lower case!");
1147    }
1148
1149    public static Object capitalize(String obj)
1150    {
1151        return String.valueOf(Character.toTitleCase(obj.charAt(0))) + obj.substring(1).toLowerCase();
1152    }
1153
1154    public static Object capitalize(Object obj)
1155    {
1156        if (obj instanceof String)
1157            return capitalize((String)obj);
1158        throw new UnsupportedOperationException("Can't convert an instance of " + obj.getClass() + " to capital case!");
1159    }
1160
1161    public static SimpleDateFormat isoDateFormatter = new SimpleDateFormat("yyyy.MM.dd'T'HH:mm:ss.SSS'000'");
1162
1163    public static String isoformat(Date obj)
1164    {
1165        return isoDateFormatter.format(obj);
1166    }
1167
1168    public static String isoformat(Object obj)
1169    {
1170        if (obj instanceof Date)
1171            return isoformat((Date)obj);
1172        throw new UnsupportedOperationException("Can't call isoformat on instance of " + obj.getClass() + "!");
1173    }
1174
1175    public static Object format(Date obj, String formatString, Locale locale)
1176    {
1177        StringBuffer javaFormatString = new StringBuffer();
1178        int formatStringLength = formatString.length();
1179        boolean escapeCharacterFound = false;
1180        boolean inLiteral = false;
1181        char formatChar;
1182        String javaFormatSequence;
1183        for (int i = 0; i < formatStringLength; i++)
1184        {
1185            formatChar = formatString.charAt(i);
1186            if (escapeCharacterFound)
1187            {
1188                switch (formatChar)
1189                {
1190                    case 'a':
1191                        javaFormatSequence = "EE";
1192                        break;
1193                    case 'A':
1194                        javaFormatSequence = "EEEE";
1195                        break;
1196                    case 'b':
1197                        javaFormatSequence = "MMM";
1198                        break;
1199                    case 'B':
1200                        javaFormatSequence = "MMMM";
1201                        break;
1202                    case 'c':
1203                        throw new UnsupportedOperationException("Unimplemented escape sequence %c");
1204                    case 'd':
1205                        javaFormatSequence = "dd";
1206                        break;
1207                    case 'f':
1208                        javaFormatSequence = "SSS'000";
1209                        break;
1210                    case 'H':
1211                        javaFormatSequence = "HH";
1212                        break;
1213                    case 'I':
1214                        javaFormatSequence = "hh";
1215                        break;
1216                    case 'j':
1217                        javaFormatSequence = "DDD";
1218                        break;
1219                    case 'm':
1220                        javaFormatSequence = "MM";
1221                        break;
1222                    case 'M':
1223                        javaFormatSequence = "mm";
1224                        break;
1225                    case 'p':
1226                        javaFormatSequence = "aa";
1227                        break;
1228                    case 'S':
1229                        javaFormatSequence = "ss";
1230                        break;
1231                    case 'U':
1232                        javaFormatSequence = "ww";
1233                        break;
1234                    case 'w':
1235                        throw new UnsupportedOperationException("Unimplemented escape sequence %w");
1236                    case 'W':
1237                        javaFormatSequence = "ww";
1238                        break;
1239                    case 'x':
1240                        throw new UnsupportedOperationException("Unimplemented escape sequence %x");
1241                    case 'X':
1242                        throw new UnsupportedOperationException("Unimplemented escape sequence %X");
1243                    case 'y':
1244                        javaFormatSequence = "yy";
1245                        break;
1246                    case 'Y':
1247                        javaFormatSequence = "yyyy";
1248                        break;
1249                    default:
1250                        javaFormatSequence = null;
1251                        break;
1252                }
1253                if (inLiteral != (null == javaFormatSequence))
1254                {
1255                    javaFormatString.append('\'');
1256                    inLiteral = !inLiteral;
1257                }
1258                if (null != javaFormatSequence)
1259                {
1260                    javaFormatString.append(javaFormatSequence);
1261                    if ('f' == formatChar)
1262                    {
1263                        inLiteral = true;
1264                    }
1265                }
1266                else
1267                {
1268                    javaFormatString.append(formatChar);
1269                }
1270                escapeCharacterFound = false;
1271            }
1272            else
1273            {
1274                escapeCharacterFound = ('%' == formatChar);
1275                if (!escapeCharacterFound)
1276                {
1277                    if (inLiteral = !inLiteral)
1278                    {
1279                        javaFormatString.append('\'');
1280                    }
1281                    javaFormatString.append(formatChar);
1282                    if ('\'' == formatChar)
1283                    {
1284                        javaFormatString.append(formatChar);
1285                    }
1286                }
1287            }
1288        }
1289        if (inLiteral)
1290        {
1291            javaFormatString.append('\'');
1292        }
1293        return new SimpleDateFormat(javaFormatString.toString(), locale).format(obj);
1294    }
1295
1296    public static Object format(Object obj, Object formatString, Locale locale)
1297    {
1298        if (formatString instanceof String)
1299        {
1300            if (obj instanceof Date)
1301            {
1302                return format((Date)obj, (String)formatString, locale);
1303            }
1304        }
1305        throw new UnsupportedOperationException("Can't call format on instance of " + obj.getClass() + " with format string instance of " + formatString.getClass() + "!");
1306    }
1307
1308    public static Object replace(Object obj, Object arg1, Object arg2)
1309    {
1310        if (obj instanceof String && arg1 instanceof String && arg2 instanceof String)
1311            return StringUtils.replace((String)obj, (String)arg1, (String)arg2);
1312        throw new UnsupportedOperationException("Can't call replace on instance of " + obj.getClass() + "!");
1313    }
1314
1315    public static Object find(Object obj, Object arg1)
1316    {
1317        if (obj instanceof String && arg1 instanceof String)
1318            return new Integer(((String)obj).indexOf((String)arg1));
1319        throw new UnsupportedOperationException("Can't call find on instance of " + obj.getClass() + "!");
1320    }
1321
1322    public static Object rfind(Object obj, Object arg1)
1323    {
1324        if (obj instanceof String && arg1 instanceof String)
1325            return new Integer(((String)obj).lastIndexOf((String)arg1));
1326        throw new UnsupportedOperationException("Can't call rfind on instance of " + obj.getClass() + "!");
1327    }
1328
1329    public static Object items(Map obj)
1330    {
1331        return new MapItemIterator(obj);
1332    }
1333
1334    public static Object items(Object obj)
1335    {
1336        if (obj instanceof Map)
1337            return items((Map)obj);
1338        throw new UnsupportedOperationException("Instance of " + obj.getClass() + " can't be iterated as a map!");
1339    }
1340
1341    public static String type(Object obj)
1342    {
1343        if (obj == null)
1344            return "none";
1345        else if (obj instanceof String)
1346            return "str";
1347        else if (obj instanceof Boolean)
1348            return "bool";
1349        else if (obj instanceof Integer || obj instanceof Long)
1350            return "int";
1351        else if (obj instanceof Double)
1352            return "float";
1353        else if (obj instanceof Date)
1354            return "date";
1355        else if (obj instanceof Color)
1356            return "color";
1357        else if (obj instanceof List)
1358            return "list";
1359        else if (obj instanceof Map)
1360            return "dict";
1361        else if (obj instanceof Template)
1362            return "template";
1363        else
1364            return null;
1365    }
1366
1367    private static double _getdouble(Object arg)
1368    {
1369        if (arg instanceof Integer)
1370            return ((Integer)arg).doubleValue();
1371        else if (arg instanceof Long)
1372            return ((Long)arg).doubleValue();
1373        else if (arg instanceof Double)
1374            return ((Double)arg).doubleValue();
1375        else
1376            throw new UnsupportedOperationException("can't convert " + arg.getClass() + " to float!");
1377    }
1378
1379    private static int _getint(Object arg)
1380    {
1381        if (arg instanceof Integer)
1382            return ((Integer)arg).intValue();
1383        else if (arg instanceof Long)
1384            return ((Long)arg).intValue();
1385        else if (arg instanceof Double)
1386            return ((Double)arg).intValue();
1387        else
1388            throw new UnsupportedOperationException("can't convert " + arg.getClass() + " to int!");
1389    }
1390
1391    public static Color rgb(Object arg1, Object arg2, Object arg3)
1392    {
1393        return Color.fromrgb(_getdouble(arg1), _getdouble(arg2), _getdouble(arg3));
1394    }
1395
1396    public static Color rgb(Object arg1, Object arg2, Object arg3, Object arg4)
1397    {
1398        return Color.fromrgb(_getdouble(arg1), _getdouble(arg2), _getdouble(arg3), _getdouble(arg4));
1399    }
1400
1401    public static Color hsv(Object arg1, Object arg2, Object arg3)
1402    {
1403        return Color.fromhsv(_getdouble(arg1), _getdouble(arg2), _getdouble(arg3));
1404    }
1405
1406    public static Color hsv(Object arg1, Object arg2, Object arg3, Object arg4)
1407    {
1408        return Color.fromhsv(_getdouble(arg1), _getdouble(arg2), _getdouble(arg3), _getdouble(arg4));
1409    }
1410
1411    public static Color hls(Object arg1, Object arg2, Object arg3)
1412    {
1413        return Color.fromhls(_getdouble(arg1), _getdouble(arg2), _getdouble(arg3));
1414    }
1415
1416    public static Color hls(Object arg1, Object arg2, Object arg3, Object arg4)
1417    {
1418        return Color.fromhls(_getdouble(arg1), _getdouble(arg2), _getdouble(arg3), _getdouble(arg4));
1419    }
1420
1421    public static Color withlum(Object arg1, Object arg2)
1422    {
1423        return ((Color)arg1).withlum(_getdouble(arg2));
1424    }
1425
1426    public static Color witha(Object arg1, Object arg2)
1427    {
1428        return ((Color)arg1).witha(_getint(arg2));
1429    }
1430
1431    public static void main(String[] args)
1432    {
1433        //System.out.println(split("\t\tgurk\t\t\t\t\t\thurz\t\tschwumpl\t\t\t\t", "\t\t"));
1434        System.out.println(split("gurk\t\t\t\t\t\thurz\t\tschwumpl", "\t\t"));
1435        //System.out.println(split("\t\tgurk\t\t\t\t\t\thurz\t\tschwumpl\t\t\t\t"));
1436        //System.out.println(split("gurk\t\t\t\t\t\thurz\t\tschwumpl"));
1437        //System.out.println(split("  gurk      hurz  schwumpl    "));
1438    }
1439}
Note: See TracBrowser for help on using the browser.