Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*******************************************************************************
* Copyright 2014 Trevor Robinson
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.scurrilous.circe;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.Iterator;
/**
* Flags indicating the support available for some set of hash algorithm.
*/
public enum HashSupport {
/**
* Indicates that the hash algorithm is available in hardware-accelerated
* native code as an {@link IncrementalIntHash} or
* {@link IncrementalLongHash}, depending on which of {@link #INT_SIZED} or
* {@link #LONG_SIZED} is set.
*/
HARDWARE_INCREMENTAL(10),
/**
* Indicates that the hash algorithm is available in hardware-accelerated
* native code.
*/
HARDWARE(20),
/**
* Indicates that the hash algorithm is available in native code as a
* {@link IncrementalIntHash} or {@link IncrementalLongHash}, depending on
* which of {@link #INT_SIZED} or {@link #LONG_SIZED} is set.
*/
NATIVE_INCREMENTAL(30),
/**
* Indicates that the hash algorithm is available in native code.
*/
NATIVE(40),
/**
* Indicates that the incremental hash algorithm supports unsafe memory
* access via {@link IncrementalIntHash#resume(int, long, long)} or
* {@link IncrementalLongHash#resume(long, long, long)}, depending on which
* of {@link #INT_SIZED} or {@link #LONG_SIZED} is set.
*/
UNSAFE_INCREMENTAL(50),
/**
* Indicates that the stateful hash algorithm unsafe memory access via
* {@link StatefulHash#update(long, long)}. If {@link #INT_SIZED} is also
* set, the function returned by {@link StatefulIntHash#asStateless()} also
* supports {@link StatelessIntHash#calculate(long, long)}. Similarly, if
* {@link #LONG_SIZED} is also set, the function returned by
* {@link StatefulLongHash#asStateless()} also supports
* {@link StatelessLongHash#calculate(long, long)}.
*/
UNSAFE(60),
/**
* Indicates that the hash algorithm is available as a
* {@link IncrementalIntHash} or {@link IncrementalLongHash}, depending on
* which of {@link #INT_SIZED} or {@link #LONG_SIZED} is set.
*/
STATELESS_INCREMENTAL(70),
/**
* Indicates that the hash algorithm is available as an incremental stateful
* hash function, for which {@link StatefulHash#supportsIncremental()}
* returns {@code true}. This flag is implied by
* {@link #STATELESS_INCREMENTAL}.
*/
INCREMENTAL(80),
/**
* Indicates that the hash algorithm is available as a
* {@link StatefulIntHash} and {@link StatelessIntHash}.
*/
INT_SIZED(90),
/**
* Indicates that the hash algorithm is available as a
* {@link StatefulLongHash} and {@link StatelessLongHash}.
*/
LONG_SIZED(90),
/**
* Indicates that the hash algorithm is available as a {@link StatefulHash}.
* If this flag is not set, the algorithm is not supported at all.
*/
STATEFUL(100);
/**
* The minimum priority value, indicating the highest priority. All flags
* have a priority value greater than this.
*/
public static final int MIN_PRIORITY = 0;
/**
* The maximum priority value, indicating the lowest priority. All flags
* have a priority value less than this.
*/
public static final int MAX_PRIORITY = 110;
private final int priority;
private HashSupport(int priority) {
this.priority = priority;
}
/**
* Returns the relative priority of a hash algorithm support flag, which is
* an indicator of its performance and flexibility. Lower values indicate
* higher priority.
*
* @return the priority of this flag (currently between 10 and 90)
*/
public int getPriority() {
return priority;
}
/**
* Returns the {@linkplain #getPriority() priority} of the highest-priority
* hash algorithm support flag in the given set of flags. If the set is
* empty, {@link #MAX_PRIORITY} is returned.
*
* @param set a set of hash algorithm support flags
* @return the highest priority (lowest value) in the set, or
* {@link #MAX_PRIORITY} if empty
*/
public static int getMaxPriority(EnumSet set) {
if (set.isEmpty())
return MAX_PRIORITY;
return set.iterator().next().getPriority();
}
/**
* Compares the given sets of hash algorithm support flags for priority
* order. The set with the highest priority flag without a flag of matching
* priority in the other set has higher priority.
*
* @param set1 the first set to be compared
* @param set2 the second set to be compared
* @return a negative integer, zero, or a positive integer if the first set
* has priority higher than, equal to, or lower than the second
*/
public static int compare(EnumSet set1, EnumSet set2) {
// assumes iterators return flags in priority order
final Iterator i1 = set1.iterator();
final Iterator i2 = set2.iterator();
int floor = MIN_PRIORITY;
while (i1.hasNext() || i2.hasNext()) {
int p1, p2;
do {
p1 = i1.hasNext() ? i1.next().getPriority() : MAX_PRIORITY;
} while (p1 == floor);
do {
p2 = i2.hasNext() ? i2.next().getPriority() : MAX_PRIORITY;
} while (p2 == floor);
if (p1 < p2)
return -1;
if (p1 > p2)
return 1;
floor = p1;
}
return 0;
}
/**
* {@link Comparator} for {@link EnumSet EnumSets} for hash support flags.
*/
static final class SetComparator implements Comparator> {
@Override
public int compare(EnumSet o1, EnumSet o2) {
return HashSupport.compare(o1, o2);
}
}
}
