_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q600
|
StreamReader.readUnknownTable
|
train
|
public List<MapRow> readUnknownTable(int rowSize, int rowMagicNumber) throws IOException
{
TableReader reader = new UnknownTableReader(this, rowSize, rowMagicNumber);
reader.read();
return reader.getRows();
}
|
java
|
{
"resource": ""
}
|
q601
|
StreamReader.readTable
|
train
|
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
|
{
"resource": ""
}
|
q602
|
StreamReader.readTableConditional
|
train
|
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
|
{
"resource": ""
}
|
q603
|
StreamReader.readBytes
|
train
|
public ByteArray readBytes(int size) throws IOException
{
byte[] data = new byte[size];
m_stream.read(data);
return new ByteArray(data);
}
|
java
|
{
"resource": ""
}
|
q604
|
StreamReader.readBlocks
|
train
|
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
|
{
"resource": ""
}
|
q605
|
TurboProjectReader.readFile
|
train
|
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
|
{
"resource": ""
}
|
q606
|
TurboProjectReader.readCalendars
|
train
|
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
|
{
"resource": ""
}
|
q607
|
TurboProjectReader.addCalendarExceptions
|
train
|
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
|
{
"resource": ""
}
|
q608
|
TurboProjectReader.readResources
|
train
|
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
|
{
"resource": ""
}
|
q609
|
TurboProjectReader.readTasks
|
train
|
private void readTasks()
{
Integer rootID = Integer.valueOf(1);
readWBS(m_projectFile, rootID);
readTasks(rootID);
m_projectFile.getTasks().synchronizeTaskIDToHierarchy();
}
|
java
|
{
"resource": ""
}
|
q610
|
TurboProjectReader.readWBS
|
train
|
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
|
{
"resource": ""
}
|
q611
|
TurboProjectReader.readTasks
|
train
|
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
|
{
"resource": ""
}
|
q612
|
TurboProjectReader.readLeafTasks
|
train
|
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
|
{
"resource": ""
}
|
q613
|
TurboProjectReader.readTask
|
train
|
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
|
{
"resource": ""
}
|
q614
|
TurboProjectReader.readRelationships
|
train
|
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
|
{
"resource": ""
}
|
q615
|
TurboProjectReader.readResourceAssignments
|
train
|
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
|
{
"resource": ""
}
|
q616
|
TurboProjectReader.getTable
|
train
|
private Table getTable(String name)
{
Table table = m_tables.get(name);
if (table == null)
{
table = EMPTY_TABLE;
}
return table;
}
|
java
|
{
"resource": ""
}
|
q617
|
TurboProjectReader.applyAliases
|
train
|
private void applyAliases()
{
CustomFieldContainer fields = m_projectFile.getCustomFields();
for (Map.Entry<FieldType, String> entry : ALIASES.entrySet())
{
fields.getCustomField(entry.getKey()).setAlias(entry.getValue());
}
}
|
java
|
{
"resource": ""
}
|
q618
|
TurboProjectReader.defineField
|
train
|
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
|
{
"resource": ""
}
|
q619
|
ExtendedData.getString
|
train
|
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
|
{
"resource": ""
}
|
q620
|
ExtendedData.getInt
|
train
|
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
|
{
"resource": ""
}
|
q621
|
ExtendedData.getLong
|
train
|
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
|
{
"resource": ""
}
|
q622
|
ResourceAssignmentFactory.processHyperlinkData
|
train
|
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
|
{
"resource": ""
}
|
q623
|
ResourceAssignmentFactory.createTimephasedData
|
train
|
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
|
{
"resource": ""
}
|
q624
|
DatatypeConverter.printTimestamp
|
train
|
public static final String printTimestamp(Date value)
{
return (value == null ? null : TIMESTAMP_FORMAT.get().format(value));
}
|
java
|
{
"resource": ""
}
|
q625
|
DatatypeConverter.parseDuration
|
train
|
public static final Duration parseDuration(String value)
{
return value == null ? null : Duration.getInstance(Double.parseDouble(value), TimeUnit.DAYS);
}
|
java
|
{
"resource": ""
}
|
q626
|
DatatypeConverter.printDuration
|
train
|
public static final String printDuration(Duration value)
{
return value == null ? null : Double.toString(value.getDuration());
}
|
java
|
{
"resource": ""
}
|
q627
|
DatatypeConverter.printDate
|
train
|
public static final String printDate(Date value)
{
return (value == null ? null : DATE_FORMAT.get().format(value));
}
|
java
|
{
"resource": ""
}
|
q628
|
DatatypeConverter.parsePercent
|
train
|
public static final Double parsePercent(String value)
{
return value == null ? null : Double.valueOf(Double.parseDouble(value) * 100.0);
}
|
java
|
{
"resource": ""
}
|
q629
|
DatatypeConverter.printPercent
|
train
|
public static final String printPercent(Double value)
{
return value == null ? null : Double.toString(value.doubleValue() / 100.0);
}
|
java
|
{
"resource": ""
}
|
q630
|
PPVItemsType.getPPVItem
|
train
|
public List<PPVItemsType.PPVItem> getPPVItem()
{
if (ppvItem == null)
{
ppvItem = new ArrayList<PPVItemsType.PPVItem>();
}
return this.ppvItem;
}
|
java
|
{
"resource": ""
}
|
q631
|
CustomFieldContainer.getCustomField
|
train
|
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
|
{
"resource": ""
}
|
q632
|
CustomFieldContainer.registerAlias
|
train
|
void registerAlias(FieldType type, String alias)
{
m_aliasMap.put(new Pair<FieldTypeClass, String>(type.getFieldTypeClass(), alias), type);
}
|
java
|
{
"resource": ""
}
|
q633
|
CustomFieldContainer.getFieldByAlias
|
train
|
public FieldType getFieldByAlias(FieldTypeClass typeClass, String alias)
{
return m_aliasMap.get(new Pair<FieldTypeClass, String>(typeClass, alias));
}
|
java
|
{
"resource": ""
}
|
q634
|
FieldMap.createFieldMap
|
train
|
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
|
{
"resource": ""
}
|
q635
|
FieldMap.createTaskFieldMap
|
train
|
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
|
{
"resource": ""
}
|
q636
|
FieldMap.createRelationFieldMap
|
train
|
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
|
{
"resource": ""
}
|
q637
|
FieldMap.createEnterpriseCustomFieldMap
|
train
|
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
|
{
"resource": ""
}
|
q638
|
FieldMap.createResourceFieldMap
|
train
|
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
|
{
"resource": ""
}
|
q639
|
FieldMap.createAssignmentFieldMap
|
train
|
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
|
{
"resource": ""
}
|
q640
|
FieldMap.populateDefaultData
|
train
|
private void populateDefaultData(FieldItem[] defaultData)
{
for (FieldItem item : defaultData)
{
m_map.put(item.getType(), item);
}
}
|
java
|
{
"resource": ""
}
|
q641
|
FieldMap.populateContainer
|
train
|
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
|
{
"resource": ""
}
|
q642
|
FieldMap.getFixedDataOffset
|
train
|
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
|
{
"resource": ""
}
|
q643
|
FieldMap.getVarDataKey
|
train
|
public Integer getVarDataKey(FieldType type)
{
Integer result = null;
FieldItem item = m_map.get(type);
if (item != null)
{
result = item.getVarDataKey();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q644
|
FieldMap.getFieldTypeFromVarDataKey
|
train
|
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
|
{
"resource": ""
}
|
q645
|
FieldMap.getFieldLocation
|
train
|
public FieldLocation getFieldLocation(FieldType type)
{
FieldLocation result = null;
FieldItem item = m_map.get(type);
if (item != null)
{
result = item.getFieldLocation();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q646
|
FieldMap.getFieldData
|
train
|
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
|
{
"resource": ""
}
|
q647
|
FieldMap.dumpKnownFieldMaps
|
train
|
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
|
{
"resource": ""
}
|
q648
|
FieldMap.getFixedDataFieldSize
|
train
|
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
|
{
"resource": ""
}
|
q649
|
ProjectCalendarWeek.setParent
|
train
|
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
|
{
"resource": ""
}
|
q650
|
ProjectCalendarWeek.getHours
|
train
|
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
|
{
"resource": ""
}
|
q651
|
ProjectCalendarWeek.addDefaultCalendarHours
|
train
|
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
|
{
"resource": ""
}
|
q652
|
ProjectCalendarWeek.addCalendarHours
|
train
|
public ProjectCalendarHours addCalendarHours(Day day)
{
ProjectCalendarHours bch = new ProjectCalendarHours(this);
bch.setDay(day);
m_hours[day.getValue() - 1] = bch;
return (bch);
}
|
java
|
{
"resource": ""
}
|
q653
|
ProjectCalendarWeek.attachHoursToDay
|
train
|
public void attachHoursToDay(ProjectCalendarHours hours)
{
if (hours.getParentCalendar() != this)
{
throw new IllegalArgumentException();
}
m_hours[hours.getDay().getValue() - 1] = hours;
}
|
java
|
{
"resource": ""
}
|
q654
|
ProjectCalendarWeek.removeHoursFromDay
|
train
|
public void removeHoursFromDay(ProjectCalendarHours hours)
{
if (hours.getParentCalendar() != this)
{
throw new IllegalArgumentException();
}
m_hours[hours.getDay().getValue() - 1] = null;
}
|
java
|
{
"resource": ""
}
|
q655
|
ProjectCalendarWeek.setWorkingDay
|
train
|
public void setWorkingDay(Day day, boolean working)
{
setWorkingDay(day, (working ? DayType.WORKING : DayType.NON_WORKING));
}
|
java
|
{
"resource": ""
}
|
q656
|
ProjectCalendarWeek.setWorkingDay
|
train
|
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
|
{
"resource": ""
}
|
q657
|
GanttDesignerReader.readCalendar
|
train
|
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
|
{
"resource": ""
}
|
q658
|
GanttDesignerReader.processTasks
|
train
|
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
|
{
"resource": ""
}
|
q659
|
GanttDesignerReader.processPredecessors
|
train
|
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
|
{
"resource": ""
}
|
q660
|
GanttDesignerReader.processRemarks
|
train
|
private void processRemarks(Gantt gantt)
{
processRemarks(gantt.getRemarks());
processRemarks(gantt.getRemarks1());
processRemarks(gantt.getRemarks2());
processRemarks(gantt.getRemarks3());
processRemarks(gantt.getRemarks4());
}
|
java
|
{
"resource": ""
}
|
q661
|
GanttDesignerReader.processRemarks
|
train
|
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
|
{
"resource": ""
}
|
q662
|
GanttDesignerReader.getParentWBS
|
train
|
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
|
{
"resource": ""
}
|
q663
|
GanttDesignerReader.getParentTask
|
train
|
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
|
{
"resource": ""
}
|
q664
|
PoiTreeModel.getChildNodes
|
train
|
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
|
{
"resource": ""
}
|
q665
|
PoiTreeModel.fireTreeStructureChanged
|
train
|
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
|
{
"resource": ""
}
|
q666
|
ProjectCalendar.getMinutesPerDay
|
train
|
public int getMinutesPerDay()
{
return m_minutesPerDay == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerDay()) : m_minutesPerDay.intValue();
}
|
java
|
{
"resource": ""
}
|
q667
|
ProjectCalendar.getMinutesPerWeek
|
train
|
public int getMinutesPerWeek()
{
return m_minutesPerWeek == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerWeek()) : m_minutesPerWeek.intValue();
}
|
java
|
{
"resource": ""
}
|
q668
|
ProjectCalendar.getMinutesPerMonth
|
train
|
public int getMinutesPerMonth()
{
return m_minutesPerMonth == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerMonth()) : m_minutesPerMonth.intValue();
}
|
java
|
{
"resource": ""
}
|
q669
|
ProjectCalendar.getMinutesPerYear
|
train
|
public int getMinutesPerYear()
{
return m_minutesPerYear == null ? NumberHelper.getInt(getParentFile().getProjectProperties().getMinutesPerYear()) : m_minutesPerYear.intValue();
}
|
java
|
{
"resource": ""
}
|
q670
|
ProjectCalendar.addWorkWeek
|
train
|
public ProjectCalendarWeek addWorkWeek()
{
ProjectCalendarWeek week = new ProjectCalendarWeek();
week.setParent(this);
m_workWeeks.add(week);
m_weeksSorted = false;
clearWorkingDateCache();
return week;
}
|
java
|
{
"resource": ""
}
|
q671
|
ProjectCalendar.addCalendarException
|
train
|
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
|
{
"resource": ""
}
|
q672
|
ProjectCalendar.setParent
|
train
|
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
|
{
"resource": ""
}
|
q673
|
ProjectCalendar.isWorkingDay
|
train
|
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
|
{
"resource": ""
}
|
q674
|
ProjectCalendar.getDuration
|
train
|
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
|
{
"resource": ""
}
|
q675
|
ProjectCalendar.getStartTime
|
train
|
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
|
{
"resource": ""
}
|
q676
|
ProjectCalendar.getFinishTime
|
train
|
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
|
{
"resource": ""
}
|
q677
|
ProjectCalendar.updateToNextWorkStart
|
train
|
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
|
{
"resource": ""
}
|
q678
|
ProjectCalendar.getNextWorkStart
|
train
|
public Date getNextWorkStart(Date date)
{
Calendar cal = Calendar.getInstance();
cal.setTime(date);
updateToNextWorkStart(cal);
return cal.getTime();
}
|
java
|
{
"resource": ""
}
|
q679
|
ProjectCalendar.getPreviousWorkFinish
|
train
|
public Date getPreviousWorkFinish(Date date)
{
Calendar cal = Calendar.getInstance();
cal.setTime(date);
updateToPreviousWorkFinish(cal);
return cal.getTime();
}
|
java
|
{
"resource": ""
}
|
q680
|
ProjectCalendar.isWorkingDate
|
train
|
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
|
{
"resource": ""
}
|
q681
|
ProjectCalendar.isWorkingDate
|
train
|
private boolean isWorkingDate(Date date, Day day)
{
ProjectCalendarDateRanges ranges = getRanges(date, null, day);
return ranges.getRangeCount() != 0;
}
|
java
|
{
"resource": ""
}
|
q682
|
ProjectCalendar.getDaysInRange
|
train
|
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
|
{
"resource": ""
}
|
q683
|
ProjectCalendar.setUniqueID
|
train
|
@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
|
{
"resource": ""
}
|
q684
|
ProjectCalendar.setResource
|
train
|
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
|
{
"resource": ""
}
|
q685
|
ProjectCalendar.getException
|
train
|
public ProjectCalendarException getException(Date date)
{
ProjectCalendarException exception = null;
// We're working with expanded exceptions, which includes any recurring exceptions
// expanded into individual entries.
populateExpandedExceptions();
if (!m_expandedExceptions.isEmpty())
{
sortExceptions();
int low = 0;
int high = m_expandedExceptions.size() - 1;
long targetDate = date.getTime();
while (low <= high)
{
int mid = (low + high) >>> 1;
ProjectCalendarException midVal = m_expandedExceptions.get(mid);
int cmp = 0 - DateHelper.compare(midVal.getFromDate(), midVal.getToDate(), targetDate);
if (cmp < 0)
{
low = mid + 1;
}
else
{
if (cmp > 0)
{
high = mid - 1;
}
else
{
exception = midVal;
break;
}
}
}
}
if (exception == null && getParent() != null)
{
// Check base calendar as well for an exception.
exception = getParent().getException(date);
}
return (exception);
}
|
java
|
{
"resource": ""
}
|
q686
|
ProjectCalendar.getWorkWeek
|
train
|
public ProjectCalendarWeek getWorkWeek(Date date)
{
ProjectCalendarWeek week = null;
if (!m_workWeeks.isEmpty())
{
sortWorkWeeks();
int low = 0;
int high = m_workWeeks.size() - 1;
long targetDate = date.getTime();
while (low <= high)
{
int mid = (low + high) >>> 1;
ProjectCalendarWeek midVal = m_workWeeks.get(mid);
int cmp = 0 - DateHelper.compare(midVal.getDateRange().getStart(), midVal.getDateRange().getEnd(), targetDate);
if (cmp < 0)
{
low = mid + 1;
}
else
{
if (cmp > 0)
{
high = mid - 1;
}
else
{
week = midVal;
break;
}
}
}
}
if (week == null && getParent() != null)
{
// Check base calendar as well for a work week.
week = getParent().getWorkWeek(date);
}
return (week);
}
|
java
|
{
"resource": ""
}
|
q687
|
ProjectCalendar.getWork
|
train
|
public Duration getWork(Date date, TimeUnit format)
{
ProjectCalendarDateRanges ranges = getRanges(date, null, null);
long time = getTotalTime(ranges);
return convertFormat(time, format);
}
|
java
|
{
"resource": ""
}
|
q688
|
ProjectCalendar.getWork
|
train
|
public Duration getWork(Date startDate, Date endDate, TimeUnit format)
{
DateRange range = new DateRange(startDate, endDate);
Long cachedResult = m_workingDateCache.get(range);
long totalTime = 0;
if (cachedResult == null)
{
//
// We want the start date to be the earliest date, and the end date
// to be the latest date. Set a flag here to indicate if we have swapped
// the order of the supplied date.
//
boolean invert = false;
if (startDate.getTime() > endDate.getTime())
{
invert = true;
Date temp = startDate;
startDate = endDate;
endDate = temp;
}
Date canonicalStartDate = DateHelper.getDayStartDate(startDate);
Date canonicalEndDate = DateHelper.getDayStartDate(endDate);
if (canonicalStartDate.getTime() == canonicalEndDate.getTime())
{
ProjectCalendarDateRanges ranges = getRanges(startDate, null, null);
if (ranges.getRangeCount() != 0)
{
totalTime = getTotalTime(ranges, startDate, endDate);
}
}
else
{
//
// Find the first working day in the range
//
Date currentDate = startDate;
Calendar cal = Calendar.getInstance();
cal.setTime(startDate);
Day day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
while (isWorkingDate(currentDate, day) == false && currentDate.getTime() < canonicalEndDate.getTime())
{
cal.add(Calendar.DAY_OF_YEAR, 1);
currentDate = cal.getTime();
day = day.getNextDay();
}
if (currentDate.getTime() < canonicalEndDate.getTime())
{
//
// Calculate the amount of working time for this day
//
totalTime += getTotalTime(getRanges(currentDate, null, day), currentDate, true);
//
// Process each working day until we reach the last day
//
while (true)
{
cal.add(Calendar.DAY_OF_YEAR, 1);
currentDate = cal.getTime();
day = day.getNextDay();
//
// We have reached the last day
//
if (currentDate.getTime() >= canonicalEndDate.getTime())
{
break;
}
//
// Skip this day if it has no working time
//
ProjectCalendarDateRanges ranges = getRanges(currentDate, null, day);
if (ranges.getRangeCount() == 0)
{
continue;
}
//
// Add the working time for the whole day
//
totalTime += getTotalTime(ranges);
}
}
//
// We are now at the last day
//
ProjectCalendarDateRanges ranges = getRanges(endDate, null, day);
if (ranges.getRangeCount() != 0)
{
totalTime += getTotalTime(ranges, DateHelper.getDayStartDate(endDate), endDate);
}
}
if (invert)
{
totalTime = -totalTime;
}
m_workingDateCache.put(range, Long.valueOf(totalTime));
}
else
{
totalTime = cachedResult.longValue();
}
return convertFormat(totalTime, format);
}
|
java
|
{
"resource": ""
}
|
q689
|
ProjectCalendar.convertFormat
|
train
|
private Duration convertFormat(long totalTime, TimeUnit format)
{
double duration = totalTime;
switch (format)
{
case MINUTES:
case ELAPSED_MINUTES:
{
duration /= (60 * 1000);
break;
}
case HOURS:
case ELAPSED_HOURS:
{
duration /= (60 * 60 * 1000);
break;
}
case DAYS:
{
double minutesPerDay = getMinutesPerDay();
if (minutesPerDay != 0)
{
duration /= (minutesPerDay * 60 * 1000);
}
else
{
duration = 0;
}
break;
}
case WEEKS:
{
double minutesPerWeek = getMinutesPerWeek();
if (minutesPerWeek != 0)
{
duration /= (minutesPerWeek * 60 * 1000);
}
else
{
duration = 0;
}
break;
}
case MONTHS:
{
double daysPerMonth = getParentFile().getProjectProperties().getDaysPerMonth().doubleValue();
double minutesPerDay = getMinutesPerDay();
if (daysPerMonth != 0 && minutesPerDay != 0)
{
duration /= (daysPerMonth * minutesPerDay * 60 * 1000);
}
else
{
duration = 0;
}
break;
}
case ELAPSED_DAYS:
{
duration /= (24 * 60 * 60 * 1000);
break;
}
case ELAPSED_WEEKS:
{
duration /= (7 * 24 * 60 * 60 * 1000);
break;
}
case ELAPSED_MONTHS:
{
duration /= (30 * 24 * 60 * 60 * 1000);
break;
}
default:
{
throw new IllegalArgumentException("TimeUnit " + format + " not supported");
}
}
return (Duration.getInstance(duration, format));
}
|
java
|
{
"resource": ""
}
|
q690
|
ProjectCalendar.getTotalTime
|
train
|
private long getTotalTime(ProjectCalendarDateRanges exception, Date date, boolean after)
{
long currentTime = DateHelper.getCanonicalTime(date).getTime();
long total = 0;
for (DateRange range : exception)
{
total += getTime(range.getStart(), range.getEnd(), currentTime, after);
}
return (total);
}
|
java
|
{
"resource": ""
}
|
q691
|
ProjectCalendar.getTotalTime
|
train
|
private long getTotalTime(ProjectCalendarDateRanges exception)
{
long total = 0;
for (DateRange range : exception)
{
total += getTime(range.getStart(), range.getEnd());
}
return (total);
}
|
java
|
{
"resource": ""
}
|
q692
|
ProjectCalendar.getTotalTime
|
train
|
private long getTotalTime(ProjectCalendarDateRanges hours, Date startDate, Date endDate)
{
long total = 0;
if (startDate.getTime() != endDate.getTime())
{
Date start = DateHelper.getCanonicalTime(startDate);
Date end = DateHelper.getCanonicalTime(endDate);
for (DateRange range : hours)
{
Date rangeStart = range.getStart();
Date rangeEnd = range.getEnd();
if (rangeStart != null && rangeEnd != null)
{
Date canoncialRangeStart = DateHelper.getCanonicalTime(rangeStart);
Date canonicalRangeEnd = DateHelper.getCanonicalTime(rangeEnd);
Date startDay = DateHelper.getDayStartDate(rangeStart);
Date finishDay = DateHelper.getDayStartDate(rangeEnd);
//
// 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.getTime() != finishDay.getTime())
{
canonicalRangeEnd = DateHelper.addDays(canonicalRangeEnd, 1);
}
if (canoncialRangeStart.getTime() == canonicalRangeEnd.getTime() && rangeEnd.getTime() > rangeStart.getTime())
{
total += (24 * 60 * 60 * 1000);
}
else
{
total += getTime(start, end, canoncialRangeStart, canonicalRangeEnd);
}
}
}
}
return (total);
}
|
java
|
{
"resource": ""
}
|
q693
|
ProjectCalendar.getTime
|
train
|
private long getTime(Date start, Date end, long target, boolean after)
{
long total = 0;
if (start != null && end != null)
{
Date startTime = DateHelper.getCanonicalTime(start);
Date endTime = DateHelper.getCanonicalTime(end);
Date startDay = DateHelper.getDayStartDate(start);
Date finishDay = DateHelper.getDayStartDate(end);
//
// 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.getTime() != finishDay.getTime())
{
endTime = DateHelper.addDays(endTime, 1);
}
int diff = DateHelper.compare(startTime, endTime, target);
if (diff == 0)
{
if (after == true)
{
total = (endTime.getTime() - target);
}
else
{
total = (target - startTime.getTime());
}
}
else
{
if ((after == true && diff < 0) || (after == false && diff > 0))
{
total = (endTime.getTime() - startTime.getTime());
}
}
}
return (total);
}
|
java
|
{
"resource": ""
}
|
q694
|
ProjectCalendar.getTime
|
train
|
private long getTime(Date start, Date end)
{
long total = 0;
if (start != null && end != null)
{
Date startTime = DateHelper.getCanonicalTime(start);
Date endTime = DateHelper.getCanonicalTime(end);
Date startDay = DateHelper.getDayStartDate(start);
Date finishDay = DateHelper.getDayStartDate(end);
//
// 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.getTime() != finishDay.getTime())
{
endTime = DateHelper.addDays(endTime, 1);
}
total = (endTime.getTime() - startTime.getTime());
}
return (total);
}
|
java
|
{
"resource": ""
}
|
q695
|
ProjectCalendar.getTime
|
train
|
private long getTime(Date start1, Date end1, Date start2, Date end2)
{
long total = 0;
if (start1 != null && end1 != null && start2 != null && end2 != null)
{
long start;
long end;
if (start1.getTime() < start2.getTime())
{
start = start2.getTime();
}
else
{
start = start1.getTime();
}
if (end1.getTime() < end2.getTime())
{
end = end1.getTime();
}
else
{
end = end2.getTime();
}
if (start < end)
{
total = end - start;
}
}
return (total);
}
|
java
|
{
"resource": ""
}
|
q696
|
ProjectCalendar.copy
|
train
|
public void copy(ProjectCalendar cal)
{
setName(cal.getName());
setParent(cal.getParent());
System.arraycopy(cal.getDays(), 0, getDays(), 0, getDays().length);
for (ProjectCalendarException ex : cal.m_exceptions)
{
addCalendarException(ex.getFromDate(), ex.getToDate());
for (DateRange range : ex)
{
ex.addRange(new DateRange(range.getStart(), range.getEnd()));
}
}
for (ProjectCalendarHours hours : getHours())
{
if (hours != null)
{
ProjectCalendarHours copyHours = cal.addCalendarHours(hours.getDay());
for (DateRange range : hours)
{
copyHours.addRange(new DateRange(range.getStart(), range.getEnd()));
}
}
}
}
|
java
|
{
"resource": ""
}
|
q697
|
ProjectCalendar.clearWorkingDateCache
|
train
|
private void clearWorkingDateCache()
{
m_workingDateCache.clear();
m_startTimeCache.clear();
m_getDateLastResult = null;
for (ProjectCalendar calendar : m_derivedCalendars)
{
calendar.clearWorkingDateCache();
}
}
|
java
|
{
"resource": ""
}
|
q698
|
ProjectCalendar.getRanges
|
train
|
private ProjectCalendarDateRanges getRanges(Date date, Calendar cal, Day day)
{
ProjectCalendarDateRanges ranges = getException(date);
if (ranges == null)
{
ProjectCalendarWeek week = getWorkWeek(date);
if (week == null)
{
week = this;
}
if (day == null)
{
if (cal == null)
{
cal = Calendar.getInstance();
cal.setTime(date);
}
day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
}
ranges = week.getHours(day);
}
return ranges;
}
|
java
|
{
"resource": ""
}
|
q699
|
ProjectCalendar.populateExpandedExceptions
|
train
|
private void populateExpandedExceptions()
{
if (!m_exceptions.isEmpty() && m_expandedExceptions.isEmpty())
{
for (ProjectCalendarException exception : m_exceptions)
{
RecurringData recurring = exception.getRecurring();
if (recurring == null)
{
m_expandedExceptions.add(exception);
}
else
{
for (Date date : recurring.getDates())
{
Date startDate = DateHelper.getDayStartDate(date);
Date endDate = DateHelper.getDayEndDate(date);
ProjectCalendarException newException = new ProjectCalendarException(startDate, endDate);
int rangeCount = exception.getRangeCount();
for (int rangeIndex = 0; rangeIndex < rangeCount; rangeIndex++)
{
newException.addRange(exception.getRange(rangeIndex));
}
m_expandedExceptions.add(newException);
}
}
}
Collections.sort(m_expandedExceptions);
}
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.