_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1100
|
Resource.setID
|
train
|
@Override public void setID(Integer val)
{
ProjectFile parent = getParentFile();
Integer previous = getID();
if (previous != null)
{
parent.getResources().unmapID(previous);
}
parent.getResources().mapID(val, this);
set(ResourceField.ID, val);
}
|
java
|
{
"resource": ""
}
|
q1101
|
Resource.getFlag
|
train
|
public boolean getFlag(int index)
{
return BooleanHelper.getBoolean((Boolean) getCachedValue(selectField(ResourceFieldLists.CUSTOM_FLAG, index)));
}
|
java
|
{
"resource": ""
}
|
q1102
|
Resource.selectField
|
train
|
private ResourceField selectField(ResourceField[] 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": ""
}
|
q1103
|
AbstractTimephasedWorkNormaliser.mergeSameWork
|
train
|
protected void mergeSameWork(LinkedList<TimephasedWork> list)
{
LinkedList<TimephasedWork> result = new LinkedList<TimephasedWork>();
TimephasedWork previousAssignment = null;
for (TimephasedWork assignment : list)
{
if (previousAssignment == null)
{
assignment.setAmountPerDay(assignment.getTotalAmount());
result.add(assignment);
}
else
{
Duration previousAssignmentWork = previousAssignment.getAmountPerDay();
Duration assignmentWork = assignment.getTotalAmount();
if (NumberHelper.equals(previousAssignmentWork.getDuration(), assignmentWork.getDuration(), 0.01))
{
Date assignmentStart = previousAssignment.getStart();
Date assignmentFinish = assignment.getFinish();
double total = previousAssignment.getTotalAmount().getDuration();
total += assignmentWork.getDuration();
Duration totalWork = Duration.getInstance(total, TimeUnit.MINUTES);
TimephasedWork merged = new TimephasedWork();
merged.setStart(assignmentStart);
merged.setFinish(assignmentFinish);
merged.setAmountPerDay(assignmentWork);
merged.setTotalAmount(totalWork);
result.removeLast();
assignment = merged;
}
else
{
assignment.setAmountPerDay(assignment.getTotalAmount());
}
result.add(assignment);
}
previousAssignment = assignment;
}
list.clear();
list.addAll(result);
}
|
java
|
{
"resource": ""
}
|
q1104
|
AbstractTimephasedWorkNormaliser.convertToHours
|
train
|
protected void convertToHours(LinkedList<TimephasedWork> list)
{
for (TimephasedWork assignment : list)
{
Duration totalWork = assignment.getTotalAmount();
Duration workPerDay = assignment.getAmountPerDay();
totalWork = Duration.getInstance(totalWork.getDuration() / 60, TimeUnit.HOURS);
workPerDay = Duration.getInstance(workPerDay.getDuration() / 60, TimeUnit.HOURS);
assignment.setTotalAmount(totalWork);
assignment.setAmountPerDay(workPerDay);
}
}
|
java
|
{
"resource": ""
}
|
q1105
|
FastTrackTable.addColumn
|
train
|
public void addColumn(FastTrackColumn column)
{
FastTrackField type = column.getType();
Object[] data = column.getData();
for (int index = 0; index < data.length; index++)
{
MapRow row = getRow(index);
row.getMap().put(type, data[index]);
}
}
|
java
|
{
"resource": ""
}
|
q1106
|
FastTrackTable.getRow
|
train
|
private MapRow getRow(int index)
{
MapRow result;
if (index == m_rows.size())
{
result = new MapRow(this, new HashMap<FastTrackField, Object>());
m_rows.add(result);
}
else
{
result = m_rows.get(index);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1107
|
Record.setRecordNumber
|
train
|
private void setRecordNumber(LinkedList<String> list)
{
try
{
String number = list.remove(0);
m_recordNumber = Integer.valueOf(number);
}
catch (NumberFormatException ex)
{
// Malformed MPX file: the record number isn't a valid integer
// Catch the exception here, leaving m_recordNumber as null
// so we will skip this record entirely.
}
}
|
java
|
{
"resource": ""
}
|
q1108
|
Record.getString
|
train
|
public String getString(int field)
{
String result;
if (field < m_fields.length)
{
result = m_fields[field];
if (result != null)
{
result = result.replace(MPXConstants.EOL_PLACEHOLDER, '\n');
}
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1109
|
Record.getCharacter
|
train
|
public Character getCharacter(int field)
{
Character result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = Character.valueOf(m_fields[field].charAt(0));
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1110
|
Record.getFloat
|
train
|
public Number getFloat(int field) throws MPXJException
{
try
{
Number result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = m_formats.getDecimalFormat().parse(m_fields[field]);
}
else
{
result = null;
}
return (result);
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse float", ex);
}
}
|
java
|
{
"resource": ""
}
|
q1111
|
Record.getNumericBoolean
|
train
|
public boolean getNumericBoolean(int field)
{
boolean result = false;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = Integer.parseInt(m_fields[field]) == 1;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1112
|
Record.getRate
|
train
|
public Rate getRate(int field) throws MPXJException
{
Rate result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
try
{
String rate = m_fields[field];
int index = rate.indexOf('/');
double amount;
TimeUnit units;
if (index == -1)
{
amount = m_formats.getCurrencyFormat().parse(rate).doubleValue();
units = TimeUnit.HOURS;
}
else
{
amount = m_formats.getCurrencyFormat().parse(rate.substring(0, index)).doubleValue();
units = TimeUnitUtility.getInstance(rate.substring(index + 1), m_locale);
}
result = new Rate(amount, units);
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse rate", ex);
}
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1113
|
Record.getDuration
|
train
|
public Duration getDuration(int field) throws MPXJException
{
Duration result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = DurationUtility.getInstance(m_fields[field], m_formats.getDurationDecimalFormat(), m_locale);
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1114
|
Record.getUnits
|
train
|
public Number getUnits(int field) throws MPXJException
{
Number result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
try
{
result = Double.valueOf(m_formats.getUnitsDecimalFormat().parse(m_fields[field]).doubleValue() * 100);
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse units", ex);
}
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1115
|
Record.getCodePage
|
train
|
public CodePage getCodePage(int field)
{
CodePage result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = CodePage.getInstance(m_fields[field]);
}
else
{
result = CodePage.getInstance(null);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1116
|
Record.getAccrueType
|
train
|
public AccrueType getAccrueType(int field)
{
AccrueType result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = AccrueTypeUtility.getInstance(m_fields[field], m_locale);
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1117
|
Record.getBoolean
|
train
|
public Boolean getBoolean(int field, String falseText)
{
Boolean result;
if ((field < m_fields.length) && (m_fields[field].length() != 0))
{
result = ((m_fields[field].equalsIgnoreCase(falseText) == true) ? Boolean.FALSE : Boolean.TRUE);
}
else
{
result = null;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1118
|
FixedData.getIndexFromOffset
|
train
|
public int getIndexFromOffset(int offset)
{
int result = -1;
for (int loop = 0; loop < m_offset.length; loop++)
{
if (m_offset[loop] == offset)
{
result = loop;
break;
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1119
|
FixDeferFix.getByteArray
|
train
|
public byte[] getByteArray(int offset)
{
byte[] result = null;
if (offset > 0 && offset < m_data.length)
{
int nextBlockOffset = MPPUtility.getInt(m_data, offset);
offset += 4;
int itemSize = MPPUtility.getInt(m_data, offset);
offset += 4;
if (itemSize > 0 && itemSize < m_data.length)
{
int blockRemainingSize = 28;
if (nextBlockOffset != -1 || itemSize <= blockRemainingSize)
{
int itemRemainingSize = itemSize;
result = new byte[itemSize];
int resultOffset = 0;
while (nextBlockOffset != -1)
{
MPPUtility.getByteArray(m_data, offset, blockRemainingSize, result, resultOffset);
resultOffset += blockRemainingSize;
offset += blockRemainingSize;
itemRemainingSize -= blockRemainingSize;
if (offset != nextBlockOffset)
{
offset = nextBlockOffset;
}
nextBlockOffset = MPPUtility.getInt(m_data, offset);
offset += 4;
blockRemainingSize = 32;
}
MPPUtility.getByteArray(m_data, offset, itemRemainingSize, result, resultOffset);
}
}
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1120
|
ResourceRequestType.getResourceRequestCriterion
|
train
|
public List<ResourceRequestType.ResourceRequestCriterion> getResourceRequestCriterion()
{
if (resourceRequestCriterion == null)
{
resourceRequestCriterion = new ArrayList<ResourceRequestType.ResourceRequestCriterion>();
}
return this.resourceRequestCriterion;
}
|
java
|
{
"resource": ""
}
|
q1121
|
CustomFieldValueReader12.populateCustomFieldMap
|
train
|
private Map<UUID, FieldType> populateCustomFieldMap()
{
byte[] data = m_taskProps.getByteArray(Props.CUSTOM_FIELDS);
int length = MPPUtility.getInt(data, 0);
int index = length + 36;
// 4 byte record count
int recordCount = MPPUtility.getInt(data, index);
index += 4;
// 8 bytes per record
index += (8 * recordCount);
Map<UUID, FieldType> map = new HashMap<UUID, FieldType>();
while (index < data.length)
{
int blockLength = MPPUtility.getInt(data, index);
if (blockLength <= 0 || index + blockLength > data.length)
{
break;
}
int fieldID = MPPUtility.getInt(data, index + 4);
FieldType field = FieldTypeHelper.getInstance(fieldID);
UUID guid = MPPUtility.getGUID(data, index + 160);
map.put(guid, field);
index += blockLength;
}
return map;
}
|
java
|
{
"resource": ""
}
|
q1122
|
FileHelper.deleteQuietly
|
train
|
public static final void deleteQuietly(File file)
{
if (file != null)
{
if (file.isDirectory())
{
File[] children = file.listFiles();
if (children != null)
{
for (File child : children)
{
deleteQuietly(child);
}
}
}
file.delete();
}
}
|
java
|
{
"resource": ""
}
|
q1123
|
P3PRXFileReader.extractFile
|
train
|
private void extractFile(InputStream stream, File dir) throws IOException
{
byte[] header = new byte[8];
byte[] fileName = new byte[13];
byte[] dataSize = new byte[4];
stream.read(header);
stream.read(fileName);
stream.read(dataSize);
int dataSizeValue = getInt(dataSize, 0);
String fileNameValue = getString(fileName, 0);
File file = new File(dir, fileNameValue);
if (dataSizeValue == 0)
{
FileHelper.createNewFile(file);
}
else
{
OutputStream os = new FileOutputStream(file);
FixedLengthInputStream inputStream = new FixedLengthInputStream(stream, dataSizeValue);
Blast blast = new Blast();
blast.blast(inputStream, os);
os.close();
}
}
|
java
|
{
"resource": ""
}
|
q1124
|
UniversalProjectReader.matchesFingerprint
|
train
|
private boolean matchesFingerprint(byte[] buffer, byte[] fingerprint)
{
return Arrays.equals(fingerprint, Arrays.copyOf(buffer, fingerprint.length));
}
|
java
|
{
"resource": ""
}
|
q1125
|
UniversalProjectReader.matchesFingerprint
|
train
|
private boolean matchesFingerprint(byte[] buffer, Pattern fingerprint)
{
return fingerprint.matcher(m_charset == null ? new String(buffer) : new String(buffer, m_charset)).matches();
}
|
java
|
{
"resource": ""
}
|
q1126
|
UniversalProjectReader.readProjectFile
|
train
|
private ProjectFile readProjectFile(ProjectReader reader, InputStream stream) throws MPXJException
{
addListeners(reader);
return reader.read(stream);
}
|
java
|
{
"resource": ""
}
|
q1127
|
UniversalProjectReader.readProjectFile
|
train
|
private ProjectFile readProjectFile(ProjectReader reader, File file) throws MPXJException
{
addListeners(reader);
return reader.read(file);
}
|
java
|
{
"resource": ""
}
|
q1128
|
UniversalProjectReader.handleOleCompoundDocument
|
train
|
private ProjectFile handleOleCompoundDocument(InputStream stream) throws Exception
{
POIFSFileSystem fs = new POIFSFileSystem(POIFSFileSystem.createNonClosingInputStream(stream));
String fileFormat = MPPReader.getFileFormat(fs);
if (fileFormat != null && fileFormat.startsWith("MSProject"))
{
MPPReader reader = new MPPReader();
addListeners(reader);
return reader.read(fs);
}
return null;
}
|
java
|
{
"resource": ""
}
|
q1129
|
UniversalProjectReader.handleMDBFile
|
train
|
private ProjectFile handleMDBFile(InputStream stream) throws Exception
{
File file = InputStreamHelper.writeStreamToTempFile(stream, ".mdb");
try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String url = "jdbc:odbc:DRIVER=Microsoft Access Driver (*.mdb);DBQ=" + file.getCanonicalPath();
Set<String> tableNames = populateTableNames(url);
if (tableNames.contains("MSP_PROJECTS"))
{
return readProjectFile(new MPDDatabaseReader(), file);
}
if (tableNames.contains("EXCEPTIONN"))
{
return readProjectFile(new AstaDatabaseReader(), file);
}
return null;
}
finally
{
FileHelper.deleteQuietly(file);
}
}
|
java
|
{
"resource": ""
}
|
q1130
|
UniversalProjectReader.handleSQLiteFile
|
train
|
private ProjectFile handleSQLiteFile(InputStream stream) throws Exception
{
File file = InputStreamHelper.writeStreamToTempFile(stream, ".sqlite");
try
{
Class.forName("org.sqlite.JDBC");
String url = "jdbc:sqlite:" + file.getCanonicalPath();
Set<String> tableNames = populateTableNames(url);
if (tableNames.contains("EXCEPTIONN"))
{
return readProjectFile(new AstaDatabaseFileReader(), file);
}
if (tableNames.contains("PROJWBS"))
{
Connection connection = null;
try
{
Properties props = new Properties();
props.setProperty("date_string_format", "yyyy-MM-dd HH:mm:ss");
connection = DriverManager.getConnection(url, props);
PrimaveraDatabaseReader reader = new PrimaveraDatabaseReader();
reader.setConnection(connection);
addListeners(reader);
return reader.read();
}
finally
{
if (connection != null)
{
connection.close();
}
}
}
if (tableNames.contains("ZSCHEDULEITEM"))
{
return readProjectFile(new MerlinReader(), file);
}
return null;
}
finally
{
FileHelper.deleteQuietly(file);
}
}
|
java
|
{
"resource": ""
}
|
q1131
|
UniversalProjectReader.handleZipFile
|
train
|
private ProjectFile handleZipFile(InputStream stream) throws Exception
{
File dir = null;
try
{
dir = InputStreamHelper.writeZipStreamToTempDir(stream);
ProjectFile result = handleDirectory(dir);
if (result != null)
{
return result;
}
}
finally
{
FileHelper.deleteQuietly(dir);
}
return null;
}
|
java
|
{
"resource": ""
}
|
q1132
|
UniversalProjectReader.handleDirectory
|
train
|
private ProjectFile handleDirectory(File directory) throws Exception
{
ProjectFile result = handleDatabaseInDirectory(directory);
if (result == null)
{
result = handleFileInDirectory(directory);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1133
|
UniversalProjectReader.handleDatabaseInDirectory
|
train
|
private ProjectFile handleDatabaseInDirectory(File directory) throws Exception
{
byte[] buffer = new byte[BUFFER_SIZE];
File[] files = directory.listFiles();
if (files != null)
{
for (File file : files)
{
if (file.isDirectory())
{
continue;
}
FileInputStream fis = new FileInputStream(file);
int bytesRead = fis.read(buffer);
fis.close();
//
// If the file is smaller than the buffer we are peeking into,
// it's probably not a valid schedule file.
//
if (bytesRead != BUFFER_SIZE)
{
continue;
}
if (matchesFingerprint(buffer, BTRIEVE_FINGERPRINT))
{
return handleP3BtrieveDatabase(directory);
}
if (matchesFingerprint(buffer, STW_FINGERPRINT))
{
return handleSureTrakDatabase(directory);
}
}
}
return null;
}
|
java
|
{
"resource": ""
}
|
q1134
|
UniversalProjectReader.handleByteOrderMark
|
train
|
private ProjectFile handleByteOrderMark(InputStream stream, int length, Charset charset) throws Exception
{
UniversalProjectReader reader = new UniversalProjectReader();
reader.setSkipBytes(length);
reader.setCharset(charset);
return reader.read(stream);
}
|
java
|
{
"resource": ""
}
|
q1135
|
UniversalProjectReader.handleDosExeFile
|
train
|
private ProjectFile handleDosExeFile(InputStream stream) throws Exception
{
File file = InputStreamHelper.writeStreamToTempFile(stream, ".tmp");
InputStream is = null;
try
{
is = new FileInputStream(file);
if (is.available() > 1350)
{
StreamHelper.skip(is, 1024);
// Bytes at offset 1024
byte[] data = new byte[2];
is.read(data);
if (matchesFingerprint(data, WINDOWS_NE_EXE_FINGERPRINT))
{
StreamHelper.skip(is, 286);
// Bytes at offset 1312
data = new byte[34];
is.read(data);
if (matchesFingerprint(data, PRX_FINGERPRINT))
{
is.close();
is = null;
return readProjectFile(new P3PRXFileReader(), file);
}
}
if (matchesFingerprint(data, STX_FINGERPRINT))
{
StreamHelper.skip(is, 31742);
// Bytes at offset 32768
data = new byte[4];
is.read(data);
if (matchesFingerprint(data, PRX3_FINGERPRINT))
{
is.close();
is = null;
return readProjectFile(new SureTrakSTXFileReader(), file);
}
}
}
return null;
}
finally
{
StreamHelper.closeQuietly(is);
FileHelper.deleteQuietly(file);
}
}
|
java
|
{
"resource": ""
}
|
q1136
|
UniversalProjectReader.handleXerFile
|
train
|
private ProjectFile handleXerFile(InputStream stream) throws Exception
{
PrimaveraXERFileReader reader = new PrimaveraXERFileReader();
reader.setCharset(m_charset);
List<ProjectFile> projects = reader.readAll(stream);
ProjectFile project = null;
for (ProjectFile file : projects)
{
if (file.getProjectProperties().getExportFlag())
{
project = file;
break;
}
}
if (project == null && !projects.isEmpty())
{
project = projects.get(0);
}
return project;
}
|
java
|
{
"resource": ""
}
|
q1137
|
UniversalProjectReader.populateTableNames
|
train
|
private Set<String> populateTableNames(String url) throws SQLException
{
Set<String> tableNames = new HashSet<String>();
Connection connection = null;
ResultSet rs = null;
try
{
connection = DriverManager.getConnection(url);
DatabaseMetaData dmd = connection.getMetaData();
rs = dmd.getTables(null, null, null, null);
while (rs.next())
{
tableNames.add(rs.getString("TABLE_NAME").toUpperCase());
}
}
finally
{
if (rs != null)
{
rs.close();
}
if (connection != null)
{
connection.close();
}
}
return tableNames;
}
|
java
|
{
"resource": ""
}
|
q1138
|
StreamHelper.skip
|
train
|
public static void skip(InputStream stream, long skip) throws IOException
{
long count = skip;
while (count > 0)
{
count -= stream.skip(count);
}
}
|
java
|
{
"resource": ""
}
|
q1139
|
MPP9Reader.processCustomValueLists
|
train
|
private void processCustomValueLists() throws IOException
{
CustomFieldValueReader9 reader = new CustomFieldValueReader9(m_projectDir, m_file.getProjectProperties(), m_projectProps, m_file.getCustomFields());
reader.process();
}
|
java
|
{
"resource": ""
}
|
q1140
|
MPP9Reader.processFieldNameAliases
|
train
|
private void processFieldNameAliases(Map<Integer, FieldType> map, byte[] data)
{
if (data != null)
{
int offset = 0;
int index = 0;
CustomFieldContainer fields = m_file.getCustomFields();
while (offset < data.length)
{
String alias = MPPUtility.getUnicodeString(data, offset);
if (!alias.isEmpty())
{
FieldType field = map.get(Integer.valueOf(index));
if (field != null)
{
fields.getCustomField(field).setAlias(alias);
}
}
offset += (alias.length() + 1) * 2;
index++;
}
}
}
|
java
|
{
"resource": ""
}
|
q1141
|
MPP9Reader.createResourceMap
|
train
|
private TreeMap<Integer, Integer> createResourceMap(FieldMap fieldMap, FixedMeta rscFixedMeta, FixedData rscFixedData)
{
TreeMap<Integer, Integer> resourceMap = new TreeMap<Integer, Integer>();
int itemCount = rscFixedMeta.getAdjustedItemCount();
for (int loop = 0; loop < itemCount; loop++)
{
byte[] data = rscFixedData.getByteArrayValue(loop);
if (data == null || data.length < fieldMap.getMaxFixedDataSize(0))
{
continue;
}
Integer uniqueID = Integer.valueOf(MPPUtility.getShort(data, 0));
resourceMap.put(uniqueID, Integer.valueOf(loop));
}
return (resourceMap);
}
|
java
|
{
"resource": ""
}
|
q1142
|
MPP9Reader.postProcessTasks
|
train
|
private void postProcessTasks()
{
List<Task> allTasks = m_file.getTasks();
if (allTasks.size() > 1)
{
Collections.sort(allTasks);
int taskID = -1;
int lastTaskID = -1;
for (int i = 0; i < allTasks.size(); i++)
{
Task task = allTasks.get(i);
taskID = NumberHelper.getInt(task.getID());
// In Project the tasks IDs are always contiguous so we can spot invalid tasks by making sure all
// IDs are represented.
if (!task.getNull() && lastTaskID != -1 && taskID > lastTaskID + 1)
{
// This task looks to be invalid.
task.setNull(true);
}
else
{
lastTaskID = taskID;
}
}
}
}
|
java
|
{
"resource": ""
}
|
q1143
|
TaskDateDump.process
|
train
|
public void process(String name) throws Exception
{
ProjectFile file = new UniversalProjectReader().read(name);
for (Task task : file.getTasks())
{
if (!task.getSummary())
{
System.out.print(task.getWBS());
System.out.print("\t");
System.out.print(task.getName());
System.out.print("\t");
System.out.print(format(task.getStart()));
System.out.print("\t");
System.out.print(format(task.getActualStart()));
System.out.print("\t");
System.out.print(format(task.getFinish()));
System.out.print("\t");
System.out.print(format(task.getActualFinish()));
System.out.println();
}
}
}
|
java
|
{
"resource": ""
}
|
q1144
|
ConceptDrawProjectReader.readProjectProperties
|
train
|
private void readProjectProperties(Document cdp)
{
WorkspaceProperties props = cdp.getWorkspaceProperties();
ProjectProperties mpxjProps = m_projectFile.getProjectProperties();
mpxjProps.setSymbolPosition(props.getCurrencyPosition());
mpxjProps.setCurrencyDigits(props.getCurrencyDigits());
mpxjProps.setCurrencySymbol(props.getCurrencySymbol());
mpxjProps.setDaysPerMonth(props.getDaysPerMonth());
mpxjProps.setMinutesPerDay(props.getHoursPerDay());
mpxjProps.setMinutesPerWeek(props.getHoursPerWeek());
m_workHoursPerDay = mpxjProps.getMinutesPerDay().doubleValue() / 60.0;
}
|
java
|
{
"resource": ""
}
|
q1145
|
ConceptDrawProjectReader.readCalendars
|
train
|
private void readCalendars(Document cdp)
{
for (Calendar calendar : cdp.getCalendars().getCalendar())
{
readCalendar(calendar);
}
for (Calendar calendar : cdp.getCalendars().getCalendar())
{
ProjectCalendar child = m_calendarMap.get(calendar.getID());
ProjectCalendar parent = m_calendarMap.get(calendar.getBaseCalendarID());
if (parent == null)
{
m_projectFile.setDefaultCalendar(child);
}
else
{
child.setParent(parent);
}
}
}
|
java
|
{
"resource": ""
}
|
q1146
|
ConceptDrawProjectReader.readWeekDay
|
train
|
private void readWeekDay(ProjectCalendar mpxjCalendar, WeekDay day)
{
if (day.isIsDayWorking())
{
ProjectCalendarHours hours = mpxjCalendar.addCalendarHours(day.getDay());
for (Document.Calendars.Calendar.WeekDays.WeekDay.TimePeriods.TimePeriod period : day.getTimePeriods().getTimePeriod())
{
hours.addRange(new DateRange(period.getFrom(), period.getTo()));
}
}
}
|
java
|
{
"resource": ""
}
|
q1147
|
ConceptDrawProjectReader.readExceptionDay
|
train
|
private void readExceptionDay(ProjectCalendar mpxjCalendar, ExceptedDay day)
{
ProjectCalendarException mpxjException = mpxjCalendar.addCalendarException(day.getDate(), day.getDate());
if (day.isIsDayWorking())
{
for (Document.Calendars.Calendar.ExceptedDays.ExceptedDay.TimePeriods.TimePeriod period : day.getTimePeriods().getTimePeriod())
{
mpxjException.addRange(new DateRange(period.getFrom(), period.getTo()));
}
}
}
|
java
|
{
"resource": ""
}
|
q1148
|
ConceptDrawProjectReader.readResources
|
train
|
private void readResources(Document cdp)
{
for (Document.Resources.Resource resource : cdp.getResources().getResource())
{
readResource(resource);
}
}
|
java
|
{
"resource": ""
}
|
q1149
|
ConceptDrawProjectReader.readResource
|
train
|
private void readResource(Document.Resources.Resource resource)
{
Resource mpxjResource = m_projectFile.addResource();
mpxjResource.setName(resource.getName());
mpxjResource.setResourceCalendar(m_calendarMap.get(resource.getCalendarID()));
mpxjResource.setStandardRate(new Rate(resource.getCost(), resource.getCostTimeUnit()));
mpxjResource.setEmailAddress(resource.getEMail());
mpxjResource.setGroup(resource.getGroup());
//resource.getHyperlinks()
mpxjResource.setUniqueID(resource.getID());
//resource.getMarkerID()
mpxjResource.setNotes(resource.getNote());
mpxjResource.setID(Integer.valueOf(resource.getOutlineNumber()));
//resource.getStyleProject()
mpxjResource.setType(resource.getSubType() == null ? resource.getType() : resource.getSubType());
}
|
java
|
{
"resource": ""
}
|
q1150
|
ConceptDrawProjectReader.readTasks
|
train
|
private void readTasks(Document cdp)
{
//
// Sort the projects into the correct order
//
List<Project> projects = new ArrayList<Project>(cdp.getProjects().getProject());
final AlphanumComparator comparator = new AlphanumComparator();
Collections.sort(projects, new Comparator<Project>()
{
@Override public int compare(Project o1, Project o2)
{
return comparator.compare(o1.getOutlineNumber(), o2.getOutlineNumber());
}
});
for (Project project : cdp.getProjects().getProject())
{
readProject(project);
}
}
|
java
|
{
"resource": ""
}
|
q1151
|
ConceptDrawProjectReader.readProject
|
train
|
private void readProject(Project project)
{
Task mpxjTask = m_projectFile.addTask();
//project.getAuthor()
mpxjTask.setBaselineCost(project.getBaselineCost());
mpxjTask.setBaselineFinish(project.getBaselineFinishDate());
mpxjTask.setBaselineStart(project.getBaselineStartDate());
//project.getBudget();
//project.getCompany()
mpxjTask.setFinish(project.getFinishDate());
//project.getGoal()
//project.getHyperlinks()
//project.getMarkerID()
mpxjTask.setName(project.getName());
mpxjTask.setNotes(project.getNote());
mpxjTask.setPriority(project.getPriority());
// project.getSite()
mpxjTask.setStart(project.getStartDate());
// project.getStyleProject()
// project.getTask()
// project.getTimeScale()
// project.getViewProperties()
String projectIdentifier = project.getID().toString();
mpxjTask.setGUID(UUID.nameUUIDFromBytes(projectIdentifier.getBytes()));
//
// Sort the tasks into the correct order
//
List<Document.Projects.Project.Task> tasks = new ArrayList<Document.Projects.Project.Task>(project.getTask());
final AlphanumComparator comparator = new AlphanumComparator();
Collections.sort(tasks, new Comparator<Document.Projects.Project.Task>()
{
@Override public int compare(Document.Projects.Project.Task o1, Document.Projects.Project.Task o2)
{
return comparator.compare(o1.getOutlineNumber(), o2.getOutlineNumber());
}
});
Map<String, Task> map = new HashMap<String, Task>();
map.put("", mpxjTask);
for (Document.Projects.Project.Task task : tasks)
{
readTask(projectIdentifier, map, task);
}
}
|
java
|
{
"resource": ""
}
|
q1152
|
ConceptDrawProjectReader.readTask
|
train
|
private void readTask(String projectIdentifier, Map<String, Task> map, Document.Projects.Project.Task task)
{
Task parentTask = map.get(getParentOutlineNumber(task.getOutlineNumber()));
Task mpxjTask = parentTask.addTask();
TimeUnit units = task.getBaseDurationTimeUnit();
mpxjTask.setCost(task.getActualCost());
mpxjTask.setDuration(getDuration(units, task.getActualDuration()));
mpxjTask.setFinish(task.getActualFinishDate());
mpxjTask.setStart(task.getActualStartDate());
mpxjTask.setBaselineDuration(getDuration(units, task.getBaseDuration()));
mpxjTask.setBaselineFinish(task.getBaseFinishDate());
mpxjTask.setBaselineCost(task.getBaselineCost());
// task.getBaselineFinishDate()
// task.getBaselineFinishTemplateOffset()
// task.getBaselineStartDate()
// task.getBaselineStartTemplateOffset()
mpxjTask.setBaselineStart(task.getBaseStartDate());
// task.getCallouts()
mpxjTask.setPercentageComplete(task.getComplete());
mpxjTask.setDeadline(task.getDeadlineDate());
// task.getDeadlineTemplateOffset()
// task.getHyperlinks()
// task.getMarkerID()
mpxjTask.setName(task.getName());
mpxjTask.setNotes(task.getNote());
mpxjTask.setPriority(task.getPriority());
// task.getRecalcBase1()
// task.getRecalcBase2()
mpxjTask.setType(task.getSchedulingType());
// task.getStyleProject()
// task.getTemplateOffset()
// task.getValidatedByProject()
if (task.isIsMilestone())
{
mpxjTask.setMilestone(true);
mpxjTask.setDuration(Duration.getInstance(0, TimeUnit.HOURS));
mpxjTask.setBaselineDuration(Duration.getInstance(0, TimeUnit.HOURS));
}
String taskIdentifier = projectIdentifier + "." + task.getID();
m_taskIdMap.put(task.getID(), mpxjTask);
mpxjTask.setGUID(UUID.nameUUIDFromBytes(taskIdentifier.getBytes()));
map.put(task.getOutlineNumber(), mpxjTask);
for (Document.Projects.Project.Task.ResourceAssignments.ResourceAssignment assignment : task.getResourceAssignments().getResourceAssignment())
{
readResourceAssignment(mpxjTask, assignment);
}
}
|
java
|
{
"resource": ""
}
|
q1153
|
ConceptDrawProjectReader.readRelationships
|
train
|
private void readRelationships(Document cdp)
{
for (Link link : cdp.getLinks().getLink())
{
readRelationship(link);
}
}
|
java
|
{
"resource": ""
}
|
q1154
|
ConceptDrawProjectReader.readRelationship
|
train
|
private void readRelationship(Link link)
{
Task sourceTask = m_taskIdMap.get(link.getSourceTaskID());
Task destinationTask = m_taskIdMap.get(link.getDestinationTaskID());
if (sourceTask != null && destinationTask != null)
{
Duration lag = getDuration(link.getLagUnit(), link.getLag());
RelationType type = link.getType();
Relation relation = destinationTask.addPredecessor(sourceTask, type, lag);
relation.setUniqueID(link.getID());
}
}
|
java
|
{
"resource": ""
}
|
q1155
|
ConceptDrawProjectReader.getDuration
|
train
|
private Duration getDuration(TimeUnit units, Double duration)
{
Duration result = null;
if (duration != null)
{
double durationValue = duration.doubleValue() * 100.0;
switch (units)
{
case MINUTES:
{
durationValue *= MINUTES_PER_DAY;
break;
}
case HOURS:
{
durationValue *= HOURS_PER_DAY;
break;
}
case DAYS:
{
durationValue *= 3.0;
break;
}
case WEEKS:
{
durationValue *= 0.6;
break;
}
case MONTHS:
{
durationValue *= 0.15;
break;
}
default:
{
throw new IllegalArgumentException("Unsupported time units " + units);
}
}
durationValue = Math.round(durationValue) / 100.0;
result = Duration.getInstance(durationValue, units);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1156
|
ConceptDrawProjectReader.getParentOutlineNumber
|
train
|
private String getParentOutlineNumber(String outlineNumber)
{
String result;
int index = outlineNumber.lastIndexOf('.');
if (index == -1)
{
result = "";
}
else
{
result = outlineNumber.substring(0, index);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1157
|
MPPConstraintField.getInstance
|
train
|
public static ConstraintField getInstance(int value)
{
ConstraintField result = null;
if (value >= 0 && value < FIELD_ARRAY.length)
{
result = FIELD_ARRAY[value];
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1158
|
MPXJFormats.update
|
train
|
public void update()
{
ProjectProperties properties = m_projectFile.getProjectProperties();
char decimalSeparator = properties.getDecimalSeparator();
char thousandsSeparator = properties.getThousandsSeparator();
m_unitsDecimalFormat.applyPattern("#.##", null, decimalSeparator, thousandsSeparator);
m_decimalFormat.applyPattern("0.00#", null, decimalSeparator, thousandsSeparator);
m_durationDecimalFormat.applyPattern("#.##", null, decimalSeparator, thousandsSeparator);
m_percentageDecimalFormat.applyPattern("##0.##", null, decimalSeparator, thousandsSeparator);
updateCurrencyFormats(properties, decimalSeparator, thousandsSeparator);
updateDateTimeFormats(properties);
}
|
java
|
{
"resource": ""
}
|
q1159
|
MPXJFormats.updateCurrencyFormats
|
train
|
private void updateCurrencyFormats(ProjectProperties properties, char decimalSeparator, char thousandsSeparator)
{
String prefix = "";
String suffix = "";
String currencySymbol = quoteFormatCharacters(properties.getCurrencySymbol());
switch (properties.getSymbolPosition())
{
case AFTER:
{
suffix = currencySymbol;
break;
}
case BEFORE:
{
prefix = currencySymbol;
break;
}
case AFTER_WITH_SPACE:
{
suffix = " " + currencySymbol;
break;
}
case BEFORE_WITH_SPACE:
{
prefix = currencySymbol + " ";
break;
}
}
StringBuilder pattern = new StringBuilder(prefix);
pattern.append("#0");
int digits = properties.getCurrencyDigits().intValue();
if (digits > 0)
{
pattern.append('.');
for (int i = 0; i < digits; i++)
{
pattern.append("0");
}
}
pattern.append(suffix);
String primaryPattern = pattern.toString();
String[] alternativePatterns = new String[7];
alternativePatterns[0] = primaryPattern + ";(" + primaryPattern + ")";
pattern.insert(prefix.length(), "#,#");
String secondaryPattern = pattern.toString();
alternativePatterns[1] = secondaryPattern;
alternativePatterns[2] = secondaryPattern + ";(" + secondaryPattern + ")";
pattern.setLength(0);
pattern.append("#0");
if (digits > 0)
{
pattern.append('.');
for (int i = 0; i < digits; i++)
{
pattern.append("0");
}
}
String noSymbolPrimaryPattern = pattern.toString();
alternativePatterns[3] = noSymbolPrimaryPattern;
alternativePatterns[4] = noSymbolPrimaryPattern + ";(" + noSymbolPrimaryPattern + ")";
pattern.insert(0, "#,#");
String noSymbolSecondaryPattern = pattern.toString();
alternativePatterns[5] = noSymbolSecondaryPattern;
alternativePatterns[6] = noSymbolSecondaryPattern + ";(" + noSymbolSecondaryPattern + ")";
m_currencyFormat.applyPattern(primaryPattern, alternativePatterns, decimalSeparator, thousandsSeparator);
}
|
java
|
{
"resource": ""
}
|
q1160
|
MPXJFormats.quoteFormatCharacters
|
train
|
private String quoteFormatCharacters(String literal)
{
StringBuilder sb = new StringBuilder();
int length = literal.length();
char c;
for (int loop = 0; loop < length; loop++)
{
c = literal.charAt(loop);
switch (c)
{
case '0':
case '#':
case '.':
case '-':
case ',':
case 'E':
case ';':
case '%':
{
sb.append("'");
sb.append(c);
sb.append("'");
break;
}
default:
{
sb.append(c);
break;
}
}
}
return (sb.toString());
}
|
java
|
{
"resource": ""
}
|
q1161
|
MPXJFormats.updateDateTimeFormats
|
train
|
private void updateDateTimeFormats(ProjectProperties properties)
{
String[] timePatterns = getTimePatterns(properties);
String[] datePatterns = getDatePatterns(properties);
String[] dateTimePatterns = getDateTimePatterns(properties, timePatterns);
m_dateTimeFormat.applyPatterns(dateTimePatterns);
m_dateFormat.applyPatterns(datePatterns);
m_timeFormat.applyPatterns(timePatterns);
m_dateTimeFormat.setLocale(m_locale);
m_dateFormat.setLocale(m_locale);
m_dateTimeFormat.setNullText(m_nullText);
m_dateFormat.setNullText(m_nullText);
m_timeFormat.setNullText(m_nullText);
m_dateTimeFormat.setAmPmText(properties.getAMText(), properties.getPMText());
m_timeFormat.setAmPmText(properties.getAMText(), properties.getPMText());
}
|
java
|
{
"resource": ""
}
|
q1162
|
MPXJFormats.getDatePatterns
|
train
|
private String[] getDatePatterns(ProjectProperties properties)
{
String pattern = "";
char datesep = properties.getDateSeparator();
DateOrder dateOrder = properties.getDateOrder();
switch (dateOrder)
{
case DMY:
{
pattern = "dd" + datesep + "MM" + datesep + "yy";
break;
}
case MDY:
{
pattern = "MM" + datesep + "dd" + datesep + "yy";
break;
}
case YMD:
{
pattern = "yy" + datesep + "MM" + datesep + "dd";
break;
}
}
return new String[]
{
pattern
};
}
|
java
|
{
"resource": ""
}
|
q1163
|
MPXJFormats.generateDateTimePatterns
|
train
|
private List<String> generateDateTimePatterns(String datePattern, String[] timePatterns)
{
List<String> patterns = new ArrayList<String>();
for (String timePattern : timePatterns)
{
patterns.add(datePattern + " " + timePattern);
}
// Always fall back on the date-only pattern
patterns.add(datePattern);
return patterns;
}
|
java
|
{
"resource": ""
}
|
q1164
|
AbstractVarMeta.getUniqueIdentifierArray
|
train
|
@Override public Integer[] getUniqueIdentifierArray()
{
Integer[] result = new Integer[m_table.size()];
int index = 0;
for (Integer value : m_table.keySet())
{
result[index] = value;
++index;
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1165
|
AbstractVarMeta.getOffset
|
train
|
@Override public Integer getOffset(Integer id, Integer type)
{
Integer result = null;
Map<Integer, Integer> map = m_table.get(id);
if (map != null && type != null)
{
result = map.get(type);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1166
|
GenericCriteria.setRightValue
|
train
|
public void setRightValue(int index, Object value)
{
m_definedRightValues[index] = value;
if (value instanceof FieldType)
{
m_symbolicValues = true;
}
else
{
if (value instanceof Duration)
{
if (((Duration) value).getUnits() != TimeUnit.HOURS)
{
value = ((Duration) value).convertUnits(TimeUnit.HOURS, m_properties);
}
}
}
m_workingRightValues[index] = value;
}
|
java
|
{
"resource": ""
}
|
q1167
|
GenericCriteria.evaluate
|
train
|
public boolean evaluate(FieldContainer container, Map<GenericCriteriaPrompt, Object> promptValues)
{
//
// Retrieve the LHS value
//
FieldType field = m_leftValue;
Object lhs;
if (field == null)
{
lhs = null;
}
else
{
lhs = container.getCurrentValue(field);
switch (field.getDataType())
{
case DATE:
{
if (lhs != null)
{
lhs = DateHelper.getDayStartDate((Date) lhs);
}
break;
}
case DURATION:
{
if (lhs != null)
{
Duration dur = (Duration) lhs;
lhs = dur.convertUnits(TimeUnit.HOURS, m_properties);
}
else
{
lhs = Duration.getInstance(0, TimeUnit.HOURS);
}
break;
}
case STRING:
{
lhs = lhs == null ? "" : lhs;
break;
}
default:
{
break;
}
}
}
//
// Retrieve the RHS values
//
Object[] rhs;
if (m_symbolicValues == true)
{
rhs = processSymbolicValues(m_workingRightValues, container, promptValues);
}
else
{
rhs = m_workingRightValues;
}
//
// Evaluate
//
boolean result;
switch (m_operator)
{
case AND:
case OR:
{
result = evaluateLogicalOperator(container, promptValues);
break;
}
default:
{
result = m_operator.evaluate(lhs, rhs);
break;
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1168
|
GenericCriteria.evaluateLogicalOperator
|
train
|
private boolean evaluateLogicalOperator(FieldContainer container, Map<GenericCriteriaPrompt, Object> promptValues)
{
boolean result = false;
if (m_criteriaList.size() == 0)
{
result = true;
}
else
{
for (GenericCriteria criteria : m_criteriaList)
{
result = criteria.evaluate(container, promptValues);
if ((m_operator == TestOperator.AND && !result) || (m_operator == TestOperator.OR && result))
{
break;
}
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1169
|
SynchroReader.read
|
train
|
private ProjectFile read() throws Exception
{
m_project = new ProjectFile();
m_eventManager = m_project.getEventManager();
m_project.getProjectProperties().setFileApplication("Synchro");
m_project.getProjectProperties().setFileType("SP");
CustomFieldContainer fields = m_project.getCustomFields();
fields.getCustomField(TaskField.TEXT1).setAlias("Code");
m_eventManager.addProjectListeners(m_projectListeners);
processCalendars();
processResources();
processTasks();
processPredecessors();
return m_project;
}
|
java
|
{
"resource": ""
}
|
q1170
|
SynchroReader.processCalendars
|
train
|
private void processCalendars() throws IOException
{
CalendarReader reader = new CalendarReader(m_data.getTableData("Calendars"));
reader.read();
for (MapRow row : reader.getRows())
{
processCalendar(row);
}
m_project.setDefaultCalendar(m_calendarMap.get(reader.getDefaultCalendarUUID()));
}
|
java
|
{
"resource": ""
}
|
q1171
|
SynchroReader.processCalendar
|
train
|
private void processCalendar(MapRow row)
{
ProjectCalendar calendar = m_project.addCalendar();
Map<UUID, List<DateRange>> dayTypeMap = processDayTypes(row.getRows("DAY_TYPES"));
calendar.setName(row.getString("NAME"));
processRanges(dayTypeMap.get(row.getUUID("SUNDAY_DAY_TYPE")), calendar.addCalendarHours(Day.SUNDAY));
processRanges(dayTypeMap.get(row.getUUID("MONDAY_DAY_TYPE")), calendar.addCalendarHours(Day.MONDAY));
processRanges(dayTypeMap.get(row.getUUID("TUESDAY_DAY_TYPE")), calendar.addCalendarHours(Day.TUESDAY));
processRanges(dayTypeMap.get(row.getUUID("WEDNESDAY_DAY_TYPE")), calendar.addCalendarHours(Day.WEDNESDAY));
processRanges(dayTypeMap.get(row.getUUID("THURSDAY_DAY_TYPE")), calendar.addCalendarHours(Day.THURSDAY));
processRanges(dayTypeMap.get(row.getUUID("FRIDAY_DAY_TYPE")), calendar.addCalendarHours(Day.FRIDAY));
processRanges(dayTypeMap.get(row.getUUID("SATURDAY_DAY_TYPE")), calendar.addCalendarHours(Day.SATURDAY));
for (MapRow assignment : row.getRows("DAY_TYPE_ASSIGNMENTS"))
{
Date date = assignment.getDate("DATE");
processRanges(dayTypeMap.get(assignment.getUUID("DAY_TYPE_UUID")), calendar.addCalendarException(date, date));
}
m_calendarMap.put(row.getUUID("UUID"), calendar);
}
|
java
|
{
"resource": ""
}
|
q1172
|
SynchroReader.processRanges
|
train
|
private void processRanges(List<DateRange> ranges, ProjectCalendarDateRanges container)
{
if (ranges != null)
{
for (DateRange range : ranges)
{
container.addRange(range);
}
}
}
|
java
|
{
"resource": ""
}
|
q1173
|
SynchroReader.processDayTypes
|
train
|
private Map<UUID, List<DateRange>> processDayTypes(List<MapRow> types)
{
Map<UUID, List<DateRange>> map = new HashMap<UUID, List<DateRange>>();
for (MapRow row : types)
{
List<DateRange> ranges = new ArrayList<DateRange>();
for (MapRow range : row.getRows("TIME_RANGES"))
{
ranges.add(new DateRange(range.getDate("START"), range.getDate("END")));
}
map.put(row.getUUID("UUID"), ranges);
}
return map;
}
|
java
|
{
"resource": ""
}
|
q1174
|
SynchroReader.processResources
|
train
|
private void processResources() throws IOException
{
CompanyReader reader = new CompanyReader(m_data.getTableData("Companies"));
reader.read();
for (MapRow companyRow : reader.getRows())
{
// TODO: need to sort by type as well as by name!
for (MapRow resourceRow : sort(companyRow.getRows("RESOURCES"), "NAME"))
{
processResource(resourceRow);
}
}
}
|
java
|
{
"resource": ""
}
|
q1175
|
SynchroReader.processResource
|
train
|
private void processResource(MapRow row) throws IOException
{
Resource resource = m_project.addResource();
resource.setName(row.getString("NAME"));
resource.setGUID(row.getUUID("UUID"));
resource.setEmailAddress(row.getString("EMAIL"));
resource.setHyperlink(row.getString("URL"));
resource.setNotes(getNotes(row.getRows("COMMENTARY")));
resource.setText(1, row.getString("DESCRIPTION"));
resource.setText(2, row.getString("SUPPLY_REFERENCE"));
resource.setActive(true);
List<MapRow> resources = row.getRows("RESOURCES");
if (resources != null)
{
for (MapRow childResource : sort(resources, "NAME"))
{
processResource(childResource);
}
}
m_resourceMap.put(resource.getGUID(), resource);
}
|
java
|
{
"resource": ""
}
|
q1176
|
SynchroReader.processTasks
|
train
|
private void processTasks() throws IOException
{
TaskReader reader = new TaskReader(m_data.getTableData("Tasks"));
reader.read();
for (MapRow row : reader.getRows())
{
processTask(m_project, row);
}
updateDates();
}
|
java
|
{
"resource": ""
}
|
q1177
|
SynchroReader.processTask
|
train
|
private void processTask(ChildTaskContainer parent, MapRow row) throws IOException
{
Task task = parent.addTask();
task.setName(row.getString("NAME"));
task.setGUID(row.getUUID("UUID"));
task.setText(1, row.getString("ID"));
task.setDuration(row.getDuration("PLANNED_DURATION"));
task.setRemainingDuration(row.getDuration("REMAINING_DURATION"));
task.setHyperlink(row.getString("URL"));
task.setPercentageComplete(row.getDouble("PERCENT_COMPLETE"));
task.setNotes(getNotes(row.getRows("COMMENTARY")));
task.setMilestone(task.getDuration().getDuration() == 0);
ProjectCalendar calendar = m_calendarMap.get(row.getUUID("CALENDAR_UUID"));
if (calendar != m_project.getDefaultCalendar())
{
task.setCalendar(calendar);
}
switch (row.getInteger("STATUS").intValue())
{
case 1: // Planned
{
task.setStart(row.getDate("PLANNED_START"));
task.setFinish(task.getEffectiveCalendar().getDate(task.getStart(), task.getDuration(), false));
break;
}
case 2: // Started
{
task.setActualStart(row.getDate("ACTUAL_START"));
task.setStart(task.getActualStart());
task.setFinish(row.getDate("ESTIMATED_FINISH"));
if (task.getFinish() == null)
{
task.setFinish(row.getDate("PLANNED_FINISH"));
}
break;
}
case 3: // Finished
{
task.setActualStart(row.getDate("ACTUAL_START"));
task.setActualFinish(row.getDate("ACTUAL_FINISH"));
task.setPercentageComplete(Double.valueOf(100.0));
task.setStart(task.getActualStart());
task.setFinish(task.getActualFinish());
break;
}
}
setConstraints(task, row);
processChildTasks(task, row);
m_taskMap.put(task.getGUID(), task);
List<MapRow> predecessors = row.getRows("PREDECESSORS");
if (predecessors != null && !predecessors.isEmpty())
{
m_predecessorMap.put(task, predecessors);
}
List<MapRow> resourceAssignmnets = row.getRows("RESOURCE_ASSIGNMENTS");
if (resourceAssignmnets != null && !resourceAssignmnets.isEmpty())
{
processResourceAssignments(task, resourceAssignmnets);
}
}
|
java
|
{
"resource": ""
}
|
q1178
|
SynchroReader.processChildTasks
|
train
|
private void processChildTasks(Task task, MapRow row) throws IOException
{
List<MapRow> tasks = row.getRows("TASKS");
if (tasks != null)
{
for (MapRow childTask : tasks)
{
processTask(task, childTask);
}
}
}
|
java
|
{
"resource": ""
}
|
q1179
|
SynchroReader.processPredecessors
|
train
|
private void processPredecessors()
{
for (Map.Entry<Task, List<MapRow>> entry : m_predecessorMap.entrySet())
{
Task task = entry.getKey();
List<MapRow> predecessors = entry.getValue();
for (MapRow predecessor : predecessors)
{
processPredecessor(task, predecessor);
}
}
}
|
java
|
{
"resource": ""
}
|
q1180
|
SynchroReader.processPredecessor
|
train
|
private void processPredecessor(Task task, MapRow row)
{
Task predecessor = m_taskMap.get(row.getUUID("PREDECESSOR_UUID"));
if (predecessor != null)
{
task.addPredecessor(predecessor, row.getRelationType("RELATION_TYPE"), row.getDuration("LAG"));
}
}
|
java
|
{
"resource": ""
}
|
q1181
|
SynchroReader.processResourceAssignments
|
train
|
private void processResourceAssignments(Task task, List<MapRow> assignments)
{
for (MapRow row : assignments)
{
processResourceAssignment(task, row);
}
}
|
java
|
{
"resource": ""
}
|
q1182
|
SynchroReader.processResourceAssignment
|
train
|
private void processResourceAssignment(Task task, MapRow row)
{
Resource resource = m_resourceMap.get(row.getUUID("RESOURCE_UUID"));
task.addResourceAssignment(resource);
}
|
java
|
{
"resource": ""
}
|
q1183
|
SynchroReader.setConstraints
|
train
|
private void setConstraints(Task task, MapRow row)
{
ConstraintType constraintType = null;
Date constraintDate = null;
Date lateDate = row.getDate("CONSTRAINT_LATE_DATE");
Date earlyDate = row.getDate("CONSTRAINT_EARLY_DATE");
switch (row.getInteger("CONSTRAINT_TYPE").intValue())
{
case 2: // Cannot Reschedule
{
constraintType = ConstraintType.MUST_START_ON;
constraintDate = task.getStart();
break;
}
case 12: //Finish Between
{
constraintType = ConstraintType.MUST_FINISH_ON;
constraintDate = lateDate;
break;
}
case 10: // Finish On or After
{
constraintType = ConstraintType.FINISH_NO_EARLIER_THAN;
constraintDate = earlyDate;
break;
}
case 11: // Finish On or Before
{
constraintType = ConstraintType.FINISH_NO_LATER_THAN;
constraintDate = lateDate;
break;
}
case 13: // Mandatory Start
case 5: // Start On
case 9: // Finish On
{
constraintType = ConstraintType.MUST_START_ON;
constraintDate = earlyDate;
break;
}
case 14: // Mandatory Finish
{
constraintType = ConstraintType.MUST_FINISH_ON;
constraintDate = earlyDate;
break;
}
case 4: // Start As Late As Possible
{
constraintType = ConstraintType.AS_LATE_AS_POSSIBLE;
break;
}
case 3: // Start As Soon As Possible
{
constraintType = ConstraintType.AS_SOON_AS_POSSIBLE;
break;
}
case 8: // Start Between
{
constraintType = ConstraintType.AS_SOON_AS_POSSIBLE;
constraintDate = earlyDate;
break;
}
case 6: // Start On or Before
{
constraintType = ConstraintType.START_NO_LATER_THAN;
constraintDate = earlyDate;
break;
}
case 15: // Work Between
{
constraintType = ConstraintType.START_NO_EARLIER_THAN;
constraintDate = earlyDate;
break;
}
}
task.setConstraintType(constraintType);
task.setConstraintDate(constraintDate);
}
|
java
|
{
"resource": ""
}
|
q1184
|
SynchroReader.getNotes
|
train
|
private String getNotes(List<MapRow> rows)
{
String result = null;
if (rows != null && !rows.isEmpty())
{
StringBuilder sb = new StringBuilder();
for (MapRow row : rows)
{
sb.append(row.getString("TITLE"));
sb.append('\n');
sb.append(row.getString("TEXT"));
sb.append("\n\n");
}
result = sb.toString();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1185
|
SynchroReader.sort
|
train
|
private List<MapRow> sort(List<MapRow> rows, final String attribute)
{
Collections.sort(rows, new Comparator<MapRow>()
{
@Override public int compare(MapRow o1, MapRow o2)
{
String value1 = o1.getString(attribute);
String value2 = o2.getString(attribute);
return value1.compareTo(value2);
}
});
return rows;
}
|
java
|
{
"resource": ""
}
|
q1186
|
SynchroReader.updateDates
|
train
|
private void updateDates(Task parentTask)
{
if (parentTask.hasChildTasks())
{
Date plannedStartDate = null;
Date plannedFinishDate = null;
for (Task task : parentTask.getChildTasks())
{
updateDates(task);
plannedStartDate = DateHelper.min(plannedStartDate, task.getStart());
plannedFinishDate = DateHelper.max(plannedFinishDate, task.getFinish());
}
parentTask.setStart(plannedStartDate);
parentTask.setFinish(plannedFinishDate);
}
}
|
java
|
{
"resource": ""
}
|
q1187
|
MultiDateFormat.parseNonNullDate
|
train
|
protected Date parseNonNullDate(String str, ParsePosition pos)
{
Date result = null;
for (int index = 0; index < m_formats.length; index++)
{
result = m_formats[index].parse(str, pos);
if (pos.getIndex() != 0)
{
break;
}
result = null;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1188
|
ProjectEntityWithIDContainer.renumberIDs
|
train
|
public void renumberIDs()
{
if (!isEmpty())
{
Collections.sort(this);
T firstEntity = get(0);
int id = NumberHelper.getInt(firstEntity.getID());
if (id != 0)
{
id = 1;
}
for (T entity : this)
{
entity.setID(Integer.valueOf(id++));
}
}
}
|
java
|
{
"resource": ""
}
|
q1189
|
Priority.getInstance
|
train
|
public static Priority getInstance(int priority)
{
Priority result;
if (priority >= LOWEST && priority <= DO_NOT_LEVEL && (priority % 100 == 0))
{
result = VALUE[(priority / 100) - 1];
}
else
{
result = new Priority(priority);
}
return (result);
}
|
java
|
{
"resource": ""
}
|
q1190
|
AstaTextFileReader.processFile
|
train
|
private void processFile(InputStream is) throws MPXJException
{
try
{
InputStreamReader reader = new InputStreamReader(is, CharsetHelper.UTF8);
Tokenizer tk = new ReaderTokenizer(reader)
{
@Override protected boolean startQuotedIsValid(StringBuilder buffer)
{
return buffer.length() == 1 && buffer.charAt(0) == '<';
}
};
tk.setDelimiter(DELIMITER);
ArrayList<String> columns = new ArrayList<String>();
String nextTokenPrefix = null;
while (tk.getType() != Tokenizer.TT_EOF)
{
columns.clear();
TableDefinition table = null;
while (tk.nextToken() == Tokenizer.TT_WORD)
{
String token = tk.getToken();
if (columns.size() == 0)
{
if (token.charAt(0) == '#')
{
int index = token.lastIndexOf(':');
if (index != -1)
{
String headerToken;
if (token.endsWith("-") || token.endsWith("="))
{
headerToken = token;
token = null;
}
else
{
headerToken = token.substring(0, index);
token = token.substring(index + 1);
}
RowHeader header = new RowHeader(headerToken);
table = m_tableDefinitions.get(header.getType());
columns.add(header.getID());
}
}
else
{
if (token.charAt(0) == 0)
{
processFileType(token);
}
}
}
if (table != null && token != null)
{
if (token.startsWith("<\"") && !token.endsWith("\">"))
{
nextTokenPrefix = token;
}
else
{
if (nextTokenPrefix != null)
{
token = nextTokenPrefix + DELIMITER + token;
nextTokenPrefix = null;
}
columns.add(token);
}
}
}
if (table != null && columns.size() > 1)
{
// System.out.println(table.getName() + " " + columns.size());
// ColumnDefinition[] columnDefs = table.getColumns();
// int unknownIndex = 1;
// for (int xx = 0; xx < columns.size(); xx++)
// {
// String x = columns.get(xx);
// String columnName = xx < columnDefs.length ? (columnDefs[xx] == null ? "UNKNOWN" + (unknownIndex++) : columnDefs[xx].getName()) : "?";
// System.out.println(columnName + ": " + x + ", ");
// }
// System.out.println();
TextFileRow row = new TextFileRow(table, columns, m_epochDateFormat);
List<Row> rows = m_tables.get(table.getName());
if (rows == null)
{
rows = new LinkedList<Row>();
m_tables.put(table.getName(), rows);
}
rows.add(row);
}
}
}
catch (Exception ex)
{
throw new MPXJException(MPXJException.READ_ERROR, ex);
}
}
|
java
|
{
"resource": ""
}
|
q1191
|
AstaTextFileReader.processFileType
|
train
|
private void processFileType(String token) throws MPXJException
{
String version = token.substring(2).split(" ")[0];
//System.out.println(version);
Class<? extends AbstractFileFormat> fileFormatClass = FILE_VERSION_MAP.get(Integer.valueOf(version));
if (fileFormatClass == null)
{
throw new MPXJException("Unsupported PP file format version " + version);
}
try
{
AbstractFileFormat format = fileFormatClass.newInstance();
m_tableDefinitions = format.tableDefinitions();
m_epochDateFormat = format.epochDateFormat();
}
catch (Exception ex)
{
throw new MPXJException("Failed to configure file format", ex);
}
}
|
java
|
{
"resource": ""
}
|
q1192
|
AstaTextFileReader.processCalendars
|
train
|
private void processCalendars() throws SQLException
{
List<Row> rows = getTable("EXCEPTIONN");
Map<Integer, DayType> exceptionMap = m_reader.createExceptionTypeMap(rows);
rows = getTable("WORK_PATTERN");
Map<Integer, Row> workPatternMap = m_reader.createWorkPatternMap(rows);
rows = new LinkedList<Row>();// getTable("WORK_PATTERN_ASSIGNMENT"); // Need to generate an example
Map<Integer, List<Row>> workPatternAssignmentMap = m_reader.createWorkPatternAssignmentMap(rows);
rows = getTable("EXCEPTION_ASSIGNMENT");
Map<Integer, List<Row>> exceptionAssignmentMap = m_reader.createExceptionAssignmentMap(rows);
rows = getTable("TIME_ENTRY");
Map<Integer, List<Row>> timeEntryMap = m_reader.createTimeEntryMap(rows);
rows = getTable("CALENDAR");
Collections.sort(rows, CALENDAR_COMPARATOR);
for (Row row : rows)
{
m_reader.processCalendar(row, workPatternMap, workPatternAssignmentMap, exceptionAssignmentMap, timeEntryMap, exceptionMap);
}
//
// Update unique counters at this point as we will be generating
// resource calendars, and will need to auto generate IDs
//
m_reader.getProject().getProjectConfig().updateUniqueCounters();
}
|
java
|
{
"resource": ""
}
|
q1193
|
AstaTextFileReader.join
|
train
|
private List<Row> join(List<Row> leftRows, String leftColumn, String rightTable, List<Row> rightRows, String rightColumn)
{
List<Row> result = new LinkedList<Row>();
RowComparator leftComparator = new RowComparator(new String[]
{
leftColumn
});
RowComparator rightComparator = new RowComparator(new String[]
{
rightColumn
});
Collections.sort(leftRows, leftComparator);
Collections.sort(rightRows, rightComparator);
ListIterator<Row> rightIterator = rightRows.listIterator();
Row rightRow = rightIterator.hasNext() ? rightIterator.next() : null;
for (Row leftRow : leftRows)
{
Integer leftValue = leftRow.getInteger(leftColumn);
boolean match = false;
while (rightRow != null)
{
Integer rightValue = rightRow.getInteger(rightColumn);
int comparison = leftValue.compareTo(rightValue);
if (comparison == 0)
{
match = true;
break;
}
if (comparison < 0)
{
if (rightIterator.hasPrevious())
{
rightRow = rightIterator.previous();
}
break;
}
rightRow = rightIterator.next();
}
if (match && rightRow != null)
{
Map<String, Object> newMap = new HashMap<String, Object>(((MapRow) leftRow).getMap());
for (Entry<String, Object> entry : ((MapRow) rightRow).getMap().entrySet())
{
String key = entry.getKey();
if (newMap.containsKey(key))
{
key = rightTable + "." + key;
}
newMap.put(key, entry.getValue());
}
result.add(new MapRow(newMap));
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1194
|
AstaTextFileReader.getTable
|
train
|
private List<Row> getTable(String name)
{
List<Row> result = m_tables.get(name);
if (result == null)
{
result = Collections.emptyList();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q1195
|
GanttProjectReader.readProjectProperties
|
train
|
private void readProjectProperties(Project ganttProject)
{
ProjectProperties mpxjProperties = m_projectFile.getProjectProperties();
mpxjProperties.setName(ganttProject.getName());
mpxjProperties.setCompany(ganttProject.getCompany());
mpxjProperties.setDefaultDurationUnits(TimeUnit.DAYS);
String locale = ganttProject.getLocale();
if (locale == null)
{
locale = "en_US";
}
m_localeDateFormat = DateFormat.getDateInstance(DateFormat.SHORT, new Locale(locale));
}
|
java
|
{
"resource": ""
}
|
q1196
|
GanttProjectReader.readCalendars
|
train
|
private void readCalendars(Project ganttProject)
{
m_mpxjCalendar = m_projectFile.addCalendar();
m_mpxjCalendar.setName(ProjectCalendar.DEFAULT_BASE_CALENDAR_NAME);
Calendars gpCalendar = ganttProject.getCalendars();
setWorkingDays(m_mpxjCalendar, gpCalendar);
setExceptions(m_mpxjCalendar, gpCalendar);
m_eventManager.fireCalendarReadEvent(m_mpxjCalendar);
}
|
java
|
{
"resource": ""
}
|
q1197
|
GanttProjectReader.setWorkingDays
|
train
|
private void setWorkingDays(ProjectCalendar mpxjCalendar, Calendars gpCalendar)
{
DayTypes dayTypes = gpCalendar.getDayTypes();
DefaultWeek defaultWeek = dayTypes.getDefaultWeek();
if (defaultWeek == null)
{
mpxjCalendar.setWorkingDay(Day.SUNDAY, false);
mpxjCalendar.setWorkingDay(Day.MONDAY, true);
mpxjCalendar.setWorkingDay(Day.TUESDAY, true);
mpxjCalendar.setWorkingDay(Day.WEDNESDAY, true);
mpxjCalendar.setWorkingDay(Day.THURSDAY, true);
mpxjCalendar.setWorkingDay(Day.FRIDAY, true);
mpxjCalendar.setWorkingDay(Day.SATURDAY, false);
}
else
{
mpxjCalendar.setWorkingDay(Day.MONDAY, isWorkingDay(defaultWeek.getMon()));
mpxjCalendar.setWorkingDay(Day.TUESDAY, isWorkingDay(defaultWeek.getTue()));
mpxjCalendar.setWorkingDay(Day.WEDNESDAY, isWorkingDay(defaultWeek.getWed()));
mpxjCalendar.setWorkingDay(Day.THURSDAY, isWorkingDay(defaultWeek.getThu()));
mpxjCalendar.setWorkingDay(Day.FRIDAY, isWorkingDay(defaultWeek.getFri()));
mpxjCalendar.setWorkingDay(Day.SATURDAY, isWorkingDay(defaultWeek.getSat()));
mpxjCalendar.setWorkingDay(Day.SUNDAY, isWorkingDay(defaultWeek.getSun()));
}
for (Day day : Day.values())
{
if (mpxjCalendar.isWorkingDay(day))
{
ProjectCalendarHours hours = mpxjCalendar.addCalendarHours(day);
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
}
}
}
|
java
|
{
"resource": ""
}
|
q1198
|
GanttProjectReader.setExceptions
|
train
|
private void setExceptions(ProjectCalendar mpxjCalendar, Calendars gpCalendar)
{
List<net.sf.mpxj.ganttproject.schema.Date> dates = gpCalendar.getDate();
for (net.sf.mpxj.ganttproject.schema.Date date : dates)
{
addException(mpxjCalendar, date);
}
}
|
java
|
{
"resource": ""
}
|
q1199
|
GanttProjectReader.addException
|
train
|
private void addException(ProjectCalendar mpxjCalendar, net.sf.mpxj.ganttproject.schema.Date date)
{
String year = date.getYear();
if (year == null || year.isEmpty())
{
// In order to process recurring exceptions using MPXJ, we need a start and end date
// to constrain the number of dates we generate.
// May need to pre-process the tasks in order to calculate a start and finish date.
// TODO: handle recurring exceptions
}
else
{
Calendar calendar = DateHelper.popCalendar();
calendar.set(Calendar.YEAR, Integer.parseInt(year));
calendar.set(Calendar.MONTH, NumberHelper.getInt(date.getMonth()));
calendar.set(Calendar.DAY_OF_MONTH, NumberHelper.getInt(date.getDate()));
Date exceptionDate = calendar.getTime();
DateHelper.pushCalendar(calendar);
ProjectCalendarException exception = mpxjCalendar.addCalendarException(exceptionDate, exceptionDate);
// TODO: not sure how NEUTRAL should be handled
if ("WORKING_DAY".equals(date.getType()))
{
exception.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
exception.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
}
}
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.