_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
---|---|---|---|---|---|
q200 | RendererBuilder.isRecyclable | train | private boolean isRecyclable(View convertView, T content) {
boolean isRecyclable = false;
if (convertView != null && convertView.getTag() != null) {
Class prototypeClass = getPrototypeClass(content);
validatePrototypeClass(prototypeClass);
isRecyclable = prototypeClass.equals(convertView.getTag().getClass());
}
return isRecyclable;
} | java | {
"resource": ""
} |
q201 | RendererBuilder.getItemViewType | train | private int getItemViewType(Class prototypeClass) {
int itemViewType = -1;
for (Renderer renderer : prototypes) {
if (renderer.getClass().equals(prototypeClass)) {
itemViewType = getPrototypeIndex(renderer);
break;
}
}
if (itemViewType == -1) {
throw new PrototypeNotFoundException(
"Review your RendererBuilder implementation, you are returning one"
+ " prototype class not found in prototypes collection");
}
return itemViewType;
} | java | {
"resource": ""
} |
q202 | RendererBuilder.getPrototypeIndex | train | private int getPrototypeIndex(Renderer renderer) {
int index = 0;
for (Renderer prototype : prototypes) {
if (prototype.getClass().equals(renderer.getClass())) {
break;
}
index++;
}
return index;
} | java | {
"resource": ""
} |
q203 | RendererBuilder.validateAttributes | train | private void validateAttributes() {
if (content == null) {
throw new NullContentException("RendererBuilder needs content to create Renderer instances");
}
if (parent == null) {
throw new NullParentException("RendererBuilder needs a parent to inflate Renderer instances");
}
if (layoutInflater == null) {
throw new NullLayoutInflaterException(
"RendererBuilder needs a LayoutInflater to inflate Renderer instances");
}
} | java | {
"resource": ""
} |
q204 | RendererBuilder.validateAttributesToCreateANewRendererViewHolder | train | private void validateAttributesToCreateANewRendererViewHolder() {
if (viewType == null) {
throw new NullContentException(
"RendererBuilder needs a view type to create a RendererViewHolder");
}
if (layoutInflater == null) {
throw new NullLayoutInflaterException(
"RendererBuilder needs a LayoutInflater to create a RendererViewHolder");
}
if (parent == null) {
throw new NullParentException(
"RendererBuilder needs a parent to create a RendererViewHolder");
}
} | java | {
"resource": ""
} |
q205 | RendererBuilder.getPrototypeClass | train | protected Class getPrototypeClass(T content) {
if (prototypes.size() == 1) {
return prototypes.get(0).getClass();
} else {
return binding.get(content.getClass());
}
} | java | {
"resource": ""
} |
q206 | VideoRenderer.inflate | train | @Override protected View inflate(LayoutInflater inflater, ViewGroup parent) {
View inflatedView = inflater.inflate(R.layout.video_renderer, parent, false);
/*
* You don't have to use ButterKnife library to implement the mapping between your layout
* and your widgets you can implement setUpView and hookListener methods declared in
* Renderer<T> class.
*/
ButterKnife.bind(this, inflatedView);
return inflatedView;
} | java | {
"resource": ""
} |
q207 | VideoRenderer.render | train | @Override public void render() {
Video video = getContent();
renderThumbnail(video);
renderTitle(video);
renderMarker(video);
renderLabel();
} | java | {
"resource": ""
} |
q208 | VideoRenderer.renderThumbnail | train | private void renderThumbnail(Video video) {
Picasso.with(getContext()).cancelRequest(thumbnail);
Picasso.with(getContext())
.load(video.getThumbnail())
.placeholder(R.drawable.placeholder)
.into(thumbnail);
} | java | {
"resource": ""
} |
q209 | Renderer.onCreate | train | public void onCreate(T content, LayoutInflater layoutInflater, ViewGroup parent) {
this.content = content;
this.rootView = inflate(layoutInflater, parent);
if (rootView == null) {
throw new NotInflateViewException(
"Renderer instances have to return a not null view in inflateView method");
}
this.rootView.setTag(this);
setUpView(rootView);
hookListeners(rootView);
} | java | {
"resource": ""
} |
q210 | Renderer.copy | train | Renderer copy() {
Renderer copy = null;
try {
copy = (Renderer) this.clone();
} catch (CloneNotSupportedException e) {
Log.e("Renderer", "All your renderers should be clonables.");
}
return copy;
} | java | {
"resource": ""
} |
q211 | RendererAdapter.getView | train | @Override public View getView(int position, View convertView, ViewGroup parent) {
T content = getItem(position);
rendererBuilder.withContent(content);
rendererBuilder.withConvertView(convertView);
rendererBuilder.withParent(parent);
rendererBuilder.withLayoutInflater(LayoutInflater.from(parent.getContext()));
Renderer<T> renderer = rendererBuilder.build();
if (renderer == null) {
throw new NullRendererBuiltException("RendererBuilder have to return a not null Renderer");
}
updateRendererExtraValues(content, renderer, position);
renderer.render();
return renderer.getRootView();
} | java | {
"resource": ""
} |
q212 | VPRendererAdapter.instantiateItem | train | @Override public Object instantiateItem(ViewGroup parent, int position) {
T content = getItem(position);
rendererBuilder.withContent(content);
rendererBuilder.withParent(parent);
rendererBuilder.withLayoutInflater(LayoutInflater.from(parent.getContext()));
Renderer<T> renderer = rendererBuilder.build();
if (renderer == null) {
throw new NullRendererBuiltException("RendererBuilder have to return a not null Renderer");
}
updateRendererExtraValues(content, renderer, position);
renderer.render();
View view = renderer.getRootView();
parent.addView(view);
return view;
} | java | {
"resource": ""
} |
q213 | RandomVideoCollectionGenerator.generate | train | public VideoCollection generate(final int videoCount) {
List<Video> videos = new LinkedList<Video>();
for (int i = 0; i < videoCount; i++) {
Video video = generateRandomVideo();
videos.add(video);
}
return new VideoCollection(videos);
} | java | {
"resource": ""
} |
q214 | RandomVideoCollectionGenerator.initializeVideoInfo | train | private void initializeVideoInfo() {
VIDEO_INFO.put("The Big Bang Theory", "http://thetvdb.com/banners/_cache/posters/80379-9.jpg");
VIDEO_INFO.put("Breaking Bad", "http://thetvdb.com/banners/_cache/posters/81189-22.jpg");
VIDEO_INFO.put("Arrow", "http://thetvdb.com/banners/_cache/posters/257655-15.jpg");
VIDEO_INFO.put("Game of Thrones", "http://thetvdb.com/banners/_cache/posters/121361-26.jpg");
VIDEO_INFO.put("Lost", "http://thetvdb.com/banners/_cache/posters/73739-2.jpg");
VIDEO_INFO.put("How I met your mother",
"http://thetvdb.com/banners/_cache/posters/75760-29.jpg");
VIDEO_INFO.put("Dexter", "http://thetvdb.com/banners/_cache/posters/79349-24.jpg");
VIDEO_INFO.put("Sleepy Hollow", "http://thetvdb.com/banners/_cache/posters/269578-5.jpg");
VIDEO_INFO.put("The Vampire Diaries", "http://thetvdb.com/banners/_cache/posters/95491-27.jpg");
VIDEO_INFO.put("Friends", "http://thetvdb.com/banners/_cache/posters/79168-4.jpg");
VIDEO_INFO.put("New Girl", "http://thetvdb.com/banners/_cache/posters/248682-9.jpg");
VIDEO_INFO.put("The Mentalist", "http://thetvdb.com/banners/_cache/posters/82459-1.jpg");
VIDEO_INFO.put("Sons of Anarchy", "http://thetvdb.com/banners/_cache/posters/82696-1.jpg");
} | java | {
"resource": ""
} |
q215 | RandomVideoCollectionGenerator.generateRandomVideo | train | private Video generateRandomVideo() {
Video video = new Video();
configureFavoriteStatus(video);
configureLikeStatus(video);
configureLiveStatus(video);
configureTitleAndThumbnail(video);
return video;
} | java | {
"resource": ""
} |
q216 | BodyAndHeaderParser.parseContent | train | protected final ByteBuffer parseContent(ByteBuffer in) throws BaseExceptions.ParserException {
if (contentComplete()) {
throw new BaseExceptions.InvalidState("content already complete: " + _endOfContent);
} else {
switch (_endOfContent) {
case UNKNOWN_CONTENT:
// This makes sense only for response parsing. Requests must always have
// either Content-Length or Transfer-Encoding
_endOfContent = EndOfContent.EOF_CONTENT;
_contentLength = Long.MAX_VALUE; // Its up to the user to limit a body size
return parseContent(in);
case CONTENT_LENGTH:
case EOF_CONTENT:
return nonChunkedContent(in);
case CHUNKED_CONTENT:
return chunkedContent(in);
default:
throw new BaseExceptions.InvalidState("not implemented: " + _endOfContent);
}
}
} | java | {
"resource": ""
} |
q217 | ParserBase.putChar | train | final protected void putChar(char c) {
final int clen = _internalBuffer.length;
if (clen == _bufferPosition) {
final char[] next = new char[2 * clen + 1];
System.arraycopy(_internalBuffer, 0, next, 0, _bufferPosition);
_internalBuffer = next;
}
_internalBuffer[_bufferPosition++] = c;
} | java | {
"resource": ""
} |
q218 | ParserBase.getTrimmedString | train | final protected String getTrimmedString() throws BadMessage {
if (_bufferPosition == 0) return "";
int start = 0;
boolean quoted = false;
// Look for start
while (start < _bufferPosition) {
final char ch = _internalBuffer[start];
if (ch == '"') {
quoted = true;
break;
}
else if (ch != HttpTokens.SPACE && ch != HttpTokens.TAB) {
break;
}
start++;
}
int end = _bufferPosition; // Position is of next write
// Look for end
while(end > start) {
final char ch = _internalBuffer[end - 1];
if (quoted) {
if (ch == '"') break;
else if (ch != HttpTokens.SPACE && ch != HttpTokens.TAB) {
throw new BadMessage("String might not quoted correctly: '" + getString() + "'");
}
}
else if (ch != HttpTokens.SPACE && ch != HttpTokens.TAB) break;
end--;
}
String str = new String(_internalBuffer, start, end - start);
return str;
} | java | {
"resource": ""
} |
q219 | ParserBase.next | train | final protected char next(final ByteBuffer buffer, boolean allow8859) throws BaseExceptions.BadMessage {
if (!buffer.hasRemaining()) return HttpTokens.EMPTY_BUFF;
if (_segmentByteLimit <= _segmentBytePosition) {
shutdownParser();
throw new BaseExceptions.BadMessage("Request length limit exceeded: " + _segmentByteLimit);
}
final byte b = buffer.get();
_segmentBytePosition++;
// If we ended on a CR, make sure we are
if (_cr) {
if (b != HttpTokens.LF) {
throw new BadCharacter("Invalid sequence: LF didn't follow CR: " + b);
}
_cr = false;
return (char)b; // must be LF
}
// Make sure its a valid character
if (b < HttpTokens.SPACE) {
if (b == HttpTokens.CR) { // Set the flag to check for _cr and just run again
_cr = true;
return next(buffer, allow8859);
}
else if (b == HttpTokens.TAB || allow8859 && b < 0) {
return (char)(b & 0xff);
}
else if (b == HttpTokens.LF) {
return (char)b; // A backend should accept a bare linefeed. http://tools.ietf.org/html/rfc2616#section-19.3
}
else if (isLenient()) {
return HttpTokens.REPLACEMENT;
}
else {
shutdownParser();
throw new BadCharacter("Invalid char: '" + (char)(b & 0xff) + "', 0x" + Integer.toHexString(b));
}
}
// valid ascii char
return (char)b;
} | java | {
"resource": ""
} |
q220 | GanttChartView.mapGanttBarHeight | train | protected int mapGanttBarHeight(int height)
{
switch (height)
{
case 0:
{
height = 6;
break;
}
case 1:
{
height = 8;
break;
}
case 2:
{
height = 10;
break;
}
case 3:
{
height = 12;
break;
}
case 4:
{
height = 14;
break;
}
case 5:
{
height = 18;
break;
}
case 6:
{
height = 24;
break;
}
}
return (height);
} | java | {
"resource": ""
} |
q221 | GanttChartView.getColumnFontStyle | train | protected TableFontStyle getColumnFontStyle(byte[] data, int offset, Map<Integer, FontBase> fontBases)
{
int uniqueID = MPPUtility.getInt(data, offset);
FieldType fieldType = MPPTaskField.getInstance(MPPUtility.getShort(data, offset + 4));
Integer index = Integer.valueOf(MPPUtility.getByte(data, offset + 8));
int style = MPPUtility.getByte(data, offset + 9);
ColorType color = ColorType.getInstance(MPPUtility.getByte(data, offset + 10));
int change = MPPUtility.getByte(data, offset + 12);
FontBase fontBase = fontBases.get(index);
boolean bold = ((style & 0x01) != 0);
boolean italic = ((style & 0x02) != 0);
boolean underline = ((style & 0x04) != 0);
boolean boldChanged = ((change & 0x01) != 0);
boolean underlineChanged = ((change & 0x02) != 0);
boolean italicChanged = ((change & 0x04) != 0);
boolean colorChanged = ((change & 0x08) != 0);
boolean fontChanged = ((change & 0x10) != 0);
boolean backgroundColorChanged = (uniqueID == -1);
boolean backgroundPatternChanged = (uniqueID == -1);
return (new TableFontStyle(uniqueID, fieldType, fontBase, italic, bold, underline, false, color.getColor(), Color.BLACK, BackgroundPattern.TRANSPARENT, italicChanged, boldChanged, underlineChanged, false, colorChanged, fontChanged, backgroundColorChanged, backgroundPatternChanged));
} | java | {
"resource": ""
} |
q222 | PhoenixInputStream.prepareInputStream | train | private InputStream prepareInputStream(InputStream stream) throws IOException
{
InputStream result;
BufferedInputStream bis = new BufferedInputStream(stream);
readHeaderProperties(bis);
if (isCompressed())
{
result = new InflaterInputStream(bis);
}
else
{
result = bis;
}
return result;
} | java | {
"resource": ""
} |
q223 | PhoenixInputStream.readHeaderString | train | private String readHeaderString(BufferedInputStream stream) throws IOException
{
int bufferSize = 100;
stream.mark(bufferSize);
byte[] buffer = new byte[bufferSize];
stream.read(buffer);
Charset charset = CharsetHelper.UTF8;
String header = new String(buffer, charset);
int prefixIndex = header.indexOf("PPX!!!!|");
int suffixIndex = header.indexOf("|!!!!XPP");
if (prefixIndex != 0 || suffixIndex == -1)
{
throw new IOException("File format not recognised");
}
int skip = suffixIndex + 9;
stream.reset();
stream.skip(skip);
return header.substring(prefixIndex + 8, suffixIndex);
} | java | {
"resource": ""
} |
q224 | PhoenixInputStream.readHeaderProperties | train | private void readHeaderProperties(BufferedInputStream stream) throws IOException
{
String header = readHeaderString(stream);
for (String property : header.split("\\|"))
{
String[] expression = property.split("=");
m_properties.put(expression[0], expression[1]);
}
} | java | {
"resource": ""
} |
q225 | MPP8Reader.process | train | @Override public void process(MPPReader reader, ProjectFile file, DirectoryEntry root) throws MPXJException, IOException
{
try
{
populateMemberData(reader, file, root);
processProjectProperties();
if (!reader.getReadPropertiesOnly())
{
processCalendarData();
processResourceData();
processTaskData();
processConstraintData();
processAssignmentData();
if (reader.getReadPresentationData())
{
processViewPropertyData();
processViewData();
processTableData();
}
}
}
finally
{
clearMemberData();
}
} | java | {
"resource": ""
} |
q226 | MPP8Reader.updateBaseCalendarNames | train | private void updateBaseCalendarNames(List<Pair<ProjectCalendar, Integer>> baseCalendars)
{
for (Pair<ProjectCalendar, Integer> pair : baseCalendars)
{
ProjectCalendar cal = pair.getFirst();
Integer baseCalendarID = pair.getSecond();
ProjectCalendar baseCal = m_calendarMap.get(baseCalendarID);
if (baseCal != null)
{
cal.setParent(baseCal);
}
}
} | java | {
"resource": ""
} |
q227 | MPP8Reader.setTaskNotes | train | private void setTaskNotes(Task task, byte[] data, ExtendedData taskExtData, FixDeferFix taskVarData)
{
String notes = taskExtData.getString(TASK_NOTES);
if (notes == null && data.length == 366)
{
byte[] offsetData = taskVarData.getByteArray(getOffset(data, 362));
if (offsetData != null && offsetData.length >= 12)
{
notes = taskVarData.getString(getOffset(offsetData, 8));
// We do pick up some random stuff with this approach, and
// we don't know enough about the file format to know when to ignore it
// so we'll use a heuristic here to ignore anything that
// doesn't look like RTF.
if (notes != null && notes.indexOf('{') == -1)
{
notes = null;
}
}
}
if (notes != null)
{
if (m_reader.getPreserveNoteFormatting() == false)
{
notes = RtfHelper.strip(notes);
}
task.setNotes(notes);
}
} | java | {
"resource": ""
} |
q228 | MPP8Reader.processHyperlinkData | train | private void processHyperlinkData(Task task, byte[] data)
{
if (data != null)
{
int offset = 12;
String hyperlink;
String address;
String subaddress;
offset += 12;
hyperlink = MPPUtility.getUnicodeString(data, offset);
offset += ((hyperlink.length() + 1) * 2);
offset += 12;
address = MPPUtility.getUnicodeString(data, offset);
offset += ((address.length() + 1) * 2);
offset += 12;
subaddress = MPPUtility.getUnicodeString(data, offset);
task.setHyperlink(hyperlink);
task.setHyperlinkAddress(address);
task.setHyperlinkSubAddress(subaddress);
}
} | java | {
"resource": ""
} |
q229 | PrimaveraConvert.process | train | public void process(String driverClass, String connectionString, String projectID, String outputFile) throws Exception
{
System.out.println("Reading Primavera database started.");
Class.forName(driverClass);
Properties props = new Properties();
//
// This is not a very robust way to detect that we're working with SQLlite...
// If you are trying to grab data from
// a standalone P6 using SQLite, the SQLite JDBC driver needs this property
// in order to correctly parse timestamps.
//
if (driverClass.equals("org.sqlite.JDBC"))
{
props.setProperty("date_string_format", "yyyy-MM-dd HH:mm:ss");
}
Connection c = DriverManager.getConnection(connectionString, props);
PrimaveraDatabaseReader reader = new PrimaveraDatabaseReader();
reader.setConnection(c);
processProject(reader, Integer.parseInt(projectID), outputFile);
} | java | {
"resource": ""
} |
q230 | PrimaveraConvert.processProject | train | private void processProject(PrimaveraDatabaseReader reader, int projectID, String outputFile) throws Exception
{
long start = System.currentTimeMillis();
reader.setProjectID(projectID);
ProjectFile projectFile = reader.read();
long elapsed = System.currentTimeMillis() - start;
System.out.println("Reading database completed in " + elapsed + "ms.");
System.out.println("Writing output file started.");
start = System.currentTimeMillis();
ProjectWriter writer = ProjectWriterUtility.getProjectWriter(outputFile);
writer.write(projectFile, outputFile);
elapsed = System.currentTimeMillis() - start;
System.out.println("Writing output completed in " + elapsed + "ms.");
} | java | {
"resource": ""
} |
q231 | MPPResourceField.getInstance | train | public static ResourceField getInstance(int value)
{
ResourceField result = null;
if (value >= 0 && value < FIELD_ARRAY.length)
{
result = FIELD_ARRAY[value];
}
else
{
if ((value & 0x8000) != 0)
{
int baseValue = ResourceField.ENTERPRISE_CUSTOM_FIELD1.getValue();
int id = baseValue + (value & 0xFFF);
result = ResourceField.getInstance(id);
}
}
return (result);
} | java | {
"resource": ""
} |
q232 | TaskModel.update | train | public void update(Record record, boolean isText) throws MPXJException
{
int length = record.getLength();
for (int i = 0; i < length; i++)
{
if (isText == true)
{
add(getTaskCode(record.getString(i)));
}
else
{
add(record.getInteger(i).intValue());
}
}
} | java | {
"resource": ""
} |
q233 | TaskModel.add | train | private void add(int field)
{
if (field < m_flags.length)
{
if (m_flags[field] == false)
{
m_flags[field] = true;
m_fields[m_count] = field;
++m_count;
}
}
} | java | {
"resource": ""
} |
q234 | TaskModel.isFieldPopulated | train | @SuppressWarnings("unchecked") private boolean isFieldPopulated(Task task, TaskField field)
{
boolean result = false;
if (field != null)
{
Object value = task.getCachedValue(field);
switch (field)
{
case PREDECESSORS:
case SUCCESSORS:
{
result = value != null && !((List<Relation>) value).isEmpty();
break;
}
default:
{
result = value != null;
break;
}
}
}
return result;
} | java | {
"resource": ""
} |
q235 | TaskModel.getTaskField | train | private String getTaskField(int key)
{
String result = null;
if ((key > 0) && (key < m_taskNames.length))
{
result = m_taskNames[key];
}
return (result);
} | java | {
"resource": ""
} |
q236 | TaskModel.getTaskCode | train | private int getTaskCode(String field) throws MPXJException
{
Integer result = m_taskNumbers.get(field.trim());
if (result == null)
{
throw new MPXJException(MPXJException.INVALID_TASK_FIELD_NAME + " " + field);
}
return (result.intValue());
} | java | {
"resource": ""
} |
q237 | DatatypeConverter.parseString | train | public static String parseString(String value)
{
if (value != null)
{
// Strip angle brackets if present
if (!value.isEmpty() && value.charAt(0) == '<')
{
value = value.substring(1, value.length() - 1);
}
// Strip quotes if present
if (!value.isEmpty() && value.charAt(0) == '"')
{
value = value.substring(1, value.length() - 1);
}
}
return value;
} | java | {
"resource": ""
} |
q238 | DatatypeConverter.parseDouble | train | public static Number parseDouble(String value) throws ParseException
{
Number result = null;
value = parseString(value);
// If we still have a value
if (value != null && !value.isEmpty() && !value.equals("-1 -1"))
{
int index = value.indexOf("E+");
if (index != -1)
{
value = value.substring(0, index) + 'E' + value.substring(index + 2, value.length());
}
if (value.indexOf('E') != -1)
{
result = DOUBLE_FORMAT.get().parse(value);
}
else
{
result = Double.valueOf(value);
}
}
return result;
} | java | {
"resource": ""
} |
q239 | DatatypeConverter.parseBoolean | train | public static Boolean parseBoolean(String value) throws ParseException
{
Boolean result = null;
Integer number = parseInteger(value);
if (number != null)
{
result = number.intValue() == 0 ? Boolean.FALSE : Boolean.TRUE;
}
return result;
} | java | {
"resource": ""
} |
q240 | DatatypeConverter.parseInteger | train | public static Integer parseInteger(String value) throws ParseException
{
Integer result = null;
if (value.length() > 0 && value.indexOf(' ') == -1)
{
if (value.indexOf('.') == -1)
{
result = Integer.valueOf(value);
}
else
{
Number n = DatatypeConverter.parseDouble(value);
result = Integer.valueOf(n.intValue());
}
}
return result;
} | java | {
"resource": ""
} |
q241 | DatatypeConverter.parseEpochTimestamp | train | public static Date parseEpochTimestamp(String value)
{
Date result = null;
if (value.length() > 0)
{
if (!value.equals("-1 -1"))
{
Calendar cal = DateHelper.popCalendar(JAVA_EPOCH);
int index = value.indexOf(' ');
if (index == -1)
{
if (value.length() < 6)
{
value = "000000" + value;
value = value.substring(value.length() - 6);
}
int hours = Integer.parseInt(value.substring(0, 2));
int minutes = Integer.parseInt(value.substring(2, 4));
int seconds = Integer.parseInt(value.substring(4));
cal.set(Calendar.HOUR, hours);
cal.set(Calendar.MINUTE, minutes);
cal.set(Calendar.SECOND, seconds);
}
else
{
long astaDays = Long.parseLong(value.substring(0, index));
int astaSeconds = Integer.parseInt(value.substring(index + 1));
cal.add(Calendar.DAY_OF_YEAR, (int) (astaDays - ASTA_EPOCH));
cal.set(Calendar.MILLISECOND, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.HOUR, 0);
cal.add(Calendar.SECOND, astaSeconds);
}
result = cal.getTime();
DateHelper.pushCalendar(cal);
}
}
return result;
} | java | {
"resource": ""
} |
q242 | MPD9AbstractReader.processProjectListItem | train | protected void processProjectListItem(Map<Integer, String> result, Row row)
{
Integer id = row.getInteger("PROJ_ID");
String name = row.getString("PROJ_NAME");
result.put(id, name);
} | java | {
"resource": ""
} |
q243 | MPD9AbstractReader.processCalendarData | train | protected void processCalendarData(ProjectCalendar calendar, Row row)
{
int dayIndex = row.getInt("CD_DAY_OR_EXCEPTION");
if (dayIndex == 0)
{
processCalendarException(calendar, row);
}
else
{
processCalendarHours(calendar, row, dayIndex);
}
} | java | {
"resource": ""
} |
q244 | MPD9AbstractReader.processCalendarException | train | private void processCalendarException(ProjectCalendar calendar, Row row)
{
Date fromDate = row.getDate("CD_FROM_DATE");
Date toDate = row.getDate("CD_TO_DATE");
boolean working = row.getInt("CD_WORKING") != 0;
ProjectCalendarException exception = calendar.addCalendarException(fromDate, toDate);
if (working)
{
exception.addRange(new DateRange(row.getDate("CD_FROM_TIME1"), row.getDate("CD_TO_TIME1")));
exception.addRange(new DateRange(row.getDate("CD_FROM_TIME2"), row.getDate("CD_TO_TIME2")));
exception.addRange(new DateRange(row.getDate("CD_FROM_TIME3"), row.getDate("CD_TO_TIME3")));
exception.addRange(new DateRange(row.getDate("CD_FROM_TIME4"), row.getDate("CD_TO_TIME4")));
exception.addRange(new DateRange(row.getDate("CD_FROM_TIME5"), row.getDate("CD_TO_TIME5")));
}
} | java | {
"resource": ""
} |
q245 | MPD9AbstractReader.processCalendarHours | train | private void processCalendarHours(ProjectCalendar calendar, Row row, int dayIndex)
{
Day day = Day.getInstance(dayIndex);
boolean working = row.getInt("CD_WORKING") != 0;
calendar.setWorkingDay(day, working);
if (working == true)
{
ProjectCalendarHours hours = calendar.addCalendarHours(day);
Date start = row.getDate("CD_FROM_TIME1");
Date end = row.getDate("CD_TO_TIME1");
if (start != null && end != null)
{
hours.addRange(new DateRange(start, end));
}
start = row.getDate("CD_FROM_TIME2");
end = row.getDate("CD_TO_TIME2");
if (start != null && end != null)
{
hours.addRange(new DateRange(start, end));
}
start = row.getDate("CD_FROM_TIME3");
end = row.getDate("CD_TO_TIME3");
if (start != null && end != null)
{
hours.addRange(new DateRange(start, end));
}
start = row.getDate("CD_FROM_TIME4");
end = row.getDate("CD_TO_TIME4");
if (start != null && end != null)
{
hours.addRange(new DateRange(start, end));
}
start = row.getDate("CD_FROM_TIME5");
end = row.getDate("CD_TO_TIME5");
if (start != null && end != null)
{
hours.addRange(new DateRange(start, end));
}
}
} | java | {
"resource": ""
} |
q246 | MPD9AbstractReader.processResourceBaseline | train | protected void processResourceBaseline(Row row)
{
Integer id = row.getInteger("RES_UID");
Resource resource = m_project.getResourceByUniqueID(id);
if (resource != null)
{
int index = row.getInt("RB_BASE_NUM");
resource.setBaselineWork(index, row.getDuration("RB_BASE_WORK"));
resource.setBaselineCost(index, row.getCurrency("RB_BASE_COST"));
}
} | java | {
"resource": ""
} |
q247 | MPD9AbstractReader.processDurationField | train | protected void processDurationField(Row row)
{
processField(row, "DUR_FIELD_ID", "DUR_REF_UID", MPDUtility.getAdjustedDuration(m_project, row.getInt("DUR_VALUE"), MPDUtility.getDurationTimeUnits(row.getInt("DUR_FMT"))));
} | java | {
"resource": ""
} |
q248 | MPD9AbstractReader.processOutlineCodeField | train | protected void processOutlineCodeField(Integer entityID, Row row)
{
processField(row, "OC_FIELD_ID", entityID, row.getString("OC_NAME"));
} | java | {
"resource": ""
} |
q249 | MPD9AbstractReader.processTaskBaseline | train | protected void processTaskBaseline(Row row)
{
Integer id = row.getInteger("TASK_UID");
Task task = m_project.getTaskByUniqueID(id);
if (task != null)
{
int index = row.getInt("TB_BASE_NUM");
task.setBaselineDuration(index, MPDUtility.getAdjustedDuration(m_project, row.getInt("TB_BASE_DUR"), MPDUtility.getDurationTimeUnits(row.getInt("TB_BASE_DUR_FMT"))));
task.setBaselineStart(index, row.getDate("TB_BASE_START"));
task.setBaselineFinish(index, row.getDate("TB_BASE_FINISH"));
task.setBaselineWork(index, row.getDuration("TB_BASE_WORK"));
task.setBaselineCost(index, row.getCurrency("TB_BASE_COST"));
}
} | java | {
"resource": ""
} |
q250 | MPD9AbstractReader.processLink | train | protected void processLink(Row row)
{
Task predecessorTask = m_project.getTaskByUniqueID(row.getInteger("LINK_PRED_UID"));
Task successorTask = m_project.getTaskByUniqueID(row.getInteger("LINK_SUCC_UID"));
if (predecessorTask != null && successorTask != null)
{
RelationType type = RelationType.getInstance(row.getInt("LINK_TYPE"));
TimeUnit durationUnits = MPDUtility.getDurationTimeUnits(row.getInt("LINK_LAG_FMT"));
Duration duration = MPDUtility.getDuration(row.getDouble("LINK_LAG").doubleValue(), durationUnits);
Relation relation = successorTask.addPredecessor(predecessorTask, type, duration);
relation.setUniqueID(row.getInteger("LINK_UID"));
m_eventManager.fireRelationReadEvent(relation);
}
} | java | {
"resource": ""
} |
q251 | MPD9AbstractReader.processAssignmentBaseline | train | protected void processAssignmentBaseline(Row row)
{
Integer id = row.getInteger("ASSN_UID");
ResourceAssignment assignment = m_assignmentMap.get(id);
if (assignment != null)
{
int index = row.getInt("AB_BASE_NUM");
assignment.setBaselineStart(index, row.getDate("AB_BASE_START"));
assignment.setBaselineFinish(index, row.getDate("AB_BASE_FINISH"));
assignment.setBaselineWork(index, row.getDuration("AB_BASE_WORK"));
assignment.setBaselineCost(index, row.getCurrency("AB_BASE_COST"));
}
} | java | {
"resource": ""
} |
q252 | MPD9AbstractReader.postProcessing | train | protected void postProcessing()
{
//
// Update the internal structure. We'll take this opportunity to
// generate outline numbers for the tasks as they don't appear to
// be present in the MPP file.
//
ProjectConfig config = m_project.getProjectConfig();
config.setAutoWBS(m_autoWBS);
config.setAutoOutlineNumber(true);
m_project.updateStructure();
config.setAutoOutlineNumber(false);
//
// Perform post-processing to set the summary flag
//
for (Task task : m_project.getTasks())
{
task.setSummary(task.hasChildTasks());
}
//
// Ensure that the unique ID counters are correct
//
config.updateUniqueCounters();
} | java | {
"resource": ""
} |
q253 | MPD9AbstractReader.getNullOnValue | train | private Integer getNullOnValue(Integer value, int nullValue)
{
return (NumberHelper.getInt(value) == nullValue ? null : value);
} | java | {
"resource": ""
} |
q254 | ConstraintFactory.process | train | public void process(DirectoryEntry projectDir, ProjectFile file, DocumentInputStreamFactory inputStreamFactory) throws IOException
{
DirectoryEntry consDir;
try
{
consDir = (DirectoryEntry) projectDir.getEntry("TBkndCons");
}
catch (FileNotFoundException ex)
{
consDir = null;
}
if (consDir != null)
{
FixedMeta consFixedMeta = new FixedMeta(new DocumentInputStream(((DocumentEntry) consDir.getEntry("FixedMeta"))), 10);
FixedData consFixedData = new FixedData(consFixedMeta, 20, inputStreamFactory.getInstance(consDir, "FixedData"));
// FixedMeta consFixed2Meta = new FixedMeta(new DocumentInputStream(((DocumentEntry) consDir.getEntry("Fixed2Meta"))), 9);
// FixedData consFixed2Data = new FixedData(consFixed2Meta, 48, getEncryptableInputStream(consDir, "Fixed2Data"));
int count = consFixedMeta.getAdjustedItemCount();
int lastConstraintID = -1;
ProjectProperties properties = file.getProjectProperties();
EventManager eventManager = file.getEventManager();
boolean project15 = NumberHelper.getInt(properties.getMppFileType()) == 14 && NumberHelper.getInt(properties.getApplicationVersion()) > ApplicationVersion.PROJECT_2010;
int durationUnitsOffset = project15 ? 18 : 14;
int durationOffset = project15 ? 14 : 16;
for (int loop = 0; loop < count; loop++)
{
byte[] metaData = consFixedMeta.getByteArrayValue(loop);
//
// SourceForge bug 2209477: we were reading an int here, but
// it looks like the deleted flag is just a short.
//
if (MPPUtility.getShort(metaData, 0) != 0)
{
continue;
}
int index = consFixedData.getIndexFromOffset(MPPUtility.getInt(metaData, 4));
if (index == -1)
{
continue;
}
//
// Do we have enough data?
//
byte[] data = consFixedData.getByteArrayValue(index);
if (data.length < 14)
{
continue;
}
int constraintID = MPPUtility.getInt(data, 0);
if (constraintID <= lastConstraintID)
{
continue;
}
lastConstraintID = constraintID;
int taskID1 = MPPUtility.getInt(data, 4);
int taskID2 = MPPUtility.getInt(data, 8);
if (taskID1 == taskID2)
{
continue;
}
// byte[] metaData2 = consFixed2Meta.getByteArrayValue(loop);
// int index2 = consFixed2Data.getIndexFromOffset(MPPUtility.getInt(metaData2, 4));
// byte[] data2 = consFixed2Data.getByteArrayValue(index2);
Task task1 = file.getTaskByUniqueID(Integer.valueOf(taskID1));
Task task2 = file.getTaskByUniqueID(Integer.valueOf(taskID2));
if (task1 != null && task2 != null)
{
RelationType type = RelationType.getInstance(MPPUtility.getShort(data, 12));
TimeUnit durationUnits = MPPUtility.getDurationTimeUnits(MPPUtility.getShort(data, durationUnitsOffset));
Duration lag = MPPUtility.getAdjustedDuration(properties, MPPUtility.getInt(data, durationOffset), durationUnits);
Relation relation = task2.addPredecessor(task1, type, lag);
relation.setUniqueID(Integer.valueOf(constraintID));
eventManager.fireRelationReadEvent(relation);
}
}
}
} | java | {
"resource": ""
} |
q255 | TextFileRow.getColumnValue | train | private Object getColumnValue(String table, String column, String data, int type, boolean epochDateFormat) throws MPXJException
{
try
{
Object value = null;
switch (type)
{
case Types.BIT:
{
value = DatatypeConverter.parseBoolean(data);
break;
}
case Types.VARCHAR:
case Types.LONGVARCHAR:
{
value = DatatypeConverter.parseString(data);
break;
}
case Types.TIME:
{
value = DatatypeConverter.parseBasicTime(data);
break;
}
case Types.TIMESTAMP:
{
if (epochDateFormat)
{
value = DatatypeConverter.parseEpochTimestamp(data);
}
else
{
value = DatatypeConverter.parseBasicTimestamp(data);
}
break;
}
case Types.DOUBLE:
{
value = DatatypeConverter.parseDouble(data);
break;
}
case Types.INTEGER:
{
value = DatatypeConverter.parseInteger(data);
break;
}
default:
{
throw new IllegalArgumentException("Unsupported SQL type: " + type);
}
}
return value;
}
catch (Exception ex)
{
throw new MPXJException("Failed to parse " + table + "." + column + " (data=" + data + ", type=" + type + ")", ex);
}
} | java | {
"resource": ""
} |
q256 | Callouts.getCallout | train | public List<Callouts.Callout> getCallout()
{
if (callout == null)
{
callout = new ArrayList<Callouts.Callout>();
}
return this.callout;
} | java | {
"resource": ""
} |
q257 | DatatypeConverter.parseMinutesFromHours | train | public static final Integer parseMinutesFromHours(String value)
{
Integer result = null;
if (value != null)
{
result = Integer.valueOf(Integer.parseInt(value) * 60);
}
return result;
} | java | {
"resource": ""
} |
q258 | DatatypeConverter.parseCurrencySymbolPosition | train | public static final CurrencySymbolPosition parseCurrencySymbolPosition(String value)
{
CurrencySymbolPosition result = MAP_TO_CURRENCY_SYMBOL_POSITION.get(value);
result = result == null ? CurrencySymbolPosition.BEFORE_WITH_SPACE : result;
return result;
} | java | {
"resource": ""
} |
q259 | DatatypeConverter.parseDate | train | public static final Date parseDate(String value)
{
Date result = null;
try
{
if (value != null && !value.isEmpty())
{
result = DATE_FORMAT.get().parse(value);
}
}
catch (ParseException ex)
{
// Ignore
}
return result;
} | java | {
"resource": ""
} |
q260 | DatatypeConverter.parseDateTime | train | public static final Date parseDateTime(String value)
{
Date result = null;
try
{
if (value != null && !value.isEmpty())
{
result = DATE_TIME_FORMAT.get().parse(value);
}
}
catch (ParseException ex)
{
// Ignore
}
return result;
} | java | {
"resource": ""
} |
q261 | PEPUtility.getInt | train | public static final int getInt(byte[] data, int offset)
{
int result = 0;
int i = offset;
for (int shiftBy = 0; shiftBy < 32; shiftBy += 8)
{
result |= ((data[i] & 0xff)) << shiftBy;
++i;
}
return result;
} | java | {
"resource": ""
} |
q262 | PEPUtility.getShort | train | public static final int getShort(byte[] data, int offset)
{
int result = 0;
int i = offset;
for (int shiftBy = 0; shiftBy < 16; shiftBy += 8)
{
result |= ((data[i] & 0xff)) << shiftBy;
++i;
}
return result;
} | java | {
"resource": ""
} |
q263 | PEPUtility.getString | train | public static final String getString(byte[] data, int offset)
{
return getString(data, offset, data.length - offset);
} | java | {
"resource": ""
} |
q264 | PEPUtility.getFinishDate | train | public static final Date getFinishDate(byte[] data, int offset)
{
Date result;
long days = getShort(data, offset);
if (days == 0x8000)
{
result = null;
}
else
{
result = DateHelper.getDateFromLong(EPOCH + ((days - 1) * DateHelper.MS_PER_DAY));
}
return (result);
} | java | {
"resource": ""
} |
q265 | ProjectProperties.setDefaultCalendarName | train | public void setDefaultCalendarName(String calendarName)
{
if (calendarName == null || calendarName.length() == 0)
{
calendarName = DEFAULT_CALENDAR_NAME;
}
set(ProjectField.DEFAULT_CALENDAR_NAME, calendarName);
} | java | {
"resource": ""
} |
q266 | ProjectProperties.getStartDate | train | public Date getStartDate()
{
Date result = (Date) getCachedValue(ProjectField.START_DATE);
if (result == null)
{
result = getParentFile().getStartDate();
}
return (result);
} | java | {
"resource": ""
} |
q267 | ProjectProperties.getFinishDate | train | public Date getFinishDate()
{
Date result = (Date) getCachedValue(ProjectField.FINISH_DATE);
if (result == null)
{
result = getParentFile().getFinishDate();
}
return (result);
} | java | {
"resource": ""
} |
q268 | ProjectProperties.setCurrencySymbol | train | public void setCurrencySymbol(String symbol)
{
if (symbol == null)
{
symbol = DEFAULT_CURRENCY_SYMBOL;
}
set(ProjectField.CURRENCY_SYMBOL, symbol);
} | java | {
"resource": ""
} |
q269 | ProjectProperties.setSymbolPosition | train | public void setSymbolPosition(CurrencySymbolPosition posn)
{
if (posn == null)
{
posn = DEFAULT_CURRENCY_SYMBOL_POSITION;
}
set(ProjectField.CURRENCY_SYMBOL_POSITION, posn);
} | java | {
"resource": ""
} |
q270 | ProjectProperties.setCurrencyDigits | train | public void setCurrencyDigits(Integer currDigs)
{
if (currDigs == null)
{
currDigs = DEFAULT_CURRENCY_DIGITS;
}
set(ProjectField.CURRENCY_DIGITS, currDigs);
} | java | {
"resource": ""
} |
q271 | ProjectProperties.getMinutesPerMonth | train | public Number getMinutesPerMonth()
{
return Integer.valueOf(NumberHelper.getInt(getMinutesPerDay()) * NumberHelper.getInt(getDaysPerMonth()));
} | java | {
"resource": ""
} |
q272 | ProjectProperties.getMinutesPerYear | train | public Number getMinutesPerYear()
{
return Integer.valueOf(NumberHelper.getInt(getMinutesPerDay()) * NumberHelper.getInt(getDaysPerMonth()) * 12);
} | java | {
"resource": ""
} |
q273 | ProjectProperties.getCustomProperties | train | @SuppressWarnings("unchecked") public Map<String, Object> getCustomProperties()
{
return (Map<String, Object>) getCachedValue(ProjectField.CUSTOM_PROPERTIES);
} | java | {
"resource": ""
} |
q274 | ProjectProperties.getCachedCharValue | train | private char getCachedCharValue(FieldType field, char defaultValue)
{
Character c = (Character) getCachedValue(field);
return c == null ? defaultValue : c.charValue();
} | java | {
"resource": ""
} |
q275 | ProjectProperties.set | train | private void set(FieldType field, boolean value)
{
set(field, (value ? Boolean.TRUE : Boolean.FALSE));
} | java | {
"resource": ""
} |
q276 | AstaDatabaseReader.getRows | train | private List<Row> getRows(String sql) throws SQLException
{
allocateConnection();
try
{
List<Row> result = new LinkedList<Row>();
m_ps = m_connection.prepareStatement(sql);
m_rs = m_ps.executeQuery();
populateMetaData();
while (m_rs.next())
{
result.add(new MpdResultSetRow(m_rs, m_meta));
}
return (result);
}
finally
{
releaseConnection();
}
} | java | {
"resource": ""
} |
q277 | AstaDatabaseReader.releaseConnection | train | private void releaseConnection()
{
if (m_rs != null)
{
try
{
m_rs.close();
}
catch (SQLException ex)
{
// silently ignore errors on close
}
m_rs = null;
}
if (m_ps != null)
{
try
{
m_ps.close();
}
catch (SQLException ex)
{
// silently ignore errors on close
}
m_ps = null;
}
} | java | {
"resource": ""
} |
q278 | AstaDatabaseReader.populateMetaData | train | private void populateMetaData() throws SQLException
{
m_meta.clear();
ResultSetMetaData meta = m_rs.getMetaData();
int columnCount = meta.getColumnCount() + 1;
for (int loop = 1; loop < columnCount; loop++)
{
String name = meta.getColumnName(loop);
Integer type = Integer.valueOf(meta.getColumnType(loop));
m_meta.put(name, type);
}
} | java | {
"resource": ""
} |
q279 | AstaDatabaseReader.setSchema | train | public void setSchema(String schema)
{
if (schema.charAt(schema.length() - 1) != '.')
{
schema = schema + '.';
}
m_schema = schema;
} | java | {
"resource": ""
} |
q280 | ActivityCode.addValue | train | public ActivityCodeValue addValue(Integer uniqueID, String name, String description)
{
ActivityCodeValue value = new ActivityCodeValue(this, uniqueID, name, description);
m_values.add(value);
return value;
} | java | {
"resource": ""
} |
q281 | DatatypeConverter.getLong | train | public static final long getLong(byte[] data, int offset)
{
long result = 0;
int i = offset;
for (int shiftBy = 0; shiftBy < 64; shiftBy += 8)
{
result |= ((long) (data[i] & 0xff)) << shiftBy;
++i;
}
return result;
} | java | {
"resource": ""
} |
q282 | DatatypeConverter.getInt | train | public static final int getInt(InputStream is) throws IOException
{
byte[] data = new byte[4];
is.read(data);
return getInt(data, 0);
} | java | {
"resource": ""
} |
q283 | DatatypeConverter.getShort | train | public static final int getShort(InputStream is) throws IOException
{
byte[] data = new byte[2];
is.read(data);
return getShort(data, 0);
} | java | {
"resource": ""
} |
q284 | DatatypeConverter.getLong | train | public static final long getLong(InputStream is) throws IOException
{
byte[] data = new byte[8];
is.read(data);
return getLong(data, 0);
} | java | {
"resource": ""
} |
q285 | DatatypeConverter.getString | train | public static final String getString(InputStream is) throws IOException
{
int type = is.read();
if (type != 1)
{
throw new IllegalArgumentException("Unexpected string format");
}
Charset charset = CharsetHelper.UTF8;
int length = is.read();
if (length == 0xFF)
{
length = getShort(is);
if (length == 0xFFFE)
{
charset = CharsetHelper.UTF16LE;
length = (is.read() * 2);
}
}
String result;
if (length == 0)
{
result = null;
}
else
{
byte[] stringData = new byte[length];
is.read(stringData);
result = new String(stringData, charset);
}
return result;
} | java | {
"resource": ""
} |
q286 | DatatypeConverter.getUUID | train | public static final UUID getUUID(InputStream is) throws IOException
{
byte[] data = new byte[16];
is.read(data);
long long1 = 0;
long1 |= ((long) (data[3] & 0xFF)) << 56;
long1 |= ((long) (data[2] & 0xFF)) << 48;
long1 |= ((long) (data[1] & 0xFF)) << 40;
long1 |= ((long) (data[0] & 0xFF)) << 32;
long1 |= ((long) (data[5] & 0xFF)) << 24;
long1 |= ((long) (data[4] & 0xFF)) << 16;
long1 |= ((long) (data[7] & 0xFF)) << 8;
long1 |= ((long) (data[6] & 0xFF)) << 0;
long long2 = 0;
long2 |= ((long) (data[8] & 0xFF)) << 56;
long2 |= ((long) (data[9] & 0xFF)) << 48;
long2 |= ((long) (data[10] & 0xFF)) << 40;
long2 |= ((long) (data[11] & 0xFF)) << 32;
long2 |= ((long) (data[12] & 0xFF)) << 24;
long2 |= ((long) (data[13] & 0xFF)) << 16;
long2 |= ((long) (data[14] & 0xFF)) << 8;
long2 |= ((long) (data[15] & 0xFF)) << 0;
return new UUID(long1, long2);
} | java | {
"resource": ""
} |
q287 | DatatypeConverter.getDate | train | public static final Date getDate(InputStream is) throws IOException
{
long timeInSeconds = getInt(is);
if (timeInSeconds == 0x93406FFF)
{
return null;
}
timeInSeconds -= 3600;
timeInSeconds *= 1000;
return DateHelper.getDateFromLong(timeInSeconds);
} | java | {
"resource": ""
} |
q288 | DatatypeConverter.getTime | train | public static final Date getTime(InputStream is) throws IOException
{
int timeValue = getInt(is);
timeValue -= 86400;
timeValue /= 60;
return DateHelper.getTimeFromMinutesPastMidnight(Integer.valueOf(timeValue));
} | java | {
"resource": ""
} |
q289 | DatatypeConverter.getDuration | train | public static final Duration getDuration(InputStream is) throws IOException
{
double durationInSeconds = getInt(is);
durationInSeconds /= (60 * 60);
return Duration.getInstance(durationInSeconds, TimeUnit.HOURS);
} | java | {
"resource": ""
} |
q290 | DatatypeConverter.getDouble | train | public static final Double getDouble(InputStream is) throws IOException
{
double result = Double.longBitsToDouble(getLong(is));
if (Double.isNaN(result))
{
result = 0;
}
return Double.valueOf(result);
} | java | {
"resource": ""
} |
q291 | CustomFieldAliasReader.process | train | public void process()
{
if (m_data != null)
{
int index = 0;
int offset = 0;
// First the length (repeated twice)
int length = MPPUtility.getInt(m_data, offset);
offset += 8;
// Then the number of custom columns
int numberOfAliases = MPPUtility.getInt(m_data, offset);
offset += 4;
// Then the aliases themselves
while (index < numberOfAliases && offset < length)
{
// Each item consists of the Field ID (2 bytes), 40 0B marker (2 bytes), and the
// offset to the string (4 bytes)
// Get the Field ID
int fieldID = MPPUtility.getInt(m_data, offset);
offset += 4;
// Get the alias offset (offset + 4 for some reason).
int aliasOffset = MPPUtility.getInt(m_data, offset) + 4;
offset += 4;
// Read the alias itself
if (aliasOffset < m_data.length)
{
String alias = MPPUtility.getUnicodeString(m_data, aliasOffset);
m_fields.getCustomField(FieldTypeHelper.getInstance(fieldID)).setAlias(alias);
}
index++;
}
}
} | java | {
"resource": ""
} |
q292 | ProjectListType.getProject | train | public List<ProjectListType.Project> getProject()
{
if (project == null)
{
project = new ArrayList<ProjectListType.Project>();
}
return this.project;
} | java | {
"resource": ""
} |
q293 | DatatypeConverter.printExtendedAttributeCurrency | train | public static final String printExtendedAttributeCurrency(Number value)
{
return (value == null ? null : NUMBER_FORMAT.get().format(value.doubleValue() * 100));
} | java | {
"resource": ""
} |
q294 | DatatypeConverter.parseExtendedAttributeCurrency | train | public static final Number parseExtendedAttributeCurrency(String value)
{
Number result;
if (value == null)
{
result = null;
}
else
{
result = NumberHelper.getDouble(Double.parseDouble(correctNumberFormat(value)) / 100);
}
return result;
} | java | {
"resource": ""
} |
q295 | DatatypeConverter.parseExtendedAttributeBoolean | train | public static final Boolean parseExtendedAttributeBoolean(String value)
{
return ((value.equals("1") ? Boolean.TRUE : Boolean.FALSE));
} | java | {
"resource": ""
} |
q296 | DatatypeConverter.printExtendedAttributeDate | train | public static final String printExtendedAttributeDate(Date value)
{
return (value == null ? null : DATE_FORMAT.get().format(value));
} | java | {
"resource": ""
} |
q297 | DatatypeConverter.parseExtendedAttributeDate | train | public static final Date parseExtendedAttributeDate(String value)
{
Date result = null;
if (value != null)
{
try
{
result = DATE_FORMAT.get().parse(value);
}
catch (ParseException ex)
{
// ignore exceptions
}
}
return (result);
} | java | {
"resource": ""
} |
q298 | DatatypeConverter.printExtendedAttribute | train | public static final String printExtendedAttribute(MSPDIWriter writer, Object value, DataType type)
{
String result;
if (type == DataType.DATE)
{
result = printExtendedAttributeDate((Date) value);
}
else
{
if (value instanceof Boolean)
{
result = printExtendedAttributeBoolean((Boolean) value);
}
else
{
if (value instanceof Duration)
{
result = printDuration(writer, (Duration) value);
}
else
{
if (type == DataType.CURRENCY)
{
result = printExtendedAttributeCurrency((Number) value);
}
else
{
if (value instanceof Number)
{
result = printExtendedAttributeNumber((Number) value);
}
else
{
result = value.toString();
}
}
}
}
}
return (result);
} | java | {
"resource": ""
} |
q299 | DatatypeConverter.parseExtendedAttribute | train | public static final void parseExtendedAttribute(ProjectFile file, FieldContainer mpx, String value, FieldType mpxFieldID, TimeUnit durationFormat)
{
if (mpxFieldID != null)
{
switch (mpxFieldID.getDataType())
{
case STRING:
{
mpx.set(mpxFieldID, value);
break;
}
case DATE:
{
mpx.set(mpxFieldID, parseExtendedAttributeDate(value));
break;
}
case CURRENCY:
{
mpx.set(mpxFieldID, parseExtendedAttributeCurrency(value));
break;
}
case BOOLEAN:
{
mpx.set(mpxFieldID, parseExtendedAttributeBoolean(value));
break;
}
case NUMERIC:
{
mpx.set(mpxFieldID, parseExtendedAttributeNumber(value));
break;
}
case DURATION:
{
mpx.set(mpxFieldID, parseDuration(file, durationFormat, value));
break;
}
default:
{
break;
}
}
}
} | java | {
"resource": ""
} |