private void loadBlocks() {
Map<IBlockState, ModelResourceLocation> stateMap =
blockModelShapes.getBlockStateMapper().putAllStateModelLocations();
Collection<ModelResourceLocation> variants = Lists.newArrayList(stateMap.values());
variants.add(
new ModelResourceLocation(
"minecraft:item_frame", "normal")); // Vanilla special cases item_frames so must we
variants.add(new ModelResourceLocation("minecraft:item_frame", "map"));
blockBar = ProgressManager.push("ModelLoader: blocks", variants.size());
loadingBlockModels.addAll(variants);
loadVariants(variants);
ProgressManager.pop(blockBar);
}
/**
* Store dependency tables for later retrieval by the EE.
*
* @param workunit
*/
void trackNewWorkUnit(final Map<Integer, List<VoltTable>> dependencies) {
for (final Entry<Integer, List<VoltTable>> e : dependencies.entrySet()) {
// could do this optionally - debug only.
verifyDependencySanity(e.getKey(), e.getValue());
// create a new list of references to the workunit's table
// to avoid any changes to the WorkUnit's list. But do not
// copy the table data.
final ArrayDeque<VoltTable> deque = new ArrayDeque<VoltTable>();
deque.addAll(e.getValue());
// intentionally overwrite the previous dependency id.
// would a lookup and a clear() be faster?
m_depsById.put(e.getKey(), deque);
}
}
/**
* Breadth-first search algorithm
*
* @param vehicle the considered vehicle
* @param available the available tasks of the world
* @param carried the tasks picked up and currently carried by the vehicle
* @return a plan (list of actions)
*/
public static Plan computeBFS(Vehicle vehicle, TaskSet available, TaskSet carried) {
Plan plan = null;
ArrayList<Task> availableTasks = new ArrayList<Task>(available);
ArrayList<Task> carriedTasks = new ArrayList<Task>(carried);
ArrayDeque<State> Q = new ArrayDeque<State>(); // States we will have to visit
ArrayList<State> C = new ArrayList<State>(); // States we have already visited, prevent cycles
City initialCity = vehicle.getCurrentCity();
State initialState =
new State(
initialCity, availableTasks, carriedTasks, new ArrayList<Action>(), vehicle, 0, 0);
Q.add(initialState);
boolean foundFinalState = false;
State finalState = null;
while (!foundFinalState) {
if (Q.isEmpty()) {
foundFinalState = true;
} else {
State visitingState = Q.poll();
if (visitingState.isFinal()) {
finalState = visitingState;
foundFinalState = true;
} else if (!C.contains(visitingState)) {
C.add(visitingState);
Q.addAll(visitingState.next()); // Hopefully at the end of the list
}
}
}
if (finalState != null) {
plan = new Plan(vehicle.getCurrentCity(), finalState.actionList);
}
return plan;
}
/**
* Store dependency tables for later retrieval by the EE.
*
* @param workunit
*/
void trackNewWorkUnit(final Map<Integer, List<VoltTable>> dependencies) {
for (final Entry<Integer, List<VoltTable>> e : dependencies.entrySet()) {
// could do this optionally - debug only.
if (d) verifyDependencySanity(e.getKey(), e.getValue());
// create a new list of references to the workunit's table
// to avoid any changes to the WorkUnit's list. But do not
// copy the table data.
ArrayDeque<VoltTable> deque = m_depsById.get(e.getKey());
if (deque == null) {
deque = new ArrayDeque<VoltTable>();
// intentionally overwrite the previous dependency id.
// would a lookup and a clear() be faster?
m_depsById.put(e.getKey(), deque);
} else {
deque.clear();
}
deque.addAll(e.getValue());
}
if (d) LOG.debug("Current InputDepencies:\n" + StringUtil.formatMaps(m_depsById));
}
private void processReferences(
JsonSchemaObject root,
Set<JsonSchemaObject> objects,
@Nullable JsonSchemaExportedDefinitions definitions) {
final ArrayDeque<JsonSchemaObject> queue = new ArrayDeque<>();
queue.addAll(objects);
int control = 10000;
while (!queue.isEmpty()) {
if (--control == 0) throw new RuntimeException("cyclic definitions search");
final JsonSchemaObject current = queue.removeFirst();
if ("#".equals(current.getRef())) continue;
if (current.getRef() != null) {
final JsonSchemaObject definition =
findDefinition(myKey, current.getRef(), root, definitions);
if (definition == null) {
if (definitions == null) {
// just skip current item
current.setRef(null);
continue;
}
throw new RuntimeException("Can not find definition: " + current.getRef());
}
if (definition.getRef() != null && !"#".equals(definition.getRef())) {
queue.addFirst(current);
queue.addFirst(definition);
continue;
}
final JsonSchemaObject copy = new JsonSchemaObject();
copy.setDefinitionAddress(current.getRef());
copy.mergeValues(definition);
copy.mergeValues(current);
current.copyValues(copy);
current.setRef(null);
}
}
}
@Override
public final void run() {
writeLock();
try {
_activeTasks.addAll(_queue);
_queue.clear();
} finally {
writeUnlock();
}
for (T task; (task = _activeTasks.pollFirst()) != null; ) {
final long begin = System.nanoTime();
try {
callTask(task);
} catch (RuntimeException e) {
_log.warn("", e);
} finally {
RunnableStatsManager.handleStats(
task.getClass(), getCalledMethodName(), System.nanoTime() - begin);
}
}
}
/** Performs heuristic header substitution. */
public IPath getPreferredRepresentativeHeaderByHeuristic(InclusionRequest request) {
Set<IIndexFile> indexFiles = request.getDeclaringFiles().keySet();
String symbolName = request.getBinding().getName();
ArrayDeque<IIndexFile> front = new ArrayDeque<IIndexFile>();
HashSet<IIndexFile> processed = new HashSet<IIndexFile>();
try {
// Look for headers without an extension and a matching name.
if (fContext.isCXXLanguage()) {
front.addAll(indexFiles);
processed.addAll(indexFiles);
while (!front.isEmpty()) {
IIndexFile file = front.remove();
String path = IncludeUtil.getPath(file);
if (!hasExtension(path) && getFilename(path).equalsIgnoreCase(symbolName)) {
// A C++ header without an extension and with a name which matches the name
// of the symbol which should be declared is a perfect candidate for inclusion.
return IndexLocationFactory.getAbsolutePath(file.getLocation());
}
// Process the next level of the include hierarchy.
IIndexInclude[] includes = fContext.getIndex().findIncludedBy(file, 0);
for (IIndexInclude include : includes) {
IIndexFile includer = include.getIncludedBy();
if (!processed.contains(includer)) {
front.add(includer);
processed.add(includer);
}
}
}
}
// Repeat the process, this time only looking for headers without an extension.
front.clear();
front.addAll(indexFiles);
processed.clear();
processed.addAll(indexFiles);
while (!front.isEmpty()) {
IIndexFile file = front.remove();
String path = IncludeUtil.getPath(file);
if (fContext.isCXXLanguage() && !hasExtension(path)) {
// A C++ header without an extension is still a very good candidate for inclusion.
return IndexLocationFactory.getAbsolutePath(file.getLocation());
}
// Process the next level of the include hierarchy.
IIndexInclude[] includes = fContext.getIndex().findIncludedBy(file, 0);
for (IIndexInclude include : includes) {
IIndexFile includer = include.getIncludedBy();
if (!processed.contains(includer)) {
URI uri = includer.getLocation().getURI();
if (IncludeUtil.isSource(includer, fContext.getProject()) || isWorkspaceFile(uri)) {
return IndexLocationFactory.getAbsolutePath(file.getLocation());
}
front.add(includer);
processed.add(includer);
}
}
}
} catch (CoreException e) {
CUIPlugin.log(e);
}
return request.getCandidatePaths().iterator().next();
}
private void refillWordQueue() {
mWordQueue.clear();
mWordQueue.addAll(Arrays.asList(mWordArray));
}