View Javadoc

1   /**
2    * JDBM LICENSE v1.00
3    *
4    * Redistribution and use of this software and associated documentation
5    * ("Software"), with or without modification, are permitted provided
6    * that the following conditions are met:
7    *
8    * 1. Redistributions of source code must retain copyright
9    *    statements and notices.  Redistributions must also contain a
10   *    copy of this document.
11   *
12   * 2. Redistributions in binary form must reproduce the
13   *    above copyright notice, this list of conditions and the
14   *    following disclaimer in the documentation and/or other
15   *    materials provided with the distribution.
16   *
17   * 3. The name "JDBM" must not be used to endorse or promote
18   *    products derived from this Software without prior written
19   *    permission of Cees de Groot.  For written permission,
20   *    please contact cg@cdegroot.com.
21   *
22   * 4. Products derived from this Software may not be called "JDBM"
23   *    nor may "JDBM" appear in their names without prior written
24   *    permission of Cees de Groot.
25   *
26   * 5. Due credit should be given to the JDBM Project
27   *    (http://jdbm.sourceforge.net/).
28   *
29   * THIS SOFTWARE IS PROVIDED BY THE JDBM PROJECT AND CONTRIBUTORS
30   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
31   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
32   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
33   * CEES DE GROOT OR ANY CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
34   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
35   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
36   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
38   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
40   * OF THE POSSIBILITY OF SUCH DAMAGE.
41   *
42   * Copyright 2001 (C) Alex Boisvert. All Rights Reserved.
43   * Contributions are Copyright (C) 2001 by their associated contributors.
44   *
45   */
46  
47  package jdbm.helper;
48  
49  import java.io.IOException;
50  import java.io.Serializable;
51  import java.util.Comparator;
52  
53  /**
54   * Comparator for objects which have been serialized into byte arrays.
55   * In effect, it wraps another Comparator which compares object and provides
56   * transparent deserialization from byte array to object.
57   *
58   * @author <a href="mailto:boisvert@intalio.com">Alex Boisvert</a>
59   * @version $Id: ObjectBAComparator.java,v 1.1 2002/05/31 06:33:20 boisvert Exp $
60   */
61  public final class ObjectBAComparator
62      implements Comparator, Serializable
63  {
64  
65      /**
66       * Version id for serialization.
67       */
68      final static long serialVersionUID = 1L;
69  
70  
71      /**
72       * Wrapped comparator.
73       */
74      private Comparator _comparator;
75  
76  
77      /**
78       * Construct an ObjectByteArrayComparator which wraps an Object Comparator.
79       *
80       * @param comparator Object comparator.
81       */
82      public ObjectBAComparator( Comparator comparator )
83      {
84          if ( comparator == null ) {
85              throw new IllegalArgumentException( "Argument 'comparator' is null" );
86          }
87  
88          _comparator = comparator;
89      }
90  
91  
92      /**
93       * Compare two objects.
94       *
95       * @param obj1 First object
96       * @param obj2 Second object
97       * @return 1 if obj1 > obj2, 0 if obj1 == obj2, -1 if obj1 < obj2
98       */
99       public int compare( Object obj1, Object obj2 )
100      {
101         if ( obj1 == null ) {
102             throw new IllegalArgumentException( "Argument 'obj1' is null" );
103         }
104 
105         if ( obj2 == null ) {
106             throw new IllegalArgumentException( "Argument 'obj2' is null" );
107         }
108 
109         try {
110             obj1 = Serialization.deserialize( (byte[]) obj1 );
111             obj2 = Serialization.deserialize( (byte[]) obj2 );
112 
113             return _comparator.compare( obj1, obj2 );
114         } catch ( IOException except ) {
115             throw new WrappedRuntimeException( except );
116         } catch ( ClassNotFoundException except ) {
117             throw new WrappedRuntimeException( except );
118         }
119      }
120 
121 
122     /**
123      * Compare two byte arrays.
124      */
125     public static int compareByteArray( byte[] thisKey, byte[] otherKey )
126     {
127         int len = Math.min( thisKey.length, otherKey.length );
128 
129         // compare the byte arrays
130         for ( int i=0; i<len; i++ ) {
131             if ( thisKey[i] >= 0 ) {
132                 if ( otherKey[i] >= 0 ) {
133                     // both positive
134                     if ( thisKey[i] < otherKey[i] ) {
135                         return -1;
136                     } else if ( thisKey[i] > otherKey[i] ) {
137                         return 1;
138                     }
139                 } else {
140                     // otherKey is negative => greater (because MSB is 1)
141                     return -1;
142                 }
143             } else {
144                 if ( otherKey[i] >= 0 ) {
145                     // thisKey is negative => greater (because MSB is 1)
146                     return 1;
147                 } else {
148                     // both negative
149                     if ( thisKey[i] < otherKey[i] ) {
150                         return -1;
151                     } else if ( thisKey[i] > otherKey[i] ) {
152                         return 1;
153                     }
154                 }
155             }
156         }
157         if ( thisKey.length == otherKey.length) {
158             return 0;
159         }
160         if ( thisKey.length < otherKey.length ) {
161             return -1;
162         }
163         return 1;
164     }
165 
166 }