001 package org.fest.util; 002 003 /* 004 * Created on Sep 17, 2010 005 * 006 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on 012 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the 013 * specific language governing permissions and limitations under the License. 014 * 015 * Copyright @2010-2011 the original author or authors. 016 */ 017 018 import static java.lang.String.format; 019 020 import java.util.Iterator; 021 022 /** 023 * Implements {@link ComparisonStrategy} contract with a comparison strategy based on {@link Object#equals(Object)} 024 * method, it is also based on {@link Comparable#compareTo(Object)} when Object are {@link Comparable} method. 025 * 026 * @author Joel Costigliola 027 */ 028 public class StandardComparisonStrategy extends AbstractComparisonStrategy { 029 030 private static final StandardComparisonStrategy INSTANCE = new StandardComparisonStrategy(); 031 032 /** 033 * Returns the singleton instance of this class. 034 * @return the singleton instance of this class. 035 */ 036 public static StandardComparisonStrategy instance() { 037 return INSTANCE; 038 } 039 040 /** 041 * Creates a new </code>{@link StandardComparisonStrategy}</code>, comparison strategy being based on 042 * {@link Object#equals(Object)}. 043 */ 044 private StandardComparisonStrategy() {} 045 046 /** 047 * Returns true if actual and other are equal based on {@link Object#equals(Object)}, false otherwise. 048 * 049 * @param actual the object to compare to other 050 * @param other the object to compare to actual 051 * @return true if actual and other are equal based on {@link Object#equals(Object)}, false otherwise. 052 */ 053 public boolean areEqual(Object actual, Object other) { 054 return Objects.areEqual(actual, other); 055 } 056 057 /** 058 * Returns true if given {@link Iterable} contains given value based on {@link Object#equals(Object)}, false 059 * otherwise.<br> 060 * If given {@link Iterable} is null, return false. 061 * 062 * @param iterable the {@link Iterable} to search value in 063 * @param value the object to look for in given {@link Iterable} 064 * @return true if given {@link Iterable} contains given value based on {@link Object#equals(Object)}, false 065 * otherwise. 066 */ 067 public boolean iterableContains(Iterable<?> iterable, Object value) { 068 if (iterable == null) return false; 069 for (Object next : iterable) { 070 // handle same or null element/value 071 if (next == value) return true; 072 // both objects are not null => if one is then the other is not => compare next element with value 073 if (value == null || next == null) continue; 074 if (next.equals(value)) return true; 075 } 076 return false; 077 } 078 079 /** 080 * {@inheritDoc} 081 */ 082 public void iterableRemoves(Iterable<?> iterable, Object value) { 083 if (iterable == null) return; 084 Iterator<?> iterator = iterable.iterator(); 085 while (iterator.hasNext()) { 086 if (iterator.next().equals(value)) { 087 iterator.remove(); 088 } 089 } 090 } 091 092 /** 093 * Returns any duplicate elements from the given collection according to {@link Object#equals(Object)} comparison 094 * strategy. 095 * 096 * @param iterable the given {@link Iterable} we want to extract duplicate elements. 097 * @return an {@link Iterable} containing the duplicate elements of the given one. If no duplicates are found, an 098 * empty {@link Iterable} is returned. 099 */ 100 // overridden to write javadoc. 101 @Override 102 public Iterable<?> duplicatesFrom(Iterable<?> iterable) { 103 return super.duplicatesFrom(iterable); 104 } 105 106 public boolean stringStartsWith(String string, String prefix) { 107 return string.startsWith(prefix); 108 } 109 110 public boolean stringEndsWith(String string, String suffix) { 111 return string.endsWith(suffix); 112 } 113 114 public boolean stringContains(String string, String sequence) { 115 return string.contains(sequence); 116 } 117 118 @SuppressWarnings({ "unchecked", "rawtypes" }) 119 public boolean isGreaterThan(Object actual, Object other) { 120 if (!Comparable.class.isAssignableFrom(actual.getClass())) 121 throw new IllegalArgumentException(format("argument '%s' should be Comparable but is not", actual)); 122 if (!Comparable.class.isAssignableFrom(other.getClass())) 123 throw new IllegalArgumentException(format("argument '%s' should be Comparable but is not", other)); 124 Comparable comparableActual = (Comparable) actual; 125 Comparable comparableOther = (Comparable) other; 126 return comparableActual.compareTo(comparableOther) > 0; 127 } 128 129 }