View Javadoc

    1
    2   package st.ata.util;
    3
    4   import java.io.PrintWriter;
    5   import java.io.StringWriter;
    6   import java.lang.reflect.UndeclaredThrowableException;
    7   import java.util.ArrayList;
    8   import java.util.Collections;
    9   import java.util.Comparator;
    10  import java.util.logging.Level;
    11  import java.util.logging.Logger;
    12
    13  // Tested by TestX.java
    14
    15  /*** A collection of useful static methods. */
    16  @SuppressWarnings("unchecked")
    17  public final class X {
    18      public static final int DEBUG = 2;
    19
    20      /*** Throws a runtime exception with message <code>m</code>. */
    21      public static void fail(String m) {
    22          RuntimeException e = new RuntimeException(m);
    23          popTrace(e, 1);
    24          throw e;
    25      }
    26
    27      /***
    28       * Throws a runtime exception with message <code>systemProperty</code>.
    29       * @param systemProperty a <code>String</code> value which specifies
    30       *        a boolean system property, which if true will cause
    31       *        an exception to be thrown.
    32       */
    33      public static void testFailure(String systemProperty) {
    34          if (!Boolean.getBoolean(systemProperty)) {
    35              return;
    36          }
    37
    38          RuntimeException e = new RuntimeException(systemProperty);
    39          popTrace(e, 1);
    40          throw e;
    41      }
    42
    43      /*** Throws a runtime exception if <code>b</code> is not true. */
    44      public static void check(boolean b) {
    45          if (b) return;
    46          RuntimeException e = new RuntimeException("assertion failure");
    47          popTrace(e, 1);
    48           throw e;
    49      }
    50
    51      /*** Throws a runtime exception if <code>b</code> is not true. */
    52      public static void check(boolean b, String m) {
    53          if (b) return;
    54          RuntimeException e = new RuntimeException(m);
    55          popTrace(e, 1);
    56          throw e;
    57      }
    58
    59      /*** Throws an illegal argument exception if <code>b</code> is not true. */
    60      public static void checkargs(boolean b) {
    61          if (b) return;
    62          RuntimeException e = new IllegalArgumentException();
    63          popTrace(e, 1);
    64          throw e;
    65      }
    66
    67      /*** Throws an illegal state exception if <code>b</code> is not true. */
    68      public static void checkstate(boolean b) {
    69          if (b) return;
    70          RuntimeException e = new IllegalStateException();
    71          popTrace(e, 1);
    72          throw e;
    73      }
    74
    75      /***
    76       *  Returns an {@link UndeclaredThrowableException}
    77       *  wrapping <code>e</code>.
    78       */
    79
    80      public static RuntimeException toRTE(Exception e) {
    81          RuntimeException rte = new UndeclaredThrowableException(e);
    82          popTrace(rte, 1);
    83          return rte;
    84      }
    85
    86      /*** Same as <c>ut(b,&nbsp;"")</c>. */
    87      public static void ut(boolean b) { ut(b, ""); }
    88
    89      /*** Test condition during unit testing.  If <c>b</c> is true, does
    90      nothing.  If <c>b</c> is not true, prints (to
    91      <c>System.out</c>)
    92      <c>"Unit&nbsp;test&nbsp;failure:&nbsp;"&nbsp;+&nbsp;m</c> and
    93      a stack trace then returns. */
    94      public static void ut(boolean b, String m) {
    95      if (! b) {
    96          try {
    97                  if (b) return;
    98                  RuntimeException e
    99                      = new RuntimeException("Unit test failure: " + m);
    100                 popTrace(e, 1);
    101                 throw e;
    102         } catch (RuntimeException e) {
    103         System.out.println("");
    104         e.printStackTrace(System.out);
    105         }
    106     }
    107     }
    108     /***
    109      * print out the programName and arguments used
    110      */
    111     public static void printArgs(String programName, String[] args) {
    112         System.out.print(programName);
    113         for (int i=0; i<args.length; i++){
    114             System.out.print(" ");
    115             System.out.print(args[i]);
    116         }
    117     }
    118     public static void noimpl() {
    119         RuntimeException e = new RuntimeException("Not implemented yet.");
    120         popTrace(e, 1);
    121         throw e;
    122     }
    123
    124     /*** Returns a full description of a {@link Throwable}.  This full
    125      *  description includes a stack trace.  This method will never
    126      *  throw an error or exception: if something bad happens, it
    127      *  simply returns null. */
    128     public static String getFullDescription(Throwable t) {
    129         try {
    130             StringWriter sw = new StringWriter();
    131             PrintWriter o = new PrintWriter(sw);
    132             t.printStackTrace(o);
    133             o.flush();
    134             return sw.toString();
    135         } catch (Throwable ignore) { return null; }
    136     }
    137
    138     /*** Removes the top <code>n</code> stack-trace elements from
    139      *  <code>t</code>.  This is useful inside methods like {@link
    140      *  #fail} to help debuggers more quickly identify the location of
    141      *  a failure. */
    142     public static void popTrace(Throwable t, int n) {
    143         /*StackTraceElement[] ot = t.getStackTrace();
    144         int len = ot.length - n;
    145         StackTraceElement[] nt = new StackTraceElement[len];
    146         System.arraycopy(ot, n, nt, 0, len);
    147         t.setStackTrace(nt);*/
    148     }
    149
    150     public static int decodeInt(byte[] buf, int offset) {
    151         return ((buf[offset+3]&0xff)<<24
    152                 | (buf[offset+2]&0xff)<<16
    153                 | (buf[offset+1]&0xff)<<8
    154                 | (buf[offset]&0xff));
    155     }
    156
    157     public static int decodeShort(byte[] buf, int offset) {
    158         return ((buf[offset+1]&0xff)<<8
    159                 | (buf[offset]&0xff));
    160     }
    161
    162     public static void encodeShort(byte[] buf, int offset, int val) {
    163         X.check(val<=Short.MAX_VALUE && val>=Short.MIN_VALUE);
    164         buf[offset++] = (byte)val; val >>= 8;
    165         buf[offset] = (byte)val;
    166     }
    167
    168     public static void encodeInt(byte[] buf, int offset, int val) {
    169         buf[offset++] = (byte)val; val >>= 8;
    170         buf[offset++] = (byte)val; val >>= 8;
    171         buf[offset++] = (byte)val; val >>= 8;
    172         buf[offset] = (byte)val;
    173     }
    174
    175     public static long decodeLong(byte[] buf, int offset) {
    176         long lo = decodeInt(buf, offset) & 0xffffffffL;
    177         long hi = decodeInt(buf, offset+4);
    178         return (hi<<32) | lo;
    179     }
    180
    181     public static void encodeLong(byte[] buf, int offset, long val) {
    182         buf[offset++] = (byte)val; val >>= 8;
    183         buf[offset++] = (byte)val; val >>= 8;
    184         buf[offset++] = (byte)val; val >>= 8;
    185         buf[offset++] = (byte)val; val >>= 8;
    186         buf[offset++] = (byte)val; val >>= 8;
    187         buf[offset++] = (byte)val; val >>= 8;
    188         buf[offset++] = (byte)val; val >>= 8;
    189         buf[offset] = (byte)val;
    190     }
    191
    192
    193     /***
    194      *  returns the printable representation of <code>data</code>
    195      *  after escaping non-printable characters in C style.
    196      */
    197     public static String printable(byte[] data) {
    198         return printable(data, 0, data.length);
    199     }
    200
    201     /***
    202      *  returns the printable representation of <code>data</code>
    203      *  from <code>start</code> (inclusive) to <code>end</code> (exclusive).
    204      *  after escaping non-printable characters in C style.
    205      *  <code>data</code> may not be <code>null</code> and
    206      *  <code>start</code> must be smaller or equal to <code>end</code>
    207      *  Both <code>start</code> and <code>end</code> are bounded by
    208      *  <code>0</code> and <code>data.length</code> bot inclusive.
    209      */
    210
    211     public static String printable(byte[] data, int start, int end) {
    212         checkargs(data != null);
    213         checkargs(start <= end);
    214         checkargs(start >= 0);
    215         checkargs(end <= data.length);
    216         StringBuffer sb = new StringBuffer();
    217
    218         for (int i = start; i < end; i++) {
    219             final byte b = data[i];
    220             if (b < 0x20 || b > 0x7e) {
    221                 switch (b) {
    222                 case '\r':
    223                     sb.append("//r");
    224                     break;
    225                 case '\n':
    226                     sb.append("//n");
    227                     break;
    228                 case '\t':
    229                     sb.append("//t");
    230                     break;
    231                 case '\b':
    232                     sb.append("//b");
    233                     break;
    234                 case '\f':
    235                     sb.append("//f");
    236                     break;
    237                 case '//':
    238                     sb.append("////");
    239                     break;
    240                 default:
    241                     sb.append('//');
    242                     sb.append(b >>> 6);
    243                     sb.append((b >>> 3) & 0x07);
    244                     sb.append(b & 0x07);
    245                     break;
    246                 }
    247             } else {
    248                 sb.append((char)b);
    249             }
    250         }
    251         return sb.toString();
    252     }
    253
    254     public static void log(String ctxt, Level level, String msg, Throwable t) {
    255         Logger.getLogger("st."+ctxt).log(level,  ctxt+": "+msg, t);
    256     }
    257     public static void log(String ctxt, Level level, String msg) {
    258         Logger.getLogger("st."+ctxt).log(level, ctxt+": "+msg);
    259     }
    260     public static ArrayList dupElim(ArrayList al, Comparator cm) {
    261         if (al.size()<2)
    262             return al;
    263         Collections.sort(al, cm);
    264         Object prev =  al.get(0);
    265         ArrayList n = new ArrayList();
    266         n.add(prev);
    267         for (int i = 1; i < al.size(); i++) {
    268             if (!prev.equals(al.get(i)))
    269                 n.add(al.get(i));
    270             prev =  al.get(i);
    271         }
    272         return n;
    273     }
    274
    275 }