_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1000
|
TableReader.readPage
|
train
|
private void readPage(byte[] buffer, Table table)
{
int magicNumber = getShort(buffer, 0);
if (magicNumber == 0x4400)
{
//System.out.println(ByteArrayHelper.hexdump(buffer, 0, 6, true, 16, ""));
int recordSize = m_definition.getRecordSize();
RowValidator rowValidator = m_definition.getRowValidator();
String primaryKeyColumnName = m_definition.getPrimaryKeyColumnName();
int index = 6;
while (index + recordSize <= buffer.length)
{
//System.out.println(ByteArrayHelper.hexdump(buffer, index, recordSize, true, 16, ""));
int btrieveValue = getShort(buffer, index);
if (btrieveValue != 0)
{
Map<String, Object> row = new HashMap<String, Object>();
row.put("ROW_VERSION", Integer.valueOf(btrieveValue));
for (ColumnDefinition column : m_definition.getColumns())
{
Object value = column.read(index, buffer);
//System.out.println(column.getName() + ": " + value);
row.put(column.getName(), value);
}
if (rowValidator == null || rowValidator.validRow(row))
{
table.addRow(primaryKeyColumnName, row);
}
}
index += recordSize;
}
}
}
|
java
|
{
"resource": ""
}
|
q1001
|
PropsBlock.populateMap
|
train
|
private void populateMap(byte[] data, Integer previousItemOffset, Integer previousItemKey, Integer itemOffset)
{
if (previousItemOffset != null)
{
int itemSize = itemOffset.intValue() - previousItemOffset.intValue();
byte[] itemData = new byte[itemSize];
System.arraycopy(data, previousItemOffset.intValue(), itemData, 0, itemSize);
m_map.put(previousItemKey, itemData);
}
}
|
java
|
{
"resource": ""
}
|
q1002
|
HexDumpController.viewDocument
|
train
|
public void viewDocument(DocumentEntry entry)
{
InputStream is = null;
try
{
is = new DocumentInputStream(entry);
byte[] data = new byte[is.available()];
is.read(data);
m_model.setData(data);
updateTables();
}
catch (IOException ex)
{
throw new RuntimeException(ex);
}
finally
{
StreamHelper.closeQuietly(is);
}
}
|
java
|
{
"resource": ""
}
|
q1003
|
HexDumpController.updateTables
|
train
|
protected void updateTables()
{
byte[] data = m_model.getData();
int columns = m_model.getColumns();
int rows = (data.length / columns) + 1;
int offset = m_model.getOffset();
String[][] hexData = new String[rows][columns];
String[][] asciiData = new String[rows][columns];
int row = 0;
int column = 0;
StringBuilder hexValue = new StringBuilder();
for (int index = offset; index < data.length; index++)
{
int value = data[index];
hexValue.setLength(0);
hexValue.append(HEX_DIGITS[(value & 0xF0) >> 4]);
hexValue.append(HEX_DIGITS[value & 0x0F]);
char c = (char) value;
if ((c > 200) || (c < 27))
{
c = ' ';
}
hexData[row][column] = hexValue.toString();
asciiData[row][column] = Character.toString(c);
++column;
if (column == columns)
{
column = 0;
++row;
}
}
String[] columnHeadings = new String[columns];
TableModel hexTableModel = new DefaultTableModel(hexData, columnHeadings)
{
@Override public boolean isCellEditable(int r, int c)
{
return false;
}
};
TableModel asciiTableModel = new DefaultTableModel(asciiData, columnHeadings)
{
@Override public boolean isCellEditable(int r, int c)
{
return false;
}
};
m_model.setSizeValueLabel(Integer.toString(data.length));
m_model.setHexTableModel(hexTableModel);
m_model.setAsciiTableModel(asciiTableModel);
m_model.setCurrentSelectionIndex(0);
m_model.setPreviousSelectionIndex(0);
}
|
java
|
{
"resource": ""
}
|
q1004
|
FieldTypeHelper.getInstance
|
train
|
public static final FieldType getInstance(int fieldID)
{
FieldType result;
int prefix = fieldID & 0xFFFF0000;
int index = fieldID & 0x0000FFFF;
switch (prefix)
{
case MPPTaskField.TASK_FIELD_BASE:
{
result = MPPTaskField.getInstance(index);
if (result == null)
{
result = getPlaceholder(TaskField.class, index);
}
break;
}
case MPPResourceField.RESOURCE_FIELD_BASE:
{
result = MPPResourceField.getInstance(index);
if (result == null)
{
result = getPlaceholder(ResourceField.class, index);
}
break;
}
case MPPAssignmentField.ASSIGNMENT_FIELD_BASE:
{
result = MPPAssignmentField.getInstance(index);
if (result == null)
{
result = getPlaceholder(AssignmentField.class, index);
}
break;
}
case MPPConstraintField.CONSTRAINT_FIELD_BASE:
{
result = MPPConstraintField.getInstance(index);
if (result == null)
{
result = getPlaceholder(ConstraintField.class, index);
}
break;
}
default:
{
result = getPlaceholder(null, index);
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1005
|
FieldTypeHelper.getPlaceholder
|
train
|
private static FieldType getPlaceholder(final Class<?> type, final int fieldID)
{
return new FieldType()
{
@Override public FieldTypeClass getFieldTypeClass()
{
return FieldTypeClass.UNKNOWN;
}
@Override public String name()
{
return "UNKNOWN";
}
@Override public int getValue()
{
return fieldID;
}
@Override public String getName()
{
return "Unknown " + (type == null ? "" : type.getSimpleName() + "(" + fieldID + ")");
}
@Override public String getName(Locale locale)
{
return getName();
}
@Override public DataType getDataType()
{
return null;
}
@Override public FieldType getUnitsType()
{
return null;
}
@Override public String toString()
{
return getName();
}
};
}
|
java
|
{
"resource": ""
}
|
q1006
|
FieldTypeHelper.valueIsNotDefault
|
train
|
public static final boolean valueIsNotDefault(FieldType type, Object value)
{
boolean result = true;
if (value == null)
{
result = false;
}
else
{
DataType dataType = type.getDataType();
switch (dataType)
{
case BOOLEAN:
{
result = ((Boolean) value).booleanValue();
break;
}
case CURRENCY:
case NUMERIC:
{
result = !NumberHelper.equals(((Number) value).doubleValue(), 0.0, 0.00001);
break;
}
case DURATION:
{
result = (((Duration) value).getDuration() != 0);
break;
}
default:
{
break;
}
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1007
|
PrimaveraXERFileReader.readAll
|
train
|
public List<ProjectFile> readAll(InputStream is, boolean linkCrossProjectRelations) throws MPXJException
{
try
{
m_tables = new HashMap<String, List<Row>>();
m_numberFormat = new DecimalFormat();
processFile(is);
List<Row> rows = getRows("project", null, null);
List<ProjectFile> result = new ArrayList<ProjectFile>(rows.size());
List<ExternalPredecessorRelation> externalPredecessors = new ArrayList<ExternalPredecessorRelation>();
for (Row row : rows)
{
setProjectID(row.getInt("proj_id"));
m_reader = new PrimaveraReader(m_taskUdfCounters, m_resourceUdfCounters, m_assignmentUdfCounters, m_resourceFields, m_wbsFields, m_taskFields, m_assignmentFields, m_aliases, m_matchPrimaveraWBS);
ProjectFile project = m_reader.getProject();
project.getEventManager().addProjectListeners(m_projectListeners);
processProjectProperties();
processUserDefinedFields();
processCalendars();
processResources();
processResourceRates();
processTasks();
processPredecessors();
processAssignments();
externalPredecessors.addAll(m_reader.getExternalPredecessors());
m_reader = null;
project.updateStructure();
result.add(project);
}
if (linkCrossProjectRelations)
{
for (ExternalPredecessorRelation externalRelation : externalPredecessors)
{
Task predecessorTask;
// we could aggregate the project task id maps but that's likely more work
// than just looping through the projects
for (ProjectFile proj : result)
{
predecessorTask = proj.getTaskByUniqueID(externalRelation.getSourceUniqueID());
if (predecessorTask != null)
{
Relation relation = externalRelation.getTargetTask().addPredecessor(predecessorTask, externalRelation.getType(), externalRelation.getLag());
relation.setUniqueID(externalRelation.getUniqueID());
break;
}
}
// if predecessorTask not found the external task is outside of the file so ignore
}
}
return result;
}
finally
{
m_reader = null;
m_tables = null;
m_currentTableName = null;
m_currentTable = null;
m_currentFieldNames = null;
m_defaultCurrencyName = null;
m_currencyMap.clear();
m_numberFormat = null;
m_defaultCurrencyData = null;
}
}
|
java
|
{
"resource": ""
}
|
q1008
|
PrimaveraXERFileReader.processFile
|
train
|
private void processFile(InputStream is) throws MPXJException
{
int line = 1;
try
{
//
// Test the header and extract the separator. If this is successful,
// we reset the stream back as far as we can. The design of the
// BufferedInputStream class means that we can't get back to character
// zero, so the first record we will read will get "RMHDR" rather than
// "ERMHDR" in the first field position.
//
BufferedInputStream bis = new BufferedInputStream(is);
byte[] data = new byte[6];
data[0] = (byte) bis.read();
bis.mark(1024);
bis.read(data, 1, 5);
if (!new String(data).equals("ERMHDR"))
{
throw new MPXJException(MPXJException.INVALID_FILE);
}
bis.reset();
InputStreamReader reader = new InputStreamReader(bis, getCharset());
Tokenizer tk = new ReaderTokenizer(reader);
tk.setDelimiter('\t');
List<String> record = new ArrayList<String>();
while (tk.getType() != Tokenizer.TT_EOF)
{
readRecord(tk, record);
if (!record.isEmpty())
{
if (processRecord(record))
{
break;
}
}
++line;
}
}
catch (Exception ex)
{
throw new MPXJException(MPXJException.READ_ERROR + " (failed at line " + line + ")", ex);
}
}
|
java
|
{
"resource": ""
}
|
q1009
|
PrimaveraXERFileReader.getCharset
|
train
|
private Charset getCharset()
{
Charset result = m_charset;
if (result == null)
{
// We default to CP1252 as this seems to be the most common encoding
result = m_encoding == null ? CharsetHelper.CP1252 : Charset.forName(m_encoding);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1010
|
PrimaveraXERFileReader.processProjectID
|
train
|
private void processProjectID()
{
if (m_projectID == null)
{
List<Row> rows = getRows("project", null, null);
if (!rows.isEmpty())
{
Row row = rows.get(0);
m_projectID = row.getInteger("proj_id");
}
}
}
|
java
|
{
"resource": ""
}
|
q1011
|
PrimaveraXERFileReader.processCurrency
|
train
|
private void processCurrency(Row row)
{
String currencyName = row.getString("curr_short_name");
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setDecimalSeparator(row.getString("decimal_symbol").charAt(0));
symbols.setGroupingSeparator(row.getString("digit_group_symbol").charAt(0));
DecimalFormat nf = new DecimalFormat();
nf.setDecimalFormatSymbols(symbols);
nf.applyPattern("#.#");
m_currencyMap.put(currencyName, nf);
if (currencyName.equalsIgnoreCase(m_defaultCurrencyName))
{
m_numberFormat = nf;
m_defaultCurrencyData = row;
}
}
|
java
|
{
"resource": ""
}
|
q1012
|
PrimaveraXERFileReader.listProjects
|
train
|
public Map<Integer, String> listProjects(InputStream is) throws MPXJException
{
try
{
m_tables = new HashMap<String, List<Row>>();
processFile(is);
Map<Integer, String> result = new HashMap<Integer, String>();
List<Row> rows = getRows("project", null, null);
for (Row row : rows)
{
Integer id = row.getInteger("proj_id");
String name = row.getString("proj_short_name");
result.put(id, name);
}
return result;
}
finally
{
m_tables = null;
m_currentTable = null;
m_currentFieldNames = null;
}
}
|
java
|
{
"resource": ""
}
|
q1013
|
PrimaveraXERFileReader.processScheduleOptions
|
train
|
private void processScheduleOptions()
{
List<Row> rows = getRows("schedoptions", "proj_id", m_projectID);
if (rows.isEmpty() == false)
{
Row row = rows.get(0);
Map<String, Object> customProperties = new HashMap<String, Object>();
customProperties.put("LagCalendar", row.getString("sched_calendar_on_relationship_lag"));
customProperties.put("RetainedLogic", Boolean.valueOf(row.getBoolean("sched_retained_logic")));
customProperties.put("ProgressOverride", Boolean.valueOf(row.getBoolean("sched_progress_override")));
customProperties.put("IgnoreOtherProjectRelationships", row.getString("sched_outer_depend_type"));
customProperties.put("StartToStartLagCalculationType", Boolean.valueOf(row.getBoolean("sched_lag_early_start_flag")));
m_reader.getProject().getProjectProperties().setCustomProperties(customProperties);
}
}
|
java
|
{
"resource": ""
}
|
q1014
|
PrimaveraXERFileReader.readRecord
|
train
|
private void readRecord(Tokenizer tk, List<String> record) throws IOException
{
record.clear();
while (tk.nextToken() == Tokenizer.TT_WORD)
{
record.add(tk.getToken());
}
}
|
java
|
{
"resource": ""
}
|
q1015
|
PrimaveraXERFileReader.processRecord
|
train
|
private boolean processRecord(List<String> record) throws MPXJException
{
boolean done = false;
XerRecordType type = RECORD_TYPE_MAP.get(record.get(0));
if (type == null)
{
throw new MPXJException(MPXJException.INVALID_FORMAT);
}
switch (type)
{
case HEADER:
{
processHeader(record);
break;
}
case TABLE:
{
m_currentTableName = record.get(1).toLowerCase();
m_skipTable = !REQUIRED_TABLES.contains(m_currentTableName);
if (m_skipTable)
{
m_currentTable = null;
}
else
{
m_currentTable = new LinkedList<Row>();
m_tables.put(m_currentTableName, m_currentTable);
}
break;
}
case FIELDS:
{
if (m_skipTable)
{
m_currentFieldNames = null;
}
else
{
m_currentFieldNames = record.toArray(new String[record.size()]);
for (int loop = 0; loop < m_currentFieldNames.length; loop++)
{
m_currentFieldNames[loop] = m_currentFieldNames[loop].toLowerCase();
}
}
break;
}
case DATA:
{
if (!m_skipTable)
{
Map<String, Object> map = new HashMap<String, Object>();
for (int loop = 1; loop < record.size(); loop++)
{
String fieldName = m_currentFieldNames[loop];
String fieldValue = record.get(loop);
XerFieldType fieldType = FIELD_TYPE_MAP.get(fieldName);
if (fieldType == null)
{
fieldType = XerFieldType.STRING;
}
Object objectValue;
if (fieldValue.length() == 0)
{
objectValue = null;
}
else
{
switch (fieldType)
{
case DATE:
{
try
{
objectValue = m_df.parseObject(fieldValue);
}
catch (ParseException ex)
{
objectValue = fieldValue;
}
break;
}
case CURRENCY:
case DOUBLE:
case DURATION:
{
try
{
objectValue = Double.valueOf(m_numberFormat.parse(fieldValue.trim()).doubleValue());
}
catch (ParseException ex)
{
objectValue = fieldValue;
}
break;
}
case INTEGER:
{
objectValue = Integer.valueOf(fieldValue.trim());
break;
}
default:
{
objectValue = fieldValue;
break;
}
}
}
map.put(fieldName, objectValue);
}
Row currentRow = new MapRow(map);
m_currentTable.add(currentRow);
//
// Special case - we need to know the default currency format
// ahead of time, so process each row as we get it so that
// we can correctly parse currency values in later tables.
//
if (m_currentTableName.equals("currtype"))
{
processCurrency(currentRow);
}
}
break;
}
case END:
{
done = true;
break;
}
default:
{
break;
}
}
return done;
}
|
java
|
{
"resource": ""
}
|
q1016
|
PrimaveraXERFileReader.getRows
|
train
|
private List<Row> getRows(String tableName, String columnName, Integer id)
{
List<Row> result;
List<Row> table = m_tables.get(tableName);
if (table == null)
{
result = Collections.<Row> emptyList();
}
else
{
if (columnName == null)
{
result = table;
}
else
{
result = new LinkedList<Row>();
for (Row row : table)
{
if (NumberHelper.equals(id, row.getInteger(columnName)))
{
result.add(row);
}
}
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1017
|
CustomFieldValueReader.getTypedValue
|
train
|
protected Object getTypedValue(int type, byte[] value)
{
Object result;
switch (type)
{
case 4: // Date
{
result = MPPUtility.getTimestamp(value, 0);
break;
}
case 6: // Duration
{
TimeUnit units = MPPUtility.getDurationTimeUnits(MPPUtility.getShort(value, 4), m_properties.getDefaultDurationUnits());
result = MPPUtility.getAdjustedDuration(m_properties, MPPUtility.getInt(value, 0), units);
break;
}
case 9: // Cost
{
result = Double.valueOf(MPPUtility.getDouble(value, 0) / 100);
break;
}
case 15: // Number
{
result = Double.valueOf(MPPUtility.getDouble(value, 0));
break;
}
case 36058:
case 21: // Text
{
result = MPPUtility.getUnicodeString(value, 0);
break;
}
default:
{
result = value;
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1018
|
Table.addRow
|
train
|
public void addRow(String primaryKeyColumnName, Map<String, Object> map)
{
Integer rowNumber = Integer.valueOf(m_rowNumber++);
map.put("ROW_NUMBER", rowNumber);
Object primaryKey = null;
if (primaryKeyColumnName != null)
{
primaryKey = map.get(primaryKeyColumnName);
}
if (primaryKey == null)
{
primaryKey = rowNumber;
}
MapRow newRow = new MapRow(map);
MapRow oldRow = m_rows.get(primaryKey);
if (oldRow == null)
{
m_rows.put(primaryKey, newRow);
}
else
{
int oldVersion = oldRow.getInteger("ROW_VERSION").intValue();
int newVersion = newRow.getInteger("ROW_VERSION").intValue();
if (newVersion > oldVersion)
{
m_rows.put(primaryKey, newRow);
}
}
}
|
java
|
{
"resource": ""
}
|
q1019
|
RTFEmbeddedObject.getEmbeddedObjects
|
train
|
public static List<List<RTFEmbeddedObject>> getEmbeddedObjects(String text)
{
List<List<RTFEmbeddedObject>> objects = null;
List<RTFEmbeddedObject> objectData;
int offset = text.indexOf(OBJDATA);
if (offset != -1)
{
objects = new LinkedList<List<RTFEmbeddedObject>>();
while (offset != -1)
{
objectData = new LinkedList<RTFEmbeddedObject>();
objects.add(objectData);
offset = readObjectData(offset, text, objectData);
offset = text.indexOf(OBJDATA, offset);
}
}
return (objects);
}
|
java
|
{
"resource": ""
}
|
q1020
|
RTFEmbeddedObject.getInt
|
train
|
private int getInt(List<byte[]> blocks)
{
int result;
if (blocks.isEmpty() == false)
{
byte[] data = blocks.remove(0);
result = MPPUtility.getInt(data, 0);
}
else
{
result = 0;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1021
|
RTFEmbeddedObject.getData
|
train
|
private byte[] getData(List<byte[]> blocks, int length)
{
byte[] result;
if (blocks.isEmpty() == false)
{
if (length < 4)
{
length = 4;
}
result = new byte[length];
int offset = 0;
byte[] data;
while (offset < length)
{
data = blocks.remove(0);
System.arraycopy(data, 0, result, offset, data.length);
offset += data.length;
}
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1022
|
RTFEmbeddedObject.readObjectData
|
train
|
private static int readObjectData(int offset, String text, List<RTFEmbeddedObject> objects)
{
LinkedList<byte[]> blocks = new LinkedList<byte[]>();
offset += (OBJDATA.length());
offset = skipEndOfLine(text, offset);
int length;
int lastOffset = offset;
while (offset != -1)
{
length = getBlockLength(text, offset);
lastOffset = readDataBlock(text, offset, length, blocks);
offset = skipEndOfLine(text, lastOffset);
}
RTFEmbeddedObject headerObject;
RTFEmbeddedObject dataObject;
while (blocks.isEmpty() == false)
{
headerObject = new RTFEmbeddedObject(blocks, 2);
objects.add(headerObject);
if (blocks.isEmpty() == false)
{
dataObject = new RTFEmbeddedObject(blocks, headerObject.getTypeFlag2());
objects.add(dataObject);
}
}
return (lastOffset);
}
|
java
|
{
"resource": ""
}
|
q1023
|
RTFEmbeddedObject.skipEndOfLine
|
train
|
private static int skipEndOfLine(String text, int offset)
{
char c;
boolean finished = false;
while (finished == false)
{
c = text.charAt(offset);
switch (c)
{
case ' ': // found that OBJDATA could be followed by a space the EOL
case '\r':
case '\n':
{
++offset;
break;
}
case '}':
{
offset = -1;
finished = true;
break;
}
default:
{
finished = true;
break;
}
}
}
return (offset);
}
|
java
|
{
"resource": ""
}
|
q1024
|
RTFEmbeddedObject.getBlockLength
|
train
|
private static int getBlockLength(String text, int offset)
{
int startIndex = offset;
boolean finished = false;
char c;
while (finished == false)
{
c = text.charAt(offset);
switch (c)
{
case '\r':
case '\n':
case '}':
{
finished = true;
break;
}
default:
{
++offset;
break;
}
}
}
int length = offset - startIndex;
return (length);
}
|
java
|
{
"resource": ""
}
|
q1025
|
RTFEmbeddedObject.readDataBlock
|
train
|
private static int readDataBlock(String text, int offset, int length, List<byte[]> blocks)
{
int bytes = length / 2;
byte[] data = new byte[bytes];
for (int index = 0; index < bytes; index++)
{
data[index] = (byte) Integer.parseInt(text.substring(offset, offset + 2), 16);
offset += 2;
}
blocks.add(data);
return (offset);
}
|
java
|
{
"resource": ""
}
|
q1026
|
MPP12Reader.readSubProject
|
train
|
private SubProject readSubProject(byte[] data, int uniqueIDOffset, int filePathOffset, int fileNameOffset, int subprojectIndex)
{
try
{
SubProject sp = new SubProject();
int type = SUBPROJECT_TASKUNIQUEID0;
if (uniqueIDOffset != -1)
{
int value = MPPUtility.getInt(data, uniqueIDOffset);
type = MPPUtility.getInt(data, uniqueIDOffset + 4);
switch (type)
{
case SUBPROJECT_TASKUNIQUEID0:
case SUBPROJECT_TASKUNIQUEID1:
case SUBPROJECT_TASKUNIQUEID2:
case SUBPROJECT_TASKUNIQUEID3:
case SUBPROJECT_TASKUNIQUEID4:
case SUBPROJECT_TASKUNIQUEID5:
case SUBPROJECT_TASKUNIQUEID6:
{
sp.setTaskUniqueID(Integer.valueOf(value));
m_taskSubProjects.put(sp.getTaskUniqueID(), sp);
break;
}
default:
{
if (value != 0)
{
sp.addExternalTaskUniqueID(Integer.valueOf(value));
m_taskSubProjects.put(Integer.valueOf(value), sp);
}
break;
}
}
// Now get the unique id offset for this subproject
value = 0x00800000 + ((subprojectIndex - 1) * 0x00400000);
sp.setUniqueIDOffset(Integer.valueOf(value));
}
if (type == SUBPROJECT_TASKUNIQUEID4)
{
sp.setFullPath(MPPUtility.getUnicodeString(data, filePathOffset));
}
else
{
//
// First block header
//
filePathOffset += 18;
//
// String size as a 4 byte int
//
filePathOffset += 4;
//
// Full DOS path
//
sp.setDosFullPath(MPPUtility.getString(data, filePathOffset));
filePathOffset += (sp.getDosFullPath().length() + 1);
//
// 24 byte block
//
filePathOffset += 24;
//
// 4 byte block size
//
int size = MPPUtility.getInt(data, filePathOffset);
filePathOffset += 4;
if (size == 0)
{
sp.setFullPath(sp.getDosFullPath());
}
else
{
//
// 4 byte unicode string size in bytes
//
size = MPPUtility.getInt(data, filePathOffset);
filePathOffset += 4;
//
// 2 byte data
//
filePathOffset += 2;
//
// Unicode string
//
sp.setFullPath(MPPUtility.getUnicodeString(data, filePathOffset, size));
//filePathOffset += size;
}
//
// Second block header
//
fileNameOffset += 18;
//
// String size as a 4 byte int
//
fileNameOffset += 4;
//
// DOS file name
//
sp.setDosFileName(MPPUtility.getString(data, fileNameOffset));
fileNameOffset += (sp.getDosFileName().length() + 1);
//
// 24 byte block
//
fileNameOffset += 24;
//
// 4 byte block size
//
size = MPPUtility.getInt(data, fileNameOffset);
fileNameOffset += 4;
if (size == 0)
{
sp.setFileName(sp.getDosFileName());
}
else
{
//
// 4 byte unicode string size in bytes
//
size = MPPUtility.getInt(data, fileNameOffset);
fileNameOffset += 4;
//
// 2 byte data
//
fileNameOffset += 2;
//
// Unicode string
//
sp.setFileName(MPPUtility.getUnicodeString(data, fileNameOffset, size));
//fileNameOffset += size;
}
}
//System.out.println(sp.toString());
// Add to the list of subprojects
m_file.getSubProjects().add(sp);
return (sp);
}
//
// Admit defeat at this point - we have probably stumbled
// upon a data format we don't understand, so we'll fail
// gracefully here. This will now be reported as a missing
// sub project error by end users of the library, rather
// than as an exception being thrown.
//
catch (ArrayIndexOutOfBoundsException ex)
{
return (null);
}
}
|
java
|
{
"resource": ""
}
|
q1027
|
TableReader.readRecord
|
train
|
private void readRecord(byte[] buffer, Table table)
{
//System.out.println(ByteArrayHelper.hexdump(buffer, true, 16, ""));
int deletedFlag = getShort(buffer, 0);
if (deletedFlag != 0)
{
Map<String, Object> row = new HashMap<String, Object>();
for (ColumnDefinition column : m_definition.getColumns())
{
Object value = column.read(0, buffer);
//System.out.println(column.getName() + ": " + value);
row.put(column.getName(), value);
}
table.addRow(m_definition.getPrimaryKeyColumnName(), row);
}
}
|
java
|
{
"resource": ""
}
|
q1028
|
MPPUtility.decodeBuffer
|
train
|
public static final void decodeBuffer(byte[] data, byte encryptionCode)
{
for (int i = 0; i < data.length; i++)
{
data[i] = (byte) (data[i] ^ encryptionCode);
}
}
|
java
|
{
"resource": ""
}
|
q1029
|
MPPUtility.decodePassword
|
train
|
public static final String decodePassword(byte[] data, byte encryptionCode)
{
String result;
if (data.length < MINIMUM_PASSWORD_DATA_LENGTH)
{
result = null;
}
else
{
MPPUtility.decodeBuffer(data, encryptionCode);
StringBuilder buffer = new StringBuilder();
char c;
for (int i = 0; i < PASSWORD_MASK.length; i++)
{
int index = PASSWORD_MASK[i];
c = (char) data[index];
if (c == 0)
{
break;
}
buffer.append(c);
}
result = buffer.toString();
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1030
|
MPPUtility.getByteArray
|
train
|
public static final void getByteArray(byte[] data, int offset, int size, byte[] buffer, int bufferOffset)
{
System.arraycopy(data, offset, buffer, bufferOffset, size);
}
|
java
|
{
"resource": ""
}
|
q1031
|
MPPUtility.getLong6
|
train
|
public static final long getLong6(byte[] data, int offset)
{
long result = 0;
int i = offset;
for (int shiftBy = 0; shiftBy < 48; shiftBy += 8)
{
result |= ((long) (data[i] & 0xff)) << shiftBy;
++i;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1032
|
MPPUtility.getTime
|
train
|
public static final Date getTime(byte[] data, int offset)
{
int time = getShort(data, offset) / 10;
Calendar cal = DateHelper.popCalendar(EPOCH_DATE);
cal.set(Calendar.HOUR_OF_DAY, (time / 60));
cal.set(Calendar.MINUTE, (time % 60));
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
DateHelper.pushCalendar(cal);
return (cal.getTime());
}
|
java
|
{
"resource": ""
}
|
q1033
|
MPPUtility.getTimestamp
|
train
|
public static final Date getTimestamp(byte[] data, int offset)
{
Date result;
long days = getShort(data, offset + 2);
if (days < 100)
{
// We are seeing some files which have very small values for the number of days.
// When the relevant field is shown in MS Project it appears as NA.
// We try to mimic this behaviour here.
days = 0;
}
if (days == 0 || days == 65535)
{
result = null;
}
else
{
long time = getShort(data, offset);
if (time == 65535)
{
time = 0;
}
result = DateHelper.getTimestampFromLong((EPOCH + (days * DateHelper.MS_PER_DAY) + ((time * DateHelper.MS_PER_MINUTE) / 10)));
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1034
|
MPPUtility.getTimestampFromTenths
|
train
|
public static final Date getTimestampFromTenths(byte[] data, int offset)
{
long ms = ((long) getInt(data, offset)) * 6000;
return (DateHelper.getTimestampFromLong(EPOCH + ms));
}
|
java
|
{
"resource": ""
}
|
q1035
|
MPPUtility.getUnicodeString
|
train
|
public static final String getUnicodeString(byte[] data, int offset)
{
int length = getUnicodeStringLengthInBytes(data, offset);
return length == 0 ? "" : new String(data, offset, length, CharsetHelper.UTF16LE);
}
|
java
|
{
"resource": ""
}
|
q1036
|
MPPUtility.getUnicodeStringLengthInBytes
|
train
|
private static final int getUnicodeStringLengthInBytes(byte[] data, int offset)
{
int result;
if (data == null || offset >= data.length)
{
result = 0;
}
else
{
result = data.length - offset;
for (int loop = offset; loop < (data.length - 1); loop += 2)
{
if (data[loop] == 0 && data[loop + 1] == 0)
{
result = loop - offset;
break;
}
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1037
|
MPPUtility.getString
|
train
|
public static final String getString(byte[] data, int offset)
{
StringBuilder buffer = new StringBuilder();
char c;
for (int loop = 0; offset + loop < data.length; loop++)
{
c = (char) data[offset + loop];
if (c == 0)
{
break;
}
buffer.append(c);
}
return (buffer.toString());
}
|
java
|
{
"resource": ""
}
|
q1038
|
MPPUtility.getColor
|
train
|
public static final Color getColor(byte[] data, int offset)
{
Color result = null;
if (getByte(data, offset + 3) == 0)
{
int r = getByte(data, offset);
int g = getByte(data, offset + 1);
int b = getByte(data, offset + 2);
result = new Color(r, g, b);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1039
|
MPPUtility.removeAmpersands
|
train
|
public static final String removeAmpersands(String name)
{
if (name != null)
{
if (name.indexOf('&') != -1)
{
StringBuilder sb = new StringBuilder();
int index = 0;
char c;
while (index < name.length())
{
c = name.charAt(index);
if (c != '&')
{
sb.append(c);
}
++index;
}
name = sb.toString();
}
}
return (name);
}
|
java
|
{
"resource": ""
}
|
q1040
|
MPPUtility.getPercentage
|
train
|
public static final Double getPercentage(byte[] data, int offset)
{
int value = MPPUtility.getShort(data, offset);
Double result = null;
if (value >= 0 && value <= 100)
{
result = NumberHelper.getDouble(value);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1041
|
MPPUtility.cloneSubArray
|
train
|
public static final byte[] cloneSubArray(byte[] data, int offset, int size)
{
byte[] newData = new byte[size];
System.arraycopy(data, offset, newData, 0, size);
return (newData);
}
|
java
|
{
"resource": ""
}
|
q1042
|
MPPUtility.dumpBlockData
|
train
|
public static void dumpBlockData(int headerSize, int blockSize, byte[] data)
{
if (data != null)
{
System.out.println(ByteArrayHelper.hexdump(data, 0, headerSize, false));
int index = headerSize;
while (index < data.length)
{
System.out.println(ByteArrayHelper.hexdump(data, index, blockSize, false));
index += blockSize;
}
}
}
|
java
|
{
"resource": ""
}
|
q1043
|
ProjectFile.getDuration
|
train
|
@Deprecated public Duration getDuration(Date startDate, Date endDate) throws MPXJException
{
return (getDuration("Standard", startDate, endDate));
}
|
java
|
{
"resource": ""
}
|
q1044
|
ProjectFile.getDuration
|
train
|
@Deprecated public Duration getDuration(String calendarName, Date startDate, Date endDate) throws MPXJException
{
ProjectCalendar calendar = getCalendarByName(calendarName);
if (calendar == null)
{
throw new MPXJException(MPXJException.CALENDAR_ERROR + ": " + calendarName);
}
return (calendar.getDuration(startDate, endDate));
}
|
java
|
{
"resource": ""
}
|
q1045
|
ProjectFile.getStartDate
|
train
|
public Date getStartDate()
{
Date startDate = null;
for (Task task : m_tasks)
{
//
// If a hidden "summary" task is present we ignore it
//
if (NumberHelper.getInt(task.getUniqueID()) == 0)
{
continue;
}
//
// Select the actual or forecast start date. Note that the
// behaviour is different for milestones. The milestone end date
// is always correct, the milestone start date may be different
// to reflect a missed deadline.
//
Date taskStartDate;
if (task.getMilestone() == true)
{
taskStartDate = task.getActualFinish();
if (taskStartDate == null)
{
taskStartDate = task.getFinish();
}
}
else
{
taskStartDate = task.getActualStart();
if (taskStartDate == null)
{
taskStartDate = task.getStart();
}
}
if (taskStartDate != null)
{
if (startDate == null)
{
startDate = taskStartDate;
}
else
{
if (taskStartDate.getTime() < startDate.getTime())
{
startDate = taskStartDate;
}
}
}
}
return (startDate);
}
|
java
|
{
"resource": ""
}
|
q1046
|
ProjectFile.getFinishDate
|
train
|
public Date getFinishDate()
{
Date finishDate = null;
for (Task task : m_tasks)
{
//
// If a hidden "summary" task is present we ignore it
//
if (NumberHelper.getInt(task.getUniqueID()) == 0)
{
continue;
}
//
// Select the actual or forecast start date
//
Date taskFinishDate;
taskFinishDate = task.getActualFinish();
if (taskFinishDate == null)
{
taskFinishDate = task.getFinish();
}
if (taskFinishDate != null)
{
if (finishDate == null)
{
finishDate = taskFinishDate;
}
else
{
if (taskFinishDate.getTime() > finishDate.getTime())
{
finishDate = taskFinishDate;
}
}
}
}
return (finishDate);
}
|
java
|
{
"resource": ""
}
|
q1047
|
ProjectFile.getDefaultCalendar
|
train
|
public ProjectCalendar getDefaultCalendar()
{
String calendarName = m_properties.getDefaultCalendarName();
ProjectCalendar calendar = getCalendarByName(calendarName);
if (calendar == null)
{
if (m_calendars.isEmpty())
{
calendar = addDefaultBaseCalendar();
}
else
{
calendar = m_calendars.get(0);
}
}
return calendar;
}
|
java
|
{
"resource": ""
}
|
q1048
|
ProjectFile.getBaselineCalendar
|
train
|
public ProjectCalendar getBaselineCalendar()
{
//
// Attempt to locate the calendar normally used by baselines
// If this isn't present, fall back to using the default
// project calendar.
//
ProjectCalendar result = getCalendarByName("Used for Microsoft Project 98 Baseline Calendar");
if (result == null)
{
result = getDefaultCalendar();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1049
|
GraphicalIndicatorReader.process
|
train
|
public void process(CustomFieldContainer indicators, ProjectProperties properties, Props props)
{
m_container = indicators;
m_properties = properties;
m_data = props.getByteArray(Props.TASK_FIELD_ATTRIBUTES);
if (m_data != null)
{
int columnsCount = MPPUtility.getInt(m_data, 4);
m_headerOffset = 8;
for (int loop = 0; loop < columnsCount; loop++)
{
processColumns();
}
}
}
|
java
|
{
"resource": ""
}
|
q1050
|
GraphicalIndicatorReader.processColumns
|
train
|
private void processColumns()
{
int fieldID = MPPUtility.getInt(m_data, m_headerOffset);
m_headerOffset += 4;
m_dataOffset = MPPUtility.getInt(m_data, m_headerOffset);
m_headerOffset += 4;
FieldType type = FieldTypeHelper.getInstance(fieldID);
if (type.getDataType() != null)
{
processKnownType(type);
}
}
|
java
|
{
"resource": ""
}
|
q1051
|
GraphicalIndicatorReader.processKnownType
|
train
|
private void processKnownType(FieldType type)
{
//System.out.println("Header: " + type);
//System.out.println(ByteArrayHelper.hexdump(m_data, m_dataOffset, 36, false, 16, ""));
GraphicalIndicator indicator = m_container.getCustomField(type).getGraphicalIndicator();
indicator.setFieldType(type);
int flags = m_data[m_dataOffset];
indicator.setProjectSummaryInheritsFromSummaryRows((flags & 0x08) != 0);
indicator.setSummaryRowsInheritFromNonSummaryRows((flags & 0x04) != 0);
indicator.setDisplayGraphicalIndicators((flags & 0x02) != 0);
indicator.setShowDataValuesInToolTips((flags & 0x01) != 0);
m_dataOffset += 20;
int nonSummaryRowOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
m_dataOffset += 4;
int summaryRowOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
m_dataOffset += 4;
int projectSummaryOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
m_dataOffset += 4;
int dataSize = MPPUtility.getInt(m_data, m_dataOffset) - 36;
m_dataOffset += 4;
//System.out.println("Data");
//System.out.println(ByteArrayHelper.hexdump(m_data, m_dataOffset, dataSize, false, 16, ""));
int maxNonSummaryRowOffset = m_dataOffset + summaryRowOffset;
int maxSummaryRowOffset = m_dataOffset + projectSummaryOffset;
int maxProjectSummaryOffset = m_dataOffset + dataSize;
m_dataOffset += nonSummaryRowOffset;
while (m_dataOffset + 2 < maxNonSummaryRowOffset)
{
indicator.addNonSummaryRowCriteria(processCriteria(type));
}
while (m_dataOffset + 2 < maxSummaryRowOffset)
{
indicator.addSummaryRowCriteria(processCriteria(type));
}
while (m_dataOffset + 2 < maxProjectSummaryOffset)
{
indicator.addProjectSummaryCriteria(processCriteria(type));
}
}
|
java
|
{
"resource": ""
}
|
q1052
|
GraphicalIndicatorReader.processCriteria
|
train
|
private GraphicalIndicatorCriteria processCriteria(FieldType type)
{
GraphicalIndicatorCriteria criteria = new GraphicalIndicatorCriteria(m_properties);
criteria.setLeftValue(type);
int indicatorType = MPPUtility.getInt(m_data, m_dataOffset);
m_dataOffset += 4;
criteria.setIndicator(indicatorType);
if (m_dataOffset + 4 < m_data.length)
{
int operatorValue = MPPUtility.getInt(m_data, m_dataOffset);
m_dataOffset += 4;
TestOperator operator = (operatorValue == 0 ? TestOperator.IS_ANY_VALUE : TestOperator.getInstance(operatorValue - 0x3E7));
criteria.setOperator(operator);
if (operator != TestOperator.IS_ANY_VALUE)
{
processOperandValue(0, type, criteria);
if (operator == TestOperator.IS_WITHIN || operator == TestOperator.IS_NOT_WITHIN)
{
processOperandValue(1, type, criteria);
}
}
}
return (criteria);
}
|
java
|
{
"resource": ""
}
|
q1053
|
GraphicalIndicatorReader.processOperandValue
|
train
|
private void processOperandValue(int index, FieldType type, GraphicalIndicatorCriteria criteria)
{
boolean valueFlag = (MPPUtility.getInt(m_data, m_dataOffset) == 1);
m_dataOffset += 4;
if (valueFlag == false)
{
int fieldID = MPPUtility.getInt(m_data, m_dataOffset);
criteria.setRightValue(index, FieldTypeHelper.getInstance(fieldID));
m_dataOffset += 4;
}
else
{
//int dataTypeValue = MPPUtility.getShort(m_data, m_dataOffset);
m_dataOffset += 2;
switch (type.getDataType())
{
case DURATION: // 0x03
{
Duration value = MPPUtility.getAdjustedDuration(m_properties, MPPUtility.getInt(m_data, m_dataOffset), MPPUtility.getDurationTimeUnits(MPPUtility.getShort(m_data, m_dataOffset + 4)));
m_dataOffset += 6;
criteria.setRightValue(index, value);
break;
}
case NUMERIC: // 0x05
{
Double value = Double.valueOf(MPPUtility.getDouble(m_data, m_dataOffset));
m_dataOffset += 8;
criteria.setRightValue(index, value);
break;
}
case CURRENCY: // 0x06
{
Double value = Double.valueOf(MPPUtility.getDouble(m_data, m_dataOffset) / 100);
m_dataOffset += 8;
criteria.setRightValue(index, value);
break;
}
case STRING: // 0x08
{
String value = MPPUtility.getUnicodeString(m_data, m_dataOffset);
m_dataOffset += ((value.length() + 1) * 2);
criteria.setRightValue(index, value);
break;
}
case BOOLEAN: // 0x0B
{
int value = MPPUtility.getShort(m_data, m_dataOffset);
m_dataOffset += 2;
criteria.setRightValue(index, value == 1 ? Boolean.TRUE : Boolean.FALSE);
break;
}
case DATE: // 0x13
{
Date value = MPPUtility.getTimestamp(m_data, m_dataOffset);
m_dataOffset += 4;
criteria.setRightValue(index, value);
break;
}
default:
{
break;
}
}
}
}
|
java
|
{
"resource": ""
}
|
q1054
|
GanttChartView12.getGridLines
|
train
|
private GridLines getGridLines(byte[] data, int offset)
{
Color normalLineColor = ColorType.getInstance(data[offset]).getColor();
LineStyle normalLineStyle = LineStyle.getInstance(data[offset + 3]);
int intervalNumber = data[offset + 4];
LineStyle intervalLineStyle = LineStyle.getInstance(data[offset + 5]);
Color intervalLineColor = ColorType.getInstance(data[offset + 6]).getColor();
return new GridLines(normalLineColor, normalLineStyle, intervalNumber, intervalLineStyle, intervalLineColor);
}
|
java
|
{
"resource": ""
}
|
q1055
|
Var2Data.getByteArray
|
train
|
public byte[] getByteArray(Integer offset)
{
byte[] result = null;
if (offset != null)
{
result = m_map.get(offset);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1056
|
Var2Data.getByteArray
|
train
|
public byte[] getByteArray(Integer id, Integer type)
{
return (getByteArray(m_meta.getOffset(id, type)));
}
|
java
|
{
"resource": ""
}
|
q1057
|
Var2Data.getUnicodeString
|
train
|
public String getUnicodeString(Integer id, Integer type)
{
return (getUnicodeString(m_meta.getOffset(id, type)));
}
|
java
|
{
"resource": ""
}
|
q1058
|
Var2Data.getString
|
train
|
public String getString(Integer offset)
{
String result = null;
if (offset != null)
{
byte[] value = m_map.get(offset);
if (value != null)
{
result = MPPUtility.getString(value, 0);
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1059
|
Var2Data.getString
|
train
|
public String getString(Integer id, Integer type)
{
return (getString(m_meta.getOffset(id, type)));
}
|
java
|
{
"resource": ""
}
|
q1060
|
Var2Data.getShort
|
train
|
public int getShort(Integer id, Integer type)
{
int result = 0;
Integer offset = m_meta.getOffset(id, type);
if (offset != null)
{
byte[] value = m_map.get(offset);
if (value != null && value.length >= 2)
{
result = MPPUtility.getShort(value, 0);
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1061
|
Var2Data.getDouble
|
train
|
public double getDouble(Integer id, Integer type)
{
double result = Double.longBitsToDouble(getLong(id, type));
if (Double.isNaN(result))
{
result = 0;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1062
|
ProjectCalendarDateRanges.getRange
|
train
|
public DateRange getRange(int index)
{
DateRange result;
if (index >= 0 && index < m_ranges.size())
{
result = m_ranges.get(index);
}
else
{
result = DateRange.EMPTY_RANGE;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1063
|
CriteriaReader.process
|
train
|
public GenericCriteria process(ProjectProperties properties, byte[] data, int dataOffset, int entryOffset, List<GenericCriteriaPrompt> prompts, List<FieldType> fields, boolean[] criteriaType)
{
m_properties = properties;
m_prompts = prompts;
m_fields = fields;
m_criteriaType = criteriaType;
m_dataOffset = dataOffset;
if (m_criteriaType != null)
{
m_criteriaType[0] = true;
m_criteriaType[1] = true;
}
m_criteriaBlockMap.clear();
m_criteriaData = data;
m_criteriaTextStart = MPPUtility.getShort(m_criteriaData, m_dataOffset + getCriteriaTextStartOffset());
//
// Populate the map
//
int criteriaStartOffset = getCriteriaStartOffset();
int criteriaBlockSize = getCriteriaBlockSize();
//System.out.println();
//System.out.println(ByteArrayHelper.hexdump(data, dataOffset, criteriaStartOffset, false));
if (m_criteriaData.length <= m_criteriaTextStart)
{
return null; // bad data
}
while (criteriaStartOffset + criteriaBlockSize <= m_criteriaTextStart)
{
byte[] block = new byte[criteriaBlockSize];
System.arraycopy(m_criteriaData, m_dataOffset + criteriaStartOffset, block, 0, criteriaBlockSize);
m_criteriaBlockMap.put(Integer.valueOf(criteriaStartOffset), block);
//System.out.println(Integer.toHexString(criteriaStartOffset) + ": " + ByteArrayHelper.hexdump(block, false));
criteriaStartOffset += criteriaBlockSize;
}
if (entryOffset == -1)
{
entryOffset = getCriteriaStartOffset();
}
List<GenericCriteria> list = new LinkedList<GenericCriteria>();
processBlock(list, m_criteriaBlockMap.get(Integer.valueOf(entryOffset)));
GenericCriteria criteria;
if (list.isEmpty())
{
criteria = null;
}
else
{
criteria = list.get(0);
}
return criteria;
}
|
java
|
{
"resource": ""
}
|
q1064
|
CriteriaReader.processBlock
|
train
|
private void processBlock(List<GenericCriteria> list, byte[] block)
{
if (block != null)
{
if (MPPUtility.getShort(block, 0) > 0x3E6)
{
addCriteria(list, block);
}
else
{
switch (block[0])
{
case (byte) 0x0B:
{
processBlock(list, getChildBlock(block));
break;
}
case (byte) 0x06:
{
processBlock(list, getListNextBlock(block));
break;
}
case (byte) 0xED: // EQUALS
{
addCriteria(list, block);
break;
}
case (byte) 0x19: // AND
case (byte) 0x1B:
{
addBlock(list, block, TestOperator.AND);
break;
}
case (byte) 0x1A: // OR
case (byte) 0x1C:
{
addBlock(list, block, TestOperator.OR);
break;
}
}
}
}
}
|
java
|
{
"resource": ""
}
|
q1065
|
CriteriaReader.addCriteria
|
train
|
private void addCriteria(List<GenericCriteria> list, byte[] block)
{
byte[] leftBlock = getChildBlock(block);
byte[] rightBlock1 = getListNextBlock(leftBlock);
byte[] rightBlock2 = getListNextBlock(rightBlock1);
TestOperator operator = TestOperator.getInstance(MPPUtility.getShort(block, 0) - 0x3E7);
FieldType leftValue = getFieldType(leftBlock);
Object rightValue1 = getValue(leftValue, rightBlock1);
Object rightValue2 = rightBlock2 == null ? null : getValue(leftValue, rightBlock2);
GenericCriteria criteria = new GenericCriteria(m_properties);
criteria.setLeftValue(leftValue);
criteria.setOperator(operator);
criteria.setRightValue(0, rightValue1);
criteria.setRightValue(1, rightValue2);
list.add(criteria);
if (m_criteriaType != null)
{
m_criteriaType[0] = leftValue.getFieldTypeClass() == FieldTypeClass.TASK;
m_criteriaType[1] = !m_criteriaType[0];
}
if (m_fields != null)
{
m_fields.add(leftValue);
}
processBlock(list, getListNextBlock(block));
}
|
java
|
{
"resource": ""
}
|
q1066
|
CriteriaReader.addBlock
|
train
|
private void addBlock(List<GenericCriteria> list, byte[] block, TestOperator operator)
{
GenericCriteria result = new GenericCriteria(m_properties);
result.setOperator(operator);
list.add(result);
processBlock(result.getCriteriaList(), getChildBlock(block));
processBlock(list, getListNextBlock(block));
}
|
java
|
{
"resource": ""
}
|
q1067
|
CriteriaReader.getValue
|
train
|
private Object getValue(FieldType field, byte[] block)
{
Object result = null;
switch (block[0])
{
case 0x07: // Field
{
result = getFieldType(block);
break;
}
case 0x01: // Constant value
{
result = getConstantValue(field, block);
break;
}
case 0x00: // Prompt
{
result = getPromptValue(field, block);
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1068
|
CriteriaReader.getConstantValue
|
train
|
private Object getConstantValue(FieldType type, byte[] block)
{
Object value;
DataType dataType = type.getDataType();
if (dataType == null)
{
value = null;
}
else
{
switch (dataType)
{
case DURATION:
{
value = MPPUtility.getAdjustedDuration(m_properties, MPPUtility.getInt(block, getValueOffset()), MPPUtility.getDurationTimeUnits(MPPUtility.getShort(block, getTimeUnitsOffset())));
break;
}
case NUMERIC:
{
value = Double.valueOf(MPPUtility.getDouble(block, getValueOffset()));
break;
}
case PERCENTAGE:
{
value = Double.valueOf(MPPUtility.getShort(block, getValueOffset()));
break;
}
case CURRENCY:
{
value = Double.valueOf(MPPUtility.getDouble(block, getValueOffset()) / 100);
break;
}
case STRING:
{
int textOffset = getTextOffset(block);
value = MPPUtility.getUnicodeString(m_criteriaData, m_dataOffset + m_criteriaTextStart + textOffset);
break;
}
case BOOLEAN:
{
int intValue = MPPUtility.getShort(block, getValueOffset());
value = (intValue == 1 ? Boolean.TRUE : Boolean.FALSE);
break;
}
case DATE:
{
value = MPPUtility.getTimestamp(block, getValueOffset());
break;
}
default:
{
value = null;
break;
}
}
}
return value;
}
|
java
|
{
"resource": ""
}
|
q1069
|
CriteriaReader.getPromptValue
|
train
|
private GenericCriteriaPrompt getPromptValue(FieldType field, byte[] block)
{
int textOffset = getPromptOffset(block);
String value = MPPUtility.getUnicodeString(m_criteriaData, m_criteriaTextStart + textOffset);
GenericCriteriaPrompt prompt = new GenericCriteriaPrompt(field.getDataType(), value);
if (m_prompts != null)
{
m_prompts.add(prompt);
}
return prompt;
}
|
java
|
{
"resource": ""
}
|
q1070
|
PredecessorReader.getRelationType
|
train
|
private RelationType getRelationType(int type)
{
RelationType result;
if (type > 0 && type < RELATION_TYPES.length)
{
result = RELATION_TYPES[type];
}
else
{
result = RelationType.FINISH_START;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1071
|
FixFix.getByteArrayValue
|
train
|
public byte[] getByteArrayValue(int index)
{
byte[] result = null;
if (m_array[index] != null)
{
result = (byte[]) m_array[index];
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1072
|
Props.getByte
|
train
|
public byte getByte(Integer type)
{
byte result = 0;
byte[] item = m_map.get(type);
if (item != null)
{
result = item[0];
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1073
|
Props.getTime
|
train
|
public Date getTime(Integer type)
{
Date result = null;
byte[] item = m_map.get(type);
if (item != null)
{
result = MPPUtility.getTime(item, 0);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1074
|
Props.getUnicodeString
|
train
|
public String getUnicodeString(Integer type)
{
String result = null;
byte[] item = m_map.get(type);
if (item != null)
{
result = MPPUtility.getUnicodeString(item, 0);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1075
|
JsonStreamWriter.writeStartObject
|
train
|
public void writeStartObject(String name) throws IOException
{
writeComma();
writeNewLineIndent();
if (name != null)
{
writeName(name);
writeNewLineIndent();
}
m_writer.write("{");
increaseIndent();
}
|
java
|
{
"resource": ""
}
|
q1076
|
JsonStreamWriter.writeStartList
|
train
|
public void writeStartList(String name) throws IOException
{
writeComma();
writeNewLineIndent();
writeName(name);
writeNewLineIndent();
m_writer.write("[");
increaseIndent();
}
|
java
|
{
"resource": ""
}
|
q1077
|
JsonStreamWriter.writeNameValuePair
|
train
|
public void writeNameValuePair(String name, String value) throws IOException
{
internalWriteNameValuePair(name, escapeString(value));
}
|
java
|
{
"resource": ""
}
|
q1078
|
JsonStreamWriter.writeNameValuePair
|
train
|
public void writeNameValuePair(String name, int value) throws IOException
{
internalWriteNameValuePair(name, Integer.toString(value));
}
|
java
|
{
"resource": ""
}
|
q1079
|
JsonStreamWriter.writeNameValuePair
|
train
|
public void writeNameValuePair(String name, long value) throws IOException
{
internalWriteNameValuePair(name, Long.toString(value));
}
|
java
|
{
"resource": ""
}
|
q1080
|
JsonStreamWriter.writeNameValuePair
|
train
|
public void writeNameValuePair(String name, double value) throws IOException
{
internalWriteNameValuePair(name, Double.toString(value));
}
|
java
|
{
"resource": ""
}
|
q1081
|
JsonStreamWriter.writeNameValuePair
|
train
|
public void writeNameValuePair(String name, Date value) throws IOException
{
internalWriteNameValuePair(name, m_format.format(value));
}
|
java
|
{
"resource": ""
}
|
q1082
|
JsonStreamWriter.internalWriteNameValuePair
|
train
|
private void internalWriteNameValuePair(String name, String value) throws IOException
{
writeComma();
writeNewLineIndent();
writeName(name);
if (m_pretty)
{
m_writer.write(' ');
}
m_writer.write(value);
}
|
java
|
{
"resource": ""
}
|
q1083
|
JsonStreamWriter.escapeString
|
train
|
private String escapeString(String value)
{
m_buffer.setLength(0);
m_buffer.append('"');
for (int index = 0; index < value.length(); index++)
{
char c = value.charAt(index);
switch (c)
{
case '"':
{
m_buffer.append("\\\"");
break;
}
case '\\':
{
m_buffer.append("\\\\");
break;
}
case '/':
{
m_buffer.append("\\/");
break;
}
case '\b':
{
m_buffer.append("\\b");
break;
}
case '\f':
{
m_buffer.append("\\f");
break;
}
case '\n':
{
m_buffer.append("\\n");
break;
}
case '\r':
{
m_buffer.append("\\r");
break;
}
case '\t':
{
m_buffer.append("\\t");
break;
}
default:
{
// Append if it's not a control character (0x00 to 0x1f)
if (c > 0x1f)
{
m_buffer.append(c);
}
break;
}
}
}
m_buffer.append('"');
return m_buffer.toString();
}
|
java
|
{
"resource": ""
}
|
q1084
|
JsonStreamWriter.writeComma
|
train
|
private void writeComma() throws IOException
{
if (m_firstNameValuePair.peek().booleanValue())
{
m_firstNameValuePair.pop();
m_firstNameValuePair.push(Boolean.FALSE);
}
else
{
m_writer.write(',');
}
}
|
java
|
{
"resource": ""
}
|
q1085
|
JsonStreamWriter.writeNewLineIndent
|
train
|
private void writeNewLineIndent() throws IOException
{
if (m_pretty)
{
if (!m_indent.isEmpty())
{
m_writer.write('\n');
m_writer.write(m_indent);
}
}
}
|
java
|
{
"resource": ""
}
|
q1086
|
JsonStreamWriter.writeName
|
train
|
private void writeName(String name) throws IOException
{
m_writer.write('"');
m_writer.write(name);
m_writer.write('"');
m_writer.write(":");
}
|
java
|
{
"resource": ""
}
|
q1087
|
JsonStreamWriter.decreaseIndent
|
train
|
private void decreaseIndent() throws IOException
{
if (m_pretty)
{
m_writer.write('\n');
m_indent = m_indent.substring(0, m_indent.length() - INDENT.length());
m_writer.write(m_indent);
}
m_firstNameValuePair.pop();
}
|
java
|
{
"resource": ""
}
|
q1088
|
AvailabilityFactory.process
|
train
|
public void process(AvailabilityTable table, byte[] data)
{
if (data != null)
{
Calendar cal = DateHelper.popCalendar();
int items = MPPUtility.getShort(data, 0);
int offset = 12;
for (int loop = 0; loop < items; loop++)
{
double unitsValue = MPPUtility.getDouble(data, offset + 4);
if (unitsValue != 0)
{
Date startDate = MPPUtility.getTimestampFromTenths(data, offset);
Date endDate = MPPUtility.getTimestampFromTenths(data, offset + 20);
cal.setTime(endDate);
cal.add(Calendar.MINUTE, -1);
endDate = cal.getTime();
Double units = NumberHelper.getDouble(unitsValue / 100);
Availability item = new Availability(startDate, endDate, units);
table.add(item);
}
offset += 20;
}
DateHelper.pushCalendar(cal);
Collections.sort(table);
}
}
|
java
|
{
"resource": ""
}
|
q1089
|
LocaleData.getObject
|
train
|
public static final Object getObject(Locale locale, String key)
{
ResourceBundle bundle = ResourceBundle.getBundle(LocaleData.class.getName(), locale);
return (bundle.getObject(key));
}
|
java
|
{
"resource": ""
}
|
q1090
|
LocaleData.getMap
|
train
|
@SuppressWarnings("rawtypes") public static final Map getMap(Locale locale, String key)
{
ResourceBundle bundle = ResourceBundle.getBundle(LocaleData.class.getName(), locale);
return ((Map) bundle.getObject(key));
}
|
java
|
{
"resource": ""
}
|
q1091
|
LocaleData.getInteger
|
train
|
public static final Integer getInteger(Locale locale, String key)
{
ResourceBundle bundle = ResourceBundle.getBundle(LocaleData.class.getName(), locale);
return ((Integer) bundle.getObject(key));
}
|
java
|
{
"resource": ""
}
|
q1092
|
LocaleData.getChar
|
train
|
public static final char getChar(Locale locale, String key)
{
ResourceBundle bundle = ResourceBundle.getBundle(LocaleData.class.getName(), locale);
return (bundle.getString(key).charAt(0));
}
|
java
|
{
"resource": ""
}
|
q1093
|
Resource.getOverAllocated
|
train
|
public boolean getOverAllocated()
{
Boolean overallocated = (Boolean) getCachedValue(ResourceField.OVERALLOCATED);
if (overallocated == null)
{
Number peakUnits = getPeakUnits();
Number maxUnits = getMaxUnits();
overallocated = Boolean.valueOf(NumberHelper.getDouble(peakUnits) > NumberHelper.getDouble(maxUnits));
set(ResourceField.OVERALLOCATED, overallocated);
}
return (overallocated.booleanValue());
}
|
java
|
{
"resource": ""
}
|
q1094
|
Resource.getStart
|
train
|
public Date getStart()
{
Date result = null;
for (ResourceAssignment assignment : m_assignments)
{
if (result == null || DateHelper.compare(result, assignment.getStart()) > 0)
{
result = assignment.getStart();
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1095
|
Resource.getWorkVariance
|
train
|
public Duration getWorkVariance()
{
Duration variance = (Duration) getCachedValue(ResourceField.WORK_VARIANCE);
if (variance == null)
{
Duration work = getWork();
Duration baselineWork = getBaselineWork();
if (work != null && baselineWork != null)
{
variance = Duration.getInstance(work.getDuration() - baselineWork.convertUnits(work.getUnits(), getParentFile().getProjectProperties()).getDuration(), work.getUnits());
set(ResourceField.WORK_VARIANCE, variance);
}
}
return (variance);
}
|
java
|
{
"resource": ""
}
|
q1096
|
Resource.getNotes
|
train
|
public String getNotes()
{
String notes = (String) getCachedValue(ResourceField.NOTES);
return (notes == null ? "" : notes);
}
|
java
|
{
"resource": ""
}
|
q1097
|
Resource.setResourceCalendar
|
train
|
public void setResourceCalendar(ProjectCalendar calendar)
{
set(ResourceField.CALENDAR, calendar);
if (calendar == null)
{
setResourceCalendarUniqueID(null);
}
else
{
calendar.setResource(this);
setResourceCalendarUniqueID(calendar.getUniqueID());
}
}
|
java
|
{
"resource": ""
}
|
q1098
|
Resource.addResourceCalendar
|
train
|
public ProjectCalendar addResourceCalendar() throws MPXJException
{
if (getResourceCalendar() != null)
{
throw new MPXJException(MPXJException.MAXIMUM_RECORDS);
}
ProjectCalendar calendar = new ProjectCalendar(getParentFile());
setResourceCalendar(calendar);
return calendar;
}
|
java
|
{
"resource": ""
}
|
q1099
|
Resource.setBaseCalendar
|
train
|
public void setBaseCalendar(String val)
{
set(ResourceField.BASE_CALENDAR, val == null || val.length() == 0 ? "Standard" : val);
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.