@NotNull
public List<FileNameMatcher> getAssociations(@NotNull T type) {
List<FileNameMatcher> result = new ArrayList<FileNameMatcher>();
for (Pair<FileNameMatcher, T> mapping : myMatchingMappings) {
if (mapping.getSecond() == type) {
result.add(mapping.getFirst());
}
}
for (Map.Entry<CharSequence, T> entries : myExactFileNameMappings.entrySet()) {
if (entries.getValue() == type) {
result.add(new ExactFileNameMatcher(entries.getKey().toString()));
}
}
for (Map.Entry<CharSequence, T> entries : myExactFileNameAnyCaseMappings.entrySet()) {
if (entries.getValue() == type) {
result.add(new ExactFileNameMatcher(entries.getKey().toString(), true));
}
}
for (Map.Entry<CharSequence, T> entries : myExtensionMappings.entrySet()) {
if (entries.getValue() == type) {
result.add(new ExtensionFileNameMatcher(entries.getKey().toString()));
}
}
return result;
}
/**
* Adds configured variables to the variable service.
*
* @param variableService service to add to
* @param variables configured variables
*/
protected static void initVariables(
VariableService variableService,
Map<String, ConfigurationVariable> variables,
EngineImportService engineImportService) {
for (Map.Entry<String, ConfigurationVariable> entry : variables.entrySet()) {
try {
Pair<String, Boolean> arrayType =
JavaClassHelper.isGetArrayType(entry.getValue().getType());
variableService.createNewVariable(
null,
entry.getKey(),
arrayType.getFirst(),
entry.getValue().isConstant(),
arrayType.getSecond(),
false,
entry.getValue().getInitializationValue(),
engineImportService);
variableService.allocateVariableState(entry.getKey(), 0, null);
} catch (VariableExistsException e) {
throw new ConfigurationException("Error configuring variables: " + e.getMessage(), e);
} catch (VariableTypeException e) {
throw new ConfigurationException("Error configuring variables: " + e.getMessage(), e);
}
}
}
Entry encode(final T o, final String parentDN) throws LDAPPersistException {
// Get the attributes that should be included in the entry.
final LinkedHashMap<String, Attribute> attrMap = new LinkedHashMap<String, Attribute>();
attrMap.put("objectClass", objectClassAttribute);
for (final Map.Entry<String, FieldInfo> e : fieldMap.entrySet()) {
final FieldInfo i = e.getValue();
if (!i.includeInAdd()) {
continue;
}
final Attribute a = i.encode(o, false);
if (a != null) {
attrMap.put(e.getKey(), a);
}
}
for (final Map.Entry<String, GetterInfo> e : getterMap.entrySet()) {
final GetterInfo i = e.getValue();
if (!i.includeInAdd()) {
continue;
}
final Attribute a = i.encode(o);
if (a != null) {
attrMap.put(e.getKey(), a);
}
}
final String dn = constructDN(o, parentDN, attrMap);
final Entry entry = new Entry(dn, attrMap.values());
if (postEncodeMethod != null) {
try {
postEncodeMethod.invoke(o, entry);
} catch (Throwable t) {
debugException(t);
if (t instanceof InvocationTargetException) {
t = ((InvocationTargetException) t).getTargetException();
}
throw new LDAPPersistException(
ERR_OBJECT_HANDLER_ERROR_INVOKING_POST_ENCODE_METHOD.get(
postEncodeMethod.getName(), type.getName(), getExceptionMessage(t)),
t);
}
}
setDNAndEntryFields(o, entry);
if (superclassHandler != null) {
final Entry e = superclassHandler.encode(o, parentDN);
for (final Attribute a : e.getAttributes()) {
entry.addAttribute(a);
}
}
return entry;
}
public PropertyMap deserialize(
JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
PropertyMap result = new PropertyMap();
Iterator i$;
Map.Entry<String, JsonElement> entry;
if ((json instanceof JsonObject)) {
JsonObject object = (JsonObject) json;
for (i$ = object.entrySet().iterator(); i$.hasNext(); ) {
entry = (Map.Entry) i$.next();
if ((entry.getValue() instanceof JsonArray)) {
for (JsonElement element : (JsonArray) entry.getValue()) {
result.put(
entry.getKey(), new Property((String) entry.getKey(), element.getAsString()));
}
}
}
} else if ((json instanceof JsonArray)) {
for (JsonElement element : (JsonArray) json) {
if ((element instanceof JsonObject)) {
JsonObject object = (JsonObject) element;
String name = object.getAsJsonPrimitive("name").getAsString();
String value = object.getAsJsonPrimitive("value").getAsString();
if (object.has("signature")) {
result.put(
name,
new Property(name, value, object.getAsJsonPrimitive("signature").getAsString()));
} else {
result.put(name, new Property(name, value));
}
}
}
}
return result;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry)) return false;
Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
return (key == null ? e.getKey() == null : key.equals(e.getKey()))
&& (value == null ? e.getValue() == null : value.equals(e.getValue()));
}
public List<Events> getEventsByParams() {
ConcurrentHashMap<Integer, Events> eventBeforeSearch =
AppStorage.INSTANCE.getEventStorageCopy();
ConcurrentHashMap<Integer, Events> eventAfterSearch = new ConcurrentHashMap<Integer, Events>();
if (city != null && city.length() != 0) {
for (Map.Entry<Integer, Events> entry : eventBeforeSearch.entrySet()) {
if (city.equalsIgnoreCase(entry.getValue().getCity()))
eventAfterSearch.put(entry.getKey(), entry.getValue());
}
}
eventBeforeSearch.clear();
eventBeforeSearch = AppStorage.INSTANCE.getEventStorageCopy();
if (description != null && description.length() > 0 && !description.equals("")) {
eventAfterSearch.clear();
for (Map.Entry<Integer, Events> entry : eventBeforeSearch.entrySet()) {
if (entry.getValue().getDescription().contains(description))
eventAfterSearch.put(entry.getKey(), entry.getValue());
}
}
eventBeforeSearch = new ConcurrentHashMap<Integer, Events>(eventAfterSearch);
/* if(date != null){
for(Map.Entry<Integer,Events> entry : eventBeforeSearch.entrySet()){
GregorianCalendar eventDate = entry.getValue().getDate();
GregorianCalendar before = new GregorianCalendar(eventDate.get(1),eventDate.get(2),eventDate.get(4)+1);
GregorianCalendar after = new GregorianCalendar(eventDate.get(1),eventDate.get(2),eventDate.get(4));
if(date.after(after) && date.before(before)) eventAfterSearch.put(entry.getKey(),entry.getValue());
}
}
*/ return new ArrayList<Events>(eventAfterSearch.values());
}
@Override
public boolean convertRecords2Links() {
final Map<OIdentifiable, Change> newChangedValues = new HashMap<OIdentifiable, Change>();
for (Map.Entry<OIdentifiable, Change> entry : changes.entrySet()) {
OIdentifiable identifiable = entry.getKey();
if (identifiable instanceof ORecord) {
ORID identity = identifiable.getIdentity();
ORecord record = (ORecord) identifiable;
identity = record.getIdentity();
newChangedValues.put(identity, entry.getValue());
} else newChangedValues.put(entry.getKey().getIdentity(), entry.getValue());
}
for (Map.Entry<OIdentifiable, Change> entry : newChangedValues.entrySet()) {
if (entry.getKey() instanceof ORecord) {
ORecord record = (ORecord) entry.getKey();
newChangedValues.put(record, entry.getValue());
} else return false;
}
newEntries.clear();
changes.clear();
changes.putAll(newChangedValues);
return true;
}
@Override
public void draw() {
if (sliders != null) {
MuseRenderer.drawCenteredString(
"Tinker", (border.left() + border.right()) / 4, border.top() / 2 + 2);
GL11.glPushMatrix();
GL11.glScaled(SCALERATIO, SCALERATIO, SCALERATIO);
super.draw();
for (ClickableSlider slider : sliders) {
slider.draw();
}
int nexty = (int) (sliders.size() * 24 + border.top() + 24);
for (Map.Entry<String, Double> property : propertyStrings.entrySet()) {
nexty += 8;
String[] str = {
property.getKey() + ':',
MuseStringUtils.formatNumberFromUnits(
property.getValue(), PowerModule.getUnit(property.getKey()))
};
MuseRenderer.drawStringsJustified(
Arrays.asList(str), border.left() + 4, border.right() - 4, nexty);
}
GL11.glPopMatrix();
}
}
public static int solve() {
Map<Integer, Integer> divisorSum = new HashMap<Integer, Integer>();
for (int i = 1; i <= 10000; i++) {
divisorSum.put(i, Divisors.getSumDivisors(i));
}
Map<Integer, Integer> amicable = new HashMap<Integer, Integer>();
for (Map.Entry e : divisorSum.entrySet()) {
if (divisorSum.get(e.getValue()) == null) {
continue;
}
if (divisorSum.get(e.getValue()).equals(e.getKey())) {
amicable.put((Integer) e.getValue(), (Integer) e.getKey());
}
}
// System.out.println("amicable: " + amicable);
int res = 0;
for (Integer n : amicable.keySet()) {
if (!n.equals(amicable.get(n))) {
res += n;
}
}
return res;
}
public void joeFiddle() {
EnemyHeadquartersUtilities enemyHeadquartersUtilities =
new EnemyHeadquartersUtilities(enemyHeadquarters, game);
Building enemyEhqNeighbor = null;
Map<Building, WeatherStationUtilities.CardinalDirection> enemyHqNeighbor =
enemyHeadquartersUtilities.getEnemyHeadquartersNeighbors();
for (Map.Entry<Building, WeatherStationUtilities.CardinalDirection> enemyneighbor :
enemyHqNeighbor.entrySet()) {
if (enemyneighbor != null && enemyneighbor.getKey().health > 0) {
enemyEhqNeighbor = enemyneighbor.getKey();
break;
}
}
if (enemyEhqNeighbor != null) {
List<Warehouse> myAttackers = player.warehouses;
while (player.bribesRemaining > 0) {
Warehouse myAttacker =
warehouseUtilities.getClosestWarehouse(enemyEhqNeighbor, myAttackers);
if (myAttacker != null) {
myAttacker.ignite(enemyEhqNeighbor);
myAttackers.remove(myAttacker);
}
}
}
}
private void addTagsToProperties(MethodInfo mi, JSONObject propJ) throws JSONException {
// create description object. description tag enables the visual tools to display description of
// keys/values
// of a map property, items of a list, properties within a complex type.
JSONObject descriptionObj = new JSONObject();
if (mi.comment != null) {
descriptionObj.put("$", mi.comment);
}
for (Map.Entry<String, String> descEntry : mi.descriptions.entrySet()) {
descriptionObj.put(descEntry.getKey(), descEntry.getValue());
}
if (descriptionObj.length() > 0) {
propJ.put("descriptions", descriptionObj);
}
// create useSchema object. useSchema tag is added to enable visual tools to be able to render a
// text field
// as a dropdown with choices populated from the schema attached to the port.
JSONObject useSchemaObj = new JSONObject();
for (Map.Entry<String, String> useSchemaEntry : mi.useSchemas.entrySet()) {
useSchemaObj.put(useSchemaEntry.getKey(), useSchemaEntry.getValue());
}
if (useSchemaObj.length() > 0) {
propJ.put("useSchema", useSchemaObj);
}
}
private void exportAttributes(Map<String, Object> attrMap) {
for (Map.Entry<String, Object> e : attrMap.entrySet()) {
if (e.getKey().equals(WikiPage.CHANGENOTE))
exportProperty("wiki:changeNote", (String) e.getValue(), STRING);
else exportProperty(e.getKey(), e.getValue().toString(), STRING);
}
}
private void buildXQueryDynamicContext(
XQueryContext context, Object[] params, MutableDocumentSet docsToLock, boolean bindVariables)
throws XPathException {
context.setBackwardsCompatibility(false);
context.setStaticallyKnownDocuments(docs);
context.setBaseURI(baseUri == null ? new AnyURIValue("/db") : baseUri);
if (bindVariables) {
for (Map.Entry<QName, Object> entry : bindings.entrySet()) {
context.declareVariable(
new org.exist.dom.QName(
entry.getKey().getLocalPart(),
entry.getKey().getNamespaceURI(),
entry.getKey().getPrefix()),
convertValue(entry.getValue()));
}
if (params != null)
for (int i = 0; i < params.length; i++) {
Object convertedValue = convertValue(params[i]);
if (docsToLock != null && convertedValue instanceof Sequence) {
docsToLock.addAll(((Sequence) convertedValue).getDocumentSet());
}
context.declareVariable("_" + (i + 1), convertedValue);
}
}
}
public static void main(String[] args) throws Exception {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// алфавит
ArrayList<Character> alphabet = new ArrayList<Character>();
for (int i = 0; i < 32; i++) {
alphabet.add((char) ('а' + i));
}
alphabet.add(6, 'ё');
// ввод строк
ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < 10; i++) {
String s = reader.readLine();
list.add(s.toLowerCase());
}
HashMap<Character, Integer> resultMap = Count(list, alphabet);
for (int i = 0; i < 33; i++) {
for (Map.Entry<Character, Integer> pair : resultMap.entrySet()) {
if (pair.getKey() == alphabet.get(i)) {
System.out.println(pair.getKey() + " " + pair.getValue());
}
}
}
}
@Test
public void testAdamUpdater() {
INDArray m, v;
double lr = 0.01;
int iteration = 0;
double beta1 = 0.8;
double beta2 = 0.888;
NeuralNetConfiguration conf =
new NeuralNetConfiguration.Builder()
.learningRate(lr)
.iterations(iteration)
.adamMeanDecay(beta1)
.adamVarDecay(beta2)
.layer(
new DenseLayer.Builder()
.nIn(nIn)
.nOut(nOut)
.updater(org.deeplearning4j.nn.conf.Updater.ADAM)
.build())
.build();
int numParams = LayerFactories.getFactory(conf).initializer().numParams(conf, true);
INDArray params = Nd4j.create(1, numParams);
Layer layer = LayerFactories.getFactory(conf).create(conf, null, 0, params, true);
Updater updater = UpdaterCreator.getUpdater(layer);
int updaterStateSize = updater.stateSizeForLayer(layer);
INDArray updaterState = Nd4j.create(1, updaterStateSize);
updater.setStateViewArray(layer, updaterState, true);
updater.update(layer, gradient, iteration, 1);
double beta1t = FastMath.pow(beta1, iteration);
double beta2t = FastMath.pow(beta2, iteration);
double alphat = lr * FastMath.sqrt(1 - beta2t) / (1 - beta1t);
if (Double.isNaN(alphat) || alphat == 0.0) alphat = epsilon;
Gradient gradientDup = new DefaultGradient();
gradientDup.setGradientFor(DefaultParamInitializer.WEIGHT_KEY, weightGradient);
gradientDup.setGradientFor(DefaultParamInitializer.BIAS_KEY, biasGradient);
for (Map.Entry<String, INDArray> entry : gradientDup.gradientForVariable().entrySet()) {
val = entry.getValue();
m = Nd4j.zeros(val.shape());
v = Nd4j.zeros(val.shape());
m.muli(beta1).addi(val.mul(1.0 - beta1));
v.muli(beta2).addi(val.mul(val).mul(1.0 - beta2));
gradExpected = m.mul(alphat).divi(Transforms.sqrt(v).addi(epsilon));
if (!gradExpected.equals(gradient.getGradientFor(entry.getKey()))) {
System.out.println(Arrays.toString(gradExpected.dup().data().asFloat()));
System.out.println(
Arrays.toString(gradient.getGradientFor(entry.getKey()).dup().data().asFloat()));
}
assertEquals(gradExpected, gradient.getGradientFor(entry.getKey()));
}
assertEquals(beta1, layer.conf().getLayer().getAdamMeanDecay(), 1e-4);
assertEquals(beta2, layer.conf().getLayer().getAdamVarDecay(), 1e-4);
}
@Test
public void getDistinctKeysAndCounts_SortByKeyDescending() {
Connection connection = null;
ResultSet resultSet = null;
try {
ConnectionManager connectionManager = temporaryFileDatabase.getConnectionManager(true);
initWithTestData(connectionManager);
connection = connectionManager.getConnection(null);
resultSet = DBQueries.getDistinctKeysAndCounts(true, NAME, connection);
Map<String, Integer> resultSetToMap = resultSetToMap(resultSet);
assertEquals(3, resultSetToMap.size());
Iterator<Map.Entry<String, Integer>> entriesIterator = resultSetToMap.entrySet().iterator();
Map.Entry entry = entriesIterator.next();
assertEquals("gps", entry.getKey());
assertEquals(1, entry.getValue());
entry = entriesIterator.next();
assertEquals("airbags", entry.getKey());
assertEquals(1, entry.getValue());
entry = entriesIterator.next();
assertEquals("abs", entry.getKey());
assertEquals(2, entry.getValue());
} finally {
DBUtils.closeQuietly(resultSet);
DBUtils.closeQuietly(connection);
}
}
/**
* Filters non endpoint configuration parameters from parameter list and puts them together as
* parameters string. According to given endpoint configuration type only non endpoint
* configuration settings are added to parameter string.
*
* @param parameters
* @param endpointConfigurationType
* @return
*/
protected String getParameterString(
Map<String, String> parameters,
Class<? extends EndpointConfiguration> endpointConfigurationType) {
StringBuilder paramString = new StringBuilder();
for (Map.Entry<String, String> parameterEntry : parameters.entrySet()) {
Field field = ReflectionUtils.findField(endpointConfigurationType, parameterEntry.getKey());
if (field == null) {
if (paramString.length() == 0) {
paramString
.append("?")
.append(parameterEntry.getKey())
.append("=")
.append(parameterEntry.getValue());
} else {
paramString
.append("&")
.append(parameterEntry.getKey())
.append("=")
.append(parameterEntry.getValue());
}
}
}
return paramString.toString();
}
/**
* {@inheritDoc}
*
* @param ctx
*/
@Override
public void prepareMarshal(GridCacheSharedContext ctx) throws IgniteCheckedException {
super.prepareMarshal(ctx);
if (ownedVals != null) {
ownedValKeys = ownedVals.keySet();
ownedValVals = ownedVals.values();
for (Map.Entry<IgniteTxKey, CacheVersionedValue> entry : ownedVals.entrySet()) {
GridCacheContext cacheCtx = ctx.cacheContext(entry.getKey().cacheId());
entry.getKey().prepareMarshal(cacheCtx);
entry.getValue().prepareMarshal(cacheCtx.cacheObjectContext());
}
}
if (retVal != null && retVal.cacheId() != 0) {
GridCacheContext cctx = ctx.cacheContext(retVal.cacheId());
assert cctx != null : retVal.cacheId();
retVal.prepareMarshal(cctx);
}
if (filterFailedKeys != null) {
for (IgniteTxKey key : filterFailedKeys) {
GridCacheContext cctx = ctx.cacheContext(key.cacheId());
key.prepareMarshal(cctx);
}
}
}
private void buildParameters(StringBuilder buf, boolean concat, String[] parameters) {
if (getParameters() != null && getParameters().size() > 0) {
List<String> includes =
(parameters == null || parameters.length == 0 ? null : Arrays.asList(parameters));
boolean first = true;
for (Map.Entry<String, String> entry :
new TreeMap<String, String>(getParameters()).entrySet()) {
if (entry.getKey() != null
&& entry.getKey().length() > 0
&& (includes == null || includes.contains(entry.getKey()))) {
if (first) {
if (concat) {
buf.append("?");
}
first = false;
} else {
buf.append("&");
}
buf.append(entry.getKey());
buf.append("=");
buf.append(entry.getValue() == null ? "" : entry.getValue().trim());
}
}
}
}
public void clopen(Object... settings) {
config = getConfiguration();
if (mgmt != null && mgmt.isOpen()) mgmt.rollback();
if (null != tx && tx.isOpen()) tx.commit();
if (settings != null && settings.length > 0) {
Map<TestConfigOption, Object> options = validateConfigOptions(settings);
TitanManagement gconf = null;
ModifiableConfiguration lconf =
new ModifiableConfiguration(
GraphDatabaseConfiguration.ROOT_NS, config, BasicConfiguration.Restriction.LOCAL);
for (Map.Entry<TestConfigOption, Object> option : options.entrySet()) {
if (option.getKey().option.isLocal()) {
lconf.set(option.getKey().option, option.getValue(), option.getKey().umbrella);
} else {
if (gconf == null) gconf = graph.openManagement();
gconf.set(
ConfigElement.getPath(option.getKey().option, option.getKey().umbrella),
option.getValue());
}
}
if (gconf != null) gconf.commit();
lconf.close();
}
if (null != graph && graph.isOpen()) graph.close();
Preconditions.checkNotNull(config);
open(config);
}
/**
* Contains the logic to create URITemplate XML Element from the swagger 2.0 resource.
*
* @param swaggerDocObject swagger document
* @return URITemplate element.
*/
private static List<OMElement> createURITemplateFromSwagger2(JsonObject swaggerDocObject) {
List<OMElement> uriTemplates = new ArrayList<>();
JsonObject paths = swaggerDocObject.get(SwaggerConstants.PATHS).getAsJsonObject();
Set<Map.Entry<String, JsonElement>> pathSet = paths.entrySet();
for (Map.Entry path : pathSet) {
JsonObject urlPattern = ((JsonElement) path.getValue()).getAsJsonObject();
String pathText = path.getKey().toString();
Set<Map.Entry<String, JsonElement>> operationSet = urlPattern.entrySet();
for (Map.Entry operationEntry : operationSet) {
OMElement uriTemplateElement = factory.createOMElement(URI_TEMPLATE, namespace);
OMElement urlPatternElement = factory.createOMElement(URL_PATTERN, namespace);
OMElement httpVerbElement = factory.createOMElement(HTTP_VERB, namespace);
OMElement authTypeElement = factory.createOMElement(AUTH_TYPE, namespace);
urlPatternElement.setText(pathText);
httpVerbElement.setText(operationEntry.getKey().toString());
uriTemplateElement.addChild(urlPatternElement);
uriTemplateElement.addChild(httpVerbElement);
uriTemplateElement.addChild(authTypeElement);
uriTemplates.add(uriTemplateElement);
}
}
return uriTemplates;
}
private List<Expression> translate(List<Statement> list, List<RexLocalRef> rexList) {
// First pass. Count how many times each sub-expression is used.
this.list = null;
for (RexNode rexExpr : rexList) {
translate(rexExpr);
}
// Mark expressions as inline if they are not used more than once.
for (Map.Entry<RexNode, Slot> entry : map.entrySet()) {
if (entry.getValue().count < 2 || entry.getKey() instanceof RexLiteral) {
inlineRexSet.add(entry.getKey());
}
}
// Second pass. When translating each expression, if it is used more
// than once, the first time it is encountered, add a declaration to the
// list and set its usage count to 0.
this.list = list;
this.map.clear();
List<Expression> translateds = new ArrayList<Expression>();
for (RexNode rexExpr : rexList) {
translateds.add(translate(rexExpr));
}
return translateds;
}
/** histograms are sampled, but we just update points */
public void mergeHistograms(
MetricInfo metricInfo,
String meta,
Map<Integer, MetricSnapshot> data,
Map<String, Integer> metaCounters,
Map<String, Map<Integer, Histogram>> histograms) {
Map<Integer, MetricSnapshot> existing = metricInfo.get_metrics().get(meta);
if (existing == null) {
metricInfo.put_to_metrics(meta, data);
Map<Integer, Histogram> histogramMap = new HashMap<>();
for (Map.Entry<Integer, MetricSnapshot> dataEntry : data.entrySet()) {
Histogram histogram = MetricUtils.metricSnapshot2Histogram(dataEntry.getValue());
histogramMap.put(dataEntry.getKey(), histogram);
}
histograms.put(meta, histogramMap);
} else {
for (Map.Entry<Integer, MetricSnapshot> dataEntry : data.entrySet()) {
Integer win = dataEntry.getKey();
MetricSnapshot snapshot = dataEntry.getValue();
MetricSnapshot old = existing.get(win);
if (old == null) {
existing.put(win, snapshot);
histograms.get(meta).put(win, MetricUtils.metricSnapshot2Histogram(snapshot));
} else {
if (snapshot.get_ts() >= old.get_ts()) {
old.set_ts(snapshot.get_ts());
// update points
MetricUtils.updateHistogramPoints(histograms.get(meta).get(win), snapshot.get_points());
}
}
}
}
updateMetricCounters(meta, metaCounters);
}
public String GetBizSign(HashMap<String, String> bizObj) throws SDKRuntimeException {
HashMap<String, String> bizParameters = new HashMap<String, String>();
List<Map.Entry<String, String>> infoIds =
new ArrayList<Map.Entry<String, String>>(bizObj.entrySet());
Collections.sort(
infoIds,
new Comparator<Map.Entry<String, String>>() {
public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
return (o1.getKey()).toString().compareTo(o2.getKey());
}
});
for (int i = 0; i < infoIds.size(); i++) {
Map.Entry<String, String> item = infoIds.get(i);
if (item.getKey() != "") {
bizParameters.put(item.getKey().toLowerCase(), item.getValue());
}
}
if (AppKey == "") {
throw new SDKRuntimeException("APPKEYΪ�գ�");
}
bizParameters.put("appkey", AppKey);
String bizString = CommonUtil.FormatBizQueryParaMap(bizParameters, false);
// System.out.println(bizString);
return SHA1Util.Sha1(bizString);
}
/**
* Prints a usage message to the given stream.
*
* @param out The output stream to write to.
*/
public void printUsage(OutputStream out) {
Formatter formatter = new Formatter(out);
Set<CommandLineOption> orderedOptions = new TreeSet<CommandLineOption>(new OptionComparator());
orderedOptions.addAll(optionsByString.values());
Map<String, String> lines = new LinkedHashMap<String, String>();
for (CommandLineOption option : orderedOptions) {
Set<String> orderedOptionStrings = new TreeSet<String>(new OptionStringComparator());
orderedOptionStrings.addAll(option.getOptions());
List<String> prefixedStrings = new ArrayList<String>();
for (String optionString : orderedOptionStrings) {
if (optionString.length() == 1) {
prefixedStrings.add("-" + optionString);
} else {
prefixedStrings.add("--" + optionString);
}
}
lines.put(GUtil.join(prefixedStrings, ", "), GUtil.elvis(option.getDescription(), ""));
}
int max = 0;
for (String optionStr : lines.keySet()) {
max = Math.max(max, optionStr.length());
}
for (Map.Entry<String, String> entry : lines.entrySet()) {
if (entry.getValue().length() == 0) {
formatter.format("%s%n", entry.getKey());
} else {
formatter.format("%-" + max + "s %s%n", entry.getKey(), entry.getValue());
}
}
formatter.flush();
}
public void prepare(String query, InetAddress toExclude) throws InterruptedException {
for (Map.Entry<Host, HostConnectionPool> entry : pools.entrySet()) {
if (entry.getKey().getAddress().equals(toExclude)) continue;
// Let's not wait too long if we can't get a connection. Things
// will fix themselves once the user tries a query anyway.
Connection c = null;
try {
c = entry.getValue().borrowConnection(200, TimeUnit.MILLISECONDS);
c.write(new PrepareMessage(query)).get();
} catch (ConnectionException e) {
// Again, not being able to prepare the query right now is no big deal, so just ignore
} catch (BusyConnectionException e) {
// Same as above
} catch (TimeoutException e) {
// Same as above
} catch (ExecutionException e) {
// We shouldn't really get exception while preparing a
// query, so log this (but ignore otherwise as it's not a big deal)
logger.error(
String.format(
"Unexpected error while preparing query (%s) on %s", query, entry.getKey()),
e);
} finally {
if (c != null) entry.getValue().returnConnection(c);
}
}
}
@Override
public final void runBare() throws Throwable {
// Patch a bug with maven that does not pass properly the system property
// with an empty value
if ("org.hsqldb.jdbcDriver".equals(System.getProperty("gatein.test.datasource.driver"))) {
System.setProperty("gatein.test.datasource.password", "");
}
//
log.info("Running unit test:" + getName());
for (Map.Entry<?, ?> entry : System.getProperties().entrySet()) {
if (entry.getKey() instanceof String) {
String key = (String) entry.getKey();
log.debug(key + "=" + entry.getValue());
}
}
//
beforeRunBare();
//
try {
super.runBare();
log.info("Unit test " + getName() + " completed");
} catch (Throwable throwable) {
log.error("Unit test " + getName() + " did not complete", throwable);
//
throw throwable;
} finally {
afterRunBare();
}
}
public int uncommittedChanges() {
Set<Map.Entry<String, Storeable>> indexedSet = tableIndexedData.entrySet();
Set<Map.Entry<String, Storeable>> diskSet = tableOnDisk.entrySet();
int count = 0;
Iterator<Map.Entry<String, Storeable>> iter1 = indexedSet.iterator();
Iterator<Map.Entry<String, Storeable>> iter2 = diskSet.iterator();
while (iter1.hasNext()) {
Map.Entry<String, Storeable> next = iter1.next();
Storeable entryOnDisk = tableOnDisk.get(next.getKey());
if (entryOnDisk == null) {
// записи на диске нет, то она изменение
++count;
} else if (!entryOnDisk.equals(next.getValue())) {
// запись на диске есть, но она другая, тоже изменение
++count;
}
}
while (iter2.hasNext()) {
Map.Entry<String, Storeable> next = iter2.next();
Storeable entryIndexed = tableIndexedData.get(next.getKey());
if (entryIndexed == null) {
// на диске есть, индексированной нет, изменение
++count;
}
}
return count;
}
static void itTest4(Map s, int size, int pos) {
IdentityHashMap seen = new IdentityHashMap(size);
reallyAssert(s.size() == size);
int sum = 0;
timer.start("Iter XEntry ", size);
Iterator it = s.entrySet().iterator();
Object k = null;
Object v = null;
for (int i = 0; i < size - pos; ++i) {
Map.Entry x = (Map.Entry) (it.next());
k = x.getKey();
v = x.getValue();
seen.put(k, k);
if (x != MISSING) ++sum;
}
reallyAssert(s.containsKey(k));
it.remove();
reallyAssert(!s.containsKey(k));
while (it.hasNext()) {
Map.Entry x = (Map.Entry) (it.next());
Object k2 = x.getKey();
seen.put(k2, k2);
if (x != MISSING) ++sum;
}
reallyAssert(s.size() == size - 1);
s.put(k, v);
reallyAssert(seen.size() == size);
timer.finish();
reallyAssert(sum == size);
reallyAssert(s.size() == size);
}
private void exportParameters() {
synchronized (exported_parameters) {
if (!exported_parameters_dirty) {
return;
}
exported_parameters_dirty = false;
try {
TreeMap<String, String> tm = new TreeMap<String, String>();
Set<String> exported_keys = new HashSet<String>();
for (String[] entry : exported_parameters.values()) {
String key = entry[0];
String value = entry[1];
exported_keys.add(key);
if (value != null) {
tm.put(key, value);
}
}
for (Map.Entry<String, String> entry : imported_parameters.entrySet()) {
String key = entry.getKey();
if (!exported_keys.contains(key)) {
tm.put(key, entry.getValue());
}
}
File parent_dir = new File(SystemProperties.getUserPath());
File props = new File(parent_dir, "exported_params.properties");
PrintWriter pw =
new PrintWriter(new OutputStreamWriter(new FileOutputStream(props), "UTF-8"));
try {
for (Map.Entry<String, String> entry : tm.entrySet()) {
pw.println(entry.getKey() + "=" + entry.getValue());
}
} finally {
pw.close();
}
} catch (Throwable e) {
e.printStackTrace();
}
}
}
