/** INTERNAL: Return if the expression is for a direct mapped attribute. */
public boolean isAttribute() {
if (isAttributeExpression == null) {
if (getSession() == null) {
// We can't tell, so say no.
return false;
}
QueryKey queryKey = getQueryKeyOrNull();
if (queryKey != null) {
isAttributeExpression = Boolean.valueOf(queryKey.isDirectQueryKey());
} else {
DatabaseMapping mapping = getMapping();
if (mapping != null) {
if (mapping.isVariableOneToOneMapping()) {
throw QueryException.cannotQueryAcrossAVariableOneToOneMapping(
mapping, mapping.getDescriptor());
} else {
isAttributeExpression = Boolean.valueOf(mapping.isDirectToFieldMapping());
}
} else {
isAttributeExpression = Boolean.FALSE;
}
}
}
return isAttributeExpression.booleanValue();
}
@Override
public int compareTo(FSError other) {
if (!getClass().equals(other.getClass())) {
return getClass().getName().compareTo(other.getClass().getName());
}
int lastComparison = 0;
lastComparison = Boolean.valueOf(isSetErrorCode()).compareTo(other.isSetErrorCode());
if (lastComparison != 0) {
return lastComparison;
}
if (isSetErrorCode()) {
lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.errorCode, other.errorCode);
if (lastComparison != 0) {
return lastComparison;
}
}
lastComparison = Boolean.valueOf(isSetErrorMsg()).compareTo(other.isSetErrorMsg());
if (lastComparison != 0) {
return lastComparison;
}
if (isSetErrorMsg()) {
lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.errorMsg, other.errorMsg);
if (lastComparison != 0) {
return lastComparison;
}
}
return 0;
}
/** Returns true if a hader compiler is available, otherwise false. */
public static boolean isShaderCompilerAvailable(final GL _gl) {
final GL2ES2 gl = _gl.getGL2ES2();
final ProfileInformation info = getProfileInformation(gl);
if (null == info.shaderCompilerAvailable) {
if (gl.isGLES2()) {
boolean queryOK = false;
try {
final byte[] param = new byte[1];
gl.glGetBooleanv(GL2ES2.GL_SHADER_COMPILER, param, 0);
final int err = gl.glGetError();
boolean v = GL.GL_NO_ERROR == err && param[0] != (byte) 0x00;
if (!v) {
final Set<Integer> bfs = getShaderBinaryFormats(gl);
if (bfs.size() == 0) {
// no supported binary formats, hence a compiler must be available!
v = true;
}
}
info.shaderCompilerAvailable = Boolean.valueOf(v);
queryOK = true;
} catch (final GLException gle) {
System.err.println("Caught exception on thread " + Thread.currentThread().getName());
gle.printStackTrace();
}
if (!queryOK) {
info.shaderCompilerAvailable = Boolean.valueOf(true);
}
} else if (gl.isGL2ES2()) {
info.shaderCompilerAvailable = new Boolean(true);
} else {
throw new GLException("Invalid OpenGL profile");
}
}
return info.shaderCompilerAvailable.booleanValue();
}
public boolean shouldSign(File input, List<Properties> containers) {
Properties inf = null;
// 1: Are we excluded from signing by our parents?
// innermost jar is first on the list, it overrides outer jars
for (Iterator<Properties> iterator = containers.iterator(); iterator.hasNext(); ) {
inf = iterator.next();
if (inf.containsKey(Utils.MARK_EXCLUDE_CHILDREN_SIGN)) {
if (Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_CHILDREN_SIGN)).booleanValue()) {
if (verbose)
System.out.println(
input.getName() + "is excluded from signing by its containers."); // $NON-NLS-1$
return false;
}
break;
}
}
// 2: Is this jar itself marked as exclude?
inf = Utils.getEclipseInf(input, verbose);
if (inf != null
&& inf.containsKey(Utils.MARK_EXCLUDE_SIGN)
&& Boolean.valueOf(inf.getProperty(Utils.MARK_EXCLUDE_SIGN)).booleanValue()) {
if (verbose)
System.out.println(
"Excluding " + input.getName() + " from signing."); // $NON-NLS-1$ //$NON-NLS-2$
return false;
}
return true;
}
public void addServerTypeToSnooper(PlayerUsageSnooper playerSnooper) {
playerSnooper.addStatToSnooper("singleplayer", Boolean.valueOf(this.isSinglePlayer()));
playerSnooper.addStatToSnooper("server_brand", this.getServerModName());
playerSnooper.addStatToSnooper(
"gui_supported", GraphicsEnvironment.isHeadless() ? "headless" : "supported");
playerSnooper.addStatToSnooper("dedicated", Boolean.valueOf(this.isDedicatedServer()));
}
static class BooleanAttribute extends GenericAttribute implements RTFAttribute {
boolean rtfDefault;
boolean swingDefault;
protected static final Boolean True = Boolean.valueOf(true);
protected static final Boolean False = Boolean.valueOf(false);
public BooleanAttribute(int d, Object s, String r, boolean ds, boolean dr) {
super(d, s, r);
swingDefault = ds;
rtfDefault = dr;
}
public BooleanAttribute(int d, Object s, String r) {
super(d, s, r);
swingDefault = false;
rtfDefault = false;
}
public boolean set(MutableAttributeSet target) {
/* TODO: There's some ambiguity about whether this should
*set* or *toggle* the attribute. */
target.addAttribute(swingName, True);
return true; /* true indicates we were successful */
}
public boolean set(MutableAttributeSet target, int parameter) {
/* See above note in the case that parameter==1 */
Boolean value = (parameter != 0 ? True : False);
target.addAttribute(swingName, value);
return true; /* true indicates we were successful */
}
public boolean setDefault(MutableAttributeSet target) {
if (swingDefault != rtfDefault || (target.getAttribute(swingName) != null))
target.addAttribute(swingName, Boolean.valueOf(rtfDefault));
return true;
}
public boolean writeValue(Object o_value, RTFGenerator target, boolean force)
throws IOException {
Boolean val;
if (o_value == null) val = Boolean.valueOf(swingDefault);
else val = (Boolean) o_value;
if (force || (val.booleanValue() != rtfDefault)) {
if (val.booleanValue()) {
target.writeControlWord(rtfName);
} else {
target.writeControlWord(rtfName, 0);
}
}
return true;
}
}
/** Synchronizes the state of the actions to the current state of this host. */
private void updateActions() {
final DeviceController currentDeviceController = getDeviceController();
final boolean deviceControllerSet = currentDeviceController != null;
final boolean deviceCapturing = deviceControllerSet && currentDeviceController.isCapturing();
final boolean deviceSetup =
deviceControllerSet && !deviceCapturing && currentDeviceController.isSetup();
getAction(CaptureAction.ID).setEnabled(deviceControllerSet);
getAction(CancelCaptureAction.ID).setEnabled(deviceCapturing);
getAction(RepeatCaptureAction.ID).setEnabled(deviceSetup);
final boolean projectChanged = this.projectManager.getCurrentProject().isChanged();
final boolean projectSavedBefore =
this.projectManager.getCurrentProject().getFilename() != null;
final boolean dataAvailable = this.dataContainer.hasCapturedData();
getAction(SaveProjectAction.ID).setEnabled(projectChanged);
getAction(SaveProjectAsAction.ID).setEnabled(projectSavedBefore && projectChanged);
getAction(SaveDataFileAction.ID).setEnabled(dataAvailable);
getAction(ZoomInAction.ID).setEnabled(dataAvailable);
getAction(ZoomOutAction.ID).setEnabled(dataAvailable);
getAction(ZoomDefaultAction.ID).setEnabled(dataAvailable);
getAction(ZoomFitAction.ID).setEnabled(dataAvailable);
final boolean triggerEnable = dataAvailable && this.dataContainer.hasTriggerData();
getAction(GotoTriggerAction.ID).setEnabled(triggerEnable);
// Update the cursor actions accordingly...
final boolean enableCursors = dataAvailable && this.dataContainer.isCursorsEnabled();
for (int c = 0; c < CapturedData.MAX_CURSORS; c++) {
final boolean enabled = enableCursors && this.dataContainer.isCursorPositionSet(c);
getAction(GotoNthCursorAction.getID(c)).setEnabled(enabled);
}
getAction(GotoFirstCursorAction.ID).setEnabled(enableCursors);
getAction(GotoLastCursorAction.ID).setEnabled(enableCursors);
getAction(SetCursorModeAction.ID).setEnabled(dataAvailable);
getAction(SetCursorModeAction.ID)
.putValue(Action.SELECTED_KEY, Boolean.valueOf(this.dataContainer.isCursorsEnabled()));
boolean anyCursorSet = false;
for (int c = 0; c < CapturedData.MAX_CURSORS; c++) {
final boolean cursorPositionSet = this.dataContainer.isCursorPositionSet(c);
anyCursorSet |= cursorPositionSet;
final Action action = getAction(SetCursorAction.getCursorId(c));
action.setEnabled(dataAvailable);
action.putValue(Action.SELECTED_KEY, Boolean.valueOf(cursorPositionSet));
}
getAction(ClearCursors.ID).setEnabled(enableCursors && anyCursorSet);
}
/**
* @attribute syn
* @aspect GenericsSubtype
* @declaredat
* /Users/eric/Documents/workspaces/clara-soot/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:212
*/
@SuppressWarnings({"unchecked", "cast"})
public boolean sameStructure(TypeDecl t) {
Object _parameters = t;
if (sameStructure_TypeDecl_values == null)
sameStructure_TypeDecl_values = new java.util.HashMap(4);
ASTNode$State.CircularValue _value;
if (sameStructure_TypeDecl_values.containsKey(_parameters)) {
Object _o = sameStructure_TypeDecl_values.get(_parameters);
if (!(_o instanceof ASTNode$State.CircularValue)) {
return ((Boolean) _o).booleanValue();
} else _value = (ASTNode$State.CircularValue) _o;
} else {
_value = new ASTNode$State.CircularValue();
sameStructure_TypeDecl_values.put(_parameters, _value);
_value.value = Boolean.valueOf(true);
}
ASTNode$State state = state();
if (!state.IN_CIRCLE) {
state.IN_CIRCLE = true;
int num = state.boundariesCrossed;
boolean isFinal = this.is$Final();
boolean new_sameStructure_TypeDecl_value;
do {
_value.visited = new Integer(state.CIRCLE_INDEX);
state.CHANGE = false;
new_sameStructure_TypeDecl_value = sameStructure_compute(t);
if (new_sameStructure_TypeDecl_value != ((Boolean) _value.value).booleanValue()) {
state.CHANGE = true;
_value.value = Boolean.valueOf(new_sameStructure_TypeDecl_value);
}
state.CIRCLE_INDEX++;
} while (state.CHANGE);
if (isFinal && num == state().boundariesCrossed) {
sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value);
} else {
sameStructure_TypeDecl_values.remove(_parameters);
state.RESET_CYCLE = true;
sameStructure_compute(t);
state.RESET_CYCLE = false;
}
state.IN_CIRCLE = false;
return new_sameStructure_TypeDecl_value;
}
if (!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
_value.visited = new Integer(state.CIRCLE_INDEX);
boolean new_sameStructure_TypeDecl_value = sameStructure_compute(t);
if (state.RESET_CYCLE) {
sameStructure_TypeDecl_values.remove(_parameters);
} else if (new_sameStructure_TypeDecl_value != ((Boolean) _value.value).booleanValue()) {
state.CHANGE = true;
_value.value = new_sameStructure_TypeDecl_value;
}
return new_sameStructure_TypeDecl_value;
}
return ((Boolean) _value.value).booleanValue();
}
/**
* Set Environment key to value
*
* @param key variable name ('#' will be converted to '_')
* @param stringValue try to convert to Object
*/
public void setEnvironment(String key, String stringValue) {
if (key == null || key.length() == 0) return;
// log.fine( "Scriptlet.setEnvironment " + key, stringValue);
if (stringValue == null) {
m_ctx.remove(key);
return;
}
// Boolean
if (stringValue.equals("Y")) {
m_ctx.put(convertKey(key), Boolean.valueOf(true));
return;
}
if (stringValue.equals("N")) {
m_ctx.put(convertKey(key), Boolean.valueOf(false));
return;
}
// Timestamp
Timestamp timeValue = null;
try {
timeValue = Timestamp.valueOf(stringValue);
m_ctx.put(convertKey(key), timeValue);
return;
} catch (Exception e) {
}
// Numeric
Integer intValue = null;
try {
intValue = Integer.valueOf(stringValue);
} catch (NumberFormatException e) {
}
Double doubleValue = null;
try {
doubleValue = Double.valueOf(stringValue);
} catch (NumberFormatException e) {
}
if (doubleValue != null) {
if (intValue != null) {
double di = Double.parseDouble(intValue.toString());
// the numbers are the same -> integer
if (Double.compare(di, doubleValue.doubleValue()) == 0) {
m_ctx.put(convertKey(key), intValue);
return;
}
}
m_ctx.put(convertKey(key), doubleValue);
return;
}
if (intValue != null) {
m_ctx.put(convertKey(key), intValue);
return;
}
m_ctx.put(convertKey(key), stringValue);
} // SetEnvironment
@RequestMapping(value = "/saveOrUpdateDriveInfo", method = RequestMethod.GET)
public @ResponseBody String saveOrUpdateDriveInfo(
@RequestParam("description") String description,
@RequestParam("month") Integer month,
@RequestParam("year") Integer year,
@RequestParam("totalAmount") String totalAmount,
@RequestParam("totalCount") String totalCount,
@RequestParam("totalCCAmount") String totalCCAmount,
@RequestParam("averageAmount") String averageAmount,
@RequestParam("Response") String Response,
@RequestParam("inProcess") String inProcess,
@RequestParam("userName") String userName,
@RequestParam("driveId") Integer driveId,
HttpServletResponse response) {
// set encoding explicitly
response.setCharacterEncoding("UTF-8");
try {
User user = userService.getUser(userName);
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = new Date();
Date currentDate = dateFormat.parse(dateFormat.format(date));
if (driveId != null) {
// update drive info
Drive drive = driveService.getDrive(driveId);
drive.setDriveName(description);
drive.setDriveMonth(month);
drive.setDriveYear(year);
drive.setFlInProcess(Boolean.valueOf(inProcess));
drive.setIdUserLastUpdated(user);
drive.setDateUpdated(currentDate);
driveService.updateDrive(drive);
return driveId.toString();
} else {
// add drive info
Drive drive = new Drive();
drive.setDriveName(description);
drive.setDriveMonth(month);
drive.setDriveYear(year);
drive.setFlInProcess(Boolean.valueOf(inProcess));
drive.setUser(user);
drive.setDateCreated(currentDate);
// set campaign
drive.setCampaigns(buildCampaigns(drive));
driveService.saveDrive(drive);
String driveIdStr = driveService.getLastDriveId();
return driveIdStr;
}
} catch (HelixServiceException e) {
e.printStackTrace();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public SCM newInstance(StaplerRequest req, JSONObject formData) throws FormException {
String path = req.getParameter("fs_scm.path");
String[] filters = req.getParameterValues("fs_scm.filters");
Boolean filterEnabled =
Boolean.valueOf("on".equalsIgnoreCase(req.getParameter("fs_scm.filterEnabled")));
Boolean includeFilter = Boolean.valueOf(req.getParameter("fs_scm.includeFilter"));
Boolean clearWorkspace =
Boolean.valueOf("on".equalsIgnoreCase(req.getParameter("fs_scm.clearWorkspace")));
return new FSSCM(path, clearWorkspace, filterEnabled, includeFilter, filters);
}
@SuppressWarnings({"unchecked", "cast"})
public boolean subtype(TypeDecl type) {
Object _parameters = type;
if (subtype_TypeDecl_visited == null) subtype_TypeDecl_visited = new java.util.HashMap(4);
if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new java.util.HashMap(4);
if (subtype_TypeDecl_computed.contains(_parameters))
return ((Boolean) subtype_TypeDecl_values.get(_parameters)).booleanValue();
if (!subtype_TypeDecl_initialized.contains(_parameters)) {
subtype_TypeDecl_initialized.add(_parameters);
subtype_TypeDecl_values.put(_parameters, Boolean.valueOf(true));
}
if (!IN_CIRCLE) {
IN_CIRCLE = true;
int num = boundariesCrossed;
boolean isFinal = this.is$Final();
CIRCLE_INDEX = 1;
boolean new_subtype_TypeDecl_value;
do {
subtype_TypeDecl_visited.put(_parameters, new Integer(CIRCLE_INDEX));
CHANGE = false;
new_subtype_TypeDecl_value = subtype_compute(type);
if (new_subtype_TypeDecl_value
!= ((Boolean) subtype_TypeDecl_values.get(_parameters)).booleanValue()) CHANGE = true;
subtype_TypeDecl_values.put(_parameters, Boolean.valueOf(new_subtype_TypeDecl_value));
CIRCLE_INDEX++;
} while (CHANGE);
if (isFinal && num == boundariesCrossed) {
subtype_TypeDecl_computed.add(_parameters);
} else {
RESET_CYCLE = true;
subtype_compute(type);
RESET_CYCLE = false;
subtype_TypeDecl_computed.remove(_parameters);
subtype_TypeDecl_initialized.remove(_parameters);
}
IN_CIRCLE = false;
return new_subtype_TypeDecl_value;
}
if (!new Integer(CIRCLE_INDEX).equals(subtype_TypeDecl_visited.get(_parameters))) {
subtype_TypeDecl_visited.put(_parameters, new Integer(CIRCLE_INDEX));
if (RESET_CYCLE) {
subtype_TypeDecl_computed.remove(_parameters);
subtype_TypeDecl_initialized.remove(_parameters);
return ((Boolean) subtype_TypeDecl_values.get(_parameters)).booleanValue();
}
boolean new_subtype_TypeDecl_value = subtype_compute(type);
if (new_subtype_TypeDecl_value
!= ((Boolean) subtype_TypeDecl_values.get(_parameters)).booleanValue()) CHANGE = true;
subtype_TypeDecl_values.put(_parameters, Boolean.valueOf(new_subtype_TypeDecl_value));
return new_subtype_TypeDecl_value;
}
return ((Boolean) subtype_TypeDecl_values.get(_parameters)).booleanValue();
}
// get licensing features, with appropriate defaults
@SuppressWarnings("unchecked")
private void loadLicensingFeatures(Element licensingElt) {
List<LicensingFeature> licensingFeats = new ArrayList<LicensingFeature>();
boolean containsLexFeat = false;
if (licensingElt != null) {
for (Iterator<Element> it = licensingElt.getChildren("feat").iterator(); it.hasNext(); ) {
Element featElt = it.next();
String attr = featElt.getAttributeValue("attr");
if (attr.equals("lex")) containsLexFeat = true;
String val = featElt.getAttributeValue("val");
List<String> alsoLicensedBy = null;
String alsoVals = featElt.getAttributeValue("also-licensed-by");
if (alsoVals != null) {
alsoLicensedBy = Arrays.asList(alsoVals.split("\\s+"));
}
boolean licenseEmptyCats = true;
boolean licenseMarkedCats = false;
boolean instantiate = true;
byte loc = LicensingFeature.BOTH;
String lmc = featElt.getAttributeValue("license-marked-cats");
if (lmc != null) {
licenseMarkedCats = Boolean.valueOf(lmc).booleanValue();
// change defaults
licenseEmptyCats = false;
loc = LicensingFeature.TARGET_ONLY;
instantiate = false;
}
String lec = featElt.getAttributeValue("license-empty-cats");
if (lec != null) {
licenseEmptyCats = Boolean.valueOf(lec).booleanValue();
}
String inst = featElt.getAttributeValue("instantiate");
if (inst != null) {
instantiate = Boolean.valueOf(inst).booleanValue();
}
String locStr = featElt.getAttributeValue("location");
if (locStr != null) {
if (locStr.equals("target-only")) loc = LicensingFeature.TARGET_ONLY;
if (locStr.equals("args-only")) loc = LicensingFeature.ARGS_ONLY;
if (locStr.equals("both")) loc = LicensingFeature.BOTH;
}
licensingFeats.add(
new LicensingFeature(
attr, val, alsoLicensedBy, licenseEmptyCats, licenseMarkedCats, instantiate, loc));
}
}
if (!containsLexFeat) {
licensingFeats.add(LicensingFeature.defaultLexFeature);
}
_licensingFeatures = new LicensingFeature[licensingFeats.size()];
licensingFeats.toArray(_licensingFeatures);
}
@Nullable
@SuppressWarnings({"HardCodedStringLiteral"})
private JPanel readExternalPanel(
final Element element, @Nullable JPanel panel, Ref<EditorWindow> currentWindow) {
final Element splitterElement = element.getChild("splitter");
if (splitterElement != null) {
return readSplitter(panel, splitterElement, currentWindow);
}
final Element leaf = element.getChild("leaf");
if (leaf == null) {
return null;
}
EditorWindow window = (panel == null) ? new EditorWindow(this) : findWindowWith(panel);
LOG.assertTrue(window != null);
@SuppressWarnings("unchecked")
final List<Element> children = ContainerUtil.newArrayList(leaf.getChildren("file"));
if (UISettings.getInstance().ACTIVATE_RIGHT_EDITOR_ON_CLOSE) {
Collections.reverse(children);
}
VirtualFile currentFile = null;
for (final Element file : children) {
try {
final HistoryEntry entry =
new HistoryEntry(getManager().getProject(), file.getChild(HistoryEntry.TAG), true);
boolean isCurrent = Boolean.valueOf(file.getAttributeValue("current")).booleanValue();
getManager().openFileImpl3(window, entry.myFile, false, entry, isCurrent);
if (getManager().isFileOpen(entry.myFile)) {
window.setFilePinned(
entry.myFile, Boolean.valueOf(file.getAttributeValue("pinned")).booleanValue());
if (Boolean.valueOf(file.getAttributeValue("current-in-tab")).booleanValue()) {
currentFile = entry.myFile;
}
}
} catch (InvalidDataException e) {
// OK
}
}
if (currentFile != null) {
final EditorComposite editor = window.findFileComposite(currentFile);
if (editor != null) {
window.setSelectedEditor(editor, true);
}
}
return window.myPanel;
}
public void addServerStatsToSnooper(PlayerUsageSnooper playerSnooper) {
playerSnooper.addClientStat("whitelist_enabled", Boolean.valueOf(false));
playerSnooper.addClientStat("whitelist_count", Integer.valueOf(0));
if (this.serverConfigManager != null) {
playerSnooper.addClientStat("players_current", Integer.valueOf(this.getCurrentPlayerCount()));
playerSnooper.addClientStat("players_max", Integer.valueOf(this.getMaxPlayers()));
playerSnooper.addClientStat(
"players_seen", Integer.valueOf(this.serverConfigManager.getAvailablePlayerDat().length));
}
playerSnooper.addClientStat("uses_auth", Boolean.valueOf(this.onlineMode));
playerSnooper.addClientStat("gui_state", this.getGuiEnabled() ? "enabled" : "disabled");
playerSnooper.addClientStat(
"run_time",
Long.valueOf(
(getCurrentTimeMillis() - playerSnooper.getMinecraftStartTimeMillis()) / 60L * 1000L));
playerSnooper.addClientStat(
"avg_tick_ms", Integer.valueOf((int) (MathHelper.average(this.tickTimeArray) * 1.0E-6D)));
int var2 = 0;
if (this.worldServers != null) {
for (int var3 = 0; var3 < this.worldServers.length; ++var3) {
if (this.worldServers[var3] != null) {
WorldServer var4 = this.worldServers[var3];
WorldInfo var5 = var4.getWorldInfo();
playerSnooper.addClientStat(
"world[" + var2 + "][dimension]", Integer.valueOf(var4.provider.getDimensionId()));
playerSnooper.addClientStat("world[" + var2 + "][mode]", var5.getGameType());
playerSnooper.addClientStat("world[" + var2 + "][difficulty]", var4.getDifficulty());
playerSnooper.addClientStat(
"world[" + var2 + "][hardcore]", Boolean.valueOf(var5.isHardcoreModeEnabled()));
playerSnooper.addClientStat(
"world[" + var2 + "][generator_name]", var5.getTerrainType().getWorldTypeName());
playerSnooper.addClientStat(
"world[" + var2 + "][generator_version]",
Integer.valueOf(var5.getTerrainType().getGeneratorVersion()));
playerSnooper.addClientStat(
"world[" + var2 + "][height]", Integer.valueOf(this.buildLimit));
playerSnooper.addClientStat(
"world[" + var2 + "][chunks_loaded]",
Integer.valueOf(var4.getChunkProvider().getLoadedChunkCount()));
++var2;
}
}
}
playerSnooper.addClientStat("worlds", Integer.valueOf(var2));
}
private boolean importOldIndentOptions(@NonNls Element element) {
final List options = element.getChildren("option");
boolean optionsImported = false;
for (Object option1 : options) {
@NonNls Element option = (Element) option1;
@NonNls final String name = option.getAttributeValue("name");
if ("TAB_SIZE".equals(name)) {
final int value = Integer.valueOf(option.getAttributeValue("value")).intValue();
JAVA_INDENT_OPTIONS.TAB_SIZE = value;
JSP_INDENT_OPTIONS.TAB_SIZE = value;
XML_INDENT_OPTIONS.TAB_SIZE = value;
OTHER_INDENT_OPTIONS.TAB_SIZE = value;
optionsImported = true;
} else if ("INDENT_SIZE".equals(name)) {
final int value = Integer.valueOf(option.getAttributeValue("value")).intValue();
JAVA_INDENT_OPTIONS.INDENT_SIZE = value;
JSP_INDENT_OPTIONS.INDENT_SIZE = value;
XML_INDENT_OPTIONS.INDENT_SIZE = value;
OTHER_INDENT_OPTIONS.INDENT_SIZE = value;
optionsImported = true;
} else if ("CONTINUATION_INDENT_SIZE".equals(name)) {
final int value = Integer.valueOf(option.getAttributeValue("value")).intValue();
JAVA_INDENT_OPTIONS.CONTINUATION_INDENT_SIZE = value;
JSP_INDENT_OPTIONS.CONTINUATION_INDENT_SIZE = value;
XML_INDENT_OPTIONS.CONTINUATION_INDENT_SIZE = value;
OTHER_INDENT_OPTIONS.CONTINUATION_INDENT_SIZE = value;
optionsImported = true;
} else if ("USE_TAB_CHARACTER".equals(name)) {
final boolean value = Boolean.valueOf(option.getAttributeValue("value")).booleanValue();
JAVA_INDENT_OPTIONS.USE_TAB_CHARACTER = value;
JSP_INDENT_OPTIONS.USE_TAB_CHARACTER = value;
XML_INDENT_OPTIONS.USE_TAB_CHARACTER = value;
OTHER_INDENT_OPTIONS.USE_TAB_CHARACTER = value;
optionsImported = true;
} else if ("SMART_TABS".equals(name)) {
final boolean value = Boolean.valueOf(option.getAttributeValue("value")).booleanValue();
JAVA_INDENT_OPTIONS.SMART_TABS = value;
JSP_INDENT_OPTIONS.SMART_TABS = value;
XML_INDENT_OPTIONS.SMART_TABS = value;
OTHER_INDENT_OPTIONS.SMART_TABS = value;
optionsImported = true;
} else if ("SPACE_AFTER_UNARY_OPERATOR".equals(name)) {
SPACE_AROUND_UNARY_OPERATOR =
Boolean.valueOf(option.getAttributeValue("value")).booleanValue();
optionsImported = true;
}
}
return optionsImported;
}
public void relateAcrossR801To(Value_c target, boolean notifyChanges) {
if (target == null) return;
if (target == IsSupertypeValue) return; // already related
if (IsSupertypeValue != target) {
Object oldKey = getInstanceKey();
if (IsSupertypeValue != null) {
IsSupertypeValue.clearBackPointerR801To(this);
if (Boolean.valueOf(System.getenv("PTC_MCC_ENABLED")) == true) { // $NON-NLS-1$
Ooaofooa.log.println(
ILogger.CONSISTENCY,
"TransientValueReference_c.relateAcrossR801To(Value_c target)",
"Relate performed across R801 from Transient Value Reference to Value without unrelate of prior instance.");
}
}
IsSupertypeValue = target;
m_value_id = target.getValue_id();
updateInstanceKey(oldKey, getInstanceKey());
target.setBackPointerR801To(this);
target.addRef();
}
}
public ArrayList<ServiceInfo> getServices(Properties properties) throws ApiException {
ArrayList<ServiceInfo> services = new ArrayList<ServiceInfo>();
try {
String defaultLangCode = this.getLangManager().getDefaultLang().getCode();
String langCode = properties.getProperty(SystemConstants.API_LANG_CODE_PARAMETER);
String tagParamValue = properties.getProperty("tag");
String myentandoParamValue = properties.getProperty("myentando");
Boolean myentando =
(null != myentandoParamValue && myentandoParamValue.trim().length() > 0)
? Boolean.valueOf(myentandoParamValue)
: null;
langCode =
(null != langCode && null != this.getLangManager().getLang(langCode))
? langCode
: defaultLangCode;
Map<String, ApiService> masterServices =
this.getApiCatalogManager().getServices(tagParamValue, myentando);
Iterator<ApiService> iter = masterServices.values().iterator();
while (iter.hasNext()) {
ApiService service = (ApiService) iter.next();
if (service.isActive()
&& !service.isHidden()
&& this.checkServiceAuthorization(service, properties, false)) {
ServiceInfo smallService = this.createServiceInfo(service, langCode, defaultLangCode);
services.add(smallService);
}
}
BeanComparator comparator = new BeanComparator("description");
Collections.sort(services, comparator);
} catch (Throwable t) {
ApsSystemUtils.logThrowable(t, this, "getServices", "Error extracting services");
throw new ApiException(IApiErrorCodes.SERVER_ERROR, "Internal error");
}
return services;
}
public GUTimeAnnotator(String name, Properties props) {
String path =
props.getProperty(GUTIME_PATH_PROPERTY, System.getProperty("gutime", DEFAULT_PATH));
this.gutimePath = new File(path);
this.outputResults = Boolean.valueOf(props.getProperty(GUTIME_OUTPUT_RESULTS, "false"));
}
public boolean hasBooleanParam(String key) {
if (this.hasParam(key)) {
Boolean val = Boolean.valueOf(this.params.get(key));
if (val != null) return (true);
}
return (false);
}
// {{{ definePackage(packageName, manifest) method
private void definePackage(String name, Manifest mf) {
if (mf == null) {
definePackage(name, null, null, null, null, null, null, null);
return;
}
Attributes sa = mf.getAttributes(name.replace('.', '/') + '/');
Attributes ma = mf.getMainAttributes();
URL sealBase = null;
if (Boolean.valueOf(getMfValue(sa, ma, Name.SEALED)).booleanValue()) {
try {
sealBase = jar.getFile().toURL();
} catch (MalformedURLException e) {
}
}
Package pkg =
definePackage(
name,
getMfValue(sa, ma, Name.SPECIFICATION_TITLE),
getMfValue(sa, ma, Name.SPECIFICATION_VERSION),
getMfValue(sa, ma, Name.SPECIFICATION_VENDOR),
getMfValue(sa, ma, Name.IMPLEMENTATION_TITLE),
getMfValue(sa, ma, Name.IMPLEMENTATION_VERSION),
getMfValue(sa, ma, Name.IMPLEMENTATION_VENDOR),
sealBase);
} // }}}
/** Usage: java ...Tunnelblick [sensitivity=1.0 [useopenni=false]] */
public static void main(String[] argv) {
float sensitivity = 1.0f;
boolean withOpenNi = false;
if (argv.length >= 1) sensitivity = Float.valueOf(argv[0]).floatValue();
if (argv.length >= 2) withOpenNi = Boolean.valueOf(argv[1]);
OpenNiBodyTrackerInputDriver onbtid =
withOpenNi ? new OpenNiBodyTrackerInputDriver(true) : null;
GameManager man = new GameManager("Tunnelblick", 800, 600);
KeyboardGestureInputDriver kgid = new KeyboardGestureInputDriver();
kgid.bind(java.awt.event.KeyEvent.VK_SPACE, InputEvent.GESTURE_JUMP);
man.installInputDriver(kgid);
MouseButtonGestureInputDriver mbgid = new MouseButtonGestureInputDriver();
mbgid.bind(java.awt.event.MouseEvent.BUTTON1, InputEvent.GESTURE_JUMP);
man.installInputDriver(mbgid);
ModalMouseMotionInputDriver mmmid = new ModalMouseMotionInputDriver();
mmmid.setPointerMode(false);
man.installInputDriver(mmmid);
if (withOpenNi) man.installInputDriver(onbtid);
Tunnelblick state = new Tunnelblick(man);
state.getPlayer().setSensitivity(sensitivity);
man.setState(state);
man.run();
man.destroy();
}
public void build(ExtFile appDir, File outFile) throws BrutException {
LOGGER.info("Using Apktool " + Androlib.getVersion());
Map<String, Object> meta = readMetaFile(appDir);
Object t1 = meta.get("isFrameworkApk");
apkOptions.isFramework = (t1 == null ? false : (Boolean) t1);
apkOptions.resourcesAreCompressed =
meta.get("compressionType") == null
? false
: Boolean.valueOf(meta.get("compressionType").toString());
mAndRes.setSdkInfo((Map<String, String>) meta.get("sdkInfo"));
mAndRes.setPackageId((Map<String, String>) meta.get("packageInfo"));
mAndRes.setPackageInfo((Map<String, String>) meta.get("packageInfo"));
mAndRes.setVersionInfo((Map<String, String>) meta.get("versionInfo"));
if (outFile == null) {
String outFileName = (String) meta.get("apkFileName");
outFile =
new File(
appDir, "dist" + File.separator + (outFileName == null ? "out.apk" : outFileName));
}
new File(appDir, APK_DIRNAME).mkdirs();
buildSources(appDir);
buildNonDefaultSources(appDir);
buildResources(appDir, (Map<String, Object>) meta.get("usesFramework"));
buildLib(appDir);
buildCopyOriginalFiles(appDir);
buildApk(appDir, outFile);
// we must go after the Apk is built, and copy the files in via Zip
// this is because Aapt won't add files it doesn't know (ex unknown files)
buildUnknownFiles(appDir, outFile, meta);
}
/**
* Initialize the backend systems, the log handler and the restrictor. A subclass can tune this
* step by overriding {@link #createRestrictor(String)} and {@link
* #createLogHandler(ServletConfig, boolean)}
*
* @param pServletConfig servlet configuration
*/
@Override
public void init(ServletConfig pServletConfig) throws ServletException {
super.init(pServletConfig);
Configuration config = initConfig(pServletConfig);
// Create a log handler early in the lifecycle, but not too early
String logHandlerClass = config.get(ConfigKey.LOGHANDLER_CLASS);
logHandler =
logHandlerClass != null
? (LogHandler) ClassUtil.newInstance(logHandlerClass)
: createLogHandler(pServletConfig, Boolean.valueOf(config.get(ConfigKey.DEBUG)));
// Different HTTP request handlers
httpGetHandler = newGetHttpRequestHandler();
httpPostHandler = newPostHttpRequestHandler();
if (restrictor == null) {
restrictor =
createRestrictor(NetworkUtil.replaceExpression(config.get(ConfigKey.POLICY_LOCATION)));
} else {
logHandler.info("Using custom access restriction provided by " + restrictor);
}
configMimeType = config.get(ConfigKey.MIME_TYPE);
backendManager = new BackendManager(config, logHandler, restrictor);
requestHandler = new HttpRequestHandler(config, backendManager, logHandler);
initDiscoveryMulticast(config);
}
public PacksModel(InstallData idata) {
this.installData = idata;
this.rules = idata.getRules();
try {
this.messages = idata.getMessages().newMessages(PackHelper.LANG_FILE_NAME);
} catch (com.izforge.izpack.api.exception.ResourceNotFoundException ex) {
this.messages = idata.getMessages();
}
this.variables = idata.getVariables();
this.packsToInstall = idata.getSelectedPacks();
this.modifyInstallation = Boolean.valueOf(idata.getVariable(InstallData.MODIFY_INSTALLATION));
this.installedPacks = loadInstallationInformation(modifyInstallation);
this.packs = getVisiblePacks();
this.hiddenPacks = getHiddenPacks();
this.allPacks = idata.getAvailablePacks();
this.nameToRow = getNametoRowMapping(packs);
this.nameToPack = getNametoPackMapping(allPacks);
this.packs = setPackProperties(packs, nameToPack);
this.checkValues = initCheckValues(packs, packsToInstall);
updateConditions(true);
updatePacksToInstall();
}
private static Object parseValue(String value, Prop p, Class type) {
Object v = value;
if (type.isArray()) {
StringTokenizer st = new StringTokenizer(value, ",");
Class ctype = type.getComponentType();
v = Array.newInstance(ctype, st.countTokens());
for (int i = 0; st.hasMoreTokens(); i++)
Array.set(v, i, parseValue(st.nextToken(), p, ctype));
} else if (type == boolean.class) {
v = Boolean.valueOf(value);
} else if (type == double.class) {
v = Double.valueOf(value);
} else if (type == int.class) {
v = Integer.valueOf(value);
} else if (p.field.isAnnotationPresent(TimeIntervalProp.class)) {
if (value.endsWith("s")) {
v = (long) (Double.parseDouble(value.substring(0, value.length() - 1)) * SEC);
} else if (value.endsWith("m")) {
v = (long) (Double.parseDouble(value.substring(0, value.length() - 1)) * MIN);
} else {
v = Long.valueOf(value);
}
}
return v;
}
public void relateAcrossR603To(Statement_c target, boolean notifyChanges) {
if (target == null) return;
if (target == IsSupertypeStatement) return; // already related
if (IsSupertypeStatement != target) {
Object oldKey = getInstanceKey();
if (IsSupertypeStatement != null) {
IsSupertypeStatement.clearBackPointerR603To(this);
if (Boolean.valueOf(System.getenv("PTC_MCC_ENABLED")) == true) { // $NON-NLS-1$
Ooaofooa.log.println(
ILogger.CONSISTENCY,
"AssignToMember_c.relateAcrossR603To(Statement_c target)",
"Relate performed across R603 from Assign to Member to Statement without unrelate of prior instance.");
}
}
IsSupertypeStatement = target;
m_statement_id = target.getStatement_id();
updateInstanceKey(oldKey, getInstanceKey());
target.setBackPointerR603To(this);
target.addRef();
}
}
@Nullable
public T process(@Nullable Element element, @Nullable T context) {
if (element == null) {
return null;
}
final Element splitterElement = element.getChild("splitter");
if (splitterElement != null) {
final Element first = splitterElement.getChild("split-first");
final Element second = splitterElement.getChild("split-second");
return processSplitter(splitterElement, first, second, context);
}
final Element leaf = element.getChild("leaf");
if (leaf == null) {
return null;
}
List<Element> fileElements = leaf.getChildren("file");
final List<Element> children = new ArrayList<Element>(fileElements.size());
// trim to EDITOR_TAB_LIMIT, ignoring CLOSE_NON_MODIFIED_FILES_FIRST policy
int toRemove = fileElements.size() - UISettings.getInstance().EDITOR_TAB_LIMIT;
for (Element fileElement : fileElements) {
if (toRemove <= 0
|| Boolean.valueOf(fileElement.getAttributeValue(PINNED)).booleanValue()) {
children.add(fileElement);
} else {
toRemove--;
}
}
return processFiles(children, context);
}
public void relateAcrossR1013To(MessageArgument_c target, boolean notifyChanges) {
if (target == null) return;
if (target == IsSupertypeMessageArgument) return; // already related
if (IsSupertypeMessageArgument != target) {
Object oldKey = getInstanceKey();
if (IsSupertypeMessageArgument != null) {
IsSupertypeMessageArgument.clearBackPointerR1013To(this);
if (Boolean.valueOf(System.getenv("PTC_MCC_ENABLED")) == true) { // $NON-NLS-1$
Ooaofooa.log.println(
ILogger.CONSISTENCY,
"InformalArgument_c.relateAcrossR1013To(MessageArgument_c target)",
"Relate performed across R1013 from Informal Argument to Message Argument without unrelate of prior instance.");
}
}
IsSupertypeMessageArgument = target;
m_arg_id = target.getArg_id();
updateInstanceKey(oldKey, getInstanceKey());
target.setBackPointerR1013To(this);
target.addRef();
if (notifyChanges) {
RelationshipChangeModelDelta change =
new RelationshipChangeModelDelta(
Modeleventnotification_c.DELTA_ELEMENT_RELATED, this, target, "1013", "");
Ooaofooa.getDefaultInstance().fireModelElementRelationChanged(change);
}
}
}
public void relateAcrossR689To(Value_c target, boolean notifyChanges) {
if (target == null) return;
if (target == WritesValue) return; // already related
if (WritesValue != target) {
Object oldKey = getInstanceKey();
if (WritesValue != null) {
WritesValue.clearBackPointerR689To(this);
if (Boolean.valueOf(System.getenv("PTC_MCC_ENABLED")) == true) { // $NON-NLS-1$
Ooaofooa.log.println(
ILogger.CONSISTENCY,
"AssignToMember_c.relateAcrossR689To(Value_c target)",
"Relate performed across R689 from Assign to Member to Value without unrelate of prior instance.");
}
}
WritesValue = target;
m_l_value_id = target.getValue_id();
updateInstanceKey(oldKey, getInstanceKey());
target.setBackPointerR689To(this);
target.addRef();
}
}
