KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > gnu > text > ReportFormat


1 package gnu.text;
2 import java.text.Format JavaDoc;
3 import java.text.FieldPosition JavaDoc;
4 import java.io.Writer JavaDoc;
5 import java.io.CharArrayWriter JavaDoc;
6 import gnu.lists.Consumer;
7
8 public abstract class ReportFormat extends Format JavaDoc
9 {
10   /** Some Formats use this to indicate a parameter that is the
11    * extracted from the argment list. */
12   public static final int PARAM_FROM_LIST = 0xA0000000;
13
14   /** Some Formats use this to indicate a parameter that is the
15    * number of remaining paramaters. */
16   public static final int PARAM_FROM_COUNT = 0xB0000000;
17
18   /** Some Formats use this to indicate an unspecified parameter. */
19   public static final int PARAM_UNSPECIFIED = 0xC0000000;
20
21   public static int result(int resultCode, int nextArg)
22   {
23     return (resultCode << 24) | nextArg;
24   }
25   public static int nextArg(int result) { return result & 0xffffff; }
26   public static int resultCode(int result) { return result >>> 24; }
27
28   /** Format an array of arguments, and write out the result.
29    * @param dst where to write the result
30    * @param args the objects to be formatted
31    * @param start the index (in args) of the argument to start with
32    * @return an integer result(resultCode, nextArg), where
33    * nextArg is the index following the last argument processed, and
34    * code is a result code (normally 0, or negative if early termintation)
35    */
36   public abstract int format(Object JavaDoc[] args, int start,
37                  Writer JavaDoc dst, FieldPosition JavaDoc fpos)
38     throws java.io.IOException JavaDoc;
39
40   public int format(Object JavaDoc arg, int start, Writer JavaDoc dst, FieldPosition JavaDoc fpos)
41     throws java.io.IOException JavaDoc
42   {
43     if (arg instanceof Object JavaDoc[])
44       return format((Object JavaDoc[]) arg, start, dst, fpos);
45     else
46       {
47         Object JavaDoc[] args = { arg };
48         return format(args, start, dst, fpos);
49       }
50   }
51
52   public StringBuffer JavaDoc format(Object JavaDoc obj, StringBuffer JavaDoc sbuf, FieldPosition JavaDoc fpos)
53   {
54     format((Object JavaDoc[]) obj, 0, sbuf, fpos);
55     return sbuf;
56   }
57
58   public int format(Object JavaDoc[] args, int start,
59             StringBuffer JavaDoc sbuf, FieldPosition JavaDoc fpos)
60   {
61     CharArrayWriter JavaDoc wr = new CharArrayWriter JavaDoc();
62     try
63       {
64     start = format(args, start, wr, fpos);
65     if (start < 0)
66       return start;
67       }
68     catch (java.io.IOException JavaDoc ex)
69       {
70     throw new Error JavaDoc("unexpected exception: "+ex);
71       }
72     sbuf.append(wr.toCharArray());
73     return start;
74   }
75
76   public static int format(Format JavaDoc fmt, Object JavaDoc[] args, int start,
77                Writer JavaDoc dst, FieldPosition JavaDoc fpos)
78     throws java.io.IOException JavaDoc
79   {
80     if (fmt instanceof ReportFormat)
81       return ((ReportFormat) fmt).format(args, start, dst, fpos);
82     StringBuffer JavaDoc sbuf = new StringBuffer JavaDoc();
83     if (fmt instanceof java.text.MessageFormat JavaDoc)
84       start = format(fmt, args, start, sbuf, fpos);
85     else
86       fmt.format(args[start++], sbuf, fpos);
87     int slen = sbuf.length();
88     char[] cbuf = new char[slen];
89     sbuf.getChars(0, slen, cbuf, 0);
90     dst.write(cbuf);
91     return start;
92   }
93
94   public static int format(Format JavaDoc fmt, Object JavaDoc[] args, int start,
95                StringBuffer JavaDoc sbuf, FieldPosition JavaDoc fpos)
96   {
97     if (fmt instanceof ReportFormat)
98       return ((ReportFormat) fmt).format(args, start, sbuf, fpos);
99     int nargs;
100     Object JavaDoc arg;
101     if (fmt instanceof java.text.MessageFormat JavaDoc)
102       {
103     nargs = args.length - start;
104     if (start > 0)
105       {
106         Object JavaDoc[] subarr = new Object JavaDoc[args.length - start];
107         System.arraycopy(args, start, subarr, 0, subarr.length);
108         arg = subarr;
109       }
110     else
111       arg = args;
112       }
113     else
114       {
115     arg = args[start];
116     nargs = 1;
117       }
118     fmt.format(arg, sbuf, fpos);
119     return start + nargs;
120   }
121
122   /** (Parameters in non-standard order.) */
123   public static void print (Writer JavaDoc dst, String JavaDoc str)
124     throws java.io.IOException JavaDoc
125   {
126     if (dst instanceof java.io.PrintWriter JavaDoc)
127       ((java.io.PrintWriter JavaDoc) dst).print(str);
128     else
129       dst.write(str.toCharArray());
130   }
131
132   public static void print (Object JavaDoc value, Consumer out)
133   {
134     if (value instanceof Printable)
135       ((Printable) value).print(out);
136     else
137       // Should we use out.writeObject?
138 // We need make consistent rules to avoid infinite recursion.
139 out.write(value == null ? "null" : value.toString());
140   }
141
142   public Object JavaDoc parseObject(String JavaDoc text, java.text.ParsePosition JavaDoc status)
143   {
144     throw new Error JavaDoc("ReportFormat.parseObject - not implemented");
145   }
146
147   public static int getParam(Object JavaDoc arg, int defaultValue)
148   {
149     if (arg instanceof Number JavaDoc)
150       return ((Number JavaDoc) arg).intValue();
151     if (arg instanceof Character JavaDoc)
152       return ((Character JavaDoc) arg).charValue();
153     if (arg instanceof Char)
154       return ((Char) arg).charValue();
155     //if (arg == null || arg == Boolean.FALSE || arg == Special.dfault)
156 return defaultValue;
157   }
158
159   protected static int getParam(int param, int defaultValue, Object JavaDoc[] args, int start)
160   {
161     if (param == PARAM_FROM_COUNT)
162       return args.length - start;
163     if (param == PARAM_FROM_LIST)
164       return args == null ? defaultValue : getParam(args[start], defaultValue);
165     if (param == PARAM_UNSPECIFIED)
166       return defaultValue;
167     // Need to mask off flags etc?
168 return param;
169   }
170
171   protected static char getParam(int param, char defaultValue, Object JavaDoc[] args, int start)
172   {
173     return (char) getParam (param, (int) defaultValue, args, start);
174   }
175
176   /** Get the index'th parameter for the conversion specification specs[speci].
177    * Note that parameters are numbered from 1 to numParams(speci).
178    * The list of arguments to be converted is args, with the current index
179    * (as of the start of this conversion, i.e. not taking into account
180    * earlier PARAM_FROM_LIST paramaters for this conversion) in start.
181    * The default value (used if PARAM_UNSPECIFIED) is defaultValue.
182    */
183   /*
184   int getParam(int speci, int index, int defaultValue, Object[] args, int start)
185   {
186     int num_params = numParams(speci);
187     int param = index <= num_params ? specs[speci+index] : PARAM_UNSPECIFIED;
188     if (param == PARAM_FROM_LIST || param == PARAM_FROM_COUNT)
189       start += adjustArgsStart(speci, index);
190     return getParam(param, defaultValue, args, start);
191   }
192   */
193 }
194
Popular Tags