1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the 7 * "License"); you may not use this file except in compliance 8 * with the License. You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, 13 * software distributed under the License is distributed on an 14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 15 * KIND, either express or implied. See the License for the 16 * specific language governing permissions and limitations 17 * under the License. 18 * 19 */ 20 package org.apache.directory.api.ldap.model.schema.comparators; 21 22 23 import org.apache.directory.api.i18n.I18n; 24 import org.apache.directory.api.ldap.model.schema.LdapComparator; 25 import org.slf4j.Logger; 26 import org.slf4j.LoggerFactory; 27 28 29 /** 30 * Compares two objects taking into account that one might be a Comparable. 31 * 32 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> 33 * @param <T> the type, must extend {@link Comparable} 34 */ 35 public class ComparableComparator<T> extends LdapComparator<Comparable<T>> 36 { 37 /** The serial version UID */ 38 private static final long serialVersionUID = 2L; 39 40 /** A logger for this class */ 41 private static final Logger LOG = LoggerFactory.getLogger( ComparableComparator.class ); 42 43 44 /** 45 * The ComparableComparator constructor. 46 * 47 * @param oid the comparator OID 48 */ 49 public ComparableComparator( String oid ) 50 { 51 super( oid ); 52 } 53 54 55 /** 56 * Compares two objects taking into account that one may be a Comparable. If 57 * the first is a comparable then its compareTo operation is called and the 58 * result returned as is. If the first is not a Comparable but the second is 59 * then its compareTo method is called and the result is returned after 60 * being negated. If none are comparable the hashCode of o1 minus the 61 * hashCode of o2 is returned. 62 * 63 * @param o1 the first comparable 64 * @param o2 the second comparable 65 * @return {@inheritDoc} 66 */ 67 @SuppressWarnings("unchecked") 68 public int compare( Comparable<T> o1, Comparable<T> o2 ) 69 { 70 LOG.debug( "comparing objects '{}' with '{}'", o1, o2 ); 71 72 if ( ( o1 == null ) && ( o2 == null ) ) 73 { 74 return 0; 75 } 76 77 if ( o1 instanceof Comparable<?> ) 78 { 79 if ( o2 == null ) 80 { 81 return -1; 82 } 83 else 84 { 85 // TODO: check type parameter 86 return o1.compareTo( ( T ) o2 ); 87 } 88 } 89 90 if ( o2 == null ) 91 { 92 return 1; 93 } 94 else if ( o2 instanceof Comparable<?> ) 95 { 96 if ( o1 == null ) 97 { 98 return -1; 99 } 100 else 101 { 102 // TODO: check type parameter 103 return -o2.compareTo( ( T ) o1 ); 104 } 105 } 106 107 // before https://issues.apache.org/jira/browse/DIRSERVER-928 it was 108 // return o1.hashCode() - o2.hashCode(); 109 110 // now we will blow a stack trace if none of the objects are Comparable 111 throw new IllegalArgumentException( I18n.err( I18n.ERR_04217, o1, o2 ) ); 112 } 113 }