/**
* Tests promises for a normal reference.
*/
static private <T extends Receiver<?>> Promise<?>
testNormal(final Eventual _, final T x) throws Exception {
final Promise<T> p = ref(x);
check(p.equals(p));
check(ref(x).equals(p));
check(x.equals(p.call()));
class EQ extends Do<T,Promise<Boolean>> implements Serializable {
static private final long serialVersionUID = 1L;
public Promise<Boolean>
fulfill(final T arg) throws Exception {
check(x.equals(arg));
return ref(true);
}
}
final Promise<?> a = _.when(p, new EQ());
final Promise<?> b = _.when(x, new EQ());
final Promise<?> c = _.when(new Sneaky<T>(x), new EQ());
final T x_ = _._(x);
check(x_.equals(x_));
check(_._(x_).equals(x_));
check(_._(x).equals(x_));
check(ref(x_).equals(p));
final Promise<?> d = _.when(x_, new EQ());
return join(_, a, b, c, d);
}
/** Returns true if the key was removed. */
public boolean remove(T key) {
int hashCode = key.hashCode();
int index = hashCode & mask;
if (key.equals(keyTable[index])) {
keyTable[index] = null;
size--;
return true;
}
index = hash2(hashCode);
if (key.equals(keyTable[index])) {
keyTable[index] = null;
size--;
return true;
}
index = hash3(hashCode);
if (key.equals(keyTable[index])) {
keyTable[index] = null;
size--;
return true;
}
return removeStash(key);
}
protected void verifyComparableToVsEquals(T o1, T o2) {
assertNotNull(o1);
assertNotNull(o2);
assertTrue((o1.compareTo(o2) == 0) == (o1.equals(o2)));
assertTrue((o2.compareTo(o1) == 0) == (o2.equals(o1)));
assertTrue((o1.compareTo(o2) == 0) == (o2.compareTo(o1) == 0));
}
/**
* Use @SuppressWarnings to allow the casts below: This follows Joshua Bloch's book Effective Java
* 2nd Edition Item 24: Eliminate unchecked warnings where it is described how to minimize scope
* of SuppressWarnings
*/
public <T extends Enum<T> & AzCategoryId> RequestAttributesFactory<T> getRequestAttributesFactory(
T t) {
if (t.equals(AzCategoryIdAction.AZ_CATEGORY_ID_ACTION)) {
@SuppressWarnings("unchecked")
RequestAttributesFactory<T> azWrapReqObjFac =
(RequestAttributesFactory<T>) getActionFactory();
return azWrapReqObjFac;
} else if (t.equals(AzCategoryIdResource.AZ_CATEGORY_ID_RESOURCE)) {
@SuppressWarnings("unchecked")
RequestAttributesFactory<T> azWrapReqObjFac =
(RequestAttributesFactory<T>) getResourceFactory();
return azWrapReqObjFac;
} else if (t.equals(AzCategoryIdSubjectAccess.AZ_CATEGORY_ID_SUBJECT_ACCESS)) {
@SuppressWarnings("unchecked")
RequestAttributesFactory<T> azWrapReqObjFac =
(RequestAttributesFactory<T>) getSubjectFactory();
return azWrapReqObjFac;
} else if (t.equals(AzCategoryIdEnvironment.AZ_CATEGORY_ID_ENVIRONMENT)) {
@SuppressWarnings("unchecked")
RequestAttributesFactory<T> azWrapReqObjFac =
(RequestAttributesFactory<T>) getEnvironmentFactory();
return azWrapReqObjFac;
}
return null;
}
@Override
public double getPerturbationPenalty(
Assignment<V, T> assignment, Model<V, T> model, T selectedValue, Collection<T> conflicts) {
double penalty = 0;
Set<T> violations =
(getViolatedInitials() == null
? null
: getViolatedInitials().getViolatedInitials(selectedValue));
if (violations != null)
for (T aValue : violations) {
if (assignment.getValue(aValue.variable()) == null)
penalty += getPenaltyA(assignment, selectedValue, aValue);
}
if (conflicts != null) {
for (T conflictValue : conflicts) {
T initialValue = conflictValue.variable().getInitialAssignment();
if (initialValue != null) {
if (initialValue.equals(conflictValue))
penalty += getPenaltyB(assignment, selectedValue, conflictValue, initialValue);
else {
if (violations == null || !violations.contains(initialValue))
penalty += getPenaltyC(assignment, selectedValue, conflictValue, initialValue);
}
}
}
}
if (selectedValue.variable().getInitialAssignment() != null
&& !selectedValue.equals(selectedValue.variable().getInitialAssignment()))
penalty +=
getPenaltyD(assignment, selectedValue, selectedValue.variable().getInitialAssignment());
return penalty;
}
public Matrix<T> getKernelBasis() {
Matrix<T> reducedRowEchelonForm = getReducedRowEchelonForm();
boolean[] hasLeadingOne = new boolean[n];
List<Integer> indices = new ArrayList<Integer>();
int j = 0;
for (int i = 0; i < m; i++)
while (j < n) {
T aij = reducedRowEchelonForm.get(i, j);
if (!aij.equals(zero)) {
if (!aij.equals(one)) throw new Error();
indices.add(j);
hasLeadingOne[j] = true;
j++;
break;
}
j++;
}
InvertibleBinaryOperation<T> addition = ring.addition();
Matrix<T> kernelBasis = new Matrix<T>(ring, n, n - indices.size());
kernelBasis.zero();
int k = 0;
for (int i = 0; i < n; i++)
if (!hasLeadingOne[i]) {
kernelBasis.set(i, k, one);
for (int l = 0; l < indices.size(); l++)
kernelBasis.set(indices.get(l), k, addition.inverse(reducedRowEchelonForm.get(l, i)));
k++;
}
if (k != kernelBasis.n) throw new Error(k + " / " + indices.size());
return kernelBasis;
}
private static <T> void updateIfValueChanged(
ContentProviderStoreCoreBase<T> store, Pair<T, Uri> pair) {
final Cursor cursor =
store.contentResolver.query(pair.second, store.getProjection(), null, null, null);
T newItem = pair.first;
boolean valuesEqual = false;
if (cursor != null) {
if (cursor.moveToFirst()) {
T currentItem = store.read(cursor);
valuesEqual = newItem.equals(currentItem);
if (!valuesEqual) {
Log.v(TAG, "Merging values at " + pair.second);
newItem = store.mergeValues(currentItem, newItem);
valuesEqual = newItem.equals(currentItem);
}
}
cursor.close();
}
if (valuesEqual) {
Log.v(TAG, "Data already up to date at " + pair.second);
return;
}
final ContentValues contentValues = store.getContentValuesForItem(newItem);
if (store.contentResolver.update(pair.second, contentValues, null, null) == 0) {
final Uri resultUri = store.contentResolver.insert(pair.second, contentValues);
Log.v(TAG, "Inserted at " + resultUri);
} else {
Log.v(TAG, "Updated at " + pair.second);
}
}
/**
* This is the main entry point for retrieving an object from this cache.
*
* @see org.broadleafcommerce.common.cache.StatisticsService
* @param responseClass the class representing the type of the cache item
* @param cacheName the name of the cache - the ehcache region name
* @param statisticsName the name to use for cache hit statistics
* @param retrieval the block of code to execute if a cache miss is not found in this cache
* @param params the appropriate params comprising a unique key for this cache item
* @param <T> the type of the cache item
* @return The object retrieved from the executiom of the PersistentRetrieval, or null if a cache
* miss was found in this cache
*/
protected <T> T getCachedObject(
Class<T> responseClass,
String cacheName,
String statisticsName,
PersistentRetrieval<T> retrieval,
String... params) {
T nullResponse = getNullObject(responseClass);
BroadleafRequestContext context = BroadleafRequestContext.getBroadleafRequestContext();
String key = buildKey(params);
T response = null;
if (context.isProductionSandBox()) {
response = getObjectFromCache(key, cacheName);
}
if (response == null) {
response = retrieval.retrievePersistentObject();
if (response == null) {
response = nullResponse;
}
// only handle null, non-hits. Otherwise, let level 2 cache handle it
if (context.isProductionSandBox() && response.equals(nullResponse)) {
statisticsService.addCacheStat(statisticsName, false);
getCache(cacheName).put(new Element(key, response));
if (getLogger().isTraceEnabled()) {
getLogger().trace("Caching [" + key + "] as null in the [" + cacheName + "] cache.");
}
}
} else {
statisticsService.addCacheStat(statisticsName, true);
}
if (response.equals(nullResponse)) {
return null;
}
return response;
}
public List<T> find(T start, T goal, StopDemander stop) {
Node<T> startNode = new Node<T>(start, null);
if (start.equals(goal)) {
return startNode.getPathElements();
}
List<Node<T>> queue = new LinkedList<Node<T>>();
Set<T> visited = new HashSet<T>();
queue.add(startNode);
visited.add(start);
while (!queue.isEmpty()) {
Node<T> node = queue.remove(0);
List<T> successors = ProductionUtil.getSuccessors(node.getElement(), productions);
for (T successor : successors) {
if (!visited.contains(successor)) {
Node<T> subNode = new Node(successor, node);
if (successor.equals(goal)) {
// The goal is found
return subNode.getPathElements();
}
queue.add(subNode);
visited.add(successor);
}
}
}
// Not found
return null;
}
public boolean equals(Object o) {
if (o == null || !(o instanceof SearchRange)) {
return false;
}
SearchRange range = (SearchRange) o;
return _from.equals(range._from) && _to.equals(range._to);
}
/**
* Modify is whether to make room for the new key if it doesn't exist. If a new entry is created,
* the value at that position will be Double.NaN. Here's where all the magic happens.
*/
private int find(T key, boolean modify) {
// System.out.println("find " + key + " " + modify + " " + mapType + " " + capacity());
if (mapType == MapType.SORTED_LIST) {
// Binary search
int i = binarySearch(key);
if (i < num && keys[i] != null && key.equals(keys[i])) return i;
if (modify) {
if (locked)
throw new RuntimeException(
"Cannot make new entry for " + key + ", because map is locked");
if (num == capacity()) changeSortedListCapacity(getCapacity(num + 1, false));
// Shift everything forward
for (int j = num; j > i; j--) {
keys[j] = keys[j - 1];
values[j] = values[j - 1];
}
num++;
values[i] = Double.NaN;
return i;
} else return -1;
} else if (mapType == MapType.HASH_TABLE) {
int capacity = capacity();
int keyHash = hash(key);
int i = keyHash % capacity;
if (i < 0) i = -i; // Arbitrary transformation
// Make sure big enough
if (!locked && modify && (num > loadFactor * capacity || capacity <= num + 1)) {
/*if(locked)
throw new RuntimeException("Cannot make new entry for " + key + ", because map is locked");*/
switchMapType(MapType.HASH_TABLE);
return find(key, modify);
}
// System.out.println("!!! " + keyHash + " " + capacity);
if (num == capacity) throw new RuntimeException("Hash table is full: " + capacity);
while (keys[i] != null && !keys[i].equals(key)) { // Collision
// Warning: infinite loop if the hash table is full
// (but this shouldn't happen based on the check above)
i++;
numCollisions++;
if (i == capacity) i = 0;
}
if (keys[i] != null) { // Found
assert key.equals(keys[i]);
return i;
}
if (modify) { // Not found
num++;
values[i] = Double.NaN;
return i;
} else return -1;
} else throw new RuntimeException("Internal bug: " + mapType);
}
@Override
public boolean equals(Object o) {
if (o instanceof SymmetricPair<?>) {
final SymmetricPair<?> p = (SymmetricPair<?>) o;
return (mFst.equals(p.mFst) && mSnd.equals(p.mSnd))
|| (mFst.equals(p.mSnd) && mSnd.equals(p.mFst));
}
return false;
}
@Override
public boolean check() {
lastValue = element.getValue();
if (lastValue.equals(pulsedValue)) {
pulses++;
} else if (pulses >= maxPulses && lastValue.equals(nonPulsedValue)) {
return true;
}
return false;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Pair)) return false;
@SuppressWarnings("unchecked")
Pair<T> p = (Pair<T>) o;
return first.equals(p.first) && second.equals(p.second);
}
public boolean equals(Object o) {
try {
@SuppressWarnings("unchecked")
Pair<T> other = (Pair<T>) o;
return (first == other.first || (first != null && first.equals(other.first)))
&& (second == other.second || (second != null && second.equals(other.second)));
} catch (Exception e) {
return false;
}
}
/**
* Compares this range to another object to test if they are equal..
*
* <p>To be equal, the minimum and maximum values must be equal, which ignores any differences in
* the comparator.
*
* @param obj the reference object with which to compare
* @return true if this object is equal
*/
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
} else if (obj == null || obj.getClass() != getClass()) {
return false;
} else {
@SuppressWarnings("unchecked") // OK because we checked the class above
Range<T> range = (Range<T>) obj;
return minimum.equals(range.minimum) && maximum.equals(range.maximum);
}
}
public boolean contains(T key) {
int hashCode = key.hashCode();
int index = hashCode & mask;
if (!key.equals(keyTable[index])) {
index = hash2(hashCode);
if (!key.equals(keyTable[index])) {
index = hash3(hashCode);
if (!key.equals(keyTable[index])) return containsKeyStash(key);
}
}
return true;
}
@Override
@SuppressWarnings("unchecked")
public <T> T promptChoiceTyped(
final String message, final List<T> options, final T defaultIfEmpty) {
if ((options == null) || options.isEmpty()) {
throw new IllegalArgumentException(
"promptChoice() Cannot ask user to select from a list of nothing. Ensure you have values in your options list.");
}
if (options.size() == 1) {
return options.get(0);
}
println(message);
Object result = InvalidInput.INSTANCE;
while (result instanceof InvalidInput) {
int count = 1;
println();
for (T entry : options) {
if ((entry != null) && entry.equals(defaultIfEmpty)) {
print(ShellColor.BOLD, " " + count + " - [" + entry + "]");
} else if (entry != null) {
print(" " + count + " - [" + entry + "]");
} else if (defaultIfEmpty == null) {
print(ShellColor.BOLD, " " + count + " - (none)");
}
if ((entry == defaultIfEmpty) || ((entry != null) && entry.equals(defaultIfEmpty))) {
print("*");
}
println();
count++;
}
println();
int input =
prompt(
"Choose an option by typing the number of the selection "
+ renderColor(ShellColor.BOLD, "[*-default] "),
Integer.class,
0)
- 1;
if ((input >= 0) && (input < options.size())) {
result = options.get(input);
} else if (input == -1) {
result = defaultIfEmpty;
} else {
println("Invalid selection, please try again.");
}
}
return (T) result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Pair other = (Pair) obj;
if (left == null) {
if (other.left != null) return false;
} else if (!left.equals(other.left)) return false;
if (right == null) {
if (other.right != null) return false;
} else if (!right.equals(other.right)) return false;
return true;
}
@Override
public boolean equals(Object obj) {
Pair other = (Pair) obj;
if (t1.equals(other.getT1()) && t2.equals(other.getT2())) {
return true;
}
if (t1.equals(other.getT2()) && t2.equals(other.getT1())) {
return true;
}
return false;
}
private <T> void assertMultivalue(
String message, T expectedVals[], Collection<T> actualVals, OperationResult result) {
if (expectedVals.length != actualVals.size()) {
fail(
message
+ ": expected "
+ expectedVals.length
+ " values but has "
+ actualVals.size()
+ " values: "
+ actualVals,
result);
return;
}
for (T expected : expectedVals) {
boolean found = false;
for (T actual : actualVals) {
if (expected.equals(actual)) {
found = true;
break;
}
}
if (!found) {
fail(
message
+ ": expected value '"
+ expected
+ "' not found in actual values "
+ actualVals,
result);
return;
}
}
}
/** sets value's explanation */
public void setNoGood(T value, Set<T> reason) {
sLogger.debug(
" -- set nogood "
+ value.variable().getName()
+ " = "
+ value.getName()
+ "(expl:"
+ expl2str(reason)
+ ")");
if (value.equals(value.variable().getAssignment())) {
try {
throw new Exception(
"An assigned value "
+ value.variable().getName()
+ " = "
+ value.getName()
+ " become no good (noGood:"
+ reason
+ ")!!");
} catch (Exception e) {
sLogger.warn(e.getMessage(), e);
}
checkExpl(reason);
printAssignments();
}
Set<T> noGood = noGood(value);
if (noGood != null) for (T v : noGood) removeSupport(v.variable(), value);
value.setExtra(reason);
for (T aValue : reason) {
addSupport(aValue.variable(), value);
}
goodnessChanged(value);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Event<?> other = (Event<?>) obj;
if (param == null) {
if (other.param != null) {
return false;
}
} else if (!param.equals(other.param)) {
return false;
}
if (type == null) {
if (other.type != null) {
return false;
}
} else if (!type.equals(other.type)) {
return false;
}
return true;
}
/**
* @param <T> The Object type.
* @param array - the array to look into.
* @param obj - the object to search for.
* @return {@code true} if the array contains the object, {@code false} otherwise.
*/
public static <T> boolean contains(T[] array, T obj) {
if (array == null || array.length == 0) return false;
for (T element : array) if (element.equals(obj)) return true;
return false;
}
/**
* After a value is assigned: explanations of other values of the value's variable are reset (to
* contain only the assigned value), propagation over the assigned variable takes place.
*/
@Override
public void afterAssigned(long iteration, T value) {
sLogger.debug("After assign " + value.variable().getName() + " = " + value.getName());
iIteration = iteration;
if (!isGood(value)) {
sLogger.warn(
value.variable().getName()
+ " = "
+ value.getName()
+ " -- not good value assigned (noGood:"
+ noGood(value)
+ ")");
setGood(value);
}
Set<T> noGood = new HashSet<T>(1);
noGood.add(value);
List<T> queue = new ArrayList<T>();
for (Iterator<T> i = value.variable().values().iterator(); i.hasNext(); ) {
T anotherValue = i.next();
if (anotherValue.equals(value) || !isGood(anotherValue)) continue;
setNoGood(anotherValue, noGood);
queue.add(anotherValue);
}
propagate(queue);
}
public void toReducedRowEchelonForm() {
InvertibleBinaryOperation<T> addition = ring.addition();
InvertibleBinaryOperation<T> multiplication =
(InvertibleBinaryOperation<T>) ring.multiplication();
toRowEchelonForm();
int j = 0;
for (int i = 0; i < m; i++) {
while (j < n) {
T aij = get(i, j);
if (!aij.equals(zero)) {
aij = multiplication.inverse(aij);
for (int k = j + 1; k < n; k++) {
T aik = multiplication.op(get(i, k), aij);
set(i, k, aik);
for (int l = 0; l < i; l++)
set(
l,
k,
addition.op(get(l, k), addition.inverse(multiplication.op(aik, get(l, j)))));
}
set(i, j, one);
for (int l = 0; l < i; l++) set(l, j, zero);
j++;
break;
}
j++;
}
}
}
/**
* Used to do a simple object.equals(lastObject) test. Simply call it like this:
* compareObjects(ec2.describeTags(), "ec2.DescribeTags") Internally this will also update the
* stateChanged count.
*
* @param object result of the AWS API method call
* @param methodName english version of the method just called
* @return true if the state was changed
*/
@SuppressWarnings("unchecked")
protected <T extends Object> boolean compareObjects(
T object, String methodName, String accoundId) {
SSCRecord record = RecordBuilder.createRecord(object, methodName, accoundId);
String lastKnown = state.getLastKnown(record.key);
// never seen before, must be new!
if (lastKnown == null) {
LOG.debug("new Record: " + record.key.toString());
state.writeNewRecord(record);
stateChanges += 1;
return true;
}
// LOG.debug("LAST RECORD: " + (lastKnown.length() >
// 500?lastKnown.substring(0,500)+"...":lastKnown));
SSCRecord last = RecordBuilder.read(lastKnown);
T value = (T) last.value;
if (!object.equals(value)) {
LOG.debug("new Record: " + record.key.toString());
state.writeNewRecord(record);
stateChanges += 1;
return true;
} else {
LOG.debug(methodName + " no state change");
return false;
}
}
/**
* Return true if the keys and the values are identical
*
* @param container The container
* @return If the two objects are equals.
*/
@Override
public boolean equals(Object container) {
Container cont = (Container) container;
return (key == cont.key && value.equals(cont.value));
}
private Character[][] returnMatrixToCharacterFromCharacter(T[][] originalFieldMatrix) {
if (originalFieldMatrix == null) return null;
fieldSize = originalFieldMatrix.length;
Character[][] fieldMatrixCharacter = new Character[fieldSize][fieldSize];
for (int i = 0; i < fieldSize; i++) {
for (int j = 0; j < fieldSize; j++) {
T sign = originalFieldMatrix[i][j];
// System.out.println("Converter::Character sign = " + sign);
if (sign.equals(SIGN_X)) fieldMatrixCharacter[i][j] = SIGN_X;
else if (sign.equals(SIGN_O)) fieldMatrixCharacter[i][j] = SIGN_O;
else fieldMatrixCharacter[i][j] = SIGN_EMPTY;
}
}
return fieldMatrixCharacter;
}
public void quitarDuplicados() {
Nodo<T> aux = inicio;
Nodo<T> aux2 = null;
T dato = null;
while (aux.getLiga() != null) {
dato = aux.getInfo();
aux2 = inicio;
int indice = 0;
boolean duplicado = false;
while (aux2 != null) {
if (dato.equals(aux2.getInfo())) {
if (!duplicado) {
duplicado = true;
aux2 = aux2.getLiga();
indice++;
} else {
aux2 = aux2.getLiga();
borrar(indice);
indice++;
}
} else {
indice++;
aux2 = aux2.getLiga();
}
}
aux = aux.getLiga();
}
}
