_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q900
|
AstaReader.processConstraints
|
train
|
private void processConstraints(Row row, Task task)
{
ConstraintType constraintType = ConstraintType.AS_SOON_AS_POSSIBLE;
Date constraintDate = null;
switch (row.getInt("CONSTRAINU"))
{
case 0:
{
if (row.getInt("PLACEMENT") == 0)
{
constraintType = ConstraintType.AS_SOON_AS_POSSIBLE;
}
else
{
constraintType = ConstraintType.AS_LATE_AS_POSSIBLE;
}
break;
}
case 1:
{
constraintType = ConstraintType.MUST_START_ON;
constraintDate = row.getDate("START_CONSTRAINT_DATE");
break;
}
case 2:
{
constraintType = ConstraintType.START_NO_LATER_THAN;
constraintDate = row.getDate("START_CONSTRAINT_DATE");
break;
}
case 3:
{
constraintType = ConstraintType.START_NO_EARLIER_THAN;
constraintDate = row.getDate("START_CONSTRAINT_DATE");
break;
}
case 4:
{
constraintType = ConstraintType.MUST_FINISH_ON;
constraintDate = row.getDate("END_CONSTRAINT_DATE");
break;
}
case 5:
{
constraintType = ConstraintType.FINISH_NO_LATER_THAN;
constraintDate = row.getDate("END_CONSTRAINT_DATE");
break;
}
case 6:
{
constraintType = ConstraintType.FINISH_NO_EARLIER_THAN;
constraintDate = row.getDate("END_CONSTRAINT_DATE");
break;
}
case 8:
{
task.setDeadline(row.getDate("END_CONSTRAINT_DATE"));
break;
}
}
task.setConstraintType(constraintType);
task.setConstraintDate(constraintDate);
}
|
java
|
{
"resource": ""
}
|
q901
|
AstaReader.createWorkPatternMap
|
train
|
public Map<Integer, Row> createWorkPatternMap(List<Row> rows)
{
Map<Integer, Row> map = new HashMap<Integer, Row>();
for (Row row : rows)
{
map.put(row.getInteger("WORK_PATTERNID"), row);
}
return map;
}
|
java
|
{
"resource": ""
}
|
q902
|
AstaReader.createWorkPatternAssignmentMap
|
train
|
public Map<Integer, List<Row>> createWorkPatternAssignmentMap(List<Row> rows)
{
Map<Integer, List<Row>> map = new HashMap<Integer, List<Row>>();
for (Row row : rows)
{
Integer calendarID = row.getInteger("WORK_PATTERN_ASSIGNMENTID");
List<Row> list = map.get(calendarID);
if (list == null)
{
list = new LinkedList<Row>();
map.put(calendarID, list);
}
list.add(row);
}
return map;
}
|
java
|
{
"resource": ""
}
|
q903
|
AstaReader.createTimeEntryMap
|
train
|
public Map<Integer, List<Row>> createTimeEntryMap(List<Row> rows)
{
Map<Integer, List<Row>> map = new HashMap<Integer, List<Row>>();
for (Row row : rows)
{
Integer workPatternID = row.getInteger("TIME_ENTRYID");
List<Row> list = map.get(workPatternID);
if (list == null)
{
list = new LinkedList<Row>();
map.put(workPatternID, list);
}
list.add(row);
}
return map;
}
|
java
|
{
"resource": ""
}
|
q904
|
AstaReader.processCalendar
|
train
|
public void processCalendar(Row calendarRow, Map<Integer, Row> workPatternMap, Map<Integer, List<Row>> workPatternAssignmentMap, Map<Integer, List<Row>> exceptionAssignmentMap, Map<Integer, List<Row>> timeEntryMap, Map<Integer, DayType> exceptionTypeMap)
{
//
// Create the calendar and add the default working hours
//
ProjectCalendar calendar = m_project.addCalendar();
Integer dominantWorkPatternID = calendarRow.getInteger("DOMINANT_WORK_PATTERN");
calendar.setUniqueID(calendarRow.getInteger("CALENDARID"));
processWorkPattern(calendar, dominantWorkPatternID, workPatternMap, timeEntryMap, exceptionTypeMap);
calendar.setName(calendarRow.getString("NAMK"));
//
// Add any additional working weeks
//
List<Row> rows = workPatternAssignmentMap.get(calendar.getUniqueID());
if (rows != null)
{
for (Row row : rows)
{
Integer workPatternID = row.getInteger("WORK_PATTERN");
if (!workPatternID.equals(dominantWorkPatternID))
{
ProjectCalendarWeek week = calendar.addWorkWeek();
week.setDateRange(new DateRange(row.getDate("START_DATE"), row.getDate("END_DATE")));
processWorkPattern(week, workPatternID, workPatternMap, timeEntryMap, exceptionTypeMap);
}
}
}
//
// Add exceptions - not sure how exceptions which turn non-working days into working days are handled by Asta - if at all?
//
rows = exceptionAssignmentMap.get(calendar.getUniqueID());
if (rows != null)
{
for (Row row : rows)
{
Date startDate = row.getDate("STARU_DATE");
Date endDate = row.getDate("ENE_DATE");
calendar.addCalendarException(startDate, endDate);
}
}
m_eventManager.fireCalendarReadEvent(calendar);
}
|
java
|
{
"resource": ""
}
|
q905
|
AstaReader.processWorkPattern
|
train
|
private void processWorkPattern(ProjectCalendarWeek week, Integer workPatternID, Map<Integer, Row> workPatternMap, Map<Integer, List<Row>> timeEntryMap, Map<Integer, DayType> exceptionTypeMap)
{
Row workPatternRow = workPatternMap.get(workPatternID);
if (workPatternRow != null)
{
week.setName(workPatternRow.getString("NAMN"));
List<Row> timeEntryRows = timeEntryMap.get(workPatternID);
if (timeEntryRows != null)
{
long lastEndTime = Long.MIN_VALUE;
Day currentDay = Day.SUNDAY;
ProjectCalendarHours hours = week.addCalendarHours(currentDay);
Arrays.fill(week.getDays(), DayType.NON_WORKING);
for (Row row : timeEntryRows)
{
Date startTime = row.getDate("START_TIME");
Date endTime = row.getDate("END_TIME");
if (startTime == null)
{
startTime = DateHelper.getDayStartDate(new Date(0));
}
if (endTime == null)
{
endTime = DateHelper.getDayEndDate(new Date(0));
}
if (startTime.getTime() > endTime.getTime())
{
endTime = DateHelper.addDays(endTime, 1);
}
if (startTime.getTime() < lastEndTime)
{
currentDay = currentDay.getNextDay();
hours = week.addCalendarHours(currentDay);
}
DayType type = exceptionTypeMap.get(row.getInteger("EXCEPTIOP"));
if (type == DayType.WORKING)
{
hours.addRange(new DateRange(startTime, endTime));
week.setWorkingDay(currentDay, DayType.WORKING);
}
lastEndTime = endTime.getTime();
}
}
}
}
|
java
|
{
"resource": ""
}
|
q906
|
AstaReader.getNotes
|
train
|
private String getNotes(Row row)
{
String notes = row.getString("NOTET");
if (notes != null)
{
if (notes.isEmpty())
{
notes = null;
}
else
{
if (notes.indexOf(LINE_BREAK) != -1)
{
notes = notes.replace(LINE_BREAK, "\n");
}
}
}
return notes;
}
|
java
|
{
"resource": ""
}
|
q907
|
AstaFileReader.addListeners
|
train
|
private void addListeners(ProjectReader reader)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
reader.addProjectListener(listener);
}
}
}
|
java
|
{
"resource": ""
}
|
q908
|
AstaFileReader.readTextFile
|
train
|
private ProjectFile readTextFile(InputStream inputStream) throws MPXJException
{
ProjectReader reader = new AstaTextFileReader();
addListeners(reader);
return reader.read(inputStream);
}
|
java
|
{
"resource": ""
}
|
q909
|
AstaFileReader.readDatabaseFile
|
train
|
private ProjectFile readDatabaseFile(InputStream inputStream) throws MPXJException
{
ProjectReader reader = new AstaDatabaseFileReader();
addListeners(reader);
return reader.read(inputStream);
}
|
java
|
{
"resource": ""
}
|
q910
|
MPPReader.getFileFormat
|
train
|
public static String getFileFormat(POIFSFileSystem fs) throws IOException
{
String fileFormat = "";
DirectoryEntry root = fs.getRoot();
if (root.getEntryNames().contains("\1CompObj"))
{
CompObj compObj = new CompObj(new DocumentInputStream((DocumentEntry) root.getEntry("\1CompObj")));
fileFormat = compObj.getFileFormat();
}
return fileFormat;
}
|
java
|
{
"resource": ""
}
|
q911
|
MPPReader.read
|
train
|
public ProjectFile read(POIFSFileSystem fs) throws MPXJException
{
try
{
ProjectFile projectFile = new ProjectFile();
ProjectConfig config = projectFile.getProjectConfig();
config.setAutoTaskID(false);
config.setAutoTaskUniqueID(false);
config.setAutoResourceID(false);
config.setAutoResourceUniqueID(false);
config.setAutoOutlineLevel(false);
config.setAutoOutlineNumber(false);
config.setAutoWBS(false);
config.setAutoCalendarUniqueID(false);
config.setAutoAssignmentUniqueID(false);
projectFile.getEventManager().addProjectListeners(m_projectListeners);
//
// Open the file system and retrieve the root directory
//
DirectoryEntry root = fs.getRoot();
//
// Retrieve the CompObj data, validate the file format and process
//
CompObj compObj = new CompObj(new DocumentInputStream((DocumentEntry) root.getEntry("\1CompObj")));
ProjectProperties projectProperties = projectFile.getProjectProperties();
projectProperties.setFullApplicationName(compObj.getApplicationName());
projectProperties.setApplicationVersion(compObj.getApplicationVersion());
String format = compObj.getFileFormat();
Class<? extends MPPVariantReader> readerClass = FILE_CLASS_MAP.get(format);
if (readerClass == null)
{
throw new MPXJException(MPXJException.INVALID_FILE + ": " + format);
}
MPPVariantReader reader = readerClass.newInstance();
reader.process(this, projectFile, root);
//
// Update the internal structure. We'll take this opportunity to
// generate outline numbers for the tasks as they don't appear to
// be present in the MPP file.
//
config.setAutoOutlineNumber(true);
projectFile.updateStructure();
config.setAutoOutlineNumber(false);
//
// Perform post-processing to set the summary flag and clean
// up any instances where a task has an empty splits list.
//
for (Task task : projectFile.getTasks())
{
task.setSummary(task.hasChildTasks());
List<DateRange> splits = task.getSplits();
if (splits != null && splits.isEmpty())
{
task.setSplits(null);
}
validationRelations(task);
}
//
// Ensure that the unique ID counters are correct
//
config.updateUniqueCounters();
//
// Add some analytics
//
String projectFilePath = projectFile.getProjectProperties().getProjectFilePath();
if (projectFilePath != null && projectFilePath.startsWith("<>\\"))
{
projectProperties.setFileApplication("Microsoft Project Server");
}
else
{
projectProperties.setFileApplication("Microsoft");
}
projectProperties.setFileType("MPP");
return (projectFile);
}
catch (IOException ex)
{
throw new MPXJException(MPXJException.READ_ERROR, ex);
}
catch (IllegalAccessException ex)
{
throw new MPXJException(MPXJException.READ_ERROR, ex);
}
catch (InstantiationException ex)
{
throw new MPXJException(MPXJException.READ_ERROR, ex);
}
}
|
java
|
{
"resource": ""
}
|
q912
|
MPPReader.validationRelations
|
train
|
private void validationRelations(Task task)
{
List<Relation> predecessors = task.getPredecessors();
if (!predecessors.isEmpty())
{
ArrayList<Relation> invalid = new ArrayList<Relation>();
for (Relation relation : predecessors)
{
Task sourceTask = relation.getSourceTask();
Task targetTask = relation.getTargetTask();
String sourceOutlineNumber = sourceTask.getOutlineNumber();
String targetOutlineNumber = targetTask.getOutlineNumber();
if (sourceOutlineNumber != null && targetOutlineNumber != null && sourceOutlineNumber.startsWith(targetOutlineNumber + '.'))
{
invalid.add(relation);
}
}
for (Relation relation : invalid)
{
relation.getSourceTask().removePredecessor(relation.getTargetTask(), relation.getType(), relation.getLag());
}
}
}
|
java
|
{
"resource": ""
}
|
q913
|
MPXTaskField.getMpxjField
|
train
|
public static TaskField getMpxjField(int value)
{
TaskField result = null;
if (value >= 0 && value < MPX_MPXJ_ARRAY.length)
{
result = MPX_MPXJ_ARRAY[value];
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q914
|
MPXTaskField.getMpxField
|
train
|
public static int getMpxField(int value)
{
int result = 0;
if (value >= 0 && value < MPXJ_MPX_ARRAY.length)
{
result = MPXJ_MPX_ARRAY[value];
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q915
|
TaskContainer.add
|
train
|
public Task add()
{
Task task = new Task(m_projectFile, (Task) null);
add(task);
m_projectFile.getChildTasks().add(task);
return task;
}
|
java
|
{
"resource": ""
}
|
q916
|
TaskContainer.synchronizeTaskIDToHierarchy
|
train
|
public void synchronizeTaskIDToHierarchy()
{
clear();
int currentID = (getByID(Integer.valueOf(0)) == null ? 1 : 0);
for (Task task : m_projectFile.getChildTasks())
{
task.setID(Integer.valueOf(currentID++));
add(task);
currentID = synchroizeTaskIDToHierarchy(task, currentID);
}
}
|
java
|
{
"resource": ""
}
|
q917
|
TaskContainer.synchroizeTaskIDToHierarchy
|
train
|
private int synchroizeTaskIDToHierarchy(Task parentTask, int currentID)
{
for (Task task : parentTask.getChildTasks())
{
task.setID(Integer.valueOf(currentID++));
add(task);
currentID = synchroizeTaskIDToHierarchy(task, currentID);
}
return currentID;
}
|
java
|
{
"resource": ""
}
|
q918
|
TaskContainer.updateStructure
|
train
|
public void updateStructure()
{
if (size() > 1)
{
Collections.sort(this);
m_projectFile.getChildTasks().clear();
Task lastTask = null;
int lastLevel = -1;
boolean autoWbs = m_projectFile.getProjectConfig().getAutoWBS();
boolean autoOutlineNumber = m_projectFile.getProjectConfig().getAutoOutlineNumber();
for (Task task : this)
{
task.clearChildTasks();
Task parent = null;
if (!task.getNull())
{
int level = NumberHelper.getInt(task.getOutlineLevel());
if (lastTask != null)
{
if (level == lastLevel || task.getNull())
{
parent = lastTask.getParentTask();
level = lastLevel;
}
else
{
if (level > lastLevel)
{
parent = lastTask;
}
else
{
while (level <= lastLevel)
{
parent = lastTask.getParentTask();
if (parent == null)
{
break;
}
lastLevel = NumberHelper.getInt(parent.getOutlineLevel());
lastTask = parent;
}
}
}
}
lastTask = task;
lastLevel = level;
if (autoWbs || task.getWBS() == null)
{
task.generateWBS(parent);
}
if (autoOutlineNumber)
{
task.generateOutlineNumber(parent);
}
}
if (parent == null)
{
m_projectFile.getChildTasks().add(task);
}
else
{
parent.addChildTask(task);
}
}
}
}
|
java
|
{
"resource": ""
}
|
q919
|
MppCleanUtility.process
|
train
|
private void process(String input, String output) throws MPXJException, IOException
{
//
// Extract the project data
//
MPPReader reader = new MPPReader();
m_project = reader.read(input);
String varDataFileName;
String projectDirName;
int mppFileType = NumberHelper.getInt(m_project.getProjectProperties().getMppFileType());
switch (mppFileType)
{
case 8:
{
projectDirName = " 1";
varDataFileName = "FixDeferFix 0";
break;
}
case 9:
{
projectDirName = " 19";
varDataFileName = "Var2Data";
break;
}
case 12:
{
projectDirName = " 112";
varDataFileName = "Var2Data";
break;
}
case 14:
{
projectDirName = " 114";
varDataFileName = "Var2Data";
break;
}
default:
{
throw new IllegalArgumentException("Unsupported file type " + mppFileType);
}
}
//
// Load the raw file
//
FileInputStream is = new FileInputStream(input);
POIFSFileSystem fs = new POIFSFileSystem(is);
is.close();
//
// Locate the root of the project file system
//
DirectoryEntry root = fs.getRoot();
m_projectDir = (DirectoryEntry) root.getEntry(projectDirName);
//
// Process Tasks
//
Map<String, String> replacements = new HashMap<String, String>();
for (Task task : m_project.getTasks())
{
mapText(task.getName(), replacements);
}
processReplacements(((DirectoryEntry) m_projectDir.getEntry("TBkndTask")), varDataFileName, replacements, true);
//
// Process Resources
//
replacements.clear();
for (Resource resource : m_project.getResources())
{
mapText(resource.getName(), replacements);
mapText(resource.getInitials(), replacements);
}
processReplacements((DirectoryEntry) m_projectDir.getEntry("TBkndRsc"), varDataFileName, replacements, true);
//
// Process project properties
//
replacements.clear();
ProjectProperties properties = m_project.getProjectProperties();
mapText(properties.getProjectTitle(), replacements);
processReplacements(m_projectDir, "Props", replacements, true);
replacements.clear();
mapText(properties.getProjectTitle(), replacements);
mapText(properties.getSubject(), replacements);
mapText(properties.getAuthor(), replacements);
mapText(properties.getKeywords(), replacements);
mapText(properties.getComments(), replacements);
processReplacements(root, "\005SummaryInformation", replacements, false);
replacements.clear();
mapText(properties.getManager(), replacements);
mapText(properties.getCompany(), replacements);
mapText(properties.getCategory(), replacements);
processReplacements(root, "\005DocumentSummaryInformation", replacements, false);
//
// Write the replacement raw file
//
FileOutputStream os = new FileOutputStream(output);
fs.writeFilesystem(os);
os.flush();
os.close();
fs.close();
}
|
java
|
{
"resource": ""
}
|
q920
|
MppCleanUtility.mapText
|
train
|
private void mapText(String oldText, Map<String, String> replacements)
{
char c2 = 0;
if (oldText != null && oldText.length() != 0 && !replacements.containsKey(oldText))
{
StringBuilder newText = new StringBuilder(oldText.length());
for (int loop = 0; loop < oldText.length(); loop++)
{
char c = oldText.charAt(loop);
if (Character.isUpperCase(c))
{
newText.append('X');
}
else
{
if (Character.isLowerCase(c))
{
newText.append('x');
}
else
{
if (Character.isDigit(c))
{
newText.append('0');
}
else
{
if (Character.isLetter(c))
{
// Handle other codepages etc. If possible find a way to
// maintain the same code page as original.
// E.g. replace with a character from the same alphabet.
// This 'should' work for most cases
if (c2 == 0)
{
c2 = c;
}
newText.append(c2);
}
else
{
newText.append(c);
}
}
}
}
}
replacements.put(oldText, newText.toString());
}
}
|
java
|
{
"resource": ""
}
|
q921
|
MppCleanUtility.getBytes
|
train
|
private byte[] getBytes(String value, boolean unicode)
{
byte[] result;
if (unicode)
{
int start = 0;
// Get the bytes in UTF-16
byte[] bytes;
try
{
bytes = value.getBytes("UTF-16");
}
catch (UnsupportedEncodingException e)
{
bytes = value.getBytes();
}
if (bytes.length > 2 && bytes[0] == -2 && bytes[1] == -1)
{
// Skip the unicode identifier
start = 2;
}
result = new byte[bytes.length - start];
for (int loop = start; loop < bytes.length - 1; loop += 2)
{
// Swap the order here
result[loop - start] = bytes[loop + 1];
result[loop + 1 - start] = bytes[loop];
}
}
else
{
result = new byte[value.length() + 1];
System.arraycopy(value.getBytes(), 0, result, 0, value.length());
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q922
|
MppCleanUtility.compareBytes
|
train
|
private boolean compareBytes(byte[] lhs, byte[] rhs, int rhsOffset)
{
boolean result = true;
for (int loop = 0; loop < lhs.length; loop++)
{
if (lhs[loop] != rhs[rhsOffset + loop])
{
result = false;
break;
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q923
|
PrimaveraPMFileWriter.writeCurrency
|
train
|
private void writeCurrency()
{
ProjectProperties props = m_projectFile.getProjectProperties();
CurrencyType currency = m_factory.createCurrencyType();
m_apibo.getCurrency().add(currency);
String positiveSymbol = getCurrencyFormat(props.getSymbolPosition());
String negativeSymbol = "(" + positiveSymbol + ")";
currency.setDecimalPlaces(props.getCurrencyDigits());
currency.setDecimalSymbol(getSymbolName(props.getDecimalSeparator()));
currency.setDigitGroupingSymbol(getSymbolName(props.getThousandsSeparator()));
currency.setExchangeRate(Double.valueOf(1.0));
currency.setId("CUR");
currency.setName("Default Currency");
currency.setNegativeSymbol(negativeSymbol);
currency.setObjectId(DEFAULT_CURRENCY_ID);
currency.setPositiveSymbol(positiveSymbol);
currency.setSymbol(props.getCurrencySymbol());
}
|
java
|
{
"resource": ""
}
|
q924
|
PrimaveraPMFileWriter.getSymbolName
|
train
|
private String getSymbolName(char c)
{
String result = null;
switch (c)
{
case ',':
{
result = "Comma";
break;
}
case '.':
{
result = "Period";
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q925
|
PrimaveraPMFileWriter.getCurrencyFormat
|
train
|
private String getCurrencyFormat(CurrencySymbolPosition position)
{
String result;
switch (position)
{
case AFTER:
{
result = "1.1#";
break;
}
case AFTER_WITH_SPACE:
{
result = "1.1 #";
break;
}
case BEFORE_WITH_SPACE:
{
result = "# 1.1";
break;
}
default:
case BEFORE:
{
result = "#1.1";
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q926
|
PrimaveraPMFileWriter.writeUserFieldDefinitions
|
train
|
private void writeUserFieldDefinitions()
{
for (CustomField cf : m_sortedCustomFieldsList)
{
if (cf.getFieldType() != null && cf.getFieldType().getDataType() != null)
{
UDFTypeType udf = m_factory.createUDFTypeType();
udf.setObjectId(Integer.valueOf(FieldTypeHelper.getFieldID(cf.getFieldType())));
udf.setDataType(UserFieldDataType.inferUserFieldDataType(cf.getFieldType().getDataType()));
udf.setSubjectArea(UserFieldDataType.inferUserFieldSubjectArea(cf.getFieldType()));
udf.setTitle(cf.getAlias());
m_apibo.getUDFType().add(udf);
}
}
}
|
java
|
{
"resource": ""
}
|
q927
|
PrimaveraPMFileWriter.writeCalendar
|
train
|
private void writeCalendar(ProjectCalendar mpxj)
{
CalendarType xml = m_factory.createCalendarType();
m_apibo.getCalendar().add(xml);
String type = mpxj.getResource() == null ? "Global" : "Resource";
xml.setBaseCalendarObjectId(getCalendarUniqueID(mpxj.getParent()));
xml.setIsPersonal(mpxj.getResource() == null ? Boolean.FALSE : Boolean.TRUE);
xml.setName(mpxj.getName());
xml.setObjectId(mpxj.getUniqueID());
xml.setType(type);
StandardWorkWeek xmlStandardWorkWeek = m_factory.createCalendarTypeStandardWorkWeek();
xml.setStandardWorkWeek(xmlStandardWorkWeek);
for (Day day : EnumSet.allOf(Day.class))
{
StandardWorkHours xmlHours = m_factory.createCalendarTypeStandardWorkWeekStandardWorkHours();
xmlStandardWorkWeek.getStandardWorkHours().add(xmlHours);
xmlHours.setDayOfWeek(getDayName(day));
for (DateRange range : mpxj.getHours(day))
{
WorkTimeType xmlWorkTime = m_factory.createWorkTimeType();
xmlHours.getWorkTime().add(xmlWorkTime);
xmlWorkTime.setStart(range.getStart());
xmlWorkTime.setFinish(getEndTime(range.getEnd()));
}
}
HolidayOrExceptions xmlExceptions = m_factory.createCalendarTypeHolidayOrExceptions();
xml.setHolidayOrExceptions(xmlExceptions);
if (!mpxj.getCalendarExceptions().isEmpty())
{
Calendar calendar = DateHelper.popCalendar();
for (ProjectCalendarException mpxjException : mpxj.getCalendarExceptions())
{
calendar.setTime(mpxjException.getFromDate());
while (calendar.getTimeInMillis() < mpxjException.getToDate().getTime())
{
HolidayOrException xmlException = m_factory.createCalendarTypeHolidayOrExceptionsHolidayOrException();
xmlExceptions.getHolidayOrException().add(xmlException);
xmlException.setDate(calendar.getTime());
for (DateRange range : mpxjException)
{
WorkTimeType xmlHours = m_factory.createWorkTimeType();
xmlException.getWorkTime().add(xmlHours);
xmlHours.setStart(range.getStart());
if (range.getEnd() != null)
{
xmlHours.setFinish(getEndTime(range.getEnd()));
}
}
calendar.add(Calendar.DAY_OF_YEAR, 1);
}
}
DateHelper.pushCalendar(calendar);
}
}
|
java
|
{
"resource": ""
}
|
q928
|
PrimaveraPMFileWriter.writeResources
|
train
|
private void writeResources()
{
for (Resource resource : m_projectFile.getResources())
{
if (resource.getUniqueID().intValue() != 0)
{
writeResource(resource);
}
}
}
|
java
|
{
"resource": ""
}
|
q929
|
PrimaveraPMFileWriter.writeResource
|
train
|
private void writeResource(Resource mpxj)
{
ResourceType xml = m_factory.createResourceType();
m_apibo.getResource().add(xml);
xml.setAutoComputeActuals(Boolean.TRUE);
xml.setCalculateCostFromUnits(Boolean.TRUE);
xml.setCalendarObjectId(getCalendarUniqueID(mpxj.getResourceCalendar()));
xml.setCurrencyObjectId(DEFAULT_CURRENCY_ID);
xml.setDefaultUnitsPerTime(Double.valueOf(1.0));
xml.setEmailAddress(mpxj.getEmailAddress());
xml.setGUID(DatatypeConverter.printUUID(mpxj.getGUID()));
xml.setId(RESOURCE_ID_PREFIX + mpxj.getUniqueID());
xml.setIsActive(Boolean.TRUE);
xml.setMaxUnitsPerTime(getPercentage(mpxj.getMaxUnits()));
xml.setName(mpxj.getName());
xml.setObjectId(mpxj.getUniqueID());
xml.setParentObjectId(mpxj.getParentID());
xml.setResourceNotes(mpxj.getNotes());
xml.setResourceType(getResourceType(mpxj));
xml.getUDF().addAll(writeUDFType(FieldTypeClass.RESOURCE, mpxj));
}
|
java
|
{
"resource": ""
}
|
q930
|
PrimaveraPMFileWriter.writeTask
|
train
|
private void writeTask(Task task)
{
if (!task.getNull())
{
if (extractAndConvertTaskType(task) == null || task.getSummary())
{
writeWBS(task);
}
else
{
writeActivity(task);
}
}
}
|
java
|
{
"resource": ""
}
|
q931
|
PrimaveraPMFileWriter.writeWBS
|
train
|
private void writeWBS(Task mpxj)
{
if (mpxj.getUniqueID().intValue() != 0)
{
WBSType xml = m_factory.createWBSType();
m_project.getWBS().add(xml);
String code = mpxj.getWBS();
code = code == null || code.length() == 0 ? DEFAULT_WBS_CODE : code;
Task parentTask = mpxj.getParentTask();
Integer parentObjectID = parentTask == null ? null : parentTask.getUniqueID();
xml.setCode(code);
xml.setGUID(DatatypeConverter.printUUID(mpxj.getGUID()));
xml.setName(mpxj.getName());
xml.setObjectId(mpxj.getUniqueID());
xml.setParentObjectId(parentObjectID);
xml.setProjectObjectId(PROJECT_OBJECT_ID);
xml.setSequenceNumber(Integer.valueOf(m_wbsSequence++));
xml.setStatus("Active");
}
writeChildTasks(mpxj);
}
|
java
|
{
"resource": ""
}
|
q932
|
PrimaveraPMFileWriter.writeActivity
|
train
|
private void writeActivity(Task mpxj)
{
ActivityType xml = m_factory.createActivityType();
m_project.getActivity().add(xml);
Task parentTask = mpxj.getParentTask();
Integer parentObjectID = parentTask == null ? null : parentTask.getUniqueID();
xml.setActualStartDate(mpxj.getActualStart());
xml.setActualFinishDate(mpxj.getActualFinish());
xml.setAtCompletionDuration(getDuration(mpxj.getDuration()));
xml.setCalendarObjectId(getCalendarUniqueID(mpxj.getCalendar()));
xml.setDurationPercentComplete(getPercentage(mpxj.getPercentageComplete()));
xml.setDurationType(DURATION_TYPE_MAP.get(mpxj.getType()));
xml.setFinishDate(mpxj.getFinish());
xml.setGUID(DatatypeConverter.printUUID(mpxj.getGUID()));
xml.setId(getActivityID(mpxj));
xml.setName(mpxj.getName());
xml.setObjectId(mpxj.getUniqueID());
xml.setPercentComplete(getPercentage(mpxj.getPercentageComplete()));
xml.setPercentCompleteType("Duration");
xml.setPrimaryConstraintType(CONSTRAINT_TYPE_MAP.get(mpxj.getConstraintType()));
xml.setPrimaryConstraintDate(mpxj.getConstraintDate());
xml.setPlannedDuration(getDuration(mpxj.getDuration()));
xml.setPlannedFinishDate(mpxj.getFinish());
xml.setPlannedStartDate(mpxj.getStart());
xml.setProjectObjectId(PROJECT_OBJECT_ID);
xml.setRemainingDuration(getDuration(mpxj.getRemainingDuration()));
xml.setRemainingEarlyFinishDate(mpxj.getEarlyFinish());
xml.setRemainingEarlyStartDate(mpxj.getResume());
xml.setRemainingLaborCost(NumberHelper.DOUBLE_ZERO);
xml.setRemainingLaborUnits(NumberHelper.DOUBLE_ZERO);
xml.setRemainingNonLaborCost(NumberHelper.DOUBLE_ZERO);
xml.setRemainingNonLaborUnits(NumberHelper.DOUBLE_ZERO);
xml.setStartDate(mpxj.getStart());
xml.setStatus(getActivityStatus(mpxj));
xml.setType(extractAndConvertTaskType(mpxj));
xml.setWBSObjectId(parentObjectID);
xml.getUDF().addAll(writeUDFType(FieldTypeClass.TASK, mpxj));
writePredecessors(mpxj);
}
|
java
|
{
"resource": ""
}
|
q933
|
PrimaveraPMFileWriter.extractAndConvertTaskType
|
train
|
private String extractAndConvertTaskType(Task task)
{
String activityType = (String) task.getCachedValue(m_activityTypeField);
if (activityType == null)
{
activityType = "Resource Dependent";
}
else
{
if (ACTIVITY_TYPE_MAP.containsKey(activityType))
{
activityType = ACTIVITY_TYPE_MAP.get(activityType);
}
}
return activityType;
}
|
java
|
{
"resource": ""
}
|
q934
|
PrimaveraPMFileWriter.writeAssignments
|
train
|
private void writeAssignments()
{
for (ResourceAssignment assignment : m_projectFile.getResourceAssignments())
{
Resource resource = assignment.getResource();
if (resource != null)
{
Task task = assignment.getTask();
if (task != null && task.getUniqueID().intValue() != 0 && !task.getSummary())
{
writeAssignment(assignment);
}
}
}
}
|
java
|
{
"resource": ""
}
|
q935
|
PrimaveraPMFileWriter.writeAssignment
|
train
|
private void writeAssignment(ResourceAssignment mpxj)
{
ResourceAssignmentType xml = m_factory.createResourceAssignmentType();
m_project.getResourceAssignment().add(xml);
Task task = mpxj.getTask();
Task parentTask = task.getParentTask();
Integer parentTaskUniqueID = parentTask == null ? null : parentTask.getUniqueID();
xml.setActivityObjectId(mpxj.getTaskUniqueID());
xml.setActualCost(getDouble(mpxj.getActualCost()));
xml.setActualFinishDate(mpxj.getActualFinish());
xml.setActualOvertimeUnits(getDuration(mpxj.getActualOvertimeWork()));
xml.setActualRegularUnits(getDuration(mpxj.getActualWork()));
xml.setActualStartDate(mpxj.getActualStart());
xml.setActualUnits(getDuration(mpxj.getActualWork()));
xml.setAtCompletionUnits(getDuration(mpxj.getRemainingWork()));
xml.setPlannedCost(getDouble(mpxj.getActualCost()));
xml.setFinishDate(mpxj.getFinish());
xml.setGUID(DatatypeConverter.printUUID(mpxj.getGUID()));
xml.setObjectId(mpxj.getUniqueID());
xml.setPlannedDuration(getDuration(mpxj.getWork()));
xml.setPlannedFinishDate(mpxj.getFinish());
xml.setPlannedStartDate(mpxj.getStart());
xml.setPlannedUnits(getDuration(mpxj.getWork()));
xml.setPlannedUnitsPerTime(getPercentage(mpxj.getUnits()));
xml.setProjectObjectId(PROJECT_OBJECT_ID);
xml.setRateSource("Resource");
xml.setRemainingCost(getDouble(mpxj.getActualCost()));
xml.setRemainingDuration(getDuration(mpxj.getRemainingWork()));
xml.setRemainingFinishDate(mpxj.getFinish());
xml.setRemainingStartDate(mpxj.getStart());
xml.setRemainingUnits(getDuration(mpxj.getRemainingWork()));
xml.setRemainingUnitsPerTime(getPercentage(mpxj.getUnits()));
xml.setResourceObjectId(mpxj.getResourceUniqueID());
xml.setStartDate(mpxj.getStart());
xml.setWBSObjectId(parentTaskUniqueID);
xml.getUDF().addAll(writeUDFType(FieldTypeClass.ASSIGNMENT, mpxj));
}
|
java
|
{
"resource": ""
}
|
q936
|
PrimaveraPMFileWriter.writePredecessors
|
train
|
private void writePredecessors(Task task)
{
List<Relation> relations = task.getPredecessors();
for (Relation mpxj : relations)
{
RelationshipType xml = m_factory.createRelationshipType();
m_project.getRelationship().add(xml);
xml.setLag(getDuration(mpxj.getLag()));
xml.setObjectId(Integer.valueOf(++m_relationshipObjectID));
xml.setPredecessorActivityObjectId(mpxj.getTargetTask().getUniqueID());
xml.setSuccessorActivityObjectId(mpxj.getSourceTask().getUniqueID());
xml.setPredecessorProjectObjectId(PROJECT_OBJECT_ID);
xml.setSuccessorProjectObjectId(PROJECT_OBJECT_ID);
xml.setType(RELATION_TYPE_MAP.get(mpxj.getType()));
}
}
|
java
|
{
"resource": ""
}
|
q937
|
PrimaveraPMFileWriter.writeUDFType
|
train
|
private List<UDFAssignmentType> writeUDFType(FieldTypeClass type, FieldContainer mpxj)
{
List<UDFAssignmentType> out = new ArrayList<UDFAssignmentType>();
for (CustomField cf : m_sortedCustomFieldsList)
{
FieldType fieldType = cf.getFieldType();
if (fieldType != null && type == fieldType.getFieldTypeClass())
{
Object value = mpxj.getCachedValue(fieldType);
if (FieldTypeHelper.valueIsNotDefault(fieldType, value))
{
UDFAssignmentType udf = m_factory.createUDFAssignmentType();
udf.setTypeObjectId(FieldTypeHelper.getFieldID(fieldType));
setUserFieldValue(udf, fieldType.getDataType(), value);
out.add(udf);
}
}
}
return out;
}
|
java
|
{
"resource": ""
}
|
q938
|
PrimaveraPMFileWriter.setUserFieldValue
|
train
|
private void setUserFieldValue(UDFAssignmentType udf, DataType dataType, Object value)
{
switch (dataType)
{
case DURATION:
{
udf.setTextValue(((Duration) value).toString());
break;
}
case CURRENCY:
{
if (!(value instanceof Double))
{
value = Double.valueOf(((Number) value).doubleValue());
}
udf.setCostValue((Double) value);
break;
}
case BINARY:
{
udf.setTextValue("");
break;
}
case STRING:
{
udf.setTextValue((String) value);
break;
}
case DATE:
{
udf.setStartDateValue((Date) value);
break;
}
case NUMERIC:
{
if (!(value instanceof Double))
{
value = Double.valueOf(((Number) value).doubleValue());
}
udf.setDoubleValue((Double) value);
break;
}
case BOOLEAN:
{
udf.setIntegerValue(BooleanHelper.getBoolean((Boolean) value) ? Integer.valueOf(1) : Integer.valueOf(0));
break;
}
case INTEGER:
case SHORT:
{
udf.setIntegerValue(NumberHelper.getInteger((Number) value));
break;
}
default:
{
throw new RuntimeException("Unconvertible data type: " + dataType);
}
}
}
|
java
|
{
"resource": ""
}
|
q939
|
PrimaveraPMFileWriter.getDuration
|
train
|
private Double getDuration(Duration duration)
{
Double result;
if (duration == null)
{
result = null;
}
else
{
if (duration.getUnits() != TimeUnit.HOURS)
{
duration = duration.convertUnits(TimeUnit.HOURS, m_projectFile.getProjectProperties());
}
result = Double.valueOf(duration.getDuration());
}
return result;
}
|
java
|
{
"resource": ""
}
|
q940
|
PrimaveraPMFileWriter.getResourceType
|
train
|
private String getResourceType(Resource resource)
{
String result;
net.sf.mpxj.ResourceType type = resource.getType();
if (type == null)
{
type = net.sf.mpxj.ResourceType.WORK;
}
switch (type)
{
case MATERIAL:
{
result = "Material";
break;
}
case COST:
{
result = "Nonlabor";
break;
}
default:
{
result = "Labor";
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q941
|
PrimaveraPMFileWriter.getPercentage
|
train
|
private Double getPercentage(Number number)
{
Double result = null;
if (number != null)
{
result = Double.valueOf(number.doubleValue() / 100);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q942
|
PrimaveraPMFileWriter.getDouble
|
train
|
private Double getDouble(Number number)
{
Double result = null;
if (number != null)
{
result = Double.valueOf(number.doubleValue());
}
return result;
}
|
java
|
{
"resource": ""
}
|
q943
|
PrimaveraPMFileWriter.getActivityStatus
|
train
|
private String getActivityStatus(Task mpxj)
{
String result;
if (mpxj.getActualStart() == null)
{
result = "Not Started";
}
else
{
if (mpxj.getActualFinish() == null)
{
result = "In Progress";
}
else
{
result = "Completed";
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q944
|
PrimaveraPMFileWriter.getActivityID
|
train
|
private String getActivityID(Task task)
{
String result = null;
if (m_activityIDField != null)
{
Object value = task.getCachedValue(m_activityIDField);
if (value != null)
{
result = value.toString();
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q945
|
PrimaveraPMFileWriter.configureCustomFields
|
train
|
private void configureCustomFields()
{
CustomFieldContainer customFields = m_projectFile.getCustomFields();
// If the caller hasn't already supplied a value for this field
if (m_activityIDField == null)
{
m_activityIDField = (TaskField) customFields.getFieldByAlias(FieldTypeClass.TASK, "Code");
if (m_activityIDField == null)
{
m_activityIDField = TaskField.WBS;
}
}
// If the caller hasn't already supplied a value for this field
if (m_activityTypeField == null)
{
m_activityTypeField = (TaskField) customFields.getFieldByAlias(FieldTypeClass.TASK, "Activity Type");
}
}
|
java
|
{
"resource": ""
}
|
q946
|
PrimaveraPMFileWriter.populateSortedCustomFieldsList
|
train
|
private void populateSortedCustomFieldsList ()
{
m_sortedCustomFieldsList = new ArrayList<CustomField>();
for (CustomField field : m_projectFile.getCustomFields())
{
FieldType fieldType = field.getFieldType();
if (fieldType != null)
{
m_sortedCustomFieldsList.add(field);
}
}
// Sort to ensure consistent order in file
Collections.sort(m_sortedCustomFieldsList, new Comparator<CustomField>()
{
@Override public int compare(CustomField customField1, CustomField customField2)
{
FieldType o1 = customField1.getFieldType();
FieldType o2 = customField2.getFieldType();
String name1 = o1.getClass().getSimpleName() + "." + o1.getName() + " " + customField1.getAlias();
String name2 = o2.getClass().getSimpleName() + "." + o2.getName() + " " + customField2.getAlias();
return name1.compareTo(name2);
}
});
}
|
java
|
{
"resource": ""
}
|
q947
|
ProjectCalendarHours.setDay
|
train
|
public void setDay(Day d)
{
if (m_day != null)
{
m_parentCalendar.removeHoursFromDay(this);
}
m_day = d;
m_parentCalendar.attachHoursToDay(this);
}
|
java
|
{
"resource": ""
}
|
q948
|
MPXJBaseFormat.applyPatterns
|
train
|
public void applyPatterns(String[] patterns)
{
m_formats = new SimpleDateFormat[patterns.length];
for (int index = 0; index < patterns.length; index++)
{
m_formats[index] = new SimpleDateFormat(patterns[index]);
}
}
|
java
|
{
"resource": ""
}
|
q949
|
RecurrenceUtility.getDuration
|
train
|
public static Duration getDuration(ProjectProperties properties, Integer durationValue, Integer unitsValue)
{
Duration result;
if (durationValue == null)
{
result = null;
}
else
{
result = Duration.getInstance(durationValue.intValue(), TimeUnit.MINUTES);
TimeUnit units = getDurationUnits(unitsValue);
if (result.getUnits() != units)
{
result = result.convertUnits(units, properties);
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q950
|
RecurrenceUtility.getDurationValue
|
train
|
public static Integer getDurationValue(ProjectProperties properties, Duration duration)
{
Integer result;
if (duration == null)
{
result = null;
}
else
{
if (duration.getUnits() != TimeUnit.MINUTES)
{
duration = duration.convertUnits(TimeUnit.MINUTES, properties);
}
result = Integer.valueOf((int) duration.getDuration());
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q951
|
RecurrenceUtility.getDurationUnits
|
train
|
public static Integer getDurationUnits(RecurringTask recurrence)
{
Duration duration = recurrence.getDuration();
Integer result = null;
if (duration != null)
{
result = UNITS_MAP.get(duration.getUnits());
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q952
|
RecurrenceUtility.getDurationUnits
|
train
|
private static TimeUnit getDurationUnits(Integer value)
{
TimeUnit result = null;
if (value != null)
{
int index = value.intValue();
if (index >= 0 && index < DURATION_UNITS.length)
{
result = DURATION_UNITS[index];
}
}
if (result == null)
{
result = TimeUnit.DAYS;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q953
|
RecurrenceUtility.getDays
|
train
|
public static Integer getDays(String days)
{
Integer result = null;
if (days != null)
{
result = Integer.valueOf(Integer.parseInt(days, 2));
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q954
|
RecurrenceUtility.getDays
|
train
|
public static String getDays(RecurringTask task)
{
StringBuilder sb = new StringBuilder();
for (Day day : Day.values())
{
sb.append(task.getWeeklyDay(day) ? "1" : "0");
}
return sb.toString();
}
|
java
|
{
"resource": ""
}
|
q955
|
RecurrenceUtility.getDay
|
train
|
public static Day getDay(Integer day)
{
Day result = null;
if (day != null)
{
result = DAY_ARRAY[day.intValue()];
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q956
|
RecurrenceUtility.getDay
|
train
|
public static Integer getDay(Day day)
{
Integer result = null;
if (day != null)
{
result = DAY_MAP.get(day);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q957
|
RecurrenceUtility.getYearlyAbsoluteAsDate
|
train
|
public static Date getYearlyAbsoluteAsDate(RecurringData data)
{
Date result;
Integer yearlyAbsoluteDay = data.getDayNumber();
Integer yearlyAbsoluteMonth = data.getMonthNumber();
Date startDate = data.getStartDate();
if (yearlyAbsoluteDay == null || yearlyAbsoluteMonth == null || startDate == null)
{
result = null;
}
else
{
Calendar cal = DateHelper.popCalendar(startDate);
cal.set(Calendar.MONTH, yearlyAbsoluteMonth.intValue() - 1);
cal.set(Calendar.DAY_OF_MONTH, yearlyAbsoluteDay.intValue());
result = cal.getTime();
DateHelper.pushCalendar(cal);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q958
|
AbstractIntColumn.readInt
|
train
|
public int readInt(int offset, byte[] data)
{
int result = 0;
int i = offset + m_offset;
for (int shiftBy = 0; shiftBy < 32; shiftBy += 8)
{
result |= ((data[i] & 0xff)) << shiftBy;
++i;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q959
|
RowHeader.parse
|
train
|
private void parse(String header)
{
ArrayList<String> list = new ArrayList<String>(4);
StringBuilder sb = new StringBuilder();
int index = 1;
while (index < header.length())
{
char c = header.charAt(index++);
if (Character.isDigit(c))
{
sb.append(c);
}
else
{
if (sb.length() != 0)
{
list.add(sb.toString());
sb.setLength(0);
}
}
}
if (sb.length() != 0)
{
list.add(sb.toString());
}
m_id = list.get(0);
m_sequence = Integer.parseInt(list.get(1));
m_type = Integer.valueOf(list.get(2));
if (list.size() > 3)
{
m_subtype = Integer.parseInt(list.get(3));
}
}
|
java
|
{
"resource": ""
}
|
q960
|
CostRateTable.getIndexByDate
|
train
|
public int getIndexByDate(Date date)
{
int result = -1;
int index = 0;
for (CostRateTableEntry entry : this)
{
if (DateHelper.compare(date, entry.getEndDate()) < 0)
{
result = index;
break;
}
++index;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q961
|
NumberHelper.getInt
|
train
|
public static final int getInt(String value)
{
return (value == null || value.length() == 0 ? 0 : Integer.parseInt(value));
}
|
java
|
{
"resource": ""
}
|
q962
|
NumberHelper.getDouble
|
train
|
public static final double getDouble(String value)
{
return (value == null || value.length() == 0 ? 0 : Double.parseDouble(value));
}
|
java
|
{
"resource": ""
}
|
q963
|
NumberHelper.getInteger
|
train
|
public static final Integer getInteger(Number value)
{
Integer result = null;
if (value != null)
{
if (value instanceof Integer)
{
result = (Integer) value;
}
else
{
result = Integer.valueOf((int) Math.round(value.doubleValue()));
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q964
|
NumberHelper.getInteger
|
train
|
public static final Integer getInteger(String value)
{
Integer result;
try
{
result = Integer.valueOf(Integer.parseInt(value));
}
catch (Exception ex)
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q965
|
NumberHelper.getBigInteger
|
train
|
public static final BigInteger getBigInteger(Number value)
{
BigInteger result = null;
if (value != null)
{
if (value instanceof BigInteger)
{
result = (BigInteger) value;
}
else
{
result = BigInteger.valueOf(Math.round(value.doubleValue()));
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q966
|
NumberHelper.round
|
train
|
public static final double round(double value, double precision)
{
precision = Math.pow(10, precision);
return Math.round(value * precision) / precision;
}
|
java
|
{
"resource": ""
}
|
q967
|
NumberHelper.parseInteger
|
train
|
public static final Integer parseInteger(String value)
{
return (value == null || value.length() == 0 ? null : Integer.valueOf(Integer.parseInt(value)));
}
|
java
|
{
"resource": ""
}
|
q968
|
NumberHelper.compare
|
train
|
public static int compare(Integer n1, Integer n2)
{
int result;
if (n1 == null || n2 == null)
{
result = (n1 == null && n2 == null ? 0 : (n1 == null ? 1 : -1));
}
else
{
result = n1.compareTo(n2);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q969
|
MapRow.getObject
|
train
|
private final Object getObject(String name)
{
if (m_map.containsKey(name) == false)
{
throw new IllegalArgumentException("Invalid column name " + name);
}
Object result = m_map.get(name);
return (result);
}
|
java
|
{
"resource": ""
}
|
q970
|
Tokenizer.nextToken
|
train
|
public int nextToken() throws IOException
{
int c;
int nextc = -1;
boolean quoted = false;
int result = m_next;
if (m_next != 0)
{
m_next = 0;
}
m_buffer.setLength(0);
while (result == 0)
{
if (nextc != -1)
{
c = nextc;
nextc = -1;
}
else
{
c = read();
}
switch (c)
{
case TT_EOF:
{
if (m_buffer.length() != 0)
{
result = TT_WORD;
m_next = TT_EOF;
}
else
{
result = TT_EOF;
}
break;
}
case TT_EOL:
{
int length = m_buffer.length();
if (length != 0 && m_buffer.charAt(length - 1) == '\r')
{
--length;
m_buffer.setLength(length);
}
if (length == 0)
{
result = TT_EOL;
}
else
{
result = TT_WORD;
m_next = TT_EOL;
}
break;
}
default:
{
if (c == m_quote)
{
if (quoted == false && startQuotedIsValid(m_buffer))
{
quoted = true;
}
else
{
if (quoted == false)
{
m_buffer.append((char) c);
}
else
{
nextc = read();
if (nextc == m_quote)
{
m_buffer.append((char) c);
nextc = -1;
}
else
{
quoted = false;
}
}
}
}
else
{
if (c == m_delimiter && quoted == false)
{
result = TT_WORD;
}
else
{
m_buffer.append((char) c);
}
}
}
}
}
m_type = result;
return (result);
}
|
java
|
{
"resource": ""
}
|
q971
|
ResourceAssignment.addWorkgroupAssignment
|
train
|
public ResourceAssignmentWorkgroupFields addWorkgroupAssignment() throws MPXJException
{
if (m_workgroup != null)
{
throw new MPXJException(MPXJException.MAXIMUM_RECORDS);
}
m_workgroup = new ResourceAssignmentWorkgroupFields();
return (m_workgroup);
}
|
java
|
{
"resource": ""
}
|
q972
|
ResourceAssignment.getStart
|
train
|
public Date getStart()
{
Date result = (Date) getCachedValue(AssignmentField.START);
if (result == null)
{
result = getTask().getStart();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q973
|
ResourceAssignment.getFinish
|
train
|
public Date getFinish()
{
Date result = (Date) getCachedValue(AssignmentField.FINISH);
if (result == null)
{
result = getTask().getFinish();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q974
|
ResourceAssignment.getTimephasedOvertimeWork
|
train
|
public List<TimephasedWork> getTimephasedOvertimeWork()
{
if (m_timephasedOvertimeWork == null && m_timephasedWork != null && getOvertimeWork() != null)
{
double perDayFactor = getRemainingOvertimeWork().getDuration() / (getRemainingWork().getDuration() - getRemainingOvertimeWork().getDuration());
double totalFactor = getRemainingOvertimeWork().getDuration() / getRemainingWork().getDuration();
perDayFactor = Double.isNaN(perDayFactor) ? 0 : perDayFactor;
totalFactor = Double.isNaN(totalFactor) ? 0 : totalFactor;
m_timephasedOvertimeWork = new DefaultTimephasedWorkContainer(m_timephasedWork, perDayFactor, totalFactor);
}
return m_timephasedOvertimeWork == null ? null : m_timephasedOvertimeWork.getData();
}
|
java
|
{
"resource": ""
}
|
q975
|
ResourceAssignment.getTimephasedCost
|
train
|
public List<TimephasedCost> getTimephasedCost()
{
if (m_timephasedCost == null)
{
Resource r = getResource();
ResourceType type = r != null ? r.getType() : ResourceType.WORK;
//for Work and Material resources, we will calculate in the normal way
if (type != ResourceType.COST)
{
if (m_timephasedWork != null && m_timephasedWork.hasData())
{
if (hasMultipleCostRates())
{
m_timephasedCost = getTimephasedCostMultipleRates(getTimephasedWork(), getTimephasedOvertimeWork());
}
else
{
m_timephasedCost = getTimephasedCostSingleRate(getTimephasedWork(), getTimephasedOvertimeWork());
}
}
}
else
{
m_timephasedCost = getTimephasedCostFixedAmount();
}
}
return m_timephasedCost;
}
|
java
|
{
"resource": ""
}
|
q976
|
ResourceAssignment.getTimephasedActualCost
|
train
|
public List<TimephasedCost> getTimephasedActualCost()
{
if (m_timephasedActualCost == null)
{
Resource r = getResource();
ResourceType type = r != null ? r.getType() : ResourceType.WORK;
//for Work and Material resources, we will calculate in the normal way
if (type != ResourceType.COST)
{
if (m_timephasedActualWork != null && m_timephasedActualWork.hasData())
{
if (hasMultipleCostRates())
{
m_timephasedActualCost = getTimephasedCostMultipleRates(getTimephasedActualWork(), getTimephasedActualOvertimeWork());
}
else
{
m_timephasedActualCost = getTimephasedCostSingleRate(getTimephasedActualWork(), getTimephasedActualOvertimeWork());
}
}
}
else
{
m_timephasedActualCost = getTimephasedActualCostFixedAmount();
}
}
return m_timephasedActualCost;
}
|
java
|
{
"resource": ""
}
|
q977
|
ResourceAssignment.getTimephasedCostMultipleRates
|
train
|
private List<TimephasedCost> getTimephasedCostMultipleRates(List<TimephasedWork> standardWorkList, List<TimephasedWork> overtimeWorkList)
{
List<TimephasedWork> standardWorkResult = new LinkedList<TimephasedWork>();
List<TimephasedWork> overtimeWorkResult = new LinkedList<TimephasedWork>();
CostRateTable table = getCostRateTable();
ProjectCalendar calendar = getCalendar();
Iterator<TimephasedWork> iter = overtimeWorkList.iterator();
for (TimephasedWork standardWork : standardWorkList)
{
TimephasedWork overtimeWork = iter.hasNext() ? iter.next() : null;
int startIndex = getCostRateTableEntryIndex(standardWork.getStart());
int finishIndex = getCostRateTableEntryIndex(standardWork.getFinish());
if (startIndex == finishIndex)
{
standardWorkResult.add(standardWork);
if (overtimeWork != null)
{
overtimeWorkResult.add(overtimeWork);
}
}
else
{
standardWorkResult.addAll(splitWork(table, calendar, standardWork, startIndex));
if (overtimeWork != null)
{
overtimeWorkResult.addAll(splitWork(table, calendar, overtimeWork, startIndex));
}
}
}
return getTimephasedCostSingleRate(standardWorkResult, overtimeWorkResult);
}
|
java
|
{
"resource": ""
}
|
q978
|
ResourceAssignment.getTimephasedCostFixedAmount
|
train
|
private List<TimephasedCost> getTimephasedCostFixedAmount()
{
List<TimephasedCost> result = new LinkedList<TimephasedCost>();
ProjectCalendar cal = getCalendar();
double remainingCost = getRemainingCost().doubleValue();
if (remainingCost > 0)
{
AccrueType accrueAt = getResource().getAccrueAt();
if (accrueAt == AccrueType.START)
{
result.add(splitCostStart(cal, remainingCost, getStart()));
}
else
if (accrueAt == AccrueType.END)
{
result.add(splitCostEnd(cal, remainingCost, getFinish()));
}
else
{
//for prorated, we have to deal with it differently depending on whether or not
//any actual has been entered, since we want to mimic the other timephased data
//where planned and actual values do not overlap
double numWorkingDays = cal.getWork(getStart(), getFinish(), TimeUnit.DAYS).getDuration();
double standardAmountPerDay = getCost().doubleValue() / numWorkingDays;
if (getActualCost().intValue() > 0)
{
//need to get three possible blocks of data: one for the possible partial amount
//overlap with timephased actual cost; one with all the standard amount days
//that happen after the actual cost stops; and one with any remaining
//partial day cost amount
int numActualDaysUsed = (int) Math.ceil(getActualCost().doubleValue() / standardAmountPerDay);
Date actualWorkFinish = cal.getDate(getStart(), Duration.getInstance(numActualDaysUsed, TimeUnit.DAYS), false);
double partialDayActualAmount = getActualCost().doubleValue() % standardAmountPerDay;
if (partialDayActualAmount > 0)
{
double dayAmount = standardAmountPerDay < remainingCost ? standardAmountPerDay - partialDayActualAmount : remainingCost;
result.add(splitCostEnd(cal, dayAmount, actualWorkFinish));
remainingCost -= dayAmount;
}
//see if there's anything left to work with
if (remainingCost > 0)
{
//have to split up the amount into standard prorated amount days and whatever is left
result.addAll(splitCostProrated(cal, remainingCost, standardAmountPerDay, cal.getNextWorkStart(actualWorkFinish)));
}
}
else
{
//no actual cost to worry about, so just a standard split from the beginning of the assignment
result.addAll(splitCostProrated(cal, remainingCost, standardAmountPerDay, getStart()));
}
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q979
|
ResourceAssignment.getTimephasedActualCostFixedAmount
|
train
|
private List<TimephasedCost> getTimephasedActualCostFixedAmount()
{
List<TimephasedCost> result = new LinkedList<TimephasedCost>();
double actualCost = getActualCost().doubleValue();
if (actualCost > 0)
{
AccrueType accrueAt = getResource().getAccrueAt();
if (accrueAt == AccrueType.START)
{
result.add(splitCostStart(getCalendar(), actualCost, getActualStart()));
}
else
if (accrueAt == AccrueType.END)
{
result.add(splitCostEnd(getCalendar(), actualCost, getActualFinish()));
}
else
{
//for prorated, we have to deal with it differently; have to 'fill up' each
//day with the standard amount before going to the next one
double numWorkingDays = getCalendar().getWork(getStart(), getFinish(), TimeUnit.DAYS).getDuration();
double standardAmountPerDay = getCost().doubleValue() / numWorkingDays;
result.addAll(splitCostProrated(getCalendar(), actualCost, standardAmountPerDay, getActualStart()));
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q980
|
ResourceAssignment.splitWork
|
train
|
private List<TimephasedWork> splitWork(CostRateTable table, ProjectCalendar calendar, TimephasedWork work, int rateIndex)
{
List<TimephasedWork> result = new LinkedList<TimephasedWork>();
work.setTotalAmount(Duration.getInstance(0, work.getAmountPerDay().getUnits()));
while (true)
{
CostRateTableEntry rate = table.get(rateIndex);
Date splitDate = rate.getEndDate();
if (splitDate.getTime() >= work.getFinish().getTime())
{
result.add(work);
break;
}
Date currentPeriodEnd = calendar.getPreviousWorkFinish(splitDate);
TimephasedWork currentPeriod = new TimephasedWork(work);
currentPeriod.setFinish(currentPeriodEnd);
result.add(currentPeriod);
Date nextPeriodStart = calendar.getNextWorkStart(splitDate);
work.setStart(nextPeriodStart);
++rateIndex;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q981
|
ResourceAssignment.hasMultipleCostRates
|
train
|
private boolean hasMultipleCostRates()
{
boolean result = false;
CostRateTable table = getCostRateTable();
if (table != null)
{
//
// We assume here that if there is just one entry in the cost rate
// table, this is an open ended rate which covers any work, it won't
// have specific dates attached to it.
//
if (table.size() > 1)
{
//
// If we have multiple rates in the table, see if the same rate
// is in force at the start and the end of the aaaignment.
//
CostRateTableEntry startEntry = table.getEntryByDate(getStart());
CostRateTableEntry finishEntry = table.getEntryByDate(getFinish());
result = (startEntry != finishEntry);
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q982
|
ResourceAssignment.getCostRateTableEntry
|
train
|
private CostRateTableEntry getCostRateTableEntry(Date date)
{
CostRateTableEntry result;
CostRateTable table = getCostRateTable();
if (table == null)
{
Resource resource = getResource();
result = new CostRateTableEntry(resource.getStandardRate(), TimeUnit.HOURS, resource.getOvertimeRate(), TimeUnit.HOURS, resource.getCostPerUse(), null);
}
else
{
if (table.size() == 1)
{
result = table.get(0);
}
else
{
result = table.getEntryByDate(date);
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q983
|
ResourceAssignment.getCostRateTableEntryIndex
|
train
|
private int getCostRateTableEntryIndex(Date date)
{
int result = -1;
CostRateTable table = getCostRateTable();
if (table != null)
{
if (table.size() == 1)
{
result = 0;
}
else
{
result = table.getIndexByDate(date);
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q984
|
ResourceAssignment.getTimephasedBaselineWork
|
train
|
public List<TimephasedWork> getTimephasedBaselineWork(int index)
{
return m_timephasedBaselineWork[index] == null ? null : m_timephasedBaselineWork[index].getData();
}
|
java
|
{
"resource": ""
}
|
q985
|
ResourceAssignment.getTimephasedBaselineCost
|
train
|
public List<TimephasedCost> getTimephasedBaselineCost(int index)
{
return m_timephasedBaselineCost[index] == null ? null : m_timephasedBaselineCost[index].getData();
}
|
java
|
{
"resource": ""
}
|
q986
|
ResourceAssignment.getCalendar
|
train
|
public ProjectCalendar getCalendar()
{
ProjectCalendar calendar = null;
Resource resource = getResource();
if (resource != null)
{
calendar = resource.getResourceCalendar();
}
Task task = getTask();
if (calendar == null || task.getIgnoreResourceCalendar())
{
calendar = task.getEffectiveCalendar();
}
return calendar;
}
|
java
|
{
"resource": ""
}
|
q987
|
ResourceAssignment.setEnterpriseCost
|
train
|
public void setEnterpriseCost(int index, Number value)
{
set(selectField(AssignmentFieldLists.ENTERPRISE_COST, index), value);
}
|
java
|
{
"resource": ""
}
|
q988
|
ResourceAssignment.setEnterpriseDate
|
train
|
public void setEnterpriseDate(int index, Date value)
{
set(selectField(AssignmentFieldLists.ENTERPRISE_DATE, index), value);
}
|
java
|
{
"resource": ""
}
|
q989
|
ResourceAssignment.setEnterpriseDuration
|
train
|
public void setEnterpriseDuration(int index, Duration value)
{
set(selectField(AssignmentFieldLists.ENTERPRISE_DURATION, index), value);
}
|
java
|
{
"resource": ""
}
|
q990
|
ResourceAssignment.setEnterpriseNumber
|
train
|
public void setEnterpriseNumber(int index, Number value)
{
set(selectField(AssignmentFieldLists.ENTERPRISE_NUMBER, index), value);
}
|
java
|
{
"resource": ""
}
|
q991
|
ResourceAssignment.setEnterpriseText
|
train
|
public void setEnterpriseText(int index, String value)
{
set(selectField(AssignmentFieldLists.ENTERPRISE_TEXT, index), value);
}
|
java
|
{
"resource": ""
}
|
q992
|
ResourceAssignment.getOvertimeCost
|
train
|
public Number getOvertimeCost()
{
Number cost = (Number) getCachedValue(AssignmentField.OVERTIME_COST);
if (cost == null)
{
Number actual = getActualOvertimeCost();
Number remaining = getRemainingOvertimeCost();
if (actual != null && remaining != null)
{
cost = NumberHelper.getDouble(actual.doubleValue() + remaining.doubleValue());
set(AssignmentField.OVERTIME_COST, cost);
}
}
return (cost);
}
|
java
|
{
"resource": ""
}
|
q993
|
ResourceAssignment.getPercentageWorkComplete
|
train
|
public Number getPercentageWorkComplete()
{
Number pct = (Number) getCachedValue(AssignmentField.PERCENT_WORK_COMPLETE);
if (pct == null)
{
Duration actualWork = getActualWork();
Duration work = getWork();
if (actualWork != null && work != null && work.getDuration() != 0)
{
pct = Double.valueOf((actualWork.getDuration() * 100) / work.convertUnits(actualWork.getUnits(), getParentFile().getProjectProperties()).getDuration());
set(AssignmentField.PERCENT_WORK_COMPLETE, pct);
}
}
return pct;
}
|
java
|
{
"resource": ""
}
|
q994
|
ResourceAssignment.getStartVariance
|
train
|
public Duration getStartVariance()
{
Duration variance = (Duration) getCachedValue(AssignmentField.START_VARIANCE);
if (variance == null)
{
TimeUnit format = getParentFile().getProjectProperties().getDefaultDurationUnits();
variance = DateHelper.getVariance(getTask(), getBaselineStart(), getStart(), format);
set(AssignmentField.START_VARIANCE, variance);
}
return (variance);
}
|
java
|
{
"resource": ""
}
|
q995
|
ResourceAssignment.getFinishVariance
|
train
|
public Duration getFinishVariance()
{
Duration variance = (Duration) getCachedValue(AssignmentField.FINISH_VARIANCE);
if (variance == null)
{
TimeUnit format = getParentFile().getProjectProperties().getDefaultDurationUnits();
variance = DateHelper.getVariance(getTask(), getBaselineFinish(), getFinish(), format);
set(AssignmentField.FINISH_VARIANCE, variance);
}
return (variance);
}
|
java
|
{
"resource": ""
}
|
q996
|
ResourceAssignment.getCostRateTableIndex
|
train
|
public int getCostRateTableIndex()
{
Integer value = (Integer) getCachedValue(AssignmentField.COST_RATE_TABLE);
return value == null ? 0 : value.intValue();
}
|
java
|
{
"resource": ""
}
|
q997
|
ResourceAssignment.selectField
|
train
|
private AssignmentField selectField(AssignmentField[] fields, int index)
{
if (index < 1 || index > fields.length)
{
throw new IllegalArgumentException(index + " is not a valid field index");
}
return (fields[index - 1]);
}
|
java
|
{
"resource": ""
}
|
q998
|
ActivitySorter.sort
|
train
|
public void sort(ChildTaskContainer container)
{
// Do we have any tasks?
List<Task> tasks = container.getChildTasks();
if (!tasks.isEmpty())
{
for (Task task : tasks)
{
//
// Sort child activities
//
sort(task);
//
// Sort Order:
// 1. Activities come first
// 2. WBS come last
// 3. Activities ordered by activity ID
// 4. WBS ordered by ID
//
Collections.sort(tasks, new Comparator<Task>()
{
@Override public int compare(Task t1, Task t2)
{
boolean t1IsWbs = m_wbsTasks.contains(t1);
boolean t2IsWbs = m_wbsTasks.contains(t2);
// Both are WBS
if (t1IsWbs && t2IsWbs)
{
return t1.getID().compareTo(t2.getID());
}
// Both are activities
if (!t1IsWbs && !t2IsWbs)
{
String activityID1 = (String) t1.getCurrentValue(m_activityIDField);
String activityID2 = (String) t2.getCurrentValue(m_activityIDField);
if (activityID1 == null || activityID2 == null)
{
return (activityID1 == null && activityID2 == null ? 0 : (activityID1 == null ? 1 : -1));
}
return activityID1.compareTo(activityID2);
}
// One activity one WBS
return t1IsWbs ? 1 : -1;
}
});
}
}
}
|
java
|
{
"resource": ""
}
|
q999
|
TableReader.read
|
train
|
public void read(File file, Table table) throws IOException
{
//System.out.println("Reading " + file.getName());
InputStream is = null;
try
{
is = new FileInputStream(file);
read(is, table);
}
finally
{
StreamHelper.closeQuietly(is);
}
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.