001: /* ====================================================================
002: * The LateralNZ Software License, Version 1.0
003: *
004: * Copyright (c) 2003 LateralNZ. All rights reserved.
005: *
006: * Redistribution and use in source and binary forms, with or without
007: * modification, are permitted provided that the following conditions
008: * are met:
009: *
010: * 1. Redistributions of source code must retain the above copyright
011: * notice, this list of conditions and the following disclaimer.
012: *
013: * 2. Redistributions in binary form must reproduce the above copyright
014: * notice, this list of conditions and the following disclaimer in
015: * the documentation and/or other materials provided with the
016: * distribution.
017: *
018: * 3. The end-user documentation included with the redistribution,
019: * if any, must include the following acknowledgment:
020: * "This product includes software developed by
021: * LateralNZ (http://www.lateralnz.org/) and other third parties."
022: * Alternately, this acknowledgment may appear in the software itself,
023: * if and wherever such third-party acknowledgments normally appear.
024: *
025: * 4. The names "LateralNZ" must not be used to endorse or promote
026: * products derived from this software without prior written
027: * permission. For written permission, please
028: * contact oss@lateralnz.org.
029: *
030: * 5. Products derived from this software may not be called "Panther",
031: * or "Lateral" or "LateralNZ", nor may "PANTHER" or "LATERAL" or
032: * "LATERALNZ" appear in their name, without prior written
033: * permission of LateralNZ.
034: *
035: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
036: * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
037: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
038: * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
039: * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
040: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
041: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
042: * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
043: * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
044: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
045: * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
046: * SUCH DAMAGE.
047: * ====================================================================
048: *
049: * This software consists of voluntary contributions made by many
050: * individuals on behalf of LateralNZ. For more
051: * information on Lateral, please see http://www.lateralnz.com/ or
052: * http://www.lateralnz.org
053: *
054: */
055: package org.lateralnz.common.util;
056:
057: import java.io.ByteArrayInputStream;
058: import java.io.ByteArrayOutputStream;
059: import java.io.IOException;
060: import java.io.ObjectInputStream;
061: import java.io.ObjectOutputStream;
062: import java.lang.reflect.Array;
063: import java.lang.reflect.Method;
064: import java.util.HashMap;
065: import java.util.Iterator;
066: import java.util.List;
067: import java.util.Map;
068:
069: /**
070: * various utility functions for object handling
071: *
072: * <pre>
073: *
074: *
075: * </pre>
076: *
077: * @author J R Briggs
078: */
079: public class ObjectUtils implements Constants {
080: private static final String L_BRACKET = "[";
081: private static final String R_BRACKET = "]";
082: private static final String BRACKETS = L_BRACKET + R_BRACKET;
083:
084: private static Map primitives = new HashMap();
085: static {
086: primitives.put("boolean", boolean.class);
087: primitives.put("byte", byte.class);
088: primitives.put("short", short.class);
089: primitives.put("char", char.class);
090: primitives.put("int", int.class);
091: primitives.put("long", long.class);
092: primitives.put("float", float.class);
093: primitives.put("double", double.class);
094: }
095:
096: /**
097: * resolve a string (specified as a primitive) to a object wrapper (i.e.
098: * turn a String into a Byte based upon a specified byte.class) given its primitive class
099: */
100: public static final Object coercePrimitive(String s, Class c) {
101: if (c == boolean.class) {
102: return new Boolean(s);
103: } else if (c == byte.class) {
104: return new Byte(s);
105: } else if (c == short.class) {
106: return new Short(s);
107: } else if (c == char.class) {
108: return s;
109: } else if (c == int.class) {
110: return new Integer(s);
111: } else if (c == long.class) {
112: return new Long(s);
113: } else if (c == float.class) {
114: return new Float(s);
115: } else if (c == double.class) {
116: return new Double(s);
117: } else {
118: return null;
119: }
120: }
121:
122: /**
123: * return true if an object is found in an array
124: */
125: public static final boolean containsObject(Object[] src,
126: Object match) {
127: for (int i = 0; i < src.length; i++) {
128: if (src[i].equals(match)) {
129: return true;
130: }
131: }
132:
133: return false;
134: }
135:
136: /**
137: * create a new array of a specified size copying the contents of a specified array
138: */
139: public static final Object copyArray(Object[] src, int newsize) {
140: if (src == null) {
141: return new Object[newsize];
142: } else if (newsize < src.length) {
143: newsize = src.length;
144: }
145:
146: Object dest = Array.newInstance(src[0].getClass(), newsize);
147:
148: String tmp[] = (String[]) dest;
149: System.arraycopy(src, 0, dest, 0, src.length);
150:
151: return dest;
152: }
153:
154: /**
155: * get a class based upon the specified classname (this method will correctly
156: * resolve primitives).
157: */
158: public static final Class getClass(String classname)
159: throws Exception {
160: if (primitives.containsKey(classname)) {
161: return (Class) primitives.get(classname);
162: } else {
163: return Class.forName(classname);
164: }
165: }
166:
167: /**
168: * return a class as a Java string
169: */
170: public static final String getParameterType(Class c) {
171: if (c.isArray()) {
172: StringBuffer sb = new StringBuffer(c.getComponentType()
173: .getName());
174:
175: for (int i = 0; i < StringUtils.countOccurrences(c
176: .getName(), '['); i++) {
177: sb.append(BRACKETS);
178: }
179:
180: return sb.toString();
181: } else {
182: return c.getName();
183: }
184: }
185:
186: /**
187: * get an md5 signature for a class based upon the methods (return type/name/parameters)
188: */
189: public static final String getMD5Signature(Class c)
190: throws Exception {
191: Method[] meth = c.getDeclaredMethods();
192: StringBuffer sb = new StringBuffer();
193: for (int i = 0; i < meth.length; i++) {
194: sb.append(meth[i].getReturnType().getName()).append(SPACE);
195: sb.append(meth[i].getName()).append(LEFT_BRACKET);
196: Class[] params = meth[i].getParameterTypes();
197: for (int j = 0; j < params.length; j++) {
198: sb.append(params[j].getName());
199: if (j < params.length - 1) {
200: sb.append(COMMA);
201: }
202: }
203: sb.append(RIGHT_BRACKET).append(NEWLINE);
204: }
205:
206: return StringUtils.toMD5Digest(sb.toString());
207: }
208:
209: /**
210: * deserialize an array of bytes into the original object
211: */
212: public static final Object deserialize(byte[] b)
213: throws IOException, ClassNotFoundException {
214: ByteArrayInputStream bais = null;
215: ObjectInputStream ois = null;
216:
217: try {
218: bais = new ByteArrayInputStream(b);
219: ois = new ObjectInputStream(bais);
220: return ois.readObject();
221: } finally {
222: IOUtils.close(ois);
223: IOUtils.close(bais);
224: }
225: }
226:
227: /**
228: * return true if the specified string classname is a primitive. This returns
229: * true if classname is "byte", "short", "char", "int", etc.
230: */
231: public static final boolean isPrimitive(String classname) {
232: return primitives.containsKey(classname);
233: }
234:
235: /**
236: * load a list with the contents of an array
237: */
238: public static final void loadList(Object[] src, List dest) {
239: for (int i = 0; i < src.length; i++) {
240: dest.add(src[i]);
241: }
242: }
243:
244: /**
245: * serialize an object into an array of bytes
246: */
247: public static final byte[] serialize(Object obj) throws IOException {
248: ByteArrayOutputStream baos = null;
249: ObjectOutputStream oos = null;
250: try {
251: baos = new ByteArrayOutputStream();
252: oos = new ObjectOutputStream(baos);
253: oos.writeObject(obj);
254: return baos.toByteArray();
255: } finally {
256: IOUtils.close(oos);
257: IOUtils.close(baos);
258: }
259: }
260:
261: /**
262: * generic function to iterate through a list of objects and return a concatenated
263: * 'toString' of them
264: */
265: public static final String toString(List objectList) {
266: StringBuffer sb = new StringBuffer();
267:
268: if ((objectList != null) && (objectList.size() > 0)) {
269: Iterator iter = objectList.iterator();
270:
271: while (iter.hasNext()) {
272: Object obj = iter.next();
273: sb.append(L_BRACKET).append(obj.toString()).append(
274: R_BRACKET);
275:
276: if (iter.hasNext()) {
277: sb.append(COMMA);
278: }
279: }
280: }
281:
282: return sb.toString();
283: }
284: }
|