code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private SynchroTable readTableHeader(byte[] header)
{
SynchroTable result = null;
String tableName = DatatypeConverter.getSimpleString(header, 0);
if (!tableName.isEmpty())
{
int offset = DatatypeConverter.getInt(header, 40);
result = new SynchroTable(tableName, offset);
}
return result;
} | java |
private void readTableData(List<SynchroTable> tables, InputStream is) throws IOException
{
for (SynchroTable table : tables)
{
if (REQUIRED_TABLES.contains(table.getName()))
{
readTable(is, table);
}
}
} | java |
private void readTable(InputStream is, SynchroTable table) throws IOException
{
int skip = table.getOffset() - m_offset;
if (skip != 0)
{
StreamHelper.skip(is, skip);
m_offset += skip;
}
String tableName = DatatypeConverter.getString(is);
int tableNameLength = 2 + tableName.length();
m_offset += tableNameLength;
int dataLength;
if (table.getLength() == -1)
{
dataLength = is.available();
}
else
{
dataLength = table.getLength() - tableNameLength;
}
SynchroLogger.log("READ", tableName);
byte[] compressedTableData = new byte[dataLength];
is.read(compressedTableData);
m_offset += dataLength;
Inflater inflater = new Inflater();
inflater.setInput(compressedTableData);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream(compressedTableData.length);
byte[] buffer = new byte[1024];
while (!inflater.finished())
{
int count;
try
{
count = inflater.inflate(buffer);
}
catch (DataFormatException ex)
{
throw new IOException(ex);
}
outputStream.write(buffer, 0, count);
}
outputStream.close();
byte[] uncompressedTableData = outputStream.toByteArray();
SynchroLogger.log(uncompressedTableData);
m_tableData.put(table.getName(), uncompressedTableData);
} | java |
private void readHeader(InputStream is) throws IOException
{
byte[] header = new byte[20];
is.read(header);
m_offset += 20;
SynchroLogger.log("HEADER", header);
} | java |
private void readVersion(InputStream is) throws IOException
{
BytesReadInputStream bytesReadStream = new BytesReadInputStream(is);
String version = DatatypeConverter.getString(bytesReadStream);
m_offset += bytesReadStream.getBytesRead();
SynchroLogger.log("VERSION", version);
String[] versionArray = version.split("\\.");
m_majorVersion = Integer.parseInt(versionArray[0]);
} | java |
public List<ProjectFile> readAll() throws MPXJException
{
Map<Integer, String> projects = listProjects();
List<ProjectFile> result = new ArrayList<ProjectFile>(projects.keySet().size());
for (Integer id : projects.keySet())
{
setProjectID(id.intValue());
result.add(read());
}
return result;
} | java |
private void processAnalytics() throws SQLException
{
allocateConnection();
try
{
DatabaseMetaData meta = m_connection.getMetaData();
String productName = meta.getDatabaseProductName();
if (productName == null || productName.isEmpty())
{
productName = "DATABASE";
}
else
{
productName = productName.toUpperCase();
}
ProjectProperties properties = m_reader.getProject().getProjectProperties();
properties.setFileApplication("Primavera");
properties.setFileType(productName);
}
finally
{
releaseConnection();
}
} | java |
private void processSchedulingProjectProperties() throws SQLException
{
List<Row> rows = getRows("select * from " + m_schema + "projprop where proj_id=? and prop_name='scheduling'", m_projectID);
if (!rows.isEmpty())
{
Row row = rows.get(0);
Record record = Record.getRecord(row.getString("prop_value"));
if (record != null)
{
String[] keyValues = record.getValue().split("\\|");
for (int i = 0; i < keyValues.length - 1; ++i)
{
if ("sched_calendar_on_relationship_lag".equals(keyValues[i]))
{
Map<String, Object> customProperties = new HashMap<String, Object>();
customProperties.put("LagCalendar", keyValues[i + 1]);
m_reader.getProject().getProjectProperties().setCustomProperties(customProperties);
break;
}
}
}
}
} | java |
private void processDefaultCurrency(Integer currencyID) throws SQLException
{
List<Row> rows = getRows("select * from " + m_schema + "currtype where curr_id=?", currencyID);
if (!rows.isEmpty())
{
Row row = rows.get(0);
m_reader.processDefaultCurrency(row);
}
} | java |
public void setSchema(String schema)
{
if (schema == null)
{
schema = "";
}
else
{
if (!schema.isEmpty() && !schema.endsWith("."))
{
schema = schema + '.';
}
}
m_schema = schema;
} | java |
public void applyPattern(String primaryPattern, String[] alternativePatterns, char decimalSeparator, char groupingSeparator)
{
m_symbols.setDecimalSeparator(decimalSeparator);
m_symbols.setGroupingSeparator(groupingSeparator);
setDecimalFormatSymbols(m_symbols);
applyPattern(primaryPattern);
if (alternativePatterns != null && alternativePatterns.length != 0)
{
int loop;
if (m_alternativeFormats == null || m_alternativeFormats.length != alternativePatterns.length)
{
m_alternativeFormats = new DecimalFormat[alternativePatterns.length];
for (loop = 0; loop < alternativePatterns.length; loop++)
{
m_alternativeFormats[loop] = new DecimalFormat();
}
}
for (loop = 0; loop < alternativePatterns.length; loop++)
{
m_alternativeFormats[loop].setDecimalFormatSymbols(m_symbols);
m_alternativeFormats[loop].applyPattern(alternativePatterns[loop]);
}
}
} | java |
private String getResourceField(int key)
{
String result = null;
if (key > 0 && key < m_resourceNames.length)
{
result = m_resourceNames[key];
}
return (result);
} | java |
private int getResourceCode(String field) throws MPXJException
{
Integer result = m_resourceNumbers.get(field);
if (result == null)
{
throw new MPXJException(MPXJException.INVALID_RESOURCE_FIELD_NAME + " " + field);
}
return (result.intValue());
} | java |
public FieldType getField()
{
FieldType result = null;
if (m_index < m_fields.length)
{
result = m_fields[m_index++];
}
return result;
} | java |
public List<MapRow> readTable(TableReader reader) throws IOException
{
reader.read();
return reader.getRows();
} | java |
public List<MapRow> readUnknownTable(int rowSize, int rowMagicNumber) throws IOException
{
TableReader reader = new UnknownTableReader(this, rowSize, rowMagicNumber);
reader.read();
return reader.getRows();
} | java |
public List<MapRow> readTable(Class<? extends TableReader> readerClass) throws IOException
{
TableReader reader;
try
{
reader = readerClass.getConstructor(StreamReader.class).newInstance(this);
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
return readTable(reader);
} | java |
public List<MapRow> readTableConditional(Class<? extends TableReader> readerClass) throws IOException
{
List<MapRow> result;
if (DatatypeConverter.getBoolean(m_stream))
{
result = readTable(readerClass);
}
else
{
result = Collections.emptyList();
}
return result;
} | java |
public ByteArray readBytes(int size) throws IOException
{
byte[] data = new byte[size];
m_stream.read(data);
return new ByteArray(data);
} | java |
public List<MapRow> readBlocks(Class<? extends BlockReader> readerClass) throws IOException
{
BlockReader reader;
try
{
reader = readerClass.getConstructor(StreamReader.class).newInstance(this);
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
return reader.read();
} | java |
private void readFile(InputStream is) throws IOException
{
StreamHelper.skip(is, 64);
int index = 64;
ArrayList<Integer> offsetList = new ArrayList<Integer>();
List<String> nameList = new ArrayList<String>();
while (true)
{
byte[] table = new byte[32];
is.read(table);
index += 32;
int offset = PEPUtility.getInt(table, 0);
offsetList.add(Integer.valueOf(offset));
if (offset == 0)
{
break;
}
nameList.add(PEPUtility.getString(table, 5).toUpperCase());
}
StreamHelper.skip(is, offsetList.get(0).intValue() - index);
for (int offsetIndex = 1; offsetIndex < offsetList.size() - 1; offsetIndex++)
{
String name = nameList.get(offsetIndex - 1);
Class<? extends Table> tableClass = TABLE_CLASSES.get(name);
if (tableClass == null)
{
tableClass = Table.class;
}
Table table;
try
{
table = tableClass.newInstance();
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
m_tables.put(name, table);
table.read(is);
}
} | java |
private void readCalendars()
{
//
// Create the calendars
//
for (MapRow row : getTable("NCALTAB"))
{
ProjectCalendar calendar = m_projectFile.addCalendar();
calendar.setUniqueID(row.getInteger("UNIQUE_ID"));
calendar.setName(row.getString("NAME"));
calendar.setWorkingDay(Day.SUNDAY, row.getBoolean("SUNDAY"));
calendar.setWorkingDay(Day.MONDAY, row.getBoolean("MONDAY"));
calendar.setWorkingDay(Day.TUESDAY, row.getBoolean("TUESDAY"));
calendar.setWorkingDay(Day.WEDNESDAY, row.getBoolean("WEDNESDAY"));
calendar.setWorkingDay(Day.THURSDAY, row.getBoolean("THURSDAY"));
calendar.setWorkingDay(Day.FRIDAY, row.getBoolean("FRIDAY"));
calendar.setWorkingDay(Day.SATURDAY, row.getBoolean("SATURDAY"));
for (Day day : Day.values())
{
if (calendar.isWorkingDay(day))
{
// TODO: this is an approximation
calendar.addDefaultCalendarHours(day);
}
}
}
//
// Set up the hierarchy and add exceptions
//
Table exceptionsTable = getTable("CALXTAB");
for (MapRow row : getTable("NCALTAB"))
{
ProjectCalendar child = m_projectFile.getCalendarByUniqueID(row.getInteger("UNIQUE_ID"));
ProjectCalendar parent = m_projectFile.getCalendarByUniqueID(row.getInteger("BASE_CALENDAR_ID"));
if (child != null && parent != null)
{
child.setParent(parent);
}
addCalendarExceptions(exceptionsTable, child, row.getInteger("FIRST_CALENDAR_EXCEPTION_ID"));
m_eventManager.fireCalendarReadEvent(child);
}
} | java |
private void addCalendarExceptions(Table table, ProjectCalendar calendar, Integer exceptionID)
{
Integer currentExceptionID = exceptionID;
while (true)
{
MapRow row = table.find(currentExceptionID);
if (row == null)
{
break;
}
Date date = row.getDate("DATE");
ProjectCalendarException exception = calendar.addCalendarException(date, date);
if (row.getBoolean("WORKING"))
{
exception.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
exception.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
}
currentExceptionID = row.getInteger("NEXT_CALENDAR_EXCEPTION_ID");
}
} | java |
private void readResources()
{
for (MapRow row : getTable("RTAB"))
{
Resource resource = m_projectFile.addResource();
setFields(RESOURCE_FIELDS, row, resource);
m_eventManager.fireResourceReadEvent(resource);
// TODO: Correctly handle calendar
}
} | java |
private void readTasks()
{
Integer rootID = Integer.valueOf(1);
readWBS(m_projectFile, rootID);
readTasks(rootID);
m_projectFile.getTasks().synchronizeTaskIDToHierarchy();
} | java |
private void readWBS(ChildTaskContainer parent, Integer id)
{
Integer currentID = id;
Table table = getTable("WBSTAB");
while (currentID.intValue() != 0)
{
MapRow row = table.find(currentID);
Integer taskID = row.getInteger("TASK_ID");
Task task = readTask(parent, taskID);
Integer childID = row.getInteger("CHILD_ID");
if (childID.intValue() != 0)
{
readWBS(task, childID);
}
currentID = row.getInteger("NEXT_ID");
}
} | java |
private void readTasks(Integer id)
{
Integer currentID = id;
Table table = getTable("WBSTAB");
while (currentID.intValue() != 0)
{
MapRow row = table.find(currentID);
Task task = m_projectFile.getTaskByUniqueID(row.getInteger("TASK_ID"));
readLeafTasks(task, row.getInteger("FIRST_CHILD_TASK_ID"));
Integer childID = row.getInteger("CHILD_ID");
if (childID.intValue() != 0)
{
readTasks(childID);
}
currentID = row.getInteger("NEXT_ID");
}
} | java |
private void readLeafTasks(Task parent, Integer id)
{
Integer currentID = id;
Table table = getTable("A1TAB");
while (currentID.intValue() != 0)
{
if (m_projectFile.getTaskByUniqueID(currentID) == null)
{
readTask(parent, currentID);
}
currentID = table.find(currentID).getInteger("NEXT_TASK_ID");
}
} | java |
private Task readTask(ChildTaskContainer parent, Integer id)
{
Table a0 = getTable("A0TAB");
Table a1 = getTable("A1TAB");
Table a2 = getTable("A2TAB");
Table a3 = getTable("A3TAB");
Table a4 = getTable("A4TAB");
Task task = parent.addTask();
MapRow a1Row = a1.find(id);
MapRow a2Row = a2.find(id);
setFields(A0TAB_FIELDS, a0.find(id), task);
setFields(A1TAB_FIELDS, a1Row, task);
setFields(A2TAB_FIELDS, a2Row, task);
setFields(A3TAB_FIELDS, a3.find(id), task);
setFields(A5TAB_FIELDS, a4.find(id), task);
task.setStart(task.getEarlyStart());
task.setFinish(task.getEarlyFinish());
if (task.getName() == null)
{
task.setName(task.getText(1));
}
m_eventManager.fireTaskReadEvent(task);
return task;
} | java |
private void readRelationships()
{
for (MapRow row : getTable("CONTAB"))
{
Task task1 = m_projectFile.getTaskByUniqueID(row.getInteger("TASK_ID_1"));
Task task2 = m_projectFile.getTaskByUniqueID(row.getInteger("TASK_ID_2"));
if (task1 != null && task2 != null)
{
RelationType type = row.getRelationType("TYPE");
Duration lag = row.getDuration("LAG");
Relation relation = task2.addPredecessor(task1, type, lag);
m_eventManager.fireRelationReadEvent(relation);
}
}
} | java |
private void readResourceAssignments()
{
for (MapRow row : getTable("USGTAB"))
{
Task task = m_projectFile.getTaskByUniqueID(row.getInteger("TASK_ID"));
Resource resource = m_projectFile.getResourceByUniqueID(row.getInteger("RESOURCE_ID"));
if (task != null && resource != null)
{
ResourceAssignment assignment = task.addResourceAssignment(resource);
m_eventManager.fireAssignmentReadEvent(assignment);
}
}
} | java |
private Table getTable(String name)
{
Table table = m_tables.get(name);
if (table == null)
{
table = EMPTY_TABLE;
}
return table;
} | java |
private void applyAliases()
{
CustomFieldContainer fields = m_projectFile.getCustomFields();
for (Map.Entry<FieldType, String> entry : ALIASES.entrySet())
{
fields.getCustomField(entry.getKey()).setAlias(entry.getValue());
}
} | java |
private static void defineField(Map<String, FieldType> container, String name, FieldType type, String alias)
{
container.put(name, type);
if (alias != null)
{
ALIASES.put(type, alias);
}
} | java |
public String getString(Integer type)
{
String result = null;
byte[] item = m_map.get(type);
if (item != null)
{
result = m_data.getString(getOffset(item));
}
return (result);
} | java |
public int getInt(Integer type)
{
int result = 0;
byte[] item = m_map.get(type);
if (item != null)
{
result = MPPUtility.getInt(item, 0);
}
return (result);
} | java |
public long getLong(Integer type)
{
long result = 0;
byte[] item = m_map.get(type);
if (item != null)
{
result = MPPUtility.getLong6(item, 0);
}
return (result);
} | java |
private void processHyperlinkData(ResourceAssignment assignment, byte[] data)
{
if (data != null)
{
int offset = 12;
offset += 12;
String hyperlink = MPPUtility.getUnicodeString(data, offset);
offset += ((hyperlink.length() + 1) * 2);
offset += 12;
String address = MPPUtility.getUnicodeString(data, offset);
offset += ((address.length() + 1) * 2);
offset += 12;
String subaddress = MPPUtility.getUnicodeString(data, offset);
offset += ((subaddress.length() + 1) * 2);
offset += 12;
String screentip = MPPUtility.getUnicodeString(data, offset);
assignment.setHyperlink(hyperlink);
assignment.setHyperlinkAddress(address);
assignment.setHyperlinkSubAddress(subaddress);
assignment.setHyperlinkScreenTip(screentip);
}
} | java |
private void createTimephasedData(ProjectFile file, ResourceAssignment assignment, List<TimephasedWork> timephasedPlanned, List<TimephasedWork> timephasedComplete)
{
if (timephasedPlanned.isEmpty() && timephasedComplete.isEmpty())
{
Duration totalMinutes = assignment.getWork().convertUnits(TimeUnit.MINUTES, file.getProjectProperties());
Duration workPerDay;
if (assignment.getResource() == null || assignment.getResource().getType() == ResourceType.WORK)
{
workPerDay = totalMinutes.getDuration() == 0 ? totalMinutes : ResourceAssignmentFactory.DEFAULT_NORMALIZER_WORK_PER_DAY;
int units = NumberHelper.getInt(assignment.getUnits());
if (units != 100)
{
workPerDay = Duration.getInstance((workPerDay.getDuration() * units) / 100.0, workPerDay.getUnits());
}
}
else
{
if (assignment.getVariableRateUnits() == null)
{
Duration workingDays = assignment.getCalendar().getWork(assignment.getStart(), assignment.getFinish(), TimeUnit.DAYS);
double units = NumberHelper.getDouble(assignment.getUnits());
double unitsPerDayAsMinutes = (units * 60) / (workingDays.getDuration() * 100);
workPerDay = Duration.getInstance(unitsPerDayAsMinutes, TimeUnit.MINUTES);
}
else
{
double unitsPerHour = NumberHelper.getDouble(assignment.getUnits());
workPerDay = ResourceAssignmentFactory.DEFAULT_NORMALIZER_WORK_PER_DAY;
Duration hoursPerDay = workPerDay.convertUnits(TimeUnit.HOURS, file.getProjectProperties());
double unitsPerDayAsHours = (unitsPerHour * hoursPerDay.getDuration()) / 100;
double unitsPerDayAsMinutes = unitsPerDayAsHours * 60;
workPerDay = Duration.getInstance(unitsPerDayAsMinutes, TimeUnit.MINUTES);
}
}
Duration overtimeWork = assignment.getOvertimeWork();
if (overtimeWork != null && overtimeWork.getDuration() != 0)
{
Duration totalOvertimeMinutes = overtimeWork.convertUnits(TimeUnit.MINUTES, file.getProjectProperties());
totalMinutes = Duration.getInstance(totalMinutes.getDuration() - totalOvertimeMinutes.getDuration(), TimeUnit.MINUTES);
}
TimephasedWork tra = new TimephasedWork();
tra.setStart(assignment.getStart());
tra.setAmountPerDay(workPerDay);
tra.setModified(false);
tra.setFinish(assignment.getFinish());
tra.setTotalAmount(totalMinutes);
timephasedPlanned.add(tra);
}
} | java |
public static final String printTimestamp(Date value)
{
return (value == null ? null : TIMESTAMP_FORMAT.get().format(value));
} | java |
public static final Duration parseDuration(String value)
{
return value == null ? null : Duration.getInstance(Double.parseDouble(value), TimeUnit.DAYS);
} | java |
public static final String printDuration(Duration value)
{
return value == null ? null : Double.toString(value.getDuration());
} | java |
public static final String printDate(Date value)
{
return (value == null ? null : DATE_FORMAT.get().format(value));
} | java |
public static final Double parsePercent(String value)
{
return value == null ? null : Double.valueOf(Double.parseDouble(value) * 100.0);
} | java |
public static final String printPercent(Double value)
{
return value == null ? null : Double.toString(value.doubleValue() / 100.0);
} | java |
public List<PPVItemsType.PPVItem> getPPVItem()
{
if (ppvItem == null)
{
ppvItem = new ArrayList<PPVItemsType.PPVItem>();
}
return this.ppvItem;
} | java |
public CustomField getCustomField(FieldType field)
{
CustomField result = m_configMap.get(field);
if (result == null)
{
result = new CustomField(field, this);
m_configMap.put(field, result);
}
return result;
} | java |
void registerAlias(FieldType type, String alias)
{
m_aliasMap.put(new Pair<FieldTypeClass, String>(type.getFieldTypeClass(), alias), type);
} | java |
public FieldType getFieldByAlias(FieldTypeClass typeClass, String alias)
{
return m_aliasMap.get(new Pair<FieldTypeClass, String>(typeClass, alias));
} | java |
private void createFieldMap(byte[] data)
{
int index = 0;
int lastDataBlockOffset = 0;
int dataBlockIndex = 0;
while (index < data.length)
{
long mask = MPPUtility.getInt(data, index + 0);
//mask = mask << 4;
int dataBlockOffset = MPPUtility.getShort(data, index + 4);
//int metaFlags = MPPUtility.getByte(data, index + 8);
FieldType type = getFieldType(MPPUtility.getInt(data, index + 12));
int category = MPPUtility.getShort(data, index + 20);
//int sizeInBytes = MPPUtility.getShort(data, index + 22);
//int metaIndex = MPPUtility.getInt(data, index + 24);
//
// Categories
//
// 02 - Short values [RATE_UNITS, WORKGROUP, ACCRUE, TIME_UNITS, PRIORITY, TASK_TYPE, CONSTRAINT, ACCRUE, PERCENTAGE, SHORT, WORK_UNITS] - BOOKING_TYPE, EARNED_VALUE_METHOD, DELIVERABLE_TYPE, RESOURCE_REQUEST_TYPE - we have as string in MPXJ????
// 03 - Int values [DURATION, INTEGER] - Recalc outline codes as Boolean?
// 05 - Rate, Number [RATE, NUMERIC]
// 08 - String (and some durations!!!) [STRING, DURATION]
// 0B - Boolean (meta block 0?) - [BOOLEAN]
// 13 - Date - [DATE]
// 48 - GUID - [GUID]
// 64 - Boolean (meta block 1?)- [BOOLEAN]
// 65 - Work, Currency [WORK, CURRENCY]
// 66 - Units [UNITS]
// 1D - Raw bytes [BINARY, ASCII_STRING] - Exception: outline code indexes, they are integers, but stored as part of a binary block
int varDataKey;
if (useTypeAsVarDataKey())
{
Integer substitute = substituteVarDataKey(type);
if (substitute == null)
{
varDataKey = (MPPUtility.getInt(data, index + 12) & 0x0000FFFF);
}
else
{
varDataKey = substitute.intValue();
}
}
else
{
varDataKey = MPPUtility.getByte(data, index + 6);
}
FieldLocation location;
int metaBlock;
switch (category)
{
case 0x0B:
{
location = FieldLocation.META_DATA;
metaBlock = 0;
break;
}
case 0x64:
{
location = FieldLocation.META_DATA;
metaBlock = 1;
break;
}
default:
{
metaBlock = 0;
if (dataBlockOffset != 65535)
{
location = FieldLocation.FIXED_DATA;
if (dataBlockOffset < lastDataBlockOffset)
{
++dataBlockIndex;
}
lastDataBlockOffset = dataBlockOffset;
int typeSize = getFixedDataFieldSize(type);
if (dataBlockOffset + typeSize > m_maxFixedDataSize[dataBlockIndex])
{
m_maxFixedDataSize[dataBlockIndex] = dataBlockOffset + typeSize;
}
}
else
{
if (varDataKey != 0)
{
location = FieldLocation.VAR_DATA;
}
else
{
location = FieldLocation.UNKNOWN;
}
}
break;
}
}
FieldItem item = new FieldItem(type, location, dataBlockIndex, dataBlockOffset, varDataKey, mask, metaBlock);
if (m_debug)
{
System.out.println(ByteArrayHelper.hexdump(data, index, 28, false) + " " + item + " mpxjDataType=" + item.getType().getDataType() + " index=" + index);
}
m_map.put(type, item);
index += 28;
}
} | java |
public void createTaskFieldMap(Props props)
{
byte[] fieldMapData = null;
for (Integer key : TASK_KEYS)
{
fieldMapData = props.getByteArray(key);
if (fieldMapData != null)
{
break;
}
}
if (fieldMapData == null)
{
populateDefaultData(getDefaultTaskData());
}
else
{
createFieldMap(fieldMapData);
}
} | java |
public void createRelationFieldMap(Props props)
{
byte[] fieldMapData = null;
for (Integer key : RELATION_KEYS)
{
fieldMapData = props.getByteArray(key);
if (fieldMapData != null)
{
break;
}
}
if (fieldMapData == null)
{
populateDefaultData(getDefaultRelationData());
}
else
{
createFieldMap(fieldMapData);
}
} | java |
public void createEnterpriseCustomFieldMap(Props props, Class<?> c)
{
byte[] fieldMapData = null;
for (Integer key : ENTERPRISE_CUSTOM_KEYS)
{
fieldMapData = props.getByteArray(key);
if (fieldMapData != null)
{
break;
}
}
if (fieldMapData != null)
{
int index = 4;
while (index < fieldMapData.length)
{
//Looks like the custom fields have varying types, it may be that the last byte of the four represents the type?
//System.out.println(ByteArrayHelper.hexdump(fieldMapData, index, 4, false));
int typeValue = MPPUtility.getInt(fieldMapData, index);
FieldType type = getFieldType(typeValue);
if (type != null && type.getClass() == c && type.toString().startsWith("Enterprise Custom Field"))
{
int varDataKey = (typeValue & 0xFFFF);
FieldItem item = new FieldItem(type, FieldLocation.VAR_DATA, 0, 0, varDataKey, 0, 0);
m_map.put(type, item);
//System.out.println(item);
}
//System.out.println((type == null ? "?" : type.getClass().getSimpleName() + "." + type) + " " + Integer.toHexString(typeValue));
index += 4;
}
}
} | java |
public void createResourceFieldMap(Props props)
{
byte[] fieldMapData = null;
for (Integer key : RESOURCE_KEYS)
{
fieldMapData = props.getByteArray(key);
if (fieldMapData != null)
{
break;
}
}
if (fieldMapData == null)
{
populateDefaultData(getDefaultResourceData());
}
else
{
createFieldMap(fieldMapData);
}
} | java |
public void createAssignmentFieldMap(Props props)
{
//System.out.println("ASSIGN");
byte[] fieldMapData = null;
for (Integer key : ASSIGNMENT_KEYS)
{
fieldMapData = props.getByteArray(key);
if (fieldMapData != null)
{
break;
}
}
if (fieldMapData == null)
{
populateDefaultData(getDefaultAssignmentData());
}
else
{
createFieldMap(fieldMapData);
}
} | java |
private void populateDefaultData(FieldItem[] defaultData)
{
for (FieldItem item : defaultData)
{
m_map.put(item.getType(), item);
}
} | java |
public void populateContainer(Class<? extends FieldType> type, FieldContainer container, Integer id, byte[][] fixedData, Var2Data varData)
{
//System.out.println(container.getClass().getSimpleName()+": " + id);
for (FieldItem item : m_map.values())
{
if (item.getType().getClass().equals(type))
{
//System.out.println(item.m_type);
Object value = item.read(id, fixedData, varData);
//System.out.println(item.m_type.getClass().getSimpleName() + "." + item.m_type + ": " + value);
container.set(item.getType(), value);
}
}
} | java |
public int getFixedDataOffset(FieldType type)
{
int result;
FieldItem item = m_map.get(type);
if (item != null)
{
result = item.getFixedDataOffset();
}
else
{
result = -1;
}
return result;
} | java |
public Integer getVarDataKey(FieldType type)
{
Integer result = null;
FieldItem item = m_map.get(type);
if (item != null)
{
result = item.getVarDataKey();
}
return result;
} | java |
public FieldType getFieldTypeFromVarDataKey(Integer key)
{
FieldType result = null;
for (Entry<FieldType, FieldMap.FieldItem> entry : m_map.entrySet())
{
if (entry.getValue().getFieldLocation() == FieldLocation.VAR_DATA && entry.getValue().getVarDataKey().equals(key))
{
result = entry.getKey();
break;
}
}
return result;
} | java |
public FieldLocation getFieldLocation(FieldType type)
{
FieldLocation result = null;
FieldItem item = m_map.get(type);
if (item != null)
{
result = item.getFieldLocation();
}
return result;
} | java |
protected Object getFieldData(Integer id, FieldType type, byte[][] fixedData, Var2Data varData)
{
Object result = null;
FieldItem item = m_map.get(type);
if (item != null)
{
result = item.read(id, fixedData, varData);
}
return result;
} | java |
public void dumpKnownFieldMaps(Props props)
{
//for (int key=131092; key < 131098; key++)
for (int key = 50331668; key < 50331674; key++)
{
byte[] fieldMapData = props.getByteArray(Integer.valueOf(key));
if (fieldMapData != null)
{
System.out.println("KEY: " + key);
createFieldMap(fieldMapData);
System.out.println(toString());
clear();
}
}
} | java |
private int getFixedDataFieldSize(FieldType type)
{
int result = 0;
DataType dataType = type.getDataType();
if (dataType != null)
{
switch (dataType)
{
case DATE:
case INTEGER:
case DURATION:
{
result = 4;
break;
}
case TIME_UNITS:
case CONSTRAINT:
case PRIORITY:
case PERCENTAGE:
case TASK_TYPE:
case ACCRUE:
case SHORT:
case BOOLEAN:
case DELAY:
case WORKGROUP:
case RATE_UNITS:
case EARNED_VALUE_METHOD:
case RESOURCE_REQUEST_TYPE:
{
result = 2;
break;
}
case CURRENCY:
case UNITS:
case RATE:
case WORK:
{
result = 8;
break;
}
case WORK_UNITS:
{
result = 1;
break;
}
case GUID:
{
result = 16;
break;
}
default:
{
result = 0;
break;
}
}
}
return result;
} | java |
void setParent(ProjectCalendarWeek parent)
{
m_parent = parent;
for (int loop = 0; loop < m_days.length; loop++)
{
if (m_days[loop] == null)
{
m_days[loop] = DayType.DEFAULT;
}
}
} | java |
public ProjectCalendarHours getHours(Day day)
{
ProjectCalendarHours result = getCalendarHours(day);
if (result == null)
{
//
// If this is a base calendar and we have no hours, then we
// have a problem - so we add the default hours and try again
//
if (m_parent == null)
{
// Only add default hours for the day that is 'missing' to avoid overwriting real calendar hours
addDefaultCalendarHours(day);
result = getCalendarHours(day);
}
else
{
result = m_parent.getHours(day);
}
}
return result;
} | java |
public void addDefaultCalendarHours(Day day)
{
ProjectCalendarHours hours = addCalendarHours(day);
if (day != Day.SATURDAY && day != Day.SUNDAY)
{
hours.addRange(DEFAULT_WORKING_MORNING);
hours.addRange(DEFAULT_WORKING_AFTERNOON);
}
} | java |
public ProjectCalendarHours addCalendarHours(Day day)
{
ProjectCalendarHours bch = new ProjectCalendarHours(this);
bch.setDay(day);
m_hours[day.getValue() - 1] = bch;
return (bch);
} | java |
public void attachHoursToDay(ProjectCalendarHours hours)
{
if (hours.getParentCalendar() != this)
{
throw new IllegalArgumentException();
}
m_hours[hours.getDay().getValue() - 1] = hours;
} | java |
public void removeHoursFromDay(ProjectCalendarHours hours)
{
if (hours.getParentCalendar() != this)
{
throw new IllegalArgumentException();
}
m_hours[hours.getDay().getValue() - 1] = null;
} | java |
public void setWorkingDay(Day day, boolean working)
{
setWorkingDay(day, (working ? DayType.WORKING : DayType.NON_WORKING));
} | java |
public void setWorkingDay(Day day, DayType working)
{
DayType value;
if (working == null)
{
if (isDerived())
{
value = DayType.DEFAULT;
}
else
{
value = DayType.WORKING;
}
}
else
{
value = working;
}
m_days[day.getValue() - 1] = value;
} | java |
private void readCalendar(Gantt gantt)
{
Gantt.Calendar ganttCalendar = gantt.getCalendar();
m_projectFile.getProjectProperties().setWeekStartDay(ganttCalendar.getWeekStart());
ProjectCalendar calendar = m_projectFile.addCalendar();
calendar.setName("Standard");
m_projectFile.setDefaultCalendar(calendar);
String workingDays = ganttCalendar.getWorkDays();
calendar.setWorkingDay(Day.SUNDAY, workingDays.charAt(0) == '1');
calendar.setWorkingDay(Day.MONDAY, workingDays.charAt(1) == '1');
calendar.setWorkingDay(Day.TUESDAY, workingDays.charAt(2) == '1');
calendar.setWorkingDay(Day.WEDNESDAY, workingDays.charAt(3) == '1');
calendar.setWorkingDay(Day.THURSDAY, workingDays.charAt(4) == '1');
calendar.setWorkingDay(Day.FRIDAY, workingDays.charAt(5) == '1');
calendar.setWorkingDay(Day.SATURDAY, workingDays.charAt(6) == '1');
for (int i = 1; i <= 7; i++)
{
Day day = Day.getInstance(i);
ProjectCalendarHours hours = calendar.addCalendarHours(day);
if (calendar.isWorkingDay(day))
{
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
}
}
for (Gantt.Holidays.Holiday holiday : gantt.getHolidays().getHoliday())
{
ProjectCalendarException exception = calendar.addCalendarException(holiday.getDate(), holiday.getDate());
exception.setName(holiday.getContent());
}
} | java |
private void processTasks(Gantt gantt)
{
ProjectCalendar calendar = m_projectFile.getDefaultCalendar();
for (Gantt.Tasks.Task ganttTask : gantt.getTasks().getTask())
{
String wbs = ganttTask.getID();
ChildTaskContainer parentTask = getParentTask(wbs);
Task task = parentTask.addTask();
//ganttTask.getB() // bar type
//ganttTask.getBC() // bar color
task.setCost(ganttTask.getC());
task.setName(ganttTask.getContent());
task.setDuration(ganttTask.getD());
task.setDeadline(ganttTask.getDL());
//ganttTask.getH() // height
//ganttTask.getIn(); // indent
task.setWBS(wbs);
task.setPercentageComplete(ganttTask.getPC());
task.setStart(ganttTask.getS());
//ganttTask.getU(); // Unknown
//ganttTask.getVA(); // Valign
task.setFinish(calendar.getDate(task.getStart(), task.getDuration(), false));
m_taskMap.put(wbs, task);
}
} | java |
private void processPredecessors(Gantt gantt)
{
for (Gantt.Tasks.Task ganttTask : gantt.getTasks().getTask())
{
String predecessors = ganttTask.getP();
if (predecessors != null && !predecessors.isEmpty())
{
String wbs = ganttTask.getID();
Task task = m_taskMap.get(wbs);
for (String predecessor : predecessors.split(";"))
{
Task predecessorTask = m_projectFile.getTaskByID(Integer.valueOf(predecessor));
task.addPredecessor(predecessorTask, RelationType.FINISH_START, ganttTask.getL());
}
}
}
} | java |
private void processRemarks(Gantt gantt)
{
processRemarks(gantt.getRemarks());
processRemarks(gantt.getRemarks1());
processRemarks(gantt.getRemarks2());
processRemarks(gantt.getRemarks3());
processRemarks(gantt.getRemarks4());
} | java |
private void processRemarks(GanttDesignerRemark remark)
{
for (GanttDesignerRemark.Task remarkTask : remark.getTask())
{
Integer id = remarkTask.getRow();
Task task = m_projectFile.getTaskByID(id);
String notes = task.getNotes();
if (notes.isEmpty())
{
notes = remarkTask.getContent();
}
else
{
notes = notes + '\n' + remarkTask.getContent();
}
task.setNotes(notes);
}
} | java |
private String getParentWBS(String wbs)
{
String result;
int index = wbs.lastIndexOf('.');
if (index == -1)
{
result = null;
}
else
{
result = wbs.substring(0, index);
}
return result;
} | java |
private ChildTaskContainer getParentTask(String wbs)
{
ChildTaskContainer result;
String parentWbs = getParentWBS(wbs);
if (parentWbs == null)
{
result = m_projectFile;
}
else
{
result = m_taskMap.get(parentWbs);
}
return result;
} | java |
private List<Entry> getChildNodes(DirectoryEntry parent)
{
List<Entry> result = new ArrayList<Entry>();
Iterator<Entry> entries = parent.getEntries();
while (entries.hasNext())
{
result.add(entries.next());
}
return result;
} | java |
private void fireTreeStructureChanged()
{
// Guaranteed to return a non-null array
Object[] listeners = m_listenerList.getListenerList();
TreeModelEvent e = null;
// Process the listeners last to first, notifying
// those that are interested in this event
for (int i = listeners.length - 2; i >= 0; i -= 2)
{
if (listeners[i] == TreeModelListener.class)
{
// Lazily create the event:
if (e == null)
{
e = new TreeModelEvent(getRoot(), new Object[]
{
getRoot()
}, null, null);
}
((TreeModelListener) listeners[i + 1]).treeStructureChanged(e);
}
}
} | java |
public int getMinutesPerDay()
{
return m_minutesPerDay == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerDay()) : m_minutesPerDay.intValue();
} | java |
public int getMinutesPerWeek()
{
return m_minutesPerWeek == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerWeek()) : m_minutesPerWeek.intValue();
} | java |
public int getMinutesPerMonth()
{
return m_minutesPerMonth == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerMonth()) : m_minutesPerMonth.intValue();
} | java |
public int getMinutesPerYear()
{
return m_minutesPerYear == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerYear()) : m_minutesPerYear.intValue();
} | java |
public ProjectCalendarWeek addWorkWeek()
{
ProjectCalendarWeek week = new ProjectCalendarWeek();
week.setParent(this);
m_workWeeks.add(week);
m_weeksSorted = false;
clearWorkingDateCache();
return week;
} | java |
public ProjectCalendarException addCalendarException(Date fromDate, Date toDate)
{
ProjectCalendarException bce = new ProjectCalendarException(fromDate, toDate);
m_exceptions.add(bce);
m_expandedExceptions.clear();
m_exceptionsSorted = false;
clearWorkingDateCache();
return bce;
} | java |
public void setParent(ProjectCalendar calendar)
{
// I've seen a malformed MSPDI file which sets the parent calendar to itself.
// Silently ignore this here.
if (calendar != this)
{
if (getParent() != null)
{
getParent().removeDerivedCalendar(this);
}
super.setParent(calendar);
if (calendar != null)
{
calendar.addDerivedCalendar(this);
}
clearWorkingDateCache();
}
} | java |
public boolean isWorkingDay(Day day)
{
DayType value = getWorkingDay(day);
boolean result;
if (value == DayType.DEFAULT)
{
ProjectCalendar cal = getParent();
if (cal != null)
{
result = cal.isWorkingDay(day);
}
else
{
result = (day != Day.SATURDAY && day != Day.SUNDAY);
}
}
else
{
result = (value == DayType.WORKING);
}
return (result);
} | java |
public Duration getDuration(Date startDate, Date endDate)
{
Calendar cal = DateHelper.popCalendar(startDate);
int days = getDaysInRange(startDate, endDate);
int duration = 0;
Day day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
while (days > 0)
{
if (isWorkingDate(cal.getTime(), day) == true)
{
++duration;
}
--days;
day = day.getNextDay();
cal.set(Calendar.DAY_OF_YEAR, cal.get(Calendar.DAY_OF_YEAR) + 1);
}
DateHelper.pushCalendar(cal);
return (Duration.getInstance(duration, TimeUnit.DAYS));
} | java |
public Date getStartTime(Date date)
{
Date result = m_startTimeCache.get(date);
if (result == null)
{
ProjectCalendarDateRanges ranges = getRanges(date, null, null);
if (ranges == null)
{
result = getParentFile().getProjectProperties().getDefaultStartTime();
}
else
{
result = ranges.getRange(0).getStart();
}
result = DateHelper.getCanonicalTime(result);
m_startTimeCache.put(new Date(date.getTime()), result);
}
return result;
} | java |
public Date getFinishTime(Date date)
{
Date result = null;
if (date != null)
{
ProjectCalendarDateRanges ranges = getRanges(date, null, null);
if (ranges == null)
{
result = getParentFile().getProjectProperties().getDefaultEndTime();
result = DateHelper.getCanonicalTime(result);
}
else
{
Date rangeStart = result = ranges.getRange(0).getStart();
Date rangeFinish = ranges.getRange(ranges.getRangeCount() - 1).getEnd();
Date startDay = DateHelper.getDayStartDate(rangeStart);
Date finishDay = DateHelper.getDayStartDate(rangeFinish);
result = DateHelper.getCanonicalTime(rangeFinish);
//
// Handle the case where the end of the range is at midnight -
// this will show up as the start and end days not matching
//
if (startDay != null && finishDay != null && startDay.getTime() != finishDay.getTime())
{
result = DateHelper.addDays(result, 1);
}
}
}
return result;
} | java |
private void updateToNextWorkStart(Calendar cal)
{
Date originalDate = cal.getTime();
//
// Find the date ranges for the current day
//
ProjectCalendarDateRanges ranges = getRanges(originalDate, cal, null);
if (ranges != null)
{
//
// Do we have a start time today?
//
Date calTime = DateHelper.getCanonicalTime(cal.getTime());
Date startTime = null;
for (DateRange range : ranges)
{
Date rangeStart = DateHelper.getCanonicalTime(range.getStart());
Date rangeEnd = DateHelper.getCanonicalTime(range.getEnd());
Date rangeStartDay = DateHelper.getDayStartDate(range.getStart());
Date rangeEndDay = DateHelper.getDayStartDate(range.getEnd());
if (rangeStartDay.getTime() != rangeEndDay.getTime())
{
rangeEnd = DateHelper.addDays(rangeEnd, 1);
}
if (calTime.getTime() < rangeEnd.getTime())
{
if (calTime.getTime() > rangeStart.getTime())
{
startTime = calTime;
}
else
{
startTime = rangeStart;
}
break;
}
}
//
// If we don't have a start time today - find the next working day
// then retrieve the start time.
//
if (startTime == null)
{
Day day;
int nonWorkingDayCount = 0;
do
{
cal.set(Calendar.DAY_OF_YEAR, cal.get(Calendar.DAY_OF_YEAR) + 1);
day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
++nonWorkingDayCount;
if (nonWorkingDayCount > MAX_NONWORKING_DAYS)
{
cal.setTime(originalDate);
break;
}
}
while (!isWorkingDate(cal.getTime(), day));
startTime = getStartTime(cal.getTime());
}
DateHelper.setTime(cal, startTime);
}
} | java |
public Date getNextWorkStart(Date date)
{
Calendar cal = Calendar.getInstance();
cal.setTime(date);
updateToNextWorkStart(cal);
return cal.getTime();
} | java |
public Date getPreviousWorkFinish(Date date)
{
Calendar cal = Calendar.getInstance();
cal.setTime(date);
updateToPreviousWorkFinish(cal);
return cal.getTime();
} | java |
public boolean isWorkingDate(Date date)
{
Calendar cal = DateHelper.popCalendar(date);
Day day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
DateHelper.pushCalendar(cal);
return isWorkingDate(date, day);
} | java |
private boolean isWorkingDate(Date date, Day day)
{
ProjectCalendarDateRanges ranges = getRanges(date, null, day);
return ranges.getRangeCount() != 0;
} | java |
private int getDaysInRange(Date startDate, Date endDate)
{
int result;
Calendar cal = DateHelper.popCalendar(endDate);
int endDateYear = cal.get(Calendar.YEAR);
int endDateDayOfYear = cal.get(Calendar.DAY_OF_YEAR);
cal.setTime(startDate);
if (endDateYear == cal.get(Calendar.YEAR))
{
result = (endDateDayOfYear - cal.get(Calendar.DAY_OF_YEAR)) + 1;
}
else
{
result = 0;
do
{
result += (cal.getActualMaximum(Calendar.DAY_OF_YEAR) - cal.get(Calendar.DAY_OF_YEAR)) + 1;
cal.roll(Calendar.YEAR, 1);
cal.set(Calendar.DAY_OF_YEAR, 1);
}
while (cal.get(Calendar.YEAR) < endDateYear);
result += endDateDayOfYear;
}
DateHelper.pushCalendar(cal);
return result;
} | java |
@Override public void setUniqueID(Integer uniqueID)
{
ProjectFile parent = getParentFile();
if (m_uniqueID != null)
{
parent.getCalendars().unmapUniqueID(m_uniqueID);
}
parent.getCalendars().mapUniqueID(uniqueID, this);
m_uniqueID = uniqueID;
} | java |
public void setResource(Resource resource)
{
m_resource = resource;
String name = m_resource.getName();
if (name == null || name.length() == 0)
{
name = "Unnamed Resource";
}
setName(name);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.