_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3 values | text stringlengths 73 34.1k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q700 | TableContainer.getIndex | train | private Map<String, Table> getIndex(Table table)
{
Map<String, Table> result;
if (!table.getResourceFlag())
{
result = m_taskTablesByName;
}
else
{
result = m_resourceTablesByName;
}
return result;
} | java | {
"resource": ""
} |
q701 | ProjectFilePanel.saveFile | train | public void saveFile(File file, String type)
{
if (file != null)
{
m_treeController.saveFile(file, type);
}
} | java | {
"resource": ""
} |
q702 | FilterContainer.addFilter | train | public void addFilter(Filter filter)
{
if (filter.isTaskFilter())
{
m_taskFilters.add(filter);
}
if (filter.isResourceFilter())
{
m_resourceFilters.add(filter);
}
m_filtersByName.put(filter.getName(), filter);
m_filtersByID.put(filter.getID(), filter);
} | java | {
"resource": ""
} |
q703 | FilterContainer.removeFilter | train | public void removeFilter(String filterName)
{
Filter filter = getFilterByName(filterName);
if (filter != null)
{
if (filter.isTaskFilter())
{
m_taskFilters.remove(filter);
}
if (filter.isResourceFilter())
{
m_resourceFilters.remove(filter);
}
m_filtersByName.remove(filterName);
m_filtersByID.remove(filter.getID());
}
} | java | {
"resource": ""
} |
q704 | PlannerWriter.writeProjectProperties | train | private void writeProjectProperties()
{
ProjectProperties properties = m_projectFile.getProjectProperties();
m_plannerProject.setCompany(properties.getCompany());
m_plannerProject.setManager(properties.getManager());
m_plannerProject.setName(getString(properties.getName()));
m_plannerProject.setProjectStart(getDateTime(properties.getStartDate()));
m_plannerProject.setCalendar(getIntegerString(m_projectFile.getDefaultCalendar().getUniqueID()));
m_plannerProject.setMrprojectVersion("2");
} | java | {
"resource": ""
} |
q705 | PlannerWriter.writeCalendars | train | private void writeCalendars() throws JAXBException
{
//
// Create the new Planner calendar list
//
Calendars calendars = m_factory.createCalendars();
m_plannerProject.setCalendars(calendars);
writeDayTypes(calendars);
List<net.sf.mpxj.planner.schema.Calendar> calendar = calendars.getCalendar();
//
// Process each calendar in turn
//
for (ProjectCalendar mpxjCalendar : m_projectFile.getCalendars())
{
net.sf.mpxj.planner.schema.Calendar plannerCalendar = m_factory.createCalendar();
calendar.add(plannerCalendar);
writeCalendar(mpxjCalendar, plannerCalendar);
}
} | java | {
"resource": ""
} |
q706 | PlannerWriter.writeDayTypes | train | private void writeDayTypes(Calendars calendars)
{
DayTypes dayTypes = m_factory.createDayTypes();
calendars.setDayTypes(dayTypes);
List<DayType> typeList = dayTypes.getDayType();
DayType dayType = m_factory.createDayType();
typeList.add(dayType);
dayType.setId("0");
dayType.setName("Working");
dayType.setDescription("A default working day");
dayType = m_factory.createDayType();
typeList.add(dayType);
dayType.setId("1");
dayType.setName("Nonworking");
dayType.setDescription("A default non working day");
dayType = m_factory.createDayType();
typeList.add(dayType);
dayType.setId("2");
dayType.setName("Use base");
dayType.setDescription("Use day from base calendar");
} | java | {
"resource": ""
} |
q707 | PlannerWriter.writeCalendar | train | private void writeCalendar(ProjectCalendar mpxjCalendar, net.sf.mpxj.planner.schema.Calendar plannerCalendar) throws JAXBException
{
//
// Populate basic details
//
plannerCalendar.setId(getIntegerString(mpxjCalendar.getUniqueID()));
plannerCalendar.setName(getString(mpxjCalendar.getName()));
//
// Set working and non working days
//
DefaultWeek dw = m_factory.createDefaultWeek();
plannerCalendar.setDefaultWeek(dw);
dw.setMon(getWorkingDayString(mpxjCalendar, Day.MONDAY));
dw.setTue(getWorkingDayString(mpxjCalendar, Day.TUESDAY));
dw.setWed(getWorkingDayString(mpxjCalendar, Day.WEDNESDAY));
dw.setThu(getWorkingDayString(mpxjCalendar, Day.THURSDAY));
dw.setFri(getWorkingDayString(mpxjCalendar, Day.FRIDAY));
dw.setSat(getWorkingDayString(mpxjCalendar, Day.SATURDAY));
dw.setSun(getWorkingDayString(mpxjCalendar, Day.SUNDAY));
//
// Set working hours
//
OverriddenDayTypes odt = m_factory.createOverriddenDayTypes();
plannerCalendar.setOverriddenDayTypes(odt);
List<OverriddenDayType> typeList = odt.getOverriddenDayType();
Sequence uniqueID = new Sequence(0);
//
// This is a bit arbitrary, so not ideal, however...
// The idea here is that MS Project allows us to specify working hours
// for each day of the week individually. Planner doesn't do this,
// but instead allows us to specify working hours for each day type.
// What we are doing here is stepping through the days of the week to
// find the first working day, then using the hours for that day
// as the hours for the working day type in Planner.
//
for (int dayLoop = 1; dayLoop < 8; dayLoop++)
{
Day day = Day.getInstance(dayLoop);
if (mpxjCalendar.isWorkingDay(day))
{
processWorkingHours(mpxjCalendar, uniqueID, day, typeList);
break;
}
}
//
// Process exception days
//
Days plannerDays = m_factory.createDays();
plannerCalendar.setDays(plannerDays);
List<net.sf.mpxj.planner.schema.Day> dayList = plannerDays.getDay();
processExceptionDays(mpxjCalendar, dayList);
m_eventManager.fireCalendarWrittenEvent(mpxjCalendar);
//
// Process any derived calendars
//
List<net.sf.mpxj.planner.schema.Calendar> calendarList = plannerCalendar.getCalendar();
for (ProjectCalendar mpxjDerivedCalendar : mpxjCalendar.getDerivedCalendars())
{
net.sf.mpxj.planner.schema.Calendar plannerDerivedCalendar = m_factory.createCalendar();
calendarList.add(plannerDerivedCalendar);
writeCalendar(mpxjDerivedCalendar, plannerDerivedCalendar);
}
} | java | {
"resource": ""
} |
q708 | PlannerWriter.processWorkingHours | train | private void processWorkingHours(ProjectCalendar mpxjCalendar, Sequence uniqueID, Day day, List<OverriddenDayType> typeList)
{
if (isWorkingDay(mpxjCalendar, day))
{
ProjectCalendarHours mpxjHours = mpxjCalendar.getCalendarHours(day);
if (mpxjHours != null)
{
OverriddenDayType odt = m_factory.createOverriddenDayType();
typeList.add(odt);
odt.setId(getIntegerString(uniqueID.next()));
List<Interval> intervalList = odt.getInterval();
for (DateRange mpxjRange : mpxjHours)
{
Date rangeStart = mpxjRange.getStart();
Date rangeEnd = mpxjRange.getEnd();
if (rangeStart != null && rangeEnd != null)
{
Interval interval = m_factory.createInterval();
intervalList.add(interval);
interval.setStart(getTimeString(rangeStart));
interval.setEnd(getTimeString(rangeEnd));
}
}
}
}
} | java | {
"resource": ""
} |
q709 | PlannerWriter.writeResources | train | private void writeResources()
{
Resources resources = m_factory.createResources();
m_plannerProject.setResources(resources);
List<net.sf.mpxj.planner.schema.Resource> resourceList = resources.getResource();
for (Resource mpxjResource : m_projectFile.getResources())
{
net.sf.mpxj.planner.schema.Resource plannerResource = m_factory.createResource();
resourceList.add(plannerResource);
writeResource(mpxjResource, plannerResource);
}
} | java | {
"resource": ""
} |
q710 | PlannerWriter.writeResource | train | private void writeResource(Resource mpxjResource, net.sf.mpxj.planner.schema.Resource plannerResource)
{
ProjectCalendar resourceCalendar = mpxjResource.getResourceCalendar();
if (resourceCalendar != null)
{
plannerResource.setCalendar(getIntegerString(resourceCalendar.getUniqueID()));
}
plannerResource.setEmail(mpxjResource.getEmailAddress());
plannerResource.setId(getIntegerString(mpxjResource.getUniqueID()));
plannerResource.setName(getString(mpxjResource.getName()));
plannerResource.setNote(mpxjResource.getNotes());
plannerResource.setShortName(mpxjResource.getInitials());
plannerResource.setType(mpxjResource.getType() == ResourceType.MATERIAL ? "2" : "1");
//plannerResource.setStdRate();
//plannerResource.setOvtRate();
plannerResource.setUnits("0");
//plannerResource.setProperties();
m_eventManager.fireResourceWrittenEvent(mpxjResource);
} | java | {
"resource": ""
} |
q711 | PlannerWriter.writeTasks | train | private void writeTasks() throws JAXBException
{
Tasks tasks = m_factory.createTasks();
m_plannerProject.setTasks(tasks);
List<net.sf.mpxj.planner.schema.Task> taskList = tasks.getTask();
for (Task task : m_projectFile.getChildTasks())
{
writeTask(task, taskList);
}
} | java | {
"resource": ""
} |
q712 | PlannerWriter.writeTask | train | private void writeTask(Task mpxjTask, List<net.sf.mpxj.planner.schema.Task> taskList) throws JAXBException
{
net.sf.mpxj.planner.schema.Task plannerTask = m_factory.createTask();
taskList.add(plannerTask);
plannerTask.setEnd(getDateTimeString(mpxjTask.getFinish()));
plannerTask.setId(getIntegerString(mpxjTask.getUniqueID()));
plannerTask.setName(getString(mpxjTask.getName()));
plannerTask.setNote(mpxjTask.getNotes());
plannerTask.setPercentComplete(getIntegerString(mpxjTask.getPercentageWorkComplete()));
plannerTask.setPriority(mpxjTask.getPriority() == null ? null : getIntegerString(mpxjTask.getPriority().getValue() * 10));
plannerTask.setScheduling(getScheduling(mpxjTask.getType()));
plannerTask.setStart(getDateTimeString(DateHelper.getDayStartDate(mpxjTask.getStart())));
if (mpxjTask.getMilestone())
{
plannerTask.setType("milestone");
}
else
{
plannerTask.setType("normal");
}
plannerTask.setWork(getDurationString(mpxjTask.getWork()));
plannerTask.setWorkStart(getDateTimeString(mpxjTask.getStart()));
ConstraintType mpxjConstraintType = mpxjTask.getConstraintType();
if (mpxjConstraintType != ConstraintType.AS_SOON_AS_POSSIBLE)
{
Constraint plannerConstraint = m_factory.createConstraint();
plannerTask.setConstraint(plannerConstraint);
if (mpxjConstraintType == ConstraintType.START_NO_EARLIER_THAN)
{
plannerConstraint.setType("start-no-earlier-than");
}
else
{
if (mpxjConstraintType == ConstraintType.MUST_START_ON)
{
plannerConstraint.setType("must-start-on");
}
}
plannerConstraint.setTime(getDateTimeString(mpxjTask.getConstraintDate()));
}
//
// Write predecessors
//
writePredecessors(mpxjTask, plannerTask);
m_eventManager.fireTaskWrittenEvent(mpxjTask);
//
// Write child tasks
//
List<net.sf.mpxj.planner.schema.Task> childTaskList = plannerTask.getTask();
for (Task task : mpxjTask.getChildTasks())
{
writeTask(task, childTaskList);
}
} | java | {
"resource": ""
} |
q713 | PlannerWriter.writePredecessors | train | private void writePredecessors(Task mpxjTask, net.sf.mpxj.planner.schema.Task plannerTask)
{
Predecessors plannerPredecessors = m_factory.createPredecessors();
plannerTask.setPredecessors(plannerPredecessors);
List<Predecessor> predecessorList = plannerPredecessors.getPredecessor();
int id = 0;
List<Relation> predecessors = mpxjTask.getPredecessors();
for (Relation rel : predecessors)
{
Integer taskUniqueID = rel.getTargetTask().getUniqueID();
Predecessor plannerPredecessor = m_factory.createPredecessor();
plannerPredecessor.setId(getIntegerString(++id));
plannerPredecessor.setPredecessorId(getIntegerString(taskUniqueID));
plannerPredecessor.setLag(getDurationString(rel.getLag()));
plannerPredecessor.setType(RELATIONSHIP_TYPES.get(rel.getType()));
predecessorList.add(plannerPredecessor);
m_eventManager.fireRelationWrittenEvent(rel);
}
} | java | {
"resource": ""
} |
q714 | PlannerWriter.writeAssignments | train | private void writeAssignments()
{
Allocations allocations = m_factory.createAllocations();
m_plannerProject.setAllocations(allocations);
List<Allocation> allocationList = allocations.getAllocation();
for (ResourceAssignment mpxjAssignment : m_projectFile.getResourceAssignments())
{
Allocation plannerAllocation = m_factory.createAllocation();
allocationList.add(plannerAllocation);
plannerAllocation.setTaskId(getIntegerString(mpxjAssignment.getTask().getUniqueID()));
plannerAllocation.setResourceId(getIntegerString(mpxjAssignment.getResourceUniqueID()));
plannerAllocation.setUnits(getIntegerString(mpxjAssignment.getUnits()));
m_eventManager.fireAssignmentWrittenEvent(mpxjAssignment);
}
} | java | {
"resource": ""
} |
q715 | PlannerWriter.getIntegerString | train | private String getIntegerString(Number value)
{
return (value == null ? null : Integer.toString(value.intValue()));
} | java | {
"resource": ""
} |
q716 | PlannerWriter.isWorkingDay | train | private boolean isWorkingDay(ProjectCalendar mpxjCalendar, Day day)
{
boolean result = false;
net.sf.mpxj.DayType type = mpxjCalendar.getWorkingDay(day);
if (type == null)
{
type = net.sf.mpxj.DayType.DEFAULT;
}
switch (type)
{
case WORKING:
{
result = true;
break;
}
case NON_WORKING:
{
result = false;
break;
}
case DEFAULT:
{
if (mpxjCalendar.getParent() == null)
{
result = false;
}
else
{
result = isWorkingDay(mpxjCalendar.getParent(), day);
}
break;
}
}
return (result);
} | java | {
"resource": ""
} |
q717 | PlannerWriter.getWorkingDayString | train | private String getWorkingDayString(ProjectCalendar mpxjCalendar, Day day)
{
String result = null;
net.sf.mpxj.DayType type = mpxjCalendar.getWorkingDay(day);
if (type == null)
{
type = net.sf.mpxj.DayType.DEFAULT;
}
switch (type)
{
case WORKING:
{
result = "0";
break;
}
case NON_WORKING:
{
result = "1";
break;
}
case DEFAULT:
{
result = "2";
break;
}
}
return (result);
} | java | {
"resource": ""
} |
q718 | PlannerWriter.getTimeString | train | private String getTimeString(Date value)
{
Calendar cal = DateHelper.popCalendar(value);
int hours = cal.get(Calendar.HOUR_OF_DAY);
int minutes = cal.get(Calendar.MINUTE);
DateHelper.pushCalendar(cal);
StringBuilder sb = new StringBuilder(4);
sb.append(m_twoDigitFormat.format(hours));
sb.append(m_twoDigitFormat.format(minutes));
return (sb.toString());
} | java | {
"resource": ""
} |
q719 | PlannerWriter.getDateString | train | private String getDateString(Date value)
{
Calendar cal = DateHelper.popCalendar(value);
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH) + 1;
int day = cal.get(Calendar.DAY_OF_MONTH);
DateHelper.pushCalendar(cal);
StringBuilder sb = new StringBuilder(8);
sb.append(m_fourDigitFormat.format(year));
sb.append(m_twoDigitFormat.format(month));
sb.append(m_twoDigitFormat.format(day));
return (sb.toString());
} | java | {
"resource": ""
} |
q720 | PlannerWriter.getDateTimeString | train | private String getDateTimeString(Date value)
{
String result = null;
if (value != null)
{
Calendar cal = DateHelper.popCalendar(value);
StringBuilder sb = new StringBuilder(16);
sb.append(m_fourDigitFormat.format(cal.get(Calendar.YEAR)));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.MONTH) + 1));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.DAY_OF_MONTH)));
sb.append('T');
sb.append(m_twoDigitFormat.format(cal.get(Calendar.HOUR_OF_DAY)));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.MINUTE)));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.SECOND)));
sb.append('Z');
result = sb.toString();
DateHelper.pushCalendar(cal);
}
return result;
} | java | {
"resource": ""
} |
q721 | PlannerWriter.getDurationString | train | private String getDurationString(Duration value)
{
String result = null;
if (value != null)
{
double seconds = 0;
switch (value.getUnits())
{
case MINUTES:
case ELAPSED_MINUTES:
{
seconds = value.getDuration() * 60;
break;
}
case HOURS:
case ELAPSED_HOURS:
{
seconds = value.getDuration() * (60 * 60);
break;
}
case DAYS:
{
double minutesPerDay = m_projectFile.getProjectProperties().getMinutesPerDay().doubleValue();
seconds = value.getDuration() * (minutesPerDay * 60);
break;
}
case ELAPSED_DAYS:
{
seconds = value.getDuration() * (24 * 60 * 60);
break;
}
case WEEKS:
{
double minutesPerWeek = m_projectFile.getProjectProperties().getMinutesPerWeek().doubleValue();
seconds = value.getDuration() * (minutesPerWeek * 60);
break;
}
case ELAPSED_WEEKS:
{
seconds = value.getDuration() * (7 * 24 * 60 * 60);
break;
}
case MONTHS:
{
double minutesPerDay = m_projectFile.getProjectProperties().getMinutesPerDay().doubleValue();
double daysPerMonth = m_projectFile.getProjectProperties().getDaysPerMonth().doubleValue();
seconds = value.getDuration() * (daysPerMonth * minutesPerDay * 60);
break;
}
case ELAPSED_MONTHS:
{
seconds = value.getDuration() * (30 * 24 * 60 * 60);
break;
}
case YEARS:
{
double minutesPerDay = m_projectFile.getProjectProperties().getMinutesPerDay().doubleValue();
double daysPerMonth = m_projectFile.getProjectProperties().getDaysPerMonth().doubleValue();
seconds = value.getDuration() * (12 * daysPerMonth * minutesPerDay * 60);
break;
}
case ELAPSED_YEARS:
{
seconds = value.getDuration() * (365 * 24 * 60 * 60);
break;
}
default:
{
break;
}
}
result = Long.toString((long) seconds);
}
return (result);
} | java | {
"resource": ""
} |
q722 | PlannerReader.readProjectProperties | train | private void readProjectProperties(Project project) throws MPXJException
{
ProjectProperties properties = m_projectFile.getProjectProperties();
properties.setCompany(project.getCompany());
properties.setManager(project.getManager());
properties.setName(project.getName());
properties.setStartDate(getDateTime(project.getProjectStart()));
} | java | {
"resource": ""
} |
q723 | PlannerReader.readCalendars | train | private void readCalendars(Project project) throws MPXJException
{
Calendars calendars = project.getCalendars();
if (calendars != null)
{
for (net.sf.mpxj.planner.schema.Calendar cal : calendars.getCalendar())
{
readCalendar(cal, null);
}
Integer defaultCalendarID = getInteger(project.getCalendar());
m_defaultCalendar = m_projectFile.getCalendarByUniqueID(defaultCalendarID);
if (m_defaultCalendar != null)
{
m_projectFile.getProjectProperties().setDefaultCalendarName(m_defaultCalendar.getName());
}
}
} | java | {
"resource": ""
} |
q724 | PlannerReader.readCalendar | train | private void readCalendar(net.sf.mpxj.planner.schema.Calendar plannerCalendar, ProjectCalendar parentMpxjCalendar) throws MPXJException
{
//
// Create a calendar instance
//
ProjectCalendar mpxjCalendar = m_projectFile.addCalendar();
//
// Populate basic details
//
mpxjCalendar.setUniqueID(getInteger(plannerCalendar.getId()));
mpxjCalendar.setName(plannerCalendar.getName());
mpxjCalendar.setParent(parentMpxjCalendar);
//
// Set working and non working days
//
DefaultWeek dw = plannerCalendar.getDefaultWeek();
setWorkingDay(mpxjCalendar, Day.MONDAY, dw.getMon());
setWorkingDay(mpxjCalendar, Day.TUESDAY, dw.getTue());
setWorkingDay(mpxjCalendar, Day.WEDNESDAY, dw.getWed());
setWorkingDay(mpxjCalendar, Day.THURSDAY, dw.getThu());
setWorkingDay(mpxjCalendar, Day.FRIDAY, dw.getFri());
setWorkingDay(mpxjCalendar, Day.SATURDAY, dw.getSat());
setWorkingDay(mpxjCalendar, Day.SUNDAY, dw.getSun());
//
// Set working hours
//
processWorkingHours(mpxjCalendar, plannerCalendar);
//
// Process exception days
//
processExceptionDays(mpxjCalendar, plannerCalendar);
m_eventManager.fireCalendarReadEvent(mpxjCalendar);
//
// Process any derived calendars
//
List<net.sf.mpxj.planner.schema.Calendar> calendarList = plannerCalendar.getCalendar();
for (net.sf.mpxj.planner.schema.Calendar cal : calendarList)
{
readCalendar(cal, mpxjCalendar);
}
} | java | {
"resource": ""
} |
q725 | PlannerReader.readResources | train | private void readResources(Project plannerProject) throws MPXJException
{
Resources resources = plannerProject.getResources();
if (resources != null)
{
for (net.sf.mpxj.planner.schema.Resource res : resources.getResource())
{
readResource(res);
}
}
} | java | {
"resource": ""
} |
q726 | PlannerReader.readResource | train | private void readResource(net.sf.mpxj.planner.schema.Resource plannerResource) throws MPXJException
{
Resource mpxjResource = m_projectFile.addResource();
//mpxjResource.setResourceCalendar(m_projectFile.getBaseCalendarByUniqueID(getInteger(plannerResource.getCalendar())));
mpxjResource.setEmailAddress(plannerResource.getEmail());
mpxjResource.setUniqueID(getInteger(plannerResource.getId()));
mpxjResource.setName(plannerResource.getName());
mpxjResource.setNotes(plannerResource.getNote());
mpxjResource.setInitials(plannerResource.getShortName());
mpxjResource.setType(getInt(plannerResource.getType()) == 2 ? ResourceType.MATERIAL : ResourceType.WORK);
//plannerResource.getStdRate();
//plannerResource.getOvtRate();
//plannerResource.getUnits();
//plannerResource.getProperties();
ProjectCalendar calendar = mpxjResource.addResourceCalendar();
calendar.setWorkingDay(Day.SUNDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.MONDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.TUESDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.WEDNESDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.THURSDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.FRIDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.SATURDAY, DayType.DEFAULT);
ProjectCalendar baseCalendar = m_projectFile.getCalendarByUniqueID(getInteger(plannerResource.getCalendar()));
if (baseCalendar == null)
{
baseCalendar = m_defaultCalendar;
}
calendar.setParent(baseCalendar);
m_eventManager.fireResourceReadEvent(mpxjResource);
} | java | {
"resource": ""
} |
q727 | PlannerReader.readTasks | train | private void readTasks(Project plannerProject) throws MPXJException
{
Tasks tasks = plannerProject.getTasks();
if (tasks != null)
{
for (net.sf.mpxj.planner.schema.Task task : tasks.getTask())
{
readTask(null, task);
}
for (net.sf.mpxj.planner.schema.Task task : tasks.getTask())
{
readPredecessors(task);
}
}
m_projectFile.updateStructure();
} | java | {
"resource": ""
} |
q728 | PlannerReader.readPredecessors | train | private void readPredecessors(net.sf.mpxj.planner.schema.Task plannerTask)
{
Task mpxjTask = m_projectFile.getTaskByUniqueID(getInteger(plannerTask.getId()));
Predecessors predecessors = plannerTask.getPredecessors();
if (predecessors != null)
{
List<Predecessor> predecessorList = predecessors.getPredecessor();
for (Predecessor predecessor : predecessorList)
{
Integer predecessorID = getInteger(predecessor.getPredecessorId());
Task predecessorTask = m_projectFile.getTaskByUniqueID(predecessorID);
if (predecessorTask != null)
{
Duration lag = getDuration(predecessor.getLag());
if (lag == null)
{
lag = Duration.getInstance(0, TimeUnit.HOURS);
}
Relation relation = mpxjTask.addPredecessor(predecessorTask, RELATIONSHIP_TYPES.get(predecessor.getType()), lag);
m_eventManager.fireRelationReadEvent(relation);
}
}
}
//
// Process child tasks
//
List<net.sf.mpxj.planner.schema.Task> childTasks = plannerTask.getTask();
for (net.sf.mpxj.planner.schema.Task childTask : childTasks)
{
readPredecessors(childTask);
}
} | java | {
"resource": ""
} |
q729 | PlannerReader.readAssignments | train | private void readAssignments(Project plannerProject)
{
Allocations allocations = plannerProject.getAllocations();
List<Allocation> allocationList = allocations.getAllocation();
Set<Task> tasksWithAssignments = new HashSet<Task>();
for (Allocation allocation : allocationList)
{
Integer taskID = getInteger(allocation.getTaskId());
Integer resourceID = getInteger(allocation.getResourceId());
Integer units = getInteger(allocation.getUnits());
Task task = m_projectFile.getTaskByUniqueID(taskID);
Resource resource = m_projectFile.getResourceByUniqueID(resourceID);
if (task != null && resource != null)
{
Duration work = task.getWork();
int percentComplete = NumberHelper.getInt(task.getPercentageComplete());
ResourceAssignment assignment = task.addResourceAssignment(resource);
assignment.setUnits(units);
assignment.setWork(work);
if (percentComplete != 0)
{
Duration actualWork = Duration.getInstance((work.getDuration() * percentComplete) / 100, work.getUnits());
assignment.setActualWork(actualWork);
assignment.setRemainingWork(Duration.getInstance(work.getDuration() - actualWork.getDuration(), work.getUnits()));
}
else
{
assignment.setRemainingWork(work);
}
assignment.setStart(task.getStart());
assignment.setFinish(task.getFinish());
tasksWithAssignments.add(task);
m_eventManager.fireAssignmentReadEvent(assignment);
}
}
//
// Adjust work per assignment for tasks with multiple assignments
//
for (Task task : tasksWithAssignments)
{
List<ResourceAssignment> assignments = task.getResourceAssignments();
if (assignments.size() > 1)
{
double maxUnits = 0;
for (ResourceAssignment assignment : assignments)
{
maxUnits += assignment.getUnits().doubleValue();
}
for (ResourceAssignment assignment : assignments)
{
Duration work = assignment.getWork();
double factor = assignment.getUnits().doubleValue() / maxUnits;
work = Duration.getInstance(work.getDuration() * factor, work.getUnits());
assignment.setWork(work);
Duration actualWork = assignment.getActualWork();
if (actualWork != null)
{
actualWork = Duration.getInstance(actualWork.getDuration() * factor, actualWork.getUnits());
assignment.setActualWork(actualWork);
}
Duration remainingWork = assignment.getRemainingWork();
if (remainingWork != null)
{
remainingWork = Duration.getInstance(remainingWork.getDuration() * factor, remainingWork.getUnits());
assignment.setRemainingWork(remainingWork);
}
}
}
}
} | java | {
"resource": ""
} |
q730 | PlannerReader.getDateTime | train | private Date getDateTime(String value) throws MPXJException
{
try
{
Number year = m_fourDigitFormat.parse(value.substring(0, 4));
Number month = m_twoDigitFormat.parse(value.substring(4, 6));
Number day = m_twoDigitFormat.parse(value.substring(6, 8));
Number hours = m_twoDigitFormat.parse(value.substring(9, 11));
Number minutes = m_twoDigitFormat.parse(value.substring(11, 13));
Calendar cal = DateHelper.popCalendar();
cal.set(Calendar.YEAR, year.intValue());
cal.set(Calendar.MONTH, month.intValue() - 1);
cal.set(Calendar.DAY_OF_MONTH, day.intValue());
cal.set(Calendar.HOUR_OF_DAY, hours.intValue());
cal.set(Calendar.MINUTE, minutes.intValue());
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
Date result = cal.getTime();
DateHelper.pushCalendar(cal);
return result;
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse date-time " + value, ex);
}
} | java | {
"resource": ""
} |
q731 | PlannerReader.getTime | train | private Date getTime(String value) throws MPXJException
{
try
{
Number hours = m_twoDigitFormat.parse(value.substring(0, 2));
Number minutes = m_twoDigitFormat.parse(value.substring(2, 4));
Calendar cal = DateHelper.popCalendar();
cal.set(Calendar.HOUR_OF_DAY, hours.intValue());
cal.set(Calendar.MINUTE, minutes.intValue());
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
Date result = cal.getTime();
DateHelper.pushCalendar(cal);
return result;
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse time " + value, ex);
}
} | java | {
"resource": ""
} |
q732 | PlannerReader.getDuration | train | private Duration getDuration(String value)
{
Duration result = null;
if (value != null && value.length() != 0)
{
double seconds = getLong(value);
double hours = seconds / (60 * 60);
double days = hours / 8;
if (days < 1)
{
result = Duration.getInstance(hours, TimeUnit.HOURS);
}
else
{
double durationDays = hours / 8;
result = Duration.getInstance(durationDays, TimeUnit.DAYS);
}
}
return (result);
} | java | {
"resource": ""
} |
q733 | TimephasedUtility.segmentWork | train | public ArrayList<Duration> segmentWork(ProjectCalendar projectCalendar, List<TimephasedWork> work, TimescaleUnits rangeUnits, List<DateRange> dateList)
{
ArrayList<Duration> result = new ArrayList<Duration>(dateList.size());
int lastStartIndex = 0;
//
// Iterate through the list of dates range we are interested in.
// Each date range in this list corresponds to a column
// shown on the "timescale" view by MS Project
//
for (DateRange range : dateList)
{
//
// If the current date range does not intersect with any of the
// assignment date ranges in the list, then we show a zero
// duration for this date range.
//
int startIndex = lastStartIndex == -1 ? -1 : getStartIndex(range, work, lastStartIndex);
if (startIndex == -1)
{
result.add(Duration.getInstance(0, TimeUnit.HOURS));
}
else
{
//
// We have found an assignment which intersects with the current
// date range, call the method below to determine how
// much time from this resource assignment can be allocated
// to the current date range.
//
result.add(getRangeDuration(projectCalendar, rangeUnits, range, work, startIndex));
lastStartIndex = startIndex;
}
}
return result;
} | java | {
"resource": ""
} |
q734 | TimephasedUtility.segmentBaselineWork | train | public ArrayList<Duration> segmentBaselineWork(ProjectFile file, List<TimephasedWork> work, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
return segmentWork(file.getBaselineCalendar(), work, rangeUnits, dateList);
} | java | {
"resource": ""
} |
q735 | TimephasedUtility.segmentCost | train | public ArrayList<Double> segmentCost(ProjectCalendar projectCalendar, List<TimephasedCost> cost, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
ArrayList<Double> result = new ArrayList<Double>(dateList.size());
int lastStartIndex = 0;
//
// Iterate through the list of dates range we are interested in.
// Each date range in this list corresponds to a column
// shown on the "timescale" view by MS Project
//
for (DateRange range : dateList)
{
//
// If the current date range does not intersect with any of the
// assignment date ranges in the list, then we show a zero
// duration for this date range.
//
int startIndex = lastStartIndex == -1 ? -1 : getStartIndex(range, cost, lastStartIndex);
if (startIndex == -1)
{
result.add(NumberHelper.DOUBLE_ZERO);
}
else
{
//
// We have found an assignment which intersects with the current
// date range, call the method below to determine how
// much time from this resource assignment can be allocated
// to the current date range.
//
result.add(getRangeCost(projectCalendar, rangeUnits, range, cost, startIndex));
lastStartIndex = startIndex;
}
}
return result;
} | java | {
"resource": ""
} |
q736 | TimephasedUtility.segmentBaselineCost | train | public ArrayList<Double> segmentBaselineCost(ProjectFile file, List<TimephasedCost> cost, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
return segmentCost(file.getBaselineCalendar(), cost, rangeUnits, dateList);
} | java | {
"resource": ""
} |
q737 | TimephasedUtility.getStartIndex | train | private <T extends TimephasedItem<?>> int getStartIndex(DateRange range, List<T> assignments, int startIndex)
{
int result = -1;
if (assignments != null)
{
long rangeStart = range.getStart().getTime();
long rangeEnd = range.getEnd().getTime();
for (int loop = startIndex; loop < assignments.size(); loop++)
{
T assignment = assignments.get(loop);
int compareResult = DateHelper.compare(assignment.getStart(), assignment.getFinish(), rangeStart);
//
// The start of the target range falls after the assignment end -
// move on to test the next assignment.
//
if (compareResult > 0)
{
continue;
}
//
// The start of the target range falls within the assignment -
// return the index of this assignment to the caller.
//
if (compareResult == 0)
{
result = loop;
break;
}
//
// At this point, we know that the start of the target range is before
// the assignment start. We need to determine if the end of the
// target range overlaps the assignment.
//
compareResult = DateHelper.compare(assignment.getStart(), assignment.getFinish(), rangeEnd);
if (compareResult >= 0)
{
result = loop;
break;
}
}
}
return result;
} | java | {
"resource": ""
} |
q738 | AbstractCalendarFactory.processCalendarHours | train | private void processCalendarHours(byte[] data, ProjectCalendar defaultCalendar, ProjectCalendar cal, boolean isBaseCalendar)
{
// Dump out the calendar related data and fields.
//MPPUtility.dataDump(data, true, false, false, false, true, false, true);
int offset;
ProjectCalendarHours hours;
int periodIndex;
int index;
int defaultFlag;
int periodCount;
Date start;
long duration;
Day day;
List<DateRange> dateRanges = new ArrayList<DateRange>(5);
for (index = 0; index < 7; index++)
{
offset = getCalendarHoursOffset() + (60 * index);
defaultFlag = data == null ? 1 : MPPUtility.getShort(data, offset);
day = Day.getInstance(index + 1);
if (defaultFlag == 1)
{
if (isBaseCalendar)
{
if (defaultCalendar == null)
{
cal.setWorkingDay(day, DEFAULT_WORKING_WEEK[index]);
if (cal.isWorkingDay(day))
{
hours = cal.addCalendarHours(Day.getInstance(index + 1));
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
}
}
else
{
boolean workingDay = defaultCalendar.isWorkingDay(day);
cal.setWorkingDay(day, workingDay);
if (workingDay)
{
hours = cal.addCalendarHours(Day.getInstance(index + 1));
for (DateRange range : defaultCalendar.getHours(day))
{
hours.addRange(range);
}
}
}
}
else
{
cal.setWorkingDay(day, DayType.DEFAULT);
}
}
else
{
dateRanges.clear();
periodIndex = 0;
periodCount = MPPUtility.getShort(data, offset + 2);
while (periodIndex < periodCount)
{
int startOffset = offset + 8 + (periodIndex * 2);
start = MPPUtility.getTime(data, startOffset);
int durationOffset = offset + 20 + (periodIndex * 4);
duration = MPPUtility.getDuration(data, durationOffset);
Date end = new Date(start.getTime() + duration);
dateRanges.add(new DateRange(start, end));
++periodIndex;
}
if (dateRanges.isEmpty())
{
cal.setWorkingDay(day, false);
}
else
{
cal.setWorkingDay(day, true);
hours = cal.addCalendarHours(Day.getInstance(index + 1));
for (DateRange range : dateRanges)
{
hours.addRange(range);
}
}
}
}
} | java | {
"resource": ""
} |
q739 | AbstractCalendarFactory.updateBaseCalendarNames | train | private void updateBaseCalendarNames(List<Pair<ProjectCalendar, Integer>> baseCalendars, HashMap<Integer, ProjectCalendar> map)
{
for (Pair<ProjectCalendar, Integer> pair : baseCalendars)
{
ProjectCalendar cal = pair.getFirst();
Integer baseCalendarID = pair.getSecond();
ProjectCalendar baseCal = map.get(baseCalendarID);
if (baseCal != null && baseCal.getName() != null)
{
cal.setParent(baseCal);
}
else
{
// Remove invalid calendar to avoid serious problems later.
m_file.removeCalendar(cal);
}
}
} | java | {
"resource": ""
} |
q740 | EventManager.fireTaskReadEvent | train | public void fireTaskReadEvent(Task task)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.taskRead(task);
}
}
} | java | {
"resource": ""
} |
q741 | EventManager.fireTaskWrittenEvent | train | public void fireTaskWrittenEvent(Task task)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.taskWritten(task);
}
}
} | java | {
"resource": ""
} |
q742 | EventManager.fireResourceReadEvent | train | public void fireResourceReadEvent(Resource resource)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.resourceRead(resource);
}
}
} | java | {
"resource": ""
} |
q743 | EventManager.fireResourceWrittenEvent | train | public void fireResourceWrittenEvent(Resource resource)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.resourceWritten(resource);
}
}
} | java | {
"resource": ""
} |
q744 | EventManager.fireCalendarReadEvent | train | public void fireCalendarReadEvent(ProjectCalendar calendar)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.calendarRead(calendar);
}
}
} | java | {
"resource": ""
} |
q745 | EventManager.fireAssignmentReadEvent | train | public void fireAssignmentReadEvent(ResourceAssignment resourceAssignment)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.assignmentRead(resourceAssignment);
}
}
} | java | {
"resource": ""
} |
q746 | EventManager.fireAssignmentWrittenEvent | train | public void fireAssignmentWrittenEvent(ResourceAssignment resourceAssignment)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.assignmentWritten(resourceAssignment);
}
}
} | java | {
"resource": ""
} |
q747 | EventManager.fireRelationReadEvent | train | public void fireRelationReadEvent(Relation relation)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.relationRead(relation);
}
}
} | java | {
"resource": ""
} |
q748 | EventManager.fireRelationWrittenEvent | train | public void fireRelationWrittenEvent(Relation relation)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.relationWritten(relation);
}
}
} | java | {
"resource": ""
} |
q749 | EventManager.fireCalendarWrittenEvent | train | public void fireCalendarWrittenEvent(ProjectCalendar calendar)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.calendarWritten(calendar);
}
}
} | java | {
"resource": ""
} |
q750 | EventManager.addProjectListeners | train | public void addProjectListeners(List<ProjectListener> listeners)
{
if (listeners != null)
{
for (ProjectListener listener : listeners)
{
addProjectListener(listener);
}
}
} | java | {
"resource": ""
} |
q751 | UserFieldCounters.nextField | train | public <E extends Enum<E> & FieldType> E nextField(Class<E> clazz, UserFieldDataType type)
{
for (String name : m_names[type.ordinal()])
{
int i = NumberHelper.getInt(m_counters.get(name)) + 1;
try
{
E e = Enum.valueOf(clazz, name + i);
m_counters.put(name, Integer.valueOf(i));
return e;
}
catch (IllegalArgumentException ex)
{
// try the next name
}
}
// no more fields available
throw new IllegalArgumentException("No fields for type " + type + " available");
} | java | {
"resource": ""
} |
q752 | FastTrackReader.read | train | private ProjectFile read() throws Exception
{
m_project = new ProjectFile();
m_eventManager = m_project.getEventManager();
ProjectConfig config = m_project.getProjectConfig();
config.setAutoCalendarUniqueID(false);
config.setAutoTaskID(false);
config.setAutoTaskUniqueID(false);
config.setAutoResourceUniqueID(false);
config.setAutoWBS(false);
config.setAutoOutlineNumber(false);
m_project.getProjectProperties().setFileApplication("FastTrack");
m_project.getProjectProperties().setFileType("FTS");
m_eventManager.addProjectListeners(m_projectListeners);
// processProject();
// processCalendars();
processResources();
processTasks();
processDependencies();
processAssignments();
return m_project;
} | java | {
"resource": ""
} |
q753 | FastTrackReader.processDependencies | train | private void processDependencies()
{
Set<Task> tasksWithBars = new HashSet<Task>();
FastTrackTable table = m_data.getTable(FastTrackTableType.ACTBARS);
for (MapRow row : table)
{
Task task = m_project.getTaskByUniqueID(row.getInteger(ActBarField._ACTIVITY));
if (task == null || tasksWithBars.contains(task))
{
continue;
}
tasksWithBars.add(task);
String predecessors = row.getString(ActBarField.PREDECESSORS);
if (predecessors == null || predecessors.isEmpty())
{
continue;
}
for (String predecessor : predecessors.split(", "))
{
Matcher matcher = RELATION_REGEX.matcher(predecessor);
matcher.matches();
Integer id = Integer.valueOf(matcher.group(1));
RelationType type = RELATION_TYPE_MAP.get(matcher.group(3));
if (type == null)
{
type = RelationType.FINISH_START;
}
String sign = matcher.group(4);
double lag = NumberHelper.getDouble(matcher.group(5));
if ("-".equals(sign))
{
lag = -lag;
}
Task targetTask = m_project.getTaskByID(id);
if (targetTask != null)
{
Duration lagDuration = Duration.getInstance(lag, m_data.getDurationTimeUnit());
Relation relation = task.addPredecessor(targetTask, type, lagDuration);
m_eventManager.fireRelationReadEvent(relation);
}
}
}
} | java | {
"resource": ""
} |
q754 | FastTrackReader.getOutlineLevel | train | private Integer getOutlineLevel(Task task)
{
String value = task.getWBS();
Integer result = Integer.valueOf(1);
if (value != null && value.length() > 0)
{
String[] path = WBS_SPLIT_REGEX.split(value);
result = Integer.valueOf(path.length);
}
return result;
} | java | {
"resource": ""
} |
q755 | RecurringData.setWeeklyDay | train | public void setWeeklyDay(Day day, boolean value)
{
if (value)
{
m_days.add(day);
}
else
{
m_days.remove(day);
}
} | java | {
"resource": ""
} |
q756 | RecurringData.setWeeklyDaysFromBitmap | train | public void setWeeklyDaysFromBitmap(Integer days, int[] masks)
{
if (days != null)
{
int value = days.intValue();
for (Day day : Day.values())
{
setWeeklyDay(day, ((value & masks[day.getValue()]) != 0));
}
}
} | java | {
"resource": ""
} |
q757 | RecurringData.getDayOfWeek | train | public Day getDayOfWeek()
{
Day result = null;
if (!m_days.isEmpty())
{
result = m_days.iterator().next();
}
return result;
} | java | {
"resource": ""
} |
q758 | RecurringData.getDates | train | public Date[] getDates()
{
int frequency = NumberHelper.getInt(m_frequency);
if (frequency < 1)
{
frequency = 1;
}
Calendar calendar = DateHelper.popCalendar(m_startDate);
List<Date> dates = new ArrayList<Date>();
switch (m_recurrenceType)
{
case DAILY:
{
getDailyDates(calendar, frequency, dates);
break;
}
case WEEKLY:
{
getWeeklyDates(calendar, frequency, dates);
break;
}
case MONTHLY:
{
getMonthlyDates(calendar, frequency, dates);
break;
}
case YEARLY:
{
getYearlyDates(calendar, dates);
break;
}
}
DateHelper.pushCalendar(calendar);
return dates.toArray(new Date[dates.size()]);
} | java | {
"resource": ""
} |
q759 | RecurringData.moreDates | train | private boolean moreDates(Calendar calendar, List<Date> dates)
{
boolean result;
if (m_finishDate == null)
{
int occurrences = NumberHelper.getInt(m_occurrences);
if (occurrences < 1)
{
occurrences = 1;
}
result = dates.size() < occurrences;
}
else
{
result = calendar.getTimeInMillis() <= m_finishDate.getTime();
}
return result;
} | java | {
"resource": ""
} |
q760 | RecurringData.getDailyDates | train | private void getDailyDates(Calendar calendar, int frequency, List<Date> dates)
{
while (moreDates(calendar, dates))
{
dates.add(calendar.getTime());
calendar.add(Calendar.DAY_OF_YEAR, frequency);
}
} | java | {
"resource": ""
} |
q761 | RecurringData.getWeeklyDates | train | private void getWeeklyDates(Calendar calendar, int frequency, List<Date> dates)
{
int currentDay = calendar.get(Calendar.DAY_OF_WEEK);
while (moreDates(calendar, dates))
{
int offset = 0;
for (int dayIndex = 0; dayIndex < 7; dayIndex++)
{
if (getWeeklyDay(Day.getInstance(currentDay)))
{
if (offset != 0)
{
calendar.add(Calendar.DAY_OF_YEAR, offset);
offset = 0;
}
if (!moreDates(calendar, dates))
{
break;
}
dates.add(calendar.getTime());
}
++offset;
++currentDay;
if (currentDay > 7)
{
currentDay = 1;
}
}
if (frequency > 1)
{
offset += (7 * (frequency - 1));
}
calendar.add(Calendar.DAY_OF_YEAR, offset);
}
} | java | {
"resource": ""
} |
q762 | RecurringData.getMonthlyDates | train | private void getMonthlyDates(Calendar calendar, int frequency, List<Date> dates)
{
if (m_relative)
{
getMonthlyRelativeDates(calendar, frequency, dates);
}
else
{
getMonthlyAbsoluteDates(calendar, frequency, dates);
}
} | java | {
"resource": ""
} |
q763 | RecurringData.getMonthlyRelativeDates | train | private void getMonthlyRelativeDates(Calendar calendar, int frequency, List<Date> dates)
{
long startDate = calendar.getTimeInMillis();
calendar.set(Calendar.DAY_OF_MONTH, 1);
int dayNumber = NumberHelper.getInt(m_dayNumber);
while (moreDates(calendar, dates))
{
if (dayNumber > 4)
{
setCalendarToLastRelativeDay(calendar);
}
else
{
setCalendarToOrdinalRelativeDay(calendar, dayNumber);
}
if (calendar.getTimeInMillis() > startDate)
{
dates.add(calendar.getTime());
if (!moreDates(calendar, dates))
{
break;
}
}
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, frequency);
}
} | java | {
"resource": ""
} |
q764 | RecurringData.getMonthlyAbsoluteDates | train | private void getMonthlyAbsoluteDates(Calendar calendar, int frequency, List<Date> dates)
{
int currentDayNumber = calendar.get(Calendar.DAY_OF_MONTH);
calendar.set(Calendar.DAY_OF_MONTH, 1);
int requiredDayNumber = NumberHelper.getInt(m_dayNumber);
if (requiredDayNumber < currentDayNumber)
{
calendar.add(Calendar.MONTH, 1);
}
while (moreDates(calendar, dates))
{
int useDayNumber = requiredDayNumber;
int maxDayNumber = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
if (useDayNumber > maxDayNumber)
{
useDayNumber = maxDayNumber;
}
calendar.set(Calendar.DAY_OF_MONTH, useDayNumber);
dates.add(calendar.getTime());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, frequency);
}
} | java | {
"resource": ""
} |
q765 | RecurringData.getYearlyDates | train | private void getYearlyDates(Calendar calendar, List<Date> dates)
{
if (m_relative)
{
getYearlyRelativeDates(calendar, dates);
}
else
{
getYearlyAbsoluteDates(calendar, dates);
}
} | java | {
"resource": ""
} |
q766 | RecurringData.getYearlyRelativeDates | train | private void getYearlyRelativeDates(Calendar calendar, List<Date> dates)
{
long startDate = calendar.getTimeInMillis();
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.MONTH, NumberHelper.getInt(m_monthNumber) - 1);
int dayNumber = NumberHelper.getInt(m_dayNumber);
while (moreDates(calendar, dates))
{
if (dayNumber > 4)
{
setCalendarToLastRelativeDay(calendar);
}
else
{
setCalendarToOrdinalRelativeDay(calendar, dayNumber);
}
if (calendar.getTimeInMillis() > startDate)
{
dates.add(calendar.getTime());
if (!moreDates(calendar, dates))
{
break;
}
}
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.YEAR, 1);
}
} | java | {
"resource": ""
} |
q767 | RecurringData.getYearlyAbsoluteDates | train | private void getYearlyAbsoluteDates(Calendar calendar, List<Date> dates)
{
long startDate = calendar.getTimeInMillis();
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.MONTH, NumberHelper.getInt(m_monthNumber) - 1);
int requiredDayNumber = NumberHelper.getInt(m_dayNumber);
while (moreDates(calendar, dates))
{
int useDayNumber = requiredDayNumber;
int maxDayNumber = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
if (useDayNumber > maxDayNumber)
{
useDayNumber = maxDayNumber;
}
calendar.set(Calendar.DAY_OF_MONTH, useDayNumber);
if (calendar.getTimeInMillis() < startDate)
{
calendar.add(Calendar.YEAR, 1);
}
dates.add(calendar.getTime());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.YEAR, 1);
}
} | java | {
"resource": ""
} |
q768 | RecurringData.setCalendarToOrdinalRelativeDay | train | private void setCalendarToOrdinalRelativeDay(Calendar calendar, int dayNumber)
{
int currentDayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int requiredDayOfWeek = getDayOfWeek().getValue();
int dayOfWeekOffset = 0;
if (requiredDayOfWeek > currentDayOfWeek)
{
dayOfWeekOffset = requiredDayOfWeek - currentDayOfWeek;
}
else
{
if (requiredDayOfWeek < currentDayOfWeek)
{
dayOfWeekOffset = 7 - (currentDayOfWeek - requiredDayOfWeek);
}
}
if (dayOfWeekOffset != 0)
{
calendar.add(Calendar.DAY_OF_YEAR, dayOfWeekOffset);
}
if (dayNumber > 1)
{
calendar.add(Calendar.DAY_OF_YEAR, (7 * (dayNumber - 1)));
}
} | java | {
"resource": ""
} |
q769 | RecurringData.setCalendarToLastRelativeDay | train | private void setCalendarToLastRelativeDay(Calendar calendar)
{
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
int currentDayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int requiredDayOfWeek = getDayOfWeek().getValue();
int dayOfWeekOffset = 0;
if (currentDayOfWeek > requiredDayOfWeek)
{
dayOfWeekOffset = requiredDayOfWeek - currentDayOfWeek;
}
else
{
if (currentDayOfWeek < requiredDayOfWeek)
{
dayOfWeekOffset = -7 + (requiredDayOfWeek - currentDayOfWeek);
}
}
if (dayOfWeekOffset != 0)
{
calendar.add(Calendar.DAY_OF_YEAR, dayOfWeekOffset);
}
} | java | {
"resource": ""
} |
q770 | RecurringData.setYearlyAbsoluteFromDate | train | public void setYearlyAbsoluteFromDate(Date date)
{
if (date != null)
{
Calendar cal = DateHelper.popCalendar(date);
m_dayNumber = Integer.valueOf(cal.get(Calendar.DAY_OF_MONTH));
m_monthNumber = Integer.valueOf(cal.get(Calendar.MONTH) + 1);
DateHelper.pushCalendar(cal);
}
} | java | {
"resource": ""
} |
q771 | RecurringData.getOrdinal | train | private String getOrdinal(Integer value)
{
String result;
int index = value.intValue();
if (index >= ORDINAL.length)
{
result = "every " + index + "th";
}
else
{
result = ORDINAL[index];
}
return result;
} | java | {
"resource": ""
} |
q772 | PriorityUtility.getInstance | train | public static Priority getInstance(Locale locale, String priority)
{
int index = DEFAULT_PRIORITY_INDEX;
if (priority != null)
{
String[] priorityTypes = LocaleData.getStringArray(locale, LocaleData.PRIORITY_TYPES);
for (int loop = 0; loop < priorityTypes.length; loop++)
{
if (priorityTypes[loop].equalsIgnoreCase(priority) == true)
{
index = loop;
break;
}
}
}
return (Priority.getInstance((index + 1) * 100));
} | java | {
"resource": ""
} |
q773 | Duration.add | train | public static Duration add(Duration a, Duration b, ProjectProperties defaults)
{
if (a == null && b == null)
{
return null;
}
if (a == null)
{
return b;
}
if (b == null)
{
return a;
}
TimeUnit unit = a.getUnits();
if (b.getUnits() != unit)
{
b = b.convertUnits(unit, defaults);
}
return Duration.getInstance(a.getDuration() + b.getDuration(), unit);
} | java | {
"resource": ""
} |
q774 | ProjectReaderUtility.getProjectReader | train | public static ProjectReader getProjectReader(String name) throws MPXJException
{
int index = name.lastIndexOf('.');
if (index == -1)
{
throw new IllegalArgumentException("Filename has no extension: " + name);
}
String extension = name.substring(index + 1).toUpperCase();
Class<? extends ProjectReader> fileClass = READER_MAP.get(extension);
if (fileClass == null)
{
throw new IllegalArgumentException("Cannot read files of type: " + extension);
}
try
{
ProjectReader file = fileClass.newInstance();
return (file);
}
catch (Exception ex)
{
throw new MPXJException("Failed to load project reader", ex);
}
} | java | {
"resource": ""
} |
q775 | MPD9DatabaseReader.processCalendars | train | private void processCalendars() throws SQLException
{
for (ResultSetRow row : getRows("SELECT * FROM MSP_CALENDARS WHERE PROJ_ID=?", m_projectID))
{
processCalendar(row);
}
updateBaseCalendarNames();
processCalendarData(m_project.getCalendars());
} | java | {
"resource": ""
} |
q776 | MPD9DatabaseReader.processCalendarData | train | private void processCalendarData(List<ProjectCalendar> calendars) throws SQLException
{
for (ProjectCalendar calendar : calendars)
{
processCalendarData(calendar, getRows("SELECT * FROM MSP_CALENDAR_DATA WHERE PROJ_ID=? AND CAL_UID=?", m_projectID, calendar.getUniqueID()));
}
} | java | {
"resource": ""
} |
q777 | MPD9DatabaseReader.processCalendarData | train | private void processCalendarData(ProjectCalendar calendar, List<ResultSetRow> calendarData)
{
for (ResultSetRow row : calendarData)
{
processCalendarData(calendar, row);
}
} | java | {
"resource": ""
} |
q778 | MPD9DatabaseReader.processSubProjects | train | private void processSubProjects()
{
int subprojectIndex = 1;
for (Task task : m_project.getTasks())
{
String subProjectFileName = task.getSubprojectName();
if (subProjectFileName != null)
{
String fileName = subProjectFileName;
int offset = 0x01000000 + (subprojectIndex * 0x00400000);
int index = subProjectFileName.lastIndexOf('\\');
if (index != -1)
{
fileName = subProjectFileName.substring(index + 1);
}
SubProject sp = new SubProject();
sp.setFileName(fileName);
sp.setFullPath(subProjectFileName);
sp.setUniqueIDOffset(Integer.valueOf(offset));
sp.setTaskUniqueID(task.getUniqueID());
task.setSubProject(sp);
++subprojectIndex;
}
}
} | java | {
"resource": ""
} |
q779 | MPD9DatabaseReader.processOutlineCodeFields | train | private void processOutlineCodeFields(Row parentRow) throws SQLException
{
Integer entityID = parentRow.getInteger("CODE_REF_UID");
Integer outlineCodeEntityID = parentRow.getInteger("CODE_UID");
for (ResultSetRow row : getRows("SELECT * FROM MSP_OUTLINE_CODES WHERE CODE_UID=?", outlineCodeEntityID))
{
processOutlineCodeField(entityID, row);
}
} | java | {
"resource": ""
} |
q780 | MPD9DatabaseReader.allocateConnection | train | private void allocateConnection() throws SQLException
{
if (m_connection == null)
{
m_connection = m_dataSource.getConnection();
m_allocatedConnection = true;
queryDatabaseMetaData();
}
} | java | {
"resource": ""
} |
q781 | MPD9DatabaseReader.queryDatabaseMetaData | train | private void queryDatabaseMetaData()
{
ResultSet rs = null;
try
{
Set<String> tables = new HashSet<String>();
DatabaseMetaData dmd = m_connection.getMetaData();
rs = dmd.getTables(null, null, null, null);
while (rs.next())
{
tables.add(rs.getString("TABLE_NAME"));
}
m_hasResourceBaselines = tables.contains("MSP_RESOURCE_BASELINES");
m_hasTaskBaselines = tables.contains("MSP_TASK_BASELINES");
m_hasAssignmentBaselines = tables.contains("MSP_ASSIGNMENT_BASELINES");
}
catch (Exception ex)
{
// Ignore errors when reading meta data
}
finally
{
if (rs != null)
{
try
{
rs.close();
}
catch (SQLException ex)
{
// Ignore errors when closing result set
}
rs = null;
}
}
} | java | {
"resource": ""
} |
q782 | DatatypeConverter.parseUUID | train | public static final UUID parseUUID(String value)
{
UUID result = null;
if (value != null && !value.isEmpty())
{
if (value.charAt(0) == '{')
{
// PMXML representation: <GUID>{0AB9133E-A09A-9648-B98A-B2384894AC44}</GUID>
result = UUID.fromString(value.substring(1, value.length() - 1));
}
else
{
// XER representation: CrkTPqCalki5irI4SJSsRA
byte[] data = javax.xml.bind.DatatypeConverter.parseBase64Binary(value + "==");
long msb = 0;
long lsb = 0;
for (int i = 0; i < 8; i++)
{
msb = (msb << 8) | (data[i] & 0xff);
}
for (int i = 8; i < 16; i++)
{
lsb = (lsb << 8) | (data[i] & 0xff);
}
result = new UUID(msb, lsb);
}
}
return result;
} | java | {
"resource": ""
} |
q783 | DatatypeConverter.printUUID | train | public static String printUUID(UUID guid)
{
return guid == null ? null : "{" + guid.toString().toUpperCase() + "}";
} | java | {
"resource": ""
} |
q784 | DatatypeConverter.printTime | train | public static final String printTime(Date value)
{
return (value == null ? null : TIME_FORMAT.get().format(value));
} | java | {
"resource": ""
} |
q785 | ProjectEntityContainer.renumberUniqueIDs | train | public void renumberUniqueIDs()
{
int uid = firstUniqueID();
for (T entity : this)
{
entity.setUniqueID(Integer.valueOf(uid++));
}
} | java | {
"resource": ""
} |
q786 | ProjectEntityContainer.validateUniqueIDsForMicrosoftProject | train | public void validateUniqueIDsForMicrosoftProject()
{
if (!isEmpty())
{
for (T entity : this)
{
if (NumberHelper.getInt(entity.getUniqueID()) > MS_PROJECT_MAX_UNIQUE_ID)
{
renumberUniqueIDs();
break;
}
}
}
} | java | {
"resource": ""
} |
q787 | SureTrakDatabaseReader.readDefinitions | train | private void readDefinitions()
{
for (MapRow row : m_tables.get("TTL"))
{
Integer id = row.getInteger("DEFINITION_ID");
List<MapRow> list = m_definitions.get(id);
if (list == null)
{
list = new ArrayList<MapRow>();
m_definitions.put(id, list);
}
list.add(row);
}
List<MapRow> rows = m_definitions.get(WBS_FORMAT_ID);
if (rows != null)
{
m_wbsFormat = new SureTrakWbsFormat(rows.get(0));
}
} | java | {
"resource": ""
} |
q788 | SureTrakDatabaseReader.readCalendars | train | private void readCalendars()
{
Table cal = m_tables.get("CAL");
for (MapRow row : cal)
{
ProjectCalendar calendar = m_projectFile.addCalendar();
m_calendarMap.put(row.getInteger("CALENDAR_ID"), calendar);
Integer[] days =
{
row.getInteger("SUNDAY_HOURS"),
row.getInteger("MONDAY_HOURS"),
row.getInteger("TUESDAY_HOURS"),
row.getInteger("WEDNESDAY_HOURS"),
row.getInteger("THURSDAY_HOURS"),
row.getInteger("FRIDAY_HOURS"),
row.getInteger("SATURDAY_HOURS")
};
calendar.setName(row.getString("NAME"));
readHours(calendar, Day.SUNDAY, days[0]);
readHours(calendar, Day.MONDAY, days[1]);
readHours(calendar, Day.TUESDAY, days[2]);
readHours(calendar, Day.WEDNESDAY, days[3]);
readHours(calendar, Day.THURSDAY, days[4]);
readHours(calendar, Day.FRIDAY, days[5]);
readHours(calendar, Day.SATURDAY, days[6]);
int workingDaysPerWeek = 0;
for (Day day : Day.values())
{
if (calendar.isWorkingDay(day))
{
++workingDaysPerWeek;
}
}
Integer workingHours = null;
for (int index = 0; index < 7; index++)
{
if (days[index].intValue() != 0)
{
workingHours = days[index];
break;
}
}
if (workingHours != null)
{
int workingHoursPerDay = countHours(workingHours);
int minutesPerDay = workingHoursPerDay * 60;
int minutesPerWeek = minutesPerDay * workingDaysPerWeek;
int minutesPerMonth = 4 * minutesPerWeek;
int minutesPerYear = 52 * minutesPerWeek;
calendar.setMinutesPerDay(Integer.valueOf(minutesPerDay));
calendar.setMinutesPerWeek(Integer.valueOf(minutesPerWeek));
calendar.setMinutesPerMonth(Integer.valueOf(minutesPerMonth));
calendar.setMinutesPerYear(Integer.valueOf(minutesPerYear));
}
}
} | java | {
"resource": ""
} |
q789 | SureTrakDatabaseReader.readHours | train | private void readHours(ProjectCalendar calendar, Day day, Integer hours)
{
int value = hours.intValue();
int startHour = 0;
ProjectCalendarHours calendarHours = null;
Calendar cal = DateHelper.popCalendar();
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
calendar.setWorkingDay(day, false);
while (value != 0)
{
// Move forward until we find a working hour
while (startHour < 24 && (value & 0x1) == 0)
{
value = value >> 1;
++startHour;
}
// No more working hours, bail out
if (startHour >= 24)
{
break;
}
// Move forward until we find the end of the working hours
int endHour = startHour;
while (endHour < 24 && (value & 0x1) != 0)
{
value = value >> 1;
++endHour;
}
cal.set(Calendar.HOUR_OF_DAY, startHour);
Date startDate = cal.getTime();
cal.set(Calendar.HOUR_OF_DAY, endHour);
Date endDate = cal.getTime();
if (calendarHours == null)
{
calendarHours = calendar.addCalendarHours(day);
calendar.setWorkingDay(day, true);
}
calendarHours.addRange(new DateRange(startDate, endDate));
startHour = endHour;
}
DateHelper.pushCalendar(cal);
} | java | {
"resource": ""
} |
q790 | SureTrakDatabaseReader.countHours | train | private int countHours(Integer hours)
{
int value = hours.intValue();
int hoursPerDay = 0;
int hour = 0;
while (value > 0)
{
// Move forward until we find a working hour
while (hour < 24)
{
if ((value & 0x1) != 0)
{
++hoursPerDay;
}
value = value >> 1;
++hour;
}
}
return hoursPerDay;
} | java | {
"resource": ""
} |
q791 | SureTrakDatabaseReader.readHolidays | train | private void readHolidays()
{
for (MapRow row : m_tables.get("HOL"))
{
ProjectCalendar calendar = m_calendarMap.get(row.getInteger("CALENDAR_ID"));
if (calendar != null)
{
Date date = row.getDate("DATE");
ProjectCalendarException exception = calendar.addCalendarException(date, date);
if (row.getBoolean("ANNUAL"))
{
RecurringData recurring = new RecurringData();
recurring.setRecurrenceType(RecurrenceType.YEARLY);
recurring.setYearlyAbsoluteFromDate(date);
recurring.setStartDate(date);
exception.setRecurring(recurring);
// TODO set end date based on project end date
}
}
}
} | java | {
"resource": ""
} |
q792 | SureTrakDatabaseReader.readActivities | train | private void readActivities()
{
List<MapRow> items = new ArrayList<MapRow>();
for (MapRow row : m_tables.get("ACT"))
{
items.add(row);
}
final AlphanumComparator comparator = new AlphanumComparator();
Collections.sort(items, new Comparator<MapRow>()
{
@Override public int compare(MapRow o1, MapRow o2)
{
return comparator.compare(o1.getString("ACTIVITY_ID"), o2.getString("ACTIVITY_ID"));
}
});
for (MapRow row : items)
{
String activityID = row.getString("ACTIVITY_ID");
String wbs;
if (m_wbsFormat == null)
{
wbs = null;
}
else
{
m_wbsFormat.parseRawValue(row.getString("WBS"));
wbs = m_wbsFormat.getFormattedValue();
}
ChildTaskContainer parent = m_wbsMap.get(wbs);
if (parent == null)
{
parent = m_projectFile;
}
Task task = parent.addTask();
setFields(TASK_FIELDS, row, task);
task.setStart(task.getEarlyStart());
task.setFinish(task.getEarlyFinish());
task.setMilestone(task.getDuration().getDuration() == 0);
task.setWBS(wbs);
Duration duration = task.getDuration();
Duration remainingDuration = task.getRemainingDuration();
task.setActualDuration(Duration.getInstance(duration.getDuration() - remainingDuration.getDuration(), TimeUnit.HOURS));
m_activityMap.put(activityID, task);
}
} | java | {
"resource": ""
} |
q793 | CostRateTableFactory.process | train | public void process(Resource resource, int index, byte[] data)
{
CostRateTable result = new CostRateTable();
if (data != null)
{
for (int i = 16; i + 44 <= data.length; i += 44)
{
Rate standardRate = new Rate(MPPUtility.getDouble(data, i), TimeUnit.HOURS);
TimeUnit standardRateFormat = getFormat(MPPUtility.getShort(data, i + 8));
Rate overtimeRate = new Rate(MPPUtility.getDouble(data, i + 16), TimeUnit.HOURS);
TimeUnit overtimeRateFormat = getFormat(MPPUtility.getShort(data, i + 24));
Double costPerUse = NumberHelper.getDouble(MPPUtility.getDouble(data, i + 32) / 100.0);
Date endDate = MPPUtility.getTimestampFromTenths(data, i + 40);
CostRateTableEntry entry = new CostRateTableEntry(standardRate, standardRateFormat, overtimeRate, overtimeRateFormat, costPerUse, endDate);
result.add(entry);
}
Collections.sort(result);
}
else
{
//
// MS Project economises by not actually storing the first cost rate
// table if it doesn't need to, so we take this into account here.
//
if (index == 0)
{
Rate standardRate = resource.getStandardRate();
Rate overtimeRate = resource.getOvertimeRate();
Number costPerUse = resource.getCostPerUse();
CostRateTableEntry entry = new CostRateTableEntry(standardRate, standardRate.getUnits(), overtimeRate, overtimeRate.getUnits(), costPerUse, CostRateTableEntry.DEFAULT_ENTRY.getEndDate());
result.add(entry);
}
else
{
result.add(CostRateTableEntry.DEFAULT_ENTRY);
}
}
resource.setCostRateTable(index, result);
} | java | {
"resource": ""
} |
q794 | CostRateTableFactory.getFormat | train | private TimeUnit getFormat(int format)
{
TimeUnit result;
if (format == 0xFFFF)
{
result = TimeUnit.HOURS;
}
else
{
result = MPPUtility.getWorkTimeUnits(format);
}
return result;
} | java | {
"resource": ""
} |
q795 | ConstraintTypeUtility.getInstance | train | public static ConstraintType getInstance(Locale locale, String type)
{
int index = 0;
String[] constraintTypes = LocaleData.getStringArray(locale, LocaleData.CONSTRAINT_TYPES);
for (int loop = 0; loop < constraintTypes.length; loop++)
{
if (constraintTypes[loop].equalsIgnoreCase(type) == true)
{
index = loop;
break;
}
}
return (ConstraintType.getInstance(index));
} | java | {
"resource": ""
} |
q796 | MpxjQuery.query | train | private static void query(String filename) throws Exception
{
ProjectFile mpx = new UniversalProjectReader().read(filename);
listProjectProperties(mpx);
listResources(mpx);
listTasks(mpx);
listAssignments(mpx);
listAssignmentsByTask(mpx);
listAssignmentsByResource(mpx);
listHierarchy(mpx);
listTaskNotes(mpx);
listResourceNotes(mpx);
listRelationships(mpx);
listSlack(mpx);
listCalendars(mpx);
} | java | {
"resource": ""
} |
q797 | MpxjQuery.listProjectProperties | train | private static void listProjectProperties(ProjectFile file)
{
SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm z");
ProjectProperties properties = file.getProjectProperties();
Date startDate = properties.getStartDate();
Date finishDate = properties.getFinishDate();
String formattedStartDate = startDate == null ? "(none)" : df.format(startDate);
String formattedFinishDate = finishDate == null ? "(none)" : df.format(finishDate);
System.out.println("MPP file type: " + properties.getMppFileType());
System.out.println("Project Properties: StartDate=" + formattedStartDate + " FinishDate=" + formattedFinishDate);
System.out.println();
} | java | {
"resource": ""
} |
q798 | MpxjQuery.listResources | train | private static void listResources(ProjectFile file)
{
for (Resource resource : file.getResources())
{
System.out.println("Resource: " + resource.getName() + " (Unique ID=" + resource.getUniqueID() + ") Start=" + resource.getStart() + " Finish=" + resource.getFinish());
}
System.out.println();
} | java | {
"resource": ""
} |
q799 | MpxjQuery.listTasks | train | private static void listTasks(ProjectFile file)
{
SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm z");
for (Task task : file.getTasks())
{
Date date = task.getStart();
String text = task.getStartText();
String startDate = text != null ? text : (date != null ? df.format(date) : "(no start date supplied)");
date = task.getFinish();
text = task.getFinishText();
String finishDate = text != null ? text : (date != null ? df.format(date) : "(no finish date supplied)");
Duration dur = task.getDuration();
text = task.getDurationText();
String duration = text != null ? text : (dur != null ? dur.toString() : "(no duration supplied)");
dur = task.getActualDuration();
String actualDuration = dur != null ? dur.toString() : "(no actual duration supplied)";
String baselineDuration = task.getBaselineDurationText();
if (baselineDuration == null)
{
dur = task.getBaselineDuration();
if (dur != null)
{
baselineDuration = dur.toString();
}
else
{
baselineDuration = "(no duration supplied)";
}
}
System.out.println("Task: " + task.getName() + " ID=" + task.getID() + " Unique ID=" + task.getUniqueID() + " (Start Date=" + startDate + " Finish Date=" + finishDate + " Duration=" + duration + " Actual Duration" + actualDuration + " Baseline Duration=" + baselineDuration + " Outline Level=" + task.getOutlineLevel() + " Outline Number=" + task.getOutlineNumber() + " Recurring=" + task.getRecurring() + ")");
}
System.out.println();
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.