_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3 values | text stringlengths 73 34.1k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q100 | StringGroovyMethods.getAt | train | public static CharSequence getAt(CharSequence text, int index) {
index = normaliseIndex(index, text.length());
return text.subSequence(index, index + 1);
} | java | {
"resource": ""
} |
q101 | StringGroovyMethods.getAt | train | public static String getAt(GString text, int index) {
return (String) getAt(text.toString(), index);
} | java | {
"resource": ""
} |
q102 | StringGroovyMethods.getAt | train | public static CharSequence getAt(CharSequence text, IntRange range) {
return getAt(text, (Range) range);
} | java | {
"resource": ""
} |
q103 | StringGroovyMethods.getAt | train | public static CharSequence getAt(CharSequence text, Range range) {
RangeInfo info = subListBorders(text.length(), range);
CharSequence sequence = text.subSequence(info.from, info.to);
return info.reverse ? reverse(sequence) : sequence;
} | java | {
"resource": ""
} |
q104 | StringGroovyMethods.getAt | train | public static String getAt(GString text, Range range) {
return getAt(text.toString(), range);
} | java | {
"resource": ""
} |
q105 | StringGroovyMethods.getAt | train | public static List getAt(Matcher self, Collection indices) {
List result = new ArrayList();
for (Object value : indices) {
if (value instanceof Range) {
result.addAll(getAt(self, (Range) value));
} else {
int idx = DefaultTypeTransformation.intUnbox(value);
result.add(getAt(self, idx));
}
}
return result;
} | java | {
"resource": ""
} |
q106 | StringGroovyMethods.getAt | train | public static String getAt(String text, int index) {
index = normaliseIndex(index, text.length());
return text.substring(index, index + 1);
} | java | {
"resource": ""
} |
q107 | StringGroovyMethods.getAt | train | public static String getAt(String text, IntRange range) {
return getAt(text, (Range) range);
} | java | {
"resource": ""
} |
q108 | StringGroovyMethods.getAt | train | public static String getAt(String text, Range range) {
RangeInfo info = subListBorders(text.length(), range);
String answer = text.substring(info.from, info.to);
if (info.reverse) {
answer = reverse(answer);
}
return answer;
} | java | {
"resource": ""
} |
q109 | StringGroovyMethods.getCount | train | public static int getCount(Matcher matcher) {
int counter = 0;
matcher.reset();
while (matcher.find()) {
counter++;
}
return counter;
} | java | {
"resource": ""
} |
q110 | StringGroovyMethods.isAllWhitespace | train | public static boolean isAllWhitespace(CharSequence self) {
String s = self.toString();
for (int i = 0; i < s.length(); i++) {
if (!Character.isWhitespace(s.charAt(i)))
return false;
}
return true;
} | java | {
"resource": ""
} |
q111 | StringGroovyMethods.isBigDecimal | train | public static boolean isBigDecimal(CharSequence self) {
try {
new BigDecimal(self.toString().trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
} | java | {
"resource": ""
} |
q112 | StringGroovyMethods.isBigInteger | train | public static boolean isBigInteger(CharSequence self) {
try {
new BigInteger(self.toString().trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
} | java | {
"resource": ""
} |
q113 | StringGroovyMethods.isDouble | train | public static boolean isDouble(CharSequence self) {
try {
Double.valueOf(self.toString().trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
} | java | {
"resource": ""
} |
q114 | StringGroovyMethods.isFloat | train | public static boolean isFloat(CharSequence self) {
try {
Float.valueOf(self.toString().trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
} | java | {
"resource": ""
} |
q115 | StringGroovyMethods.isInteger | train | public static boolean isInteger(CharSequence self) {
try {
Integer.valueOf(self.toString().trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
} | java | {
"resource": ""
} |
q116 | StringGroovyMethods.isLong | train | public static boolean isLong(CharSequence self) {
try {
Long.valueOf(self.toString().trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
} | java | {
"resource": ""
} |
q117 | StringGroovyMethods.leftShift | train | public static StringBuffer leftShift(String self, Object value) {
return new StringBuffer(self).append(value);
} | java | {
"resource": ""
} |
q118 | StringGroovyMethods.leftShift | train | public static StringBuilder leftShift(StringBuilder self, Object value) {
self.append(value);
return self;
} | java | {
"resource": ""
} |
q119 | StringGroovyMethods.minus | train | public static String minus(CharSequence self, Object target) {
String s = self.toString();
String text = DefaultGroovyMethods.toString(target);
int index = s.indexOf(text);
if (index == -1) return s;
int end = index + text.length();
if (s.length() > end) {
return s.substring(0, index) + s.substring(end);
}
return s.substring(0, index);
} | java | {
"resource": ""
} |
q120 | StringGroovyMethods.minus | train | public static String minus(CharSequence self, Pattern pattern) {
return pattern.matcher(self).replaceFirst("");
} | java | {
"resource": ""
} |
q121 | StringGroovyMethods.multiply | train | public static String multiply(CharSequence self, Number factor) {
String s = self.toString();
int size = factor.intValue();
if (size == 0)
return "";
else if (size < 0) {
throw new IllegalArgumentException("multiply() should be called with a number of 0 or greater not: " + size);
}
StringBuilder answer = new StringBuilder(s);
for (int i = 1; i < size; i++) {
answer.append(s);
}
return answer.toString();
} | java | {
"resource": ""
} |
q122 | StringGroovyMethods.next | train | public static String next(CharSequence self) {
StringBuilder buffer = new StringBuilder(self);
if (buffer.length() == 0) {
buffer.append(Character.MIN_VALUE);
} else {
char last = buffer.charAt(buffer.length() - 1);
if (last == Character.MAX_VALUE) {
buffer.append(Character.MIN_VALUE);
} else {
char next = last;
next++;
buffer.setCharAt(buffer.length() - 1, next);
}
}
return buffer.toString();
} | java | {
"resource": ""
} |
q123 | StringGroovyMethods.normalize | train | public static String normalize(final CharSequence self) {
final String s = self.toString();
int nx = s.indexOf('\r');
if (nx < 0) {
return s;
}
final int len = s.length();
final StringBuilder sb = new StringBuilder(len);
int i = 0;
do {
sb.append(s, i, nx);
sb.append('\n');
if ((i = nx + 1) >= len) break;
if (s.charAt(i) == '\n') {
// skip the LF in CR LF
if (++i >= len) break;
}
nx = s.indexOf('\r', i);
} while (nx > 0);
sb.append(s, i, len);
return sb.toString();
} | java | {
"resource": ""
} |
q124 | StringGroovyMethods.plus | train | public static String plus(CharSequence left, Object value) {
return left + DefaultGroovyMethods.toString(value);
} | java | {
"resource": ""
} |
q125 | StringGroovyMethods.plus | train | public static String plus(Number value, String right) {
return DefaultGroovyMethods.toString(value) + right;
} | java | {
"resource": ""
} |
q126 | StringGroovyMethods.readLines | train | public static List<String> readLines(CharSequence self) throws IOException {
return IOGroovyMethods.readLines(new StringReader(self.toString()));
} | java | {
"resource": ""
} |
q127 | StringGroovyMethods.replaceAll | train | public static String replaceAll(final CharSequence self, final CharSequence regex, final CharSequence replacement) {
return self.toString().replaceAll(regex.toString(), replacement.toString());
} | java | {
"resource": ""
} |
q128 | StringGroovyMethods.replaceFirst | train | public static String replaceFirst(final CharSequence self, final CharSequence regex, final CharSequence replacement) {
return self.toString().replaceFirst(regex.toString(), replacement.toString());
} | java | {
"resource": ""
} |
q129 | StringGroovyMethods.setIndex | train | public static void setIndex(Matcher matcher, int idx) {
int count = getCount(matcher);
if (idx < -count || idx >= count) {
throw new IndexOutOfBoundsException("index is out of range " + (-count) + ".." + (count - 1) + " (index = " + idx + ")");
}
if (idx == 0) {
matcher.reset();
} else if (idx > 0) {
matcher.reset();
for (int i = 0; i < idx; i++) {
matcher.find();
}
} else if (idx < 0) {
matcher.reset();
idx += getCount(matcher);
for (int i = 0; i < idx; i++) {
matcher.find();
}
}
} | java | {
"resource": ""
} |
q130 | StringGroovyMethods.splitEachLine | train | public static <T> T splitEachLine(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options="List<String>") Closure<T> closure) throws IOException {
return splitEachLine(self, Pattern.compile(regex.toString()), closure);
} | java | {
"resource": ""
} |
q131 | StringGroovyMethods.splitEachLine | train | public static <T> T splitEachLine(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options="List<String>") Closure<T> closure) throws IOException {
final List<String> list = readLines(self);
T result = null;
for (String line : list) {
List vals = Arrays.asList(pattern.split(line));
result = closure.call(vals);
}
return result;
} | java | {
"resource": ""
} |
q132 | StringGroovyMethods.takeWhile | train | public static String takeWhile(GString self, @ClosureParams(value=SimpleType.class, options="char") Closure condition) {
return (String) takeWhile(self.toString(), condition);
} | java | {
"resource": ""
} |
q133 | StringGroovyMethods.toList | train | public static List<String> toList(CharSequence self) {
String s = self.toString();
int size = s.length();
List<String> answer = new ArrayList<String>(size);
for (int i = 0; i < size; i++) {
answer.add(s.substring(i, i + 1));
}
return answer;
} | java | {
"resource": ""
} |
q134 | StringGroovyMethods.unexpand | train | public static String unexpand(CharSequence self, int tabStop) {
String s = self.toString();
if (s.length() == 0) return s;
try {
StringBuilder builder = new StringBuilder();
for (String line : readLines((CharSequence) s)) {
builder.append(unexpandLine(line, tabStop));
builder.append("\n");
}
// remove the normalized ending line ending if it was not present
if (!s.endsWith("\n")) {
builder.deleteCharAt(builder.length() - 1);
}
return builder.toString();
} catch (IOException e) {
/* ignore */
}
return s;
} | java | {
"resource": ""
} |
q135 | StringGroovyMethods.unexpandLine | train | public static String unexpandLine(CharSequence self, int tabStop) {
StringBuilder builder = new StringBuilder(self.toString());
int index = 0;
while (index + tabStop < builder.length()) {
// cut original string in tabstop-length pieces
String piece = builder.substring(index, index + tabStop);
// count trailing whitespace characters
int count = 0;
while ((count < tabStop) && (Character.isWhitespace(piece.charAt(tabStop - (count + 1)))))
count++;
// replace if whitespace was found
if (count > 0) {
piece = piece.substring(0, tabStop - count) + '\t';
builder.replace(index, index + tabStop, piece);
index = index + tabStop - (count - 1);
} else
index = index + tabStop;
}
return builder.toString();
} | java | {
"resource": ""
} |
q136 | ClassNode.hasPossibleMethod | train | public boolean hasPossibleMethod(String name, Expression arguments) {
int count = 0;
if (arguments instanceof TupleExpression) {
TupleExpression tuple = (TupleExpression) arguments;
// TODO this won't strictly be true when using list expansion in argument calls
count = tuple.getExpressions().size();
}
ClassNode node = this;
do {
for (MethodNode method : getMethods(name)) {
if (method.getParameters().length == count && !method.isStatic()) {
return true;
}
}
node = node.getSuperClass();
}
while (node != null);
return false;
} | java | {
"resource": ""
} |
q137 | StaticTypeCheckingVisitor.checkOrMarkPrivateAccess | train | private void checkOrMarkPrivateAccess(Expression source, FieldNode fn) {
if (fn!=null && Modifier.isPrivate(fn.getModifiers()) &&
(fn.getDeclaringClass() != typeCheckingContext.getEnclosingClassNode() || typeCheckingContext.getEnclosingClosure()!=null) &&
fn.getDeclaringClass().getModule() == typeCheckingContext.getEnclosingClassNode().getModule()) {
addPrivateFieldOrMethodAccess(source, fn.getDeclaringClass(), StaticTypesMarker.PV_FIELDS_ACCESS, fn);
}
} | java | {
"resource": ""
} |
q138 | StaticTypeCheckingVisitor.checkOrMarkPrivateAccess | train | private void checkOrMarkPrivateAccess(Expression source, MethodNode mn) {
if (mn==null) {
return;
}
ClassNode declaringClass = mn.getDeclaringClass();
ClassNode enclosingClassNode = typeCheckingContext.getEnclosingClassNode();
if (declaringClass != enclosingClassNode || typeCheckingContext.getEnclosingClosure() != null) {
int mods = mn.getModifiers();
boolean sameModule = declaringClass.getModule() == enclosingClassNode.getModule();
String packageName = declaringClass.getPackageName();
if (packageName==null) {
packageName = "";
}
if ((Modifier.isPrivate(mods) && sameModule)
|| (Modifier.isProtected(mods) && !packageName.equals(enclosingClassNode.getPackageName()))) {
addPrivateFieldOrMethodAccess(source, sameModule? declaringClass : enclosingClassNode, StaticTypesMarker.PV_METHODS_ACCESS, mn);
}
}
} | java | {
"resource": ""
} |
q139 | StaticTypeCheckingVisitor.ensureValidSetter | train | private boolean ensureValidSetter(final Expression expression, final Expression leftExpression, final Expression rightExpression, final SetterInfo setterInfo) {
// for expressions like foo = { ... }
// we know that the RHS type is a closure
// but we must check if the binary expression is an assignment
// because we need to check if a setter uses @DelegatesTo
VariableExpression ve = new VariableExpression("%", setterInfo.receiverType);
MethodCallExpression call = new MethodCallExpression(
ve,
setterInfo.name,
rightExpression
);
call.setImplicitThis(false);
visitMethodCallExpression(call);
MethodNode directSetterCandidate = call.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET);
if (directSetterCandidate==null) {
// this may happen if there's a setter of type boolean/String/Class, and that we are using the property
// notation AND that the RHS is not a boolean/String/Class
for (MethodNode setter : setterInfo.setters) {
ClassNode type = getWrapper(setter.getParameters()[0].getOriginType());
if (Boolean_TYPE.equals(type) || STRING_TYPE.equals(type) || CLASS_Type.equals(type)) {
call = new MethodCallExpression(
ve,
setterInfo.name,
new CastExpression(type,rightExpression)
);
call.setImplicitThis(false);
visitMethodCallExpression(call);
directSetterCandidate = call.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET);
if (directSetterCandidate!=null) {
break;
}
}
}
}
if (directSetterCandidate != null) {
for (MethodNode setter : setterInfo.setters) {
if (setter == directSetterCandidate) {
leftExpression.putNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET, directSetterCandidate);
storeType(leftExpression, getType(rightExpression));
break;
}
}
} else {
ClassNode firstSetterType = setterInfo.setters.iterator().next().getParameters()[0].getOriginType();
addAssignmentError(firstSetterType, getType(rightExpression), expression);
return true;
}
return false;
} | java | {
"resource": ""
} |
q140 | StaticTypeCheckingVisitor.addArrayMethods | train | private void addArrayMethods(List<MethodNode> methods, ClassNode receiver, String name, ClassNode[] args) {
if (args.length!=1) return;
if (!receiver.isArray()) return;
if (!isIntCategory(getUnwrapper(args[0]))) return;
if ("getAt".equals(name)) {
MethodNode node = new MethodNode(name, Opcodes.ACC_PUBLIC, receiver.getComponentType(), new Parameter[]{new Parameter(args[0],"arg")}, null, null);
node.setDeclaringClass(receiver.redirect());
methods.add(node);
} else if ("setAt".equals(name)) {
MethodNode node = new MethodNode(name, Opcodes.ACC_PUBLIC, VOID_TYPE, new Parameter[]{new Parameter(args[0],"arg")}, null, null);
node.setDeclaringClass(receiver.redirect());
methods.add(node);
}
} | java | {
"resource": ""
} |
q141 | StaticTypeCheckingVisitor.getGenericsResolvedTypeOfFieldOrProperty | train | private ClassNode getGenericsResolvedTypeOfFieldOrProperty(AnnotatedNode an, ClassNode type) {
if (!type.isUsingGenerics()) return type;
Map<String, GenericsType> connections = new HashMap();
//TODO: inner classes mean a different this-type. This is ignored here!
extractGenericsConnections(connections, typeCheckingContext.getEnclosingClassNode(), an.getDeclaringClass());
type= applyGenericsContext(connections, type);
return type;
} | java | {
"resource": ""
} |
q142 | EncodingGroovyMethods.decodeBase64 | train | public static byte[] decodeBase64(String value) {
int byteShift = 4;
int tmp = 0;
boolean done = false;
final StringBuilder buffer = new StringBuilder();
for (int i = 0; i != value.length(); i++) {
final char c = value.charAt(i);
final int sixBit = (c < 123) ? EncodingGroovyMethodsSupport.TRANSLATE_TABLE[c] : 66;
if (sixBit < 64) {
if (done)
throw new RuntimeException("= character not at end of base64 value"); // TODO: change this exception type
tmp = (tmp << 6) | sixBit;
if (byteShift-- != 4) {
buffer.append((char) ((tmp >> (byteShift * 2)) & 0XFF));
}
} else if (sixBit == 64) {
byteShift--;
done = true;
} else if (sixBit == 66) {
// RFC 2045 says that I'm allowed to take the presence of
// these characters as evidence of data corruption
// So I will
throw new RuntimeException("bad character in base64 value"); // TODO: change this exception type
}
if (byteShift == 0) byteShift = 4;
}
try {
return buffer.toString().getBytes("ISO-8859-1");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("Base 64 decode produced byte values > 255"); // TODO: change this exception type
}
} | java | {
"resource": ""
} |
q143 | Groovy.runStatements | train | protected void runStatements(Reader reader, PrintStream out)
throws IOException {
log.debug("runStatements()");
StringBuilder txt = new StringBuilder();
String line = "";
BufferedReader in = new BufferedReader(reader);
while ((line = in.readLine()) != null) {
line = getProject().replaceProperties(line);
if (line.indexOf("--") >= 0) {
txt.append("\n");
}
}
// Catch any statements not followed by ;
if (!txt.toString().equals("")) {
execGroovy(txt.toString(), out);
}
} | java | {
"resource": ""
} |
q144 | JsonOutput.toJson | train | public static String toJson(Date date) {
if (date == null) {
return NULL_VALUE;
}
CharBuf buffer = CharBuf.create(26);
writeDate(date, buffer);
return buffer.toString();
} | java | {
"resource": ""
} |
q145 | JsonOutput.toJson | train | public static String toJson(Calendar cal) {
if (cal == null) {
return NULL_VALUE;
}
CharBuf buffer = CharBuf.create(26);
writeDate(cal.getTime(), buffer);
return buffer.toString();
} | java | {
"resource": ""
} |
q146 | JsonOutput.writeNumber | train | private static void writeNumber(Class<?> numberClass, Number value, CharBuf buffer) {
if (numberClass == Integer.class) {
buffer.addInt((Integer) value);
} else if (numberClass == Long.class) {
buffer.addLong((Long) value);
} else if (numberClass == BigInteger.class) {
buffer.addBigInteger((BigInteger) value);
} else if (numberClass == BigDecimal.class) {
buffer.addBigDecimal((BigDecimal) value);
} else if (numberClass == Double.class) {
Double doubleValue = (Double) value;
if (doubleValue.isInfinite()) {
throw new JsonException("Number " + value + " can't be serialized as JSON: infinite are not allowed in JSON.");
}
if (doubleValue.isNaN()) {
throw new JsonException("Number " + value + " can't be serialized as JSON: NaN are not allowed in JSON.");
}
buffer.addDouble(doubleValue);
} else if (numberClass == Float.class) {
Float floatValue = (Float) value;
if (floatValue.isInfinite()) {
throw new JsonException("Number " + value + " can't be serialized as JSON: infinite are not allowed in JSON.");
}
if (floatValue.isNaN()) {
throw new JsonException("Number " + value + " can't be serialized as JSON: NaN are not allowed in JSON.");
}
buffer.addFloat(floatValue);
} else if (numberClass == Byte.class) {
buffer.addByte((Byte) value);
} else if (numberClass == Short.class) {
buffer.addShort((Short) value);
} else { // Handle other Number implementations
buffer.addString(value.toString());
}
} | java | {
"resource": ""
} |
q147 | JsonOutput.writeCharSequence | train | private static void writeCharSequence(CharSequence seq, CharBuf buffer) {
if (seq.length() > 0) {
buffer.addJsonEscapedString(seq.toString());
} else {
buffer.addChars(EMPTY_STRING_CHARS);
}
} | java | {
"resource": ""
} |
q148 | ShortTypeHandling.castToEnum | train | public static Enum castToEnum(Object object, Class<? extends Enum> type) {
if (object==null) return null;
if (type.isInstance(object)) return (Enum) object;
if (object instanceof String || object instanceof GString) {
return Enum.valueOf(type, object.toString());
}
throw new GroovyCastException(object, type);
} | java | {
"resource": ""
} |
q149 | Groovyc.setTargetBytecode | train | public void setTargetBytecode(String version) {
if (CompilerConfiguration.PRE_JDK5.equals(version) || CompilerConfiguration.POST_JDK5.equals(version)) {
this.targetBytecode = version;
}
} | java | {
"resource": ""
} |
q150 | Node.depthFirst | train | public List depthFirst() {
List answer = new NodeList();
answer.add(this);
answer.addAll(depthFirstRest());
return answer;
} | java | {
"resource": ""
} |
q151 | MetaProperty.getGetterName | train | public static String getGetterName(String propertyName, Class type) {
String prefix = type == boolean.class || type == Boolean.class ? "is" : "get";
return prefix + MetaClassHelper.capitalize(propertyName);
} | java | {
"resource": ""
} |
q152 | ProxyMetaClass.getInstance | train | public static ProxyMetaClass getInstance(Class theClass) throws IntrospectionException {
MetaClassRegistry metaRegistry = GroovySystem.getMetaClassRegistry();
MetaClass meta = metaRegistry.getMetaClass(theClass);
return new ProxyMetaClass(metaRegistry, theClass, meta);
} | java | {
"resource": ""
} |
q153 | ResolveVisitor.correctClassClassChain | train | private Expression correctClassClassChain(PropertyExpression pe) {
LinkedList<Expression> stack = new LinkedList<Expression>();
ClassExpression found = null;
for (Expression it = pe; it != null; it = ((PropertyExpression) it).getObjectExpression()) {
if (it instanceof ClassExpression) {
found = (ClassExpression) it;
break;
} else if (!(it.getClass() == PropertyExpression.class)) {
return pe;
}
stack.addFirst(it);
}
if (found == null) return pe;
if (stack.isEmpty()) return pe;
Object stackElement = stack.removeFirst();
if (!(stackElement.getClass() == PropertyExpression.class)) return pe;
PropertyExpression classPropertyExpression = (PropertyExpression) stackElement;
String propertyNamePart = classPropertyExpression.getPropertyAsString();
if (propertyNamePart == null || !propertyNamePart.equals("class")) return pe;
found.setSourcePosition(classPropertyExpression);
if (stack.isEmpty()) return found;
stackElement = stack.removeFirst();
if (!(stackElement.getClass() == PropertyExpression.class)) return pe;
PropertyExpression classPropertyExpressionContainer = (PropertyExpression) stackElement;
classPropertyExpressionContainer.setObjectExpression(found);
return pe;
} | java | {
"resource": ""
} |
q154 | DefaultGroovyMethodsSupport.closeWithWarning | train | public static void closeWithWarning(Closeable c) {
if (c != null) {
try {
c.close();
} catch (IOException e) {
LOG.warning("Caught exception during close(): " + e);
}
}
} | java | {
"resource": ""
} |
q155 | ManagedConcurrentValueMap.get | train | public V get(K key) {
ManagedReference<V> ref = internalMap.get(key);
if (ref!=null) return ref.get();
return null;
} | java | {
"resource": ""
} |
q156 | ManagedConcurrentValueMap.put | train | public void put(final K key, V value) {
ManagedReference<V> ref = new ManagedReference<V>(bundle, value) {
@Override
public void finalizeReference() {
super.finalizeReference();
internalMap.remove(key, get());
}
};
internalMap.put(key, ref);
} | java | {
"resource": ""
} |
q157 | SourceUnit.getSample | train | public String getSample(int line, int column, Janitor janitor) {
String sample = null;
String text = source.getLine(line, janitor);
if (text != null) {
if (column > 0) {
String marker = Utilities.repeatString(" ", column - 1) + "^";
if (column > 40) {
int start = column - 30 - 1;
int end = (column + 10 > text.length() ? text.length() : column + 10 - 1);
sample = " " + text.substring(start, end) + Utilities.eol() + " " +
marker.substring(start, marker.length());
} else {
sample = " " + text + Utilities.eol() + " " + marker;
}
} else {
sample = text;
}
}
return sample;
} | java | {
"resource": ""
} |
q158 | Sql.withInstance | train | public static void withInstance(String url, Closure c) throws SQLException {
Sql sql = null;
try {
sql = newInstance(url);
c.call(sql);
} finally {
if (sql != null) sql.close();
}
} | java | {
"resource": ""
} |
q159 | Sql.withTransaction | train | public synchronized void withTransaction(Closure closure) throws SQLException {
boolean savedCacheConnection = cacheConnection;
cacheConnection = true;
Connection connection = null;
boolean savedAutoCommit = true;
try {
connection = createConnection();
savedAutoCommit = connection.getAutoCommit();
connection.setAutoCommit(false);
callClosurePossiblyWithConnection(closure, connection);
connection.commit();
} catch (SQLException e) {
handleError(connection, e);
throw e;
} catch (RuntimeException e) {
handleError(connection, e);
throw e;
} catch (Error e) {
handleError(connection, e);
throw e;
} catch (Exception e) {
handleError(connection, e);
throw new SQLException("Unexpected exception during transaction", e);
} finally {
if (connection != null) {
try {
connection.setAutoCommit(savedAutoCommit);
}
catch (SQLException e) {
LOG.finest("Caught exception resetting auto commit: " + e.getMessage() + " - continuing");
}
}
cacheConnection = false;
closeResources(connection, null);
cacheConnection = savedCacheConnection;
if (dataSource != null && !cacheConnection) {
useConnection = null;
}
}
} | java | {
"resource": ""
} |
q160 | ReflectionMethodInvoker.invoke | train | public static Object invoke(Object object, String methodName, Object[] parameters) {
try {
Class[] classTypes = new Class[parameters.length];
for (int i = 0; i < classTypes.length; i++) {
classTypes[i] = parameters[i].getClass();
}
Method method = object.getClass().getMethod(methodName, classTypes);
return method.invoke(object, parameters);
} catch (Throwable t) {
return InvokerHelper.invokeMethod(object, methodName, parameters);
}
} | java | {
"resource": ""
} |
q161 | StringHelper.tokenizeUnquoted | train | public static String[] tokenizeUnquoted(String s) {
List tokens = new LinkedList();
int first = 0;
while (first < s.length()) {
first = skipWhitespace(s, first);
int last = scanToken(s, first);
if (first < last) {
tokens.add(s.substring(first, last));
}
first = last;
}
return (String[])tokens.toArray(new String[tokens.size()]);
} | java | {
"resource": ""
} |
q162 | StaticCompilationVisitor.addPrivateFieldsAccessors | train | @SuppressWarnings("unchecked")
private void addPrivateFieldsAccessors(ClassNode node) {
Set<ASTNode> accessedFields = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_FIELDS_ACCESS);
if (accessedFields==null) return;
Map<String, MethodNode> privateConstantAccessors = (Map<String, MethodNode>) node.getNodeMetaData(PRIVATE_FIELDS_ACCESSORS);
if (privateConstantAccessors!=null) {
// already added
return;
}
int acc = -1;
privateConstantAccessors = new HashMap<String, MethodNode>();
final int access = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC;
for (FieldNode fieldNode : node.getFields()) {
if (accessedFields.contains(fieldNode)) {
acc++;
Parameter param = new Parameter(node.getPlainNodeReference(), "$that");
Expression receiver = fieldNode.isStatic()?new ClassExpression(node):new VariableExpression(param);
Statement stmt = new ExpressionStatement(new PropertyExpression(
receiver,
fieldNode.getName()
));
MethodNode accessor = node.addMethod("pfaccess$"+acc, access, fieldNode.getOriginType(), new Parameter[]{param}, ClassNode.EMPTY_ARRAY, stmt);
privateConstantAccessors.put(fieldNode.getName(), accessor);
}
}
node.setNodeMetaData(PRIVATE_FIELDS_ACCESSORS, privateConstantAccessors);
} | java | {
"resource": ""
} |
q163 | CompilerConfiguration.isPostJDK5 | train | public static boolean isPostJDK5(String bytecodeVersion) {
return JDK5.equals(bytecodeVersion)
|| JDK6.equals(bytecodeVersion)
|| JDK7.equals(bytecodeVersion)
|| JDK8.equals(bytecodeVersion);
} | java | {
"resource": ""
} |
q164 | CompilerConfiguration.setTargetDirectory | train | public void setTargetDirectory(String directory) {
if (directory != null && directory.length() > 0) {
this.targetDirectory = new File(directory);
} else {
this.targetDirectory = null;
}
} | java | {
"resource": ""
} |
q165 | RootLoader.loadClass | train | protected synchronized Class loadClass(final String name, boolean resolve) throws ClassNotFoundException {
Class c = this.findLoadedClass(name);
if (c != null) return c;
c = (Class) customClasses.get(name);
if (c != null) return c;
try {
c = oldFindClass(name);
} catch (ClassNotFoundException cnfe) {
// IGNORE
}
if (c == null) c = super.loadClass(name, resolve);
if (resolve) resolveClass(c);
return c;
} | java | {
"resource": ""
} |
q166 | NodeList.getAt | train | public NodeList getAt(String name) {
NodeList answer = new NodeList();
for (Object child : this) {
if (child instanceof Node) {
Node childNode = (Node) child;
Object temp = childNode.get(name);
if (temp instanceof Collection) {
answer.addAll((Collection) temp);
} else {
answer.add(temp);
}
}
}
return answer;
} | java | {
"resource": ""
} |
q167 | NodeList.text | train | public String text() {
String previousText = null;
StringBuilder buffer = null;
for (Object child : this) {
String text = null;
if (child instanceof String) {
text = (String) child;
} else if (child instanceof Node) {
text = ((Node) child).text();
}
if (text != null) {
if (previousText == null) {
previousText = text;
} else {
if (buffer == null) {
buffer = new StringBuilder();
buffer.append(previousText);
}
buffer.append(text);
}
}
}
if (buffer != null) {
return buffer.toString();
}
if (previousText != null) {
return previousText;
}
return "";
} | java | {
"resource": ""
} |
q168 | Parser.isAllNumeric | train | private boolean isAllNumeric(TokenStream stream) {
List<Token> tokens = ((NattyTokenSource) stream.getTokenSource()).getTokens();
for(Token token:tokens) {
try {
Integer.parseInt(token.getText());
} catch(NumberFormatException e) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q169 | Parser.collectTokenStreams | train | private List<TokenStream> collectTokenStreams(TokenStream stream) {
// walk through the token stream and build a collection
// of sub token streams that represent possible date locations
List<Token> currentGroup = null;
List<List<Token>> groups = new ArrayList<List<Token>>();
Token currentToken;
int currentTokenType;
StringBuilder tokenString = new StringBuilder();
while((currentToken = stream.getTokenSource().nextToken()).getType() != DateLexer.EOF) {
currentTokenType = currentToken.getType();
tokenString.append(DateParser.tokenNames[currentTokenType]).append(" ");
// we're currently NOT collecting for a possible date group
if(currentGroup == null) {
// skip over white space and known tokens that cannot be the start of a date
if(currentTokenType != DateLexer.WHITE_SPACE &&
DateParser.FOLLOW_empty_in_parse186.member(currentTokenType)) {
currentGroup = new ArrayList<Token>();
currentGroup.add(currentToken);
}
}
// we're currently collecting
else {
// preserve white space
if(currentTokenType == DateLexer.WHITE_SPACE) {
currentGroup.add(currentToken);
}
else {
// if this is an unknown token, we'll close out the current group
if(currentTokenType == DateLexer.UNKNOWN) {
addGroup(currentGroup, groups);
currentGroup = null;
}
// otherwise, the token is known and we're currently collecting for
// a group, so we'll add it to the current group
else {
currentGroup.add(currentToken);
}
}
}
}
if(currentGroup != null) {
addGroup(currentGroup, groups);
}
_logger.info("STREAM: " + tokenString.toString());
List<TokenStream> streams = new ArrayList<TokenStream>();
for(List<Token> group:groups) {
if(!group.isEmpty()) {
StringBuilder builder = new StringBuilder();
builder.append("GROUP: ");
for (Token token : group) {
builder.append(DateParser.tokenNames[token.getType()]).append(" ");
}
_logger.info(builder.toString());
streams.add(new CommonTokenStream(new NattyTokenSource(group)));
}
}
return streams;
} | java | {
"resource": ""
} |
q170 | Parser.addGroup | train | private void addGroup(List<Token> group, List<List<Token>> groups) {
if(group.isEmpty()) return;
// remove trailing tokens that should be ignored
while(!group.isEmpty() && IGNORED_TRAILING_TOKENS.contains(
group.get(group.size() - 1).getType())) {
group.remove(group.size() - 1);
}
// if the group still has some tokens left, we'll add it to our list of groups
if(!group.isEmpty()) {
groups.add(group);
}
} | java | {
"resource": ""
} |
q171 | WalkerState.seekToDayOfWeek | train | public void seekToDayOfWeek(String direction, String seekType, String seekAmount, String dayOfWeek) {
int dayOfWeekInt = Integer.parseInt(dayOfWeek);
int seekAmountInt = Integer.parseInt(seekAmount);
assert(direction.equals(DIR_LEFT) || direction.equals(DIR_RIGHT));
assert(seekType.equals(SEEK_BY_DAY) || seekType.equals(SEEK_BY_WEEK));
assert(dayOfWeekInt >= 1 && dayOfWeekInt <= 7);
markDateInvocation();
int sign = direction.equals(DIR_RIGHT) ? 1 : -1;
if(seekType.equals(SEEK_BY_WEEK)) {
// set our calendar to this weeks requested day of the week,
// then add or subtract the week(s)
_calendar.set(Calendar.DAY_OF_WEEK, dayOfWeekInt);
_calendar.add(Calendar.DAY_OF_YEAR, seekAmountInt * 7 * sign);
}
else if(seekType.equals(SEEK_BY_DAY)) {
// find the closest day
do {
_calendar.add(Calendar.DAY_OF_YEAR, sign);
} while(_calendar.get(Calendar.DAY_OF_WEEK) != dayOfWeekInt);
// now add/subtract any additional days
if(seekAmountInt > 0) {
_calendar.add(Calendar.WEEK_OF_YEAR, (seekAmountInt - 1) * sign);
}
}
} | java | {
"resource": ""
} |
q172 | WalkerState.seekToDayOfMonth | train | public void seekToDayOfMonth(String dayOfMonth) {
int dayOfMonthInt = Integer.parseInt(dayOfMonth);
assert(dayOfMonthInt >= 1 && dayOfMonthInt <= 31);
markDateInvocation();
dayOfMonthInt = Math.min(dayOfMonthInt, _calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
_calendar.set(Calendar.DAY_OF_MONTH, dayOfMonthInt);
} | java | {
"resource": ""
} |
q173 | WalkerState.seekToDayOfYear | train | public void seekToDayOfYear(String dayOfYear) {
int dayOfYearInt = Integer.parseInt(dayOfYear);
assert(dayOfYearInt >= 1 && dayOfYearInt <= 366);
markDateInvocation();
dayOfYearInt = Math.min(dayOfYearInt, _calendar.getActualMaximum(Calendar.DAY_OF_YEAR));
_calendar.set(Calendar.DAY_OF_YEAR, dayOfYearInt);
} | java | {
"resource": ""
} |
q174 | WalkerState.seekToMonth | train | public void seekToMonth(String direction, String seekAmount, String month) {
int seekAmountInt = Integer.parseInt(seekAmount);
int monthInt = Integer.parseInt(month);
assert(direction.equals(DIR_LEFT) || direction.equals(DIR_RIGHT));
assert(monthInt >= 1 && monthInt <= 12);
markDateInvocation();
// set the day to the first of month. This step is necessary because if we seek to the
// current day of a month whose number of days is less than the current day, we will
// pushed into the next month.
_calendar.set(Calendar.DAY_OF_MONTH, 1);
// seek to the appropriate year
if(seekAmountInt > 0) {
int currentMonth = _calendar.get(Calendar.MONTH) + 1;
int sign = direction.equals(DIR_RIGHT) ? 1 : -1;
int numYearsToShift = seekAmountInt +
(currentMonth == monthInt ? 0 : (currentMonth < monthInt ? sign > 0 ? -1 : 0 : sign > 0 ? 0 : -1));
_calendar.add(Calendar.YEAR, (numYearsToShift * sign));
}
// now set the month
_calendar.set(Calendar.MONTH, monthInt - 1);
} | java | {
"resource": ""
} |
q175 | WalkerState.setExplicitTime | train | public void setExplicitTime(String hours, String minutes, String seconds, String amPm, String zoneString) {
int hoursInt = Integer.parseInt(hours);
int minutesInt = minutes != null ? Integer.parseInt(minutes) : 0;
assert(amPm == null || amPm.equals(AM) || amPm.equals(PM));
assert(hoursInt >= 0);
assert(minutesInt >= 0 && minutesInt < 60);
markTimeInvocation(amPm);
// reset milliseconds to 0
_calendar.set(Calendar.MILLISECOND, 0);
// if no explicit zone is given, we use our own
TimeZone zone = null;
if(zoneString != null) {
if(zoneString.startsWith(PLUS) || zoneString.startsWith(MINUS)) {
zoneString = GMT + zoneString;
}
zone = TimeZone.getTimeZone(zoneString);
}
_calendar.setTimeZone(zone != null ? zone : _defaultTimeZone);
_calendar.set(Calendar.HOUR_OF_DAY, hoursInt);
// hours greater than 12 are in 24-hour time
if(hoursInt <= 12) {
int amPmInt = amPm == null ?
(hoursInt >= 12 ? Calendar.PM : Calendar.AM) :
amPm.equals(PM) ? Calendar.PM : Calendar.AM;
_calendar.set(Calendar.AM_PM, amPmInt);
// calendar is whacky at 12 o'clock (must use 0)
if(hoursInt == 12) hoursInt = 0;
_calendar.set(Calendar.HOUR, hoursInt);
}
if(seconds != null) {
int secondsInt = Integer.parseInt(seconds);
assert(secondsInt >= 0 && secondsInt < 60);
_calendar.set(Calendar.SECOND, secondsInt);
}
else {
_calendar.set(Calendar.SECOND, 0);
}
_calendar.set(Calendar.MINUTE, minutesInt);
} | java | {
"resource": ""
} |
q176 | WalkerState.seekToHoliday | train | public void seekToHoliday(String holidayString, String direction, String seekAmount) {
Holiday holiday = Holiday.valueOf(holidayString);
assert(holiday != null);
seekToIcsEvent(HOLIDAY_ICS_FILE, holiday.getSummary(), direction, seekAmount);
} | java | {
"resource": ""
} |
q177 | WalkerState.seekToHolidayYear | train | public void seekToHolidayYear(String holidayString, String yearString) {
Holiday holiday = Holiday.valueOf(holidayString);
assert(holiday != null);
seekToIcsEventYear(HOLIDAY_ICS_FILE, yearString, holiday.getSummary());
} | java | {
"resource": ""
} |
q178 | WalkerState.seekToSeason | train | public void seekToSeason(String seasonString, String direction, String seekAmount) {
Season season = Season.valueOf(seasonString);
assert(season!= null);
seekToIcsEvent(SEASON_ICS_FILE, season.getSummary(), direction, seekAmount);
} | java | {
"resource": ""
} |
q179 | WalkerState.seekToSeasonYear | train | public void seekToSeasonYear(String seasonString, String yearString) {
Season season = Season.valueOf(seasonString);
assert(season != null);
seekToIcsEventYear(SEASON_ICS_FILE, yearString, season.getSummary());
} | java | {
"resource": ""
} |
q180 | WalkerState.resetCalendar | train | private void resetCalendar() {
_calendar = getCalendar();
if (_defaultTimeZone != null) {
_calendar.setTimeZone(_defaultTimeZone);
}
_currentYear = _calendar.get(Calendar.YEAR);
} | java | {
"resource": ""
} |
q181 | WalkerState.seasonalDateFromIcs | train | private Date seasonalDateFromIcs(String icsFileName, String eventSummary, int year) {
Map<Integer, Date> dates = getDatesFromIcs(icsFileName, eventSummary, year, year);
return dates.get(year - (eventSummary.equals(Holiday.NEW_YEARS_EVE.getSummary()) ? 1 : 0));
} | java | {
"resource": ""
} |
q182 | WalkerState.markDateInvocation | train | private void markDateInvocation() {
_updatePreviousDates = !_dateGivenInGroup;
_dateGivenInGroup = true;
_dateGroup.setDateInferred(false);
if(_firstDateInvocationInGroup) {
// if a time has been given within the current date group,
// we capture the current time before resetting the calendar
if(_timeGivenInGroup) {
int hours = _calendar.get(Calendar.HOUR_OF_DAY);
int minutes = _calendar.get(Calendar.MINUTE);
int seconds = _calendar.get(Calendar.SECOND);
resetCalendar();
_calendar.set(Calendar.HOUR_OF_DAY, hours);
_calendar.set(Calendar.MINUTE, minutes);
_calendar.set(Calendar.SECOND, seconds);
}
else {
resetCalendar();
}
_firstDateInvocationInGroup = false;
}
} | java | {
"resource": ""
} |
q183 | HistQuotesRequest.cleanHistCalendar | train | private Calendar cleanHistCalendar(Calendar cal) {
cal.set(Calendar.MILLISECOND, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.HOUR, 0);
return cal;
} | java | {
"resource": ""
} |
q184 | Utils.parseDividendDate | train | public static Calendar parseDividendDate(String date) {
if (!Utils.isParseable(date)) {
return null;
}
date = date.trim();
SimpleDateFormat format = new SimpleDateFormat(Utils.getDividendDateFormat(date), Locale.US);
format.setTimeZone(TimeZone.getTimeZone(YahooFinance.TIMEZONE));
try {
Calendar today = Calendar.getInstance(TimeZone.getTimeZone(YahooFinance.TIMEZONE));
Calendar parsedDate = Calendar.getInstance(TimeZone.getTimeZone(YahooFinance.TIMEZONE));
parsedDate.setTime(format.parse(date));
if (parsedDate.get(Calendar.YEAR) == 1970) {
// Not really clear which year the dividend date is... making a reasonable guess.
int monthDiff = parsedDate.get(Calendar.MONTH) - today.get(Calendar.MONTH);
int year = today.get(Calendar.YEAR);
if (monthDiff > 6) {
year -= 1;
} else if (monthDiff < -6) {
year += 1;
}
parsedDate.set(Calendar.YEAR, year);
}
return parsedDate;
} catch (ParseException ex) {
log.warn("Failed to parse dividend date: " + date);
log.debug("Failed to parse dividend date: " + date, ex);
return null;
}
} | java | {
"resource": ""
} |
q185 | ExchangeTimeZone.get | train | public static TimeZone get(String suffix) {
if(SUFFIX_TIMEZONES.containsKey(suffix)) {
return SUFFIX_TIMEZONES.get(suffix);
}
log.warn("Cannot find time zone for exchange suffix: '{}'. Using default: America/New_York", suffix);
return SUFFIX_TIMEZONES.get("");
} | java | {
"resource": ""
} |
q186 | ExchangeTimeZone.getStockTimeZone | train | public static TimeZone getStockTimeZone(String symbol) {
// First check if it's a known stock index
if(INDEX_TIMEZONES.containsKey(symbol)) {
return INDEX_TIMEZONES.get(symbol);
}
if(!symbol.contains(".")) {
return ExchangeTimeZone.get("");
}
String[] split = symbol.split("\\.");
return ExchangeTimeZone.get(split[split.length - 1]);
} | java | {
"resource": ""
} |
q187 | VideoRendererBuilder.getPrototypeClass | train | @Override protected Class getPrototypeClass(Video content) {
Class prototypeClass;
if (content.isFavorite()) {
prototypeClass = FavoriteVideoRenderer.class;
} else if (content.isLive()) {
prototypeClass = LiveVideoRenderer.class;
} else {
prototypeClass = LikeVideoRenderer.class;
}
return prototypeClass;
} | java | {
"resource": ""
} |
q188 | RVRendererAdapter.getItemViewType | train | @Override public int getItemViewType(int position) {
T content = getItem(position);
return rendererBuilder.getItemViewType(content);
} | java | {
"resource": ""
} |
q189 | RVRendererAdapter.onCreateViewHolder | train | @Override public RendererViewHolder onCreateViewHolder(ViewGroup viewGroup, int viewType) {
rendererBuilder.withParent(viewGroup);
rendererBuilder.withLayoutInflater(LayoutInflater.from(viewGroup.getContext()));
rendererBuilder.withViewType(viewType);
RendererViewHolder viewHolder = rendererBuilder.buildRendererViewHolder();
if (viewHolder == null) {
throw new NullRendererBuiltException("RendererBuilder have to return a not null viewHolder");
}
return viewHolder;
} | java | {
"resource": ""
} |
q190 | RVRendererAdapter.onBindViewHolder | train | @Override public void onBindViewHolder(RendererViewHolder viewHolder, int position) {
T content = getItem(position);
Renderer<T> renderer = viewHolder.getRenderer();
if (renderer == null) {
throw new NullRendererBuiltException("RendererBuilder have to return a not null renderer");
}
renderer.setContent(content);
updateRendererExtraValues(content, renderer, position);
renderer.render();
} | java | {
"resource": ""
} |
q191 | RVRendererAdapter.diffUpdate | train | public void diffUpdate(List<T> newList) {
if (getCollection().size() == 0) {
addAll(newList);
notifyDataSetChanged();
} else {
DiffCallback diffCallback = new DiffCallback(collection, newList);
DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);
clear();
addAll(newList);
diffResult.dispatchUpdatesTo(this);
}
} | java | {
"resource": ""
} |
q192 | RendererBuilder.withPrototype | train | public RendererBuilder<T> withPrototype(Renderer<? extends T> renderer) {
if (renderer == null) {
throw new NeedsPrototypesException(
"RendererBuilder can't use a null Renderer<T> instance as prototype");
}
this.prototypes.add(renderer);
return this;
} | java | {
"resource": ""
} |
q193 | RendererBuilder.bind | train | public <G extends T> RendererBuilder<T> bind(Class<G> clazz, Renderer<? extends G> prototype) {
if (clazz == null || prototype == null) {
throw new IllegalArgumentException(
"The binding RecyclerView binding can't be configured using null instances");
}
prototypes.add(prototype);
binding.put(clazz, prototype.getClass());
return this;
} | java | {
"resource": ""
} |
q194 | RendererBuilder.getItemViewType | train | int getItemViewType(T content) {
Class prototypeClass = getPrototypeClass(content);
validatePrototypeClass(prototypeClass);
return getItemViewType(prototypeClass);
} | java | {
"resource": ""
} |
q195 | RendererBuilder.build | train | protected Renderer build() {
validateAttributes();
Renderer renderer;
if (isRecyclable(convertView, content)) {
renderer = recycle(convertView, content);
} else {
renderer = createRenderer(content, parent);
}
return renderer;
} | java | {
"resource": ""
} |
q196 | RendererBuilder.buildRendererViewHolder | train | protected RendererViewHolder buildRendererViewHolder() {
validateAttributesToCreateANewRendererViewHolder();
Renderer renderer = getPrototypeByIndex(viewType).copy();
renderer.onCreate(null, layoutInflater, parent);
return new RendererViewHolder(renderer);
} | java | {
"resource": ""
} |
q197 | RendererBuilder.recycle | train | private Renderer recycle(View convertView, T content) {
Renderer renderer = (Renderer) convertView.getTag();
renderer.onRecycle(content);
return renderer;
} | java | {
"resource": ""
} |
q198 | RendererBuilder.createRenderer | train | private Renderer createRenderer(T content, ViewGroup parent) {
int prototypeIndex = getPrototypeIndex(content);
Renderer renderer = getPrototypeByIndex(prototypeIndex).copy();
renderer.onCreate(content, layoutInflater, parent);
return renderer;
} | java | {
"resource": ""
} |
q199 | RendererBuilder.getPrototypeByIndex | train | private Renderer getPrototypeByIndex(final int prototypeIndex) {
Renderer prototypeSelected = null;
int i = 0;
for (Renderer prototype : prototypes) {
if (i == prototypeIndex) {
prototypeSelected = prototype;
}
i++;
}
return prototypeSelected;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.