_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q19000 | FormatTrackingHSSFListenerPlus.getFormatIndex | train | public int getFormatIndex(CellValueRecordInterface cell) {
ExtendedFormatRecord xfr = _xfRecords.get(cell.getXFIndex());
if (xfr == null) {
logger.log(POILogger.ERROR, "Cell " + cell.getRow() + "," + cell.getColumn()
+ " uses XF with index " + cell.getXFIndex() + ", but we don't have that");
return -1;
}
return xfr.getFormatIndex();
} | java | {
"resource": ""
} |
q19001 | Template.readResourceAsStream | train | public static String readResourceAsStream(String path) {
try {
InputStream inputStream = ResourceUtil.getResourceAsStream(path);
return ResourceUtil.readFromInputStreamIntoString(inputStream);
} catch (Exception e) {
throw new DataUtilException("Failed to load resource", e);
}
} | java | {
"resource": ""
} |
q19002 | Template.readResource | train | public static String readResource(String path) {
try {
File file = ResourceUtil.getResourceFile(path);
return ResourceUtil.readFromFileIntoString(file);
} catch (Exception e) {
throw new DataUtilException("Failed to load resource", e);
}
} | java | {
"resource": ""
} |
q19003 | Geometry.cloneRecursively | train | private Geometry cloneRecursively(Geometry geometry) {
Geometry clone = new Geometry(geometry.geometryType, geometry.srid, geometry.precision);
if (geometry.getGeometries() != null) {
Geometry[] geometryClones = new Geometry[geometry.getGeometries().length];
for (int i = 0; i < geometry.getGeometries().length; i++) {
geometryClones[i] = cloneRecursively(geometry.getGeometries()[i]);
}
clone.setGeometries(geometryClones);
}
if (geometry.getCoordinates() != null) {
Coordinate[] coordinateClones = new Coordinate[geometry.getCoordinates().length];
for (int i = 0; i < geometry.getCoordinates().length; i++) {
coordinateClones[i] = (Coordinate) geometry.getCoordinates()[i].clone();
}
clone.setCoordinates(coordinateClones);
}
return clone;
} | java | {
"resource": ""
} |
q19004 | SubClass.resolveFieldIndex | train | int resolveFieldIndex(VariableElement field)
{
TypeElement declaringClass = (TypeElement) field.getEnclosingElement();
String descriptor = Descriptor.getDesriptor(field);
int index = resolveFieldIndex(declaringClass, field.getSimpleName().toString(), descriptor);
addIndexedElement(index, field);
return index;
} | java | {
"resource": ""
} |
q19005 | SubClass.resolveFieldIndex | train | private int resolveFieldIndex(TypeElement declaringClass, String name, String descriptor)
{
int size = 0;
int index = 0;
constantReadLock.lock();
try
{
size = getConstantPoolSize();
index = getRefIndex(Fieldref.class, declaringClass.getQualifiedName().toString(), name, descriptor);
}
finally
{
constantReadLock.unlock();
}
if (index == -1)
{
// add entry to constant pool
int ci = resolveClassIndex(declaringClass);
int nati = resolveNameAndTypeIndex(name, descriptor);
return addConstantInfo(new Fieldref(ci, nati), size);
}
return index;
} | java | {
"resource": ""
} |
q19006 | SubClass.resolveMethodIndex | train | int resolveMethodIndex(ExecutableElement method)
{
int size = 0;
int index = 0;
constantReadLock.lock();
TypeElement declaringClass = (TypeElement) method.getEnclosingElement();
String declaringClassname = declaringClass.getQualifiedName().toString();
String descriptor = Descriptor.getDesriptor(method);
String name = method.getSimpleName().toString();
try
{
size = getConstantPoolSize();
index = getRefIndex(Methodref.class, declaringClassname, name, descriptor);
}
finally
{
constantReadLock.unlock();
}
if (index == -1)
{
// add entry to constant pool
int ci = resolveClassIndex(declaringClass);
int nati = resolveNameAndTypeIndex(name, descriptor);
index = addConstantInfo(new Methodref(ci, nati), size);
}
addIndexedElement(index, method);
return index;
} | java | {
"resource": ""
} |
q19007 | SubClass.resolveNameIndex | train | final int resolveNameIndex(CharSequence name)
{
int size = 0;
int index = 0;
constantReadLock.lock();
try
{
size = getConstantPoolSize();
index = getNameIndex(name);
}
finally
{
constantReadLock.unlock();
}
if (index != -1)
{
return index;
}
else
{
return addConstantInfo(new Utf8(name), size);
}
} | java | {
"resource": ""
} |
q19008 | SubClass.resolveNameAndTypeIndex | train | int resolveNameAndTypeIndex(String name, String descriptor)
{
int size = 0;
int index = 0;
constantReadLock.lock();
try
{
size = getConstantPoolSize();
index = getNameAndTypeIndex(name, descriptor);
}
finally
{
constantReadLock.unlock();
}
if (index != -1)
{
return index;
}
else
{
int nameIndex = resolveNameIndex(name);
int typeIndex = resolveNameIndex(descriptor);
return addConstantInfo(new NameAndType(nameIndex, typeIndex), size);
}
} | java | {
"resource": ""
} |
q19009 | SubClass.defineConstantField | train | public void defineConstantField(int modifier, String fieldName, int constant)
{
DeclaredType dt = (DeclaredType)asType();
VariableBuilder builder = new VariableBuilder(this, fieldName, dt.getTypeArguments(), typeParameterMap);
builder.addModifiers(modifier);
builder.addModifier(Modifier.STATIC);
builder.setType(Typ.IntA);
FieldInfo fieldInfo = new FieldInfo(this, builder.getVariableElement(), new ConstantValue(this, constant));
addFieldInfo(fieldInfo);
fieldInfo.readyToWrite();
} | java | {
"resource": ""
} |
q19010 | SubClass.save | train | public void save(ProcessingEnvironment env) throws IOException
{
Filer filer = env.getFiler();
//JavaFileObject sourceFile = filer.createClassFile(getQualifiedName(), superClass);
FileObject sourceFile = filer.createResource(
StandardLocation.CLASS_OUTPUT,
El.getPackageOf(this).getQualifiedName(),
getSimpleName()+".class"
);
BufferedOutputStream bos = new BufferedOutputStream(sourceFile.openOutputStream());
DataOutputStream dos = new DataOutputStream(bos);
write(dos);
dos.close();
System.err.println("wrote "+sourceFile.getName());
} | java | {
"resource": ""
} |
q19011 | SubClass.write | train | @Override
public void write(DataOutput out) throws IOException
{
addSignatureIfNeed();
out.writeInt(magic);
out.writeShort(minor_version);
out.writeShort(major_version);
out.writeShort(constant_pool.size()+1);
for (ConstantInfo ci : constant_pool)
{
ci.write(out);
}
int modifier = ClassFlags.getModifier(getModifiers());
modifier |= ClassFlags.ACC_SYNTHETIC | ClassFlags.ACC_PUBLIC | ClassFlags.ACC_SUPER;
out.writeShort(modifier);
out.writeShort(this_class);
out.writeShort(super_class);
out.writeShort(interfaces.size());
for (int ii : interfaces)
{
out.writeShort(ii);
}
out.writeShort(fields.size());
for (FieldInfo fi : fields)
{
fi.write(out);
}
out.writeShort(methods.size());
for (MethodInfo mi : methods)
{
mi.write(out);
}
out.writeShort(attributes.size());
for (AttributeInfo ai : attributes)
{
ai.write(out);
}
} | java | {
"resource": ""
} |
q19012 | XmlPath.matches | train | public boolean matches(LinkedList<Node> nodePath) {
if(simplePattern) {
// simple pattern
return items.get(0).matches(nodePath.getLast());
}
// match the full pattern
if(items.size() != nodePath.size()) {
// different size
return false;
}
for(int i=0; i<items.size(); i++) {
if (! items.get(i).matches(nodePath.get(i))) {
// failed a comparison
return false;
}
}
// pass all comparisons
return true;
} | java | {
"resource": ""
} |
q19013 | Pepmint.newLexer | train | public Lexer newLexer(String name) {
PyObject object = pythonInterpreter.get("get_lexer_by_name");
object = object.__call__(new PyString(name));
return new Lexer(object);
} | java | {
"resource": ""
} |
q19014 | Pepmint.newHtmlFormatter | train | public HtmlFormatter newHtmlFormatter(String params) {
PyObject object = pythonInterpreter.eval("HtmlFormatter(" + params + ")");
return new HtmlFormatter(object);
} | java | {
"resource": ""
} |
q19015 | Pepmint.highlight | train | public String highlight(String code, Lexer lexer, Formatter formatter) {
PyFunction function = pythonInterpreter.get("highlight", PyFunction.class);
PyString pyCode = new PyString(code);
PyObject pyLexer = lexer.getLexer();
PyObject pyFormatter = formatter.getFormatter();
return function.__call__(pyCode, pyLexer, pyFormatter).asString();
} | java | {
"resource": ""
} |
q19016 | RestController.putParam | train | protected void putParam(String name, Object object) {
this.response.getRequest().setAttribute(name, object);
} | java | {
"resource": ""
} |
q19017 | Label.addToSubroutine | train | void addToSubroutine(final long id, final int nbSubroutines) {
if ((status & VISITED) == 0) {
status |= VISITED;
srcAndRefPositions = new int[nbSubroutines / 32 + 1];
}
srcAndRefPositions[(int) (id >>> 32)] |= (int) id;
} | java | {
"resource": ""
} |
q19018 | Label.visitSubroutine | train | void visitSubroutine(final Label JSR, final long id, final int nbSubroutines) {
// user managed stack of labels, to avoid using a recursive method
// (recursivity can lead to stack overflow with very large methods)
Label stack = this;
while (stack != null) {
// removes a label l from the stack
Label l = stack;
stack = l.next;
l.next = null;
if (JSR != null) {
if ((l.status & VISITED2) != 0) {
continue;
}
l.status |= VISITED2;
// adds JSR to the successors of l, if it is a RET block
if ((l.status & RET) != 0) {
if (!l.inSameSubroutine(JSR)) {
Edge e = new Edge();
e.info = l.inputStackTop;
e.successor = JSR.successors.successor;
e.next = l.successors;
l.successors = e;
}
}
} else {
// if the l block already belongs to subroutine 'id', continue
if (l.inSubroutine(id)) {
continue;
}
// marks the l block as belonging to subroutine 'id'
l.addToSubroutine(id, nbSubroutines);
}
// pushes each successor of l on the stack, except JSR targets
Edge e = l.successors;
while (e != null) {
// if the l block is a JSR block, then 'l.successors.next' leads
// to the JSR target (see {@link #visitJumpInsn}) and must
// therefore not be followed
if ((l.status & Label.JSR) == 0 || e != l.successors.next) {
// pushes e.successor on the stack if it not already added
if (e.successor.next == null) {
e.successor.next = stack;
stack = e.successor;
}
}
e = e.next;
}
}
} | java | {
"resource": ""
} |
q19019 | XmlSerializer.serialize | train | public String serialize(Object object) {
XStream xstream = new XStream();
return xstream.toXML(object);
} | java | {
"resource": ""
} |
q19020 | FileMerger.merge | train | public static void merge(File mergeDir, List<File> sortedFiles, File mergedFile, Comparator<String> comparator) {
merge(mergeDir, sortedFiles, mergedFile, comparator, MERGE_FACTOR);
} | java | {
"resource": ""
} |
q19021 | FileMerger.merge | train | public static void merge(File mergeDir, List<File> sortedFiles, File mergedFile, Comparator<String> comparator,
int mergeFactor) {
LinkedList<File> mergeFiles = new LinkedList<File>(sortedFiles);
// merge all files
LinkedList<BatchFile> batch = new LinkedList<BatchFile>();
try {
while(mergeFiles.size() > 0) {
// create batch
batch.clear();
for(int i = 0; i < mergeFactor && mergeFiles.size() > 0; i++) {
batch.add(new BatchFile(mergeFiles.remove()));
}
// create aggregation file
File aggFile;
if(mergeFiles.size() > 0) {
// create new aggregate file
aggFile = File.createTempFile("merge-", ".part", mergeDir);
mergeFiles.addLast(aggFile);
} else {
// create final file
aggFile = mergedFile;
}
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(aggFile.getAbsoluteFile(), false),DataUtilDefaults.charSet));
// process batch
String [] buffer = new String[batch.size()];
Arrays.fill(buffer, null);
boolean [] inUse = new boolean[batch.size()];
Arrays.fill(inUse, true);
boolean inUseFlag = true;
while(inUseFlag) {
// load comparison buffer
int index = -1;
String selected = null;
for (int i = 0; i < batch.size(); i++) {
if(inUse[i]) {
if(buffer[i] == null) {
// need more data
buffer[i] = batch.get(i).getRow();
if(buffer[i] == null) {
inUse[i] = false;
}
}
if(buffer[i] != null) {
if(index == -1) {
// set item
index = i;
selected = buffer[i];
} else if(comparator.compare(buffer[i], selected) < 0) {
// replace item
index = i;
selected = buffer[i];
}
}
}
}
if(index >= 0) {
// select item and write to new aggregate file
writer.write(buffer[index] + DataUtilDefaults.lineTerminator);
buffer[index] = null;
inUseFlag = true;
} else {
inUseFlag = false;
}
}
// no more data
writer.flush();
writer.close();
}
} catch (IOException e) {
throw new DataUtilException(e);
}
} | java | {
"resource": ""
} |
q19022 | FieldInfo.readyToWrite | train | public void readyToWrite()
{
addSignatureIfNeed();
this.name_index = ((SubClass)classFile).resolveNameIndex(getSimpleName());
this.descriptor_index = ((SubClass)classFile).resolveNameIndex(Descriptor.getDesriptor(this));
readyToWrite = true;
} | java | {
"resource": ""
} |
q19023 | Xml.bfsComparison | train | private boolean bfsComparison(Node root, Node other) {
if(root instanceof Content || other instanceof Content) {
return root.equals(other);
}
if(! root.equals(other)) {
return false;
}
List<Node> a = ((Element)root).getChildElements();
List<Node> b = ((Element)other).getChildElements();
if(a.size() != b.size()) {
return false;
}
for(int i=0; i<a.size(); i++) {
if(! a.get(i).equals(b.get(i))) {
return false;
}
}
for(int i=0; i<a.size(); i++) {
if(! bfsComparison(a.get(i), b.get(i))) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q19024 | Xml.bsfHashCode | train | private int bsfHashCode(Node node, int result) {
result += 31 * node.hashCode();
if(node instanceof Content) {
return result;
}
Element elem = (Element) node;
List<Node> childElements = elem.getChildElements();
for (Node childElement : childElements) {
result += 31 * childElement.hashCode();
}
for (Node child : childElements) {
if (child instanceof Content) {
result += 31 * child.hashCode();
} else {
result = bsfHashCode(child, result);
}
}
return result;
} | java | {
"resource": ""
} |
q19025 | Xml.deepCopy | train | private void deepCopy(Element origElement, Element copyElement) {
List<Node> children = origElement.getChildElements();
for(Node node : children) {
try {
if(node instanceof Content) {
Content content = (Content) ((Content) node).clone();
copyElement.addChildElement(content);
} else {
Element element = (Element) ((Element) node).clone();
copyElement.addChildElement(element);
deepCopy((Element)node, element);
}
} catch (CloneNotSupportedException e) {
throw new XmlModelException("Unable to clone object", e);
}
}
} | java | {
"resource": ""
} |
q19026 | Jav.makeJavaIdentifier | train | public String makeJavaIdentifier(String id)
{
String jid = makeJavaId(id);
String old = map.put(jid, id);
if (old != null && !old.equals(id))
{
throw new IllegalArgumentException("both "+id+" and "+old+" makes the same java id "+jid);
}
return jid;
} | java | {
"resource": ""
} |
q19027 | Jav.makeUniqueJavaIdentifier | train | public String makeUniqueJavaIdentifier(String id)
{
String jid = makeJavaId(id);
String old = map.put(jid, id);
if (old != null)
{
String oid = jid;
for (int ii=1;old != null;ii++)
{
jid = oid+ii;
old = map.put(jid, id);
}
}
return jid;
} | java | {
"resource": ""
} |
q19028 | FileOutputCollector.write | train | @Override
public void write(String output) throws MapReduceException {
try {
writer.write(output + DataUtilDefaults.lineTerminator);
} catch (IOException e) {
throw new MapReduceException("Failed to write to the output collector", e);
}
} | java | {
"resource": ""
} |
q19029 | FileOutputCollector.close | train | public void close() throws MapReduceException {
try {
if(writer != null) {
writer.flush();
writer.close();
}
} catch (IOException e) {
throw new MapReduceException("Failed to close the output collector", e);
}
} | java | {
"resource": ""
} |
q19030 | StringUtil.pad | train | public static String pad(int repeat, String str) {
StringBuilder sb = new StringBuilder();
for(int i=0; i < repeat; i++) {
sb.append(str);
}
return sb.toString();
} | java | {
"resource": ""
} |
q19031 | ResponseHelper.setFile | train | public void setFile(File file, String attachmentFilename, String contentType) {
this.file = file;
this.attachmentFilename = attachmentFilename;
this.contentType = contentType;
} | java | {
"resource": ""
} |
q19032 | ResponseHelper.existsPage | train | private Boolean existsPage(String page) throws MalformedURLException {
// Searching the page...
LOGGER.debug("Searching page [{}]...", page);
LOGGER.debug("Page's real path is [{}]", this.context.getRealPath(page));
File file = new File(this.context.getRealPath(page));
Boolean exists = file.exists();
LOGGER.debug("Page [{}]{}found", page, (exists ? " " : " not "));
return exists;
} | java | {
"resource": ""
} |
q19033 | Sets.createSet | train | public static <T> Set<T> createSet(T... args) {
HashSet<T> newSet = new HashSet<T>();
Collections.addAll(newSet, args);
return newSet;
} | java | {
"resource": ""
} |
q19034 | Sets.arrayToSet | train | public static <T> Set<T> arrayToSet(T [] array) {
return new HashSet<T>(Arrays.asList(array));
} | java | {
"resource": ""
} |
q19035 | Sets.intersection | train | public static <T> Set<T> intersection(Set<T> setA, Set<T> setB) {
Set<T> intersection = new HashSet<T>(setA);
intersection.retainAll(setB);
return intersection;
} | java | {
"resource": ""
} |
q19036 | Sets.union | train | public static <T> Set<T> union(Set<T> setA, Set<T> setB) {
Set<T> union = new HashSet<T>(setA);
union.addAll(setB);
return union;
} | java | {
"resource": ""
} |
q19037 | Sets.difference | train | public static <T> Set<T> difference(Set<T> setA, Set<T> setB) {
Set<T> difference = new HashSet<T>(setA);
difference.removeAll(setB);
return difference;
} | java | {
"resource": ""
} |
q19038 | Sets.symmetricDifference | train | public static <T> Set<T> symmetricDifference(Set<T> setA, Set<T> setB) {
Set<T> union = union(setA, setB);
Set<T> intersection = intersection(setA, setB);
return difference(union, intersection);
} | java | {
"resource": ""
} |
q19039 | Sets.isSubset | train | public static <T> boolean isSubset(Set<T> setA, Set<T> setB) {
return setB.containsAll(setA);
} | java | {
"resource": ""
} |
q19040 | Sets.isSuperset | train | public static <T> boolean isSuperset(Set<T> setA, Set<T> setB) {
return setA.containsAll(setB);
} | java | {
"resource": ""
} |
q19041 | Type.getClassName | train | public String getClassName() {
switch (sort) {
case VOID:
return "void";
case BOOLEAN:
return "boolean";
case CHAR:
return "char";
case BYTE:
return "byte";
case SHORT:
return "short";
case INT:
return "int";
case FLOAT:
return "float";
case LONG:
return "long";
case DOUBLE:
return "double";
case ARRAY:
StringBuilder sb = new StringBuilder(getElementType().getClassName());
for (int i = getDimensions(); i > 0; --i) {
sb.append("[]");
}
return sb.toString();
case OBJECT:
return new String(buf, off, len).replace('/', '.').intern();
default:
return null;
}
} | java | {
"resource": ""
} |
q19042 | AccountPatternMatcher.matchUrl | train | public static boolean matchUrl(Account account, String url) {
for (AccountPatternData pattern : account.getPatterns()) {
AccountPatternType type = pattern.getType();
if (type == AccountPatternType.REGEX) {
if (regexMatch(pattern.getPattern(), url))
return true;
} else if (type == AccountPatternType.WILDCARD) {
if (globMatch(pattern.getPattern(), url))
return true;
} else {
Logger logger = Logger.getLogger(AccountPatternMatcher.class.getName());
logger.warning("Unknown pattern match type '" + type.toString() + "' for account '" +
account.getName() + "' id='" + account.getId() + "'");
// meh
}
}
return account.getUrl().equalsIgnoreCase(url);
} | java | {
"resource": ""
} |
q19043 | FileDeleter.deleteFilesByExtension | train | public static void deleteFilesByExtension(File dir, String extension) {
if(extension == null) {
throw new DataUtilException("Filename extension can not be a null value");
}
FilenameFilter filter = new FileExtensionFilenameFilter(extension);
FileDeleter.deleteFiles(dir, filter);
} | java | {
"resource": ""
} |
q19044 | FileDeleter.deleteFilesByRegex | train | public static void deleteFilesByRegex(File dir, String regex) {
if(regex == null) {
throw new DataUtilException("Filename regex can not be null");
}
FilenameFilter filter = new RegexFilenameFilter(regex);
FileDeleter.deleteFiles(dir, filter);
} | java | {
"resource": ""
} |
q19045 | FileDeleter.deleteFiles | train | public static void deleteFiles(File dir, FilenameFilter filter) {
// validations
if(dir == null) {
throw new DataUtilException("The delete directory parameter can not be a null value");
} else if(!dir.exists() || !dir.isDirectory()) {
throw new DataUtilException("The delete directory does not exist: " + dir.getAbsolutePath());
}
// delete files
File [] files;
if(filter == null) {
files = dir.listFiles();
} else {
files = dir.listFiles(filter);
}
if (files != null) {
for(File file : files) {
if(file.isFile()) {
if(!file.delete()) {
throw new DataUtilException("Failed to delete file: " + file.getAbsolutePath());
}
}
}
}
} | java | {
"resource": ""
} |
q19046 | ResourceUtil.readFromFileIntoString | train | public static String readFromFileIntoString(File file) throws IOException {
FileInputStream inputStream = new FileInputStream(file);
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
StringBuilder text = new StringBuilder();
String line;
while( (line = reader.readLine()) != null) {
text.append(line).append("\n");
}
inputStream.close();
return text.toString();
} | java | {
"resource": ""
} |
q19047 | ResourceUtil.writeStringToTempFile | train | public static File writeStringToTempFile(String prefix, String suffix, String data) throws IOException {
File testFile = File.createTempFile(prefix, suffix);
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(
testFile.getAbsoluteFile(), false),DataUtilDefaults.charSet));
writer.write(data);
writer.flush();
writer.close();
return testFile;
} | java | {
"resource": ""
} |
q19048 | ResourceUtil.createRandomData | train | public static String createRandomData(int rows, int rowLength, boolean skipTrailingNewline) {
Random random = new Random(System.currentTimeMillis());
StringBuilder strb = new StringBuilder();
for(int i=0; i<rows; i++) {
for(int j=0; j<rowLength; j++) {
strb.append((char)(((int)'a') + random.nextFloat() * 25));
}
if(skipTrailingNewline || i<rows) {
strb.append("\n");
}
}
return strb.toString();
} | java | {
"resource": ""
} |
q19049 | ResourceUtil.createTmpDir | train | public static File createTmpDir(String directoryName) {
File tmpDir = new File(System.getProperty("java.io.tmpdir"));
File testDir = new File(tmpDir, directoryName);
if(!testDir.mkdir()) {
throw new ResourceUtilException("Can't create directory: " + testDir.getAbsolutePath());
}
testDir.deleteOnExit();
return testDir;
} | java | {
"resource": ""
} |
q19050 | BboxService.setCenterPoint | train | public static Bbox setCenterPoint(Bbox bbox, Coordinate center) {
double x = center.getX() - 0.5 * bbox.getWidth();
double y = center.getY() - 0.5 * bbox.getHeight();
return new Bbox(x, y, bbox.getWidth(), bbox.getHeight());
} | java | {
"resource": ""
} |
q19051 | BboxService.contains | train | public static boolean contains(Bbox parent, Bbox child) {
if (child.getX() < parent.getX()) {
return false;
}
if (child.getY() < parent.getY()) {
return false;
}
if (child.getMaxX() > parent.getMaxX()) {
return false;
}
if (child.getMaxY() > parent.getMaxY()) {
return false;
}
return true;
} | java | {
"resource": ""
} |
q19052 | BboxService.contains | train | public static boolean contains(Bbox bbox, Coordinate coordinate) {
if (bbox.getX() >= coordinate.getX()) {
return false;
}
if (bbox.getY() >= coordinate.getY()) {
return false;
}
if (bbox.getMaxX() <= coordinate.getX()) {
return false;
}
if (bbox.getMaxY() <= coordinate.getY()) {
return false;
}
return true;
} | java | {
"resource": ""
} |
q19053 | BboxService.intersects | train | public static boolean intersects(Bbox one, Bbox two) {
if (two.getX() > one.getMaxX()) {
return false;
}
if (two.getY() > one.getMaxY()) {
return false;
}
if (two.getMaxX() < one.getX()) {
return false;
}
if (two.getMaxY() < one.getY()) {
return false;
}
return true;
} | java | {
"resource": ""
} |
q19054 | BboxService.intersection | train | public static Bbox intersection(Bbox one, Bbox two) {
if (!intersects(one, two)) {
return null;
} else {
double minx = two.getX() > one.getX() ? two.getX() : one.getX();
double maxx = two.getMaxX() < one.getMaxX() ? two.getMaxX() : one.getMaxX();
double miny = two.getY() > one.getY() ? two.getY() : one.getY();
double maxy = two.getMaxY() < one.getMaxY() ? two.getMaxY() : one.getMaxY();
return new Bbox(minx, miny, (maxx - minx), (maxy - miny));
}
} | java | {
"resource": ""
} |
q19055 | BboxService.buffer | train | public static Bbox buffer(Bbox bbox, double range) {
if (range >= 0) {
double r2 = range * 2;
return new Bbox(bbox.getX() - range, bbox.getY() - range, bbox.getWidth() + r2, bbox.getHeight() + r2);
}
throw new IllegalArgumentException("Buffer range must always be positive.");
} | java | {
"resource": ""
} |
q19056 | BboxService.translate | train | public static Bbox translate(Bbox bbox, double deltaX, double deltaY) {
return new Bbox(bbox.getX() + deltaX, bbox.getY() + deltaY, bbox.getWidth(), bbox.getHeight());
} | java | {
"resource": ""
} |
q19057 | JsonSerializer.serialize | train | public String serialize(Object object) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Serializing object to Json");
}
XStream xstream = new XStream(new JettisonMappedXmlDriver());
String json = xstream.toXML(object);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Object serialized well");
}
return json;
} | java | {
"resource": ""
} |
q19058 | JsonSerializer.deserialize | train | public Object deserialize(String jsonObject) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Deserializing Json object");
}
XStream xstream = new XStream(new JettisonMappedXmlDriver());
Object obj = xstream.fromXML(jsonObject);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Object deserialized");
}
return obj;
} | java | {
"resource": ""
} |
q19059 | Splitter.filterOutEmptyStrings | train | private Iterator<String> filterOutEmptyStrings(final Iterator<String> splitted) {
return new Iterator<String>() {
String next = getNext();
@Override
public boolean hasNext() {
return next != null;
}
@Override
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
String result = next;
next = getNext();
return result;
}
public String getNext() {
while (splitted.hasNext()) {
String value = splitted.next();
if ( value != null && !value.isEmpty() ) {
return value;
}
}
return null;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
} | java | {
"resource": ""
} |
q19060 | GeometryConverterService.toJts | train | public static Envelope toJts(Bbox bbox) throws JtsConversionException {
if (bbox == null) {
throw new JtsConversionException("Cannot convert null argument");
}
return new Envelope(bbox.getX(), bbox.getMaxX(), bbox.getY(), bbox.getMaxY());
} | java | {
"resource": ""
} |
q19061 | GeometryConverterService.toJts | train | public static com.vividsolutions.jts.geom.Coordinate toJts(org.geomajas.geometry.Coordinate coordinate)
throws JtsConversionException {
if (coordinate == null) {
throw new JtsConversionException("Cannot convert null argument");
}
return new com.vividsolutions.jts.geom.Coordinate(coordinate.getX(), coordinate.getY());
} | java | {
"resource": ""
} |
q19062 | GeometryConverterService.fromJts | train | public static Geometry fromJts(com.vividsolutions.jts.geom.Geometry geometry) throws JtsConversionException {
if (geometry == null) {
throw new JtsConversionException("Cannot convert null argument");
}
int srid = geometry.getSRID();
int precision = -1;
PrecisionModel precisionmodel = geometry.getPrecisionModel();
if (!precisionmodel.isFloating()) {
precision = (int) Math.log10(precisionmodel.getScale());
}
String geometryType = getGeometryType(geometry);
Geometry dto = new Geometry(geometryType, srid, precision);
if (geometry.isEmpty()) {
// nothing to do
} else if (geometry instanceof Point) {
dto.setCoordinates(convertCoordinates(geometry));
} else if (geometry instanceof LinearRing) {
dto.setCoordinates(convertCoordinates(geometry));
} else if (geometry instanceof LineString) {
dto.setCoordinates(convertCoordinates(geometry));
} else if (geometry instanceof Polygon) {
Polygon polygon = (Polygon) geometry;
Geometry[] geometries = new Geometry[polygon.getNumInteriorRing() + 1];
for (int i = 0; i < geometries.length; i++) {
if (i == 0) {
geometries[i] = fromJts(polygon.getExteriorRing());
} else {
geometries[i] = fromJts(polygon.getInteriorRingN(i - 1));
}
}
dto.setGeometries(geometries);
} else if (geometry instanceof MultiPoint) {
dto.setGeometries(convertGeometries(geometry));
} else if (geometry instanceof MultiLineString) {
dto.setGeometries(convertGeometries(geometry));
} else if (geometry instanceof MultiPolygon) {
dto.setGeometries(convertGeometries(geometry));
} else {
throw new JtsConversionException("Cannot convert geometry: Unsupported type.");
}
return dto;
} | java | {
"resource": ""
} |
q19063 | GeometryConverterService.fromJts | train | public static Bbox fromJts(Envelope envelope) throws JtsConversionException {
if (envelope == null) {
throw new JtsConversionException("Cannot convert null argument");
}
return new Bbox(envelope.getMinX(), envelope.getMinY(), envelope.getWidth(), envelope.getHeight());
} | java | {
"resource": ""
} |
q19064 | GeometryConverterService.fromJts | train | public static Coordinate fromJts(com.vividsolutions.jts.geom.Coordinate coordinate) throws JtsConversionException {
if (coordinate == null) {
throw new JtsConversionException("Cannot convert null argument");
}
return new Coordinate(coordinate.x, coordinate.y);
} | java | {
"resource": ""
} |
q19065 | FilePart.writeTo | train | public long writeTo(File fileOrDirectory) throws IOException {
long written = 0;
OutputStream fileOut = null;
try {
// Only do something if this part contains a file
if (fileName != null) {
// Check if user supplied directory
File file;
if (fileOrDirectory.isDirectory()) {
// Write it to that dir the user supplied,
// with the filename it arrived with
file = new File(fileOrDirectory, fileName);
}
else {
// Write it to the file the user supplied,
// ignoring the filename it arrived with
file = fileOrDirectory;
}
if (policy != null) {
file = policy.rename(file);
fileName = file.getName();
}
fileOut = new BufferedOutputStream(new FileOutputStream(file));
written = write(fileOut);
}
}
finally {
if (fileOut != null) fileOut.close();
}
return written;
} | java | {
"resource": ""
} |
q19066 | FilePart.writeTo | train | public long writeTo(OutputStream out) throws IOException {
long size=0;
// Only do something if this part contains a file
if (fileName != null) {
// Write it out
size = write( out );
}
return size;
} | java | {
"resource": ""
} |
q19067 | FilePart.write | train | long write(OutputStream out) throws IOException {
// decode macbinary if this was sent
if (contentType.equals("application/x-macbinary")) {
out = new MacBinaryDecoderOutputStream(out);
}
long size=0;
int read;
byte[] buf = new byte[8 * 1024];
while((read = partInput.read(buf)) != -1) {
out.write(buf, 0, read);
size += read;
}
return size;
} | java | {
"resource": ""
} |
q19068 | XmlReader.readAllFromResource | train | public static Xml readAllFromResource(String resourceName) {
InputStream is = XmlReader.class.getResourceAsStream(resourceName);
XmlReader reader = new XmlReader(is);
Xml xml = reader.read("node()");
reader.close();
return xml;
} | java | {
"resource": ""
} |
q19069 | XmlReader.init | train | private void init(InputStream inputStream) {
this.inputStream = inputStream;
currentPath = new LinkedList<Node>();
nodeQueue = new LinkedList<XmlNode>();
XMLInputFactory factory = XMLInputFactory.newInstance();
factory.setProperty("javax.xml.stream.isCoalescing", true);
factory.setProperty("javax.xml.stream.isReplacingEntityReferences", true);
try {
reader = factory.createXMLStreamReader(inputStream);
} catch (XMLStreamException e) {
throw new XmlReaderException(e);
}
} | java | {
"resource": ""
} |
q19070 | XmlReader.find | train | public boolean find(String xmlPathQuery) {
XmlPath xmlPath = XmlPathParser.parse(xmlPathQuery);
XmlNode node;
while((node = pullXmlNode()) != null) {
if(node instanceof XmlStartElement) {
XmlStartElement startElement = (XmlStartElement) node;
Element element = new Element(startElement.getLocalName());
element.addAttributes(startElement.getAttributes());
currentPath.addLast(element);
if(xmlPath.matches(currentPath)) {
nodeQueue.push(node);
currentPath.removeLast();
return true;
}
} else if(node instanceof XmlEndElement) {
if(currentPath.getLast() instanceof Content) {
currentPath.removeLast();
}
currentPath.removeLast();
} else if(node instanceof XmlContent) {
XmlContent content = (XmlContent) node;
if(currentPath.getLast() instanceof Content) {
currentPath.removeLast();
}
currentPath.addLast(new Content(content.getText()));
} else {
throw new XmlReaderException("Unknown XmlNode type: " + node);
}
}
return false;
} | java | {
"resource": ""
} |
q19071 | XmlReader.pullXmlNode | train | private XmlNode pullXmlNode() {
// read from queue
if(! nodeQueue.isEmpty()) {
return nodeQueue.poll();
}
// read from stream
try {
while(reader.hasNext()) {
int event = reader.next();
switch(event) {
case XMLStreamConstants.START_ELEMENT:
return new XmlStartElement(reader.getLocalName(), getAttributes(reader));
case XMLStreamConstants.CHARACTERS:
// capture XML?
String text = filterWhitespace(reader.getText());
if(text.length() > 0) {
return new XmlContent(text);
}
break;
case XMLStreamConstants.END_ELEMENT:
return new XmlEndElement(reader.getLocalName());
default:
// do nothing
}
}
} catch (XMLStreamException e) {
throw new XmlReaderException(e);
}
// nothing to return
return null;
} | java | {
"resource": ""
} |
q19072 | XmlReader.filterWhitespace | train | private String filterWhitespace(String text) {
text = text.replace("\n", " ");
text = text.replaceAll(" {2,}", " ");
text = XmlEscape.escape(text);
return text.trim();
} | java | {
"resource": ""
} |
q19073 | XmlReader.getAttributes | train | private List<Attribute> getAttributes(XMLStreamReader reader) {
List<Attribute> list = new ArrayList<Attribute>();
for(int i=0; i<reader.getAttributeCount(); i++) {
list.add(new Attribute(reader.getAttributeLocalName(i), reader.getAttributeValue(i)));
}
return list;
} | java | {
"resource": ""
} |
q19074 | ClassUtils.isOverridable | train | private static boolean isOverridable(Method method, Class<?> targetClass) {
if (Modifier.isPrivate(method.getModifiers())) {
return false;
}
if (Modifier.isPublic(method.getModifiers()) || Modifier.isProtected(method.getModifiers())) {
return true;
}
return (targetClass == null ||
getPackageName(method.getDeclaringClass()).equals(getPackageName(targetClass)));
} | java | {
"resource": ""
} |
q19075 | Disposer.register | train | <I> void register( Method disposeMethod, I injectee )
{
disposables.add( new Disposable( disposeMethod, injectee ) );
} | java | {
"resource": ""
} |
q19076 | PathParamDispatch.dispatch | train | @Override
public void dispatch(ParameterResolveFactory parameterResolveFactory, ActionParam param, Route route, Object[] args) {
if (!route.isRegex()) return;
Matcher matcher = route.getMatcher();
String[] pathParameters = new String[matcher.groupCount()];
for (int i = 1, len = matcher.groupCount(); i <= len; i++) {
pathParameters[i - 1] = matcher.group(i);
}
Map<String, String> path = new HashMap<>();
route.getRegexRoute().getNames().forEach(name -> CollectionKit.MapAdd(path, name, matcher.group(name)));
param.getRequest().setPathNamedParameters(path);
param.getRequest().setPathParameters(pathParameters);
} | java | {
"resource": ""
} |
q19077 | FileTracker.createDir | train | public File createDir(File dir) throws DataUtilException {
if(dir == null) {
throw new DataUtilException("Dir parameter can not be a null value");
}
if(dir.exists()) {
throw new DataUtilException("Directory already exists: " + dir.getAbsolutePath());
}
if(! dir.mkdir()) {
throw new DataUtilException("The result of File.mkDir() was false. Failed to create directory. : "
+ dir.getAbsolutePath());
}
trackedFiles.add(dir);
return dir;
} | java | {
"resource": ""
} |
q19078 | FileTracker.deleteAll | train | public void deleteAll() {
if(trackedFiles.size() == 0) {
return;
}
ArrayList<File> files = new ArrayList<File>(trackedFiles);
Collections.sort(files, filePathComparator);
for(File file : files) {
if(file.exists()) {
if(!file.delete()) {
throw new DataUtilException("Couldn't delete a tracked "
+ (file.isFile()? "file":"directory" + ": ") + file.getAbsolutePath());
}
}
}
trackedFiles.clear();
} | java | {
"resource": ""
} |
q19079 | FedoraResourceImpl.removeTombstone | train | public void removeTombstone(final String path) throws FedoraException {
final HttpDelete delete = httpHelper.createDeleteMethod(path + "/fcr:tombstone");
try {
final HttpResponse response = httpHelper.execute( delete );
final StatusLine status = response.getStatusLine();
final String uri = delete.getURI().toString();
if ( status.getStatusCode() == SC_NO_CONTENT) {
LOGGER.debug("triples updated successfully for resource {}", uri);
} else if ( status.getStatusCode() == SC_NOT_FOUND) {
LOGGER.error("resource {} does not exist, cannot update", uri);
throw new NotFoundException("resource " + uri + " does not exist, cannot update");
} else {
LOGGER.error("error updating resource {}: {} {}", uri, status.getStatusCode(),
status.getReasonPhrase());
throw new FedoraException("error updating resource " + uri + ": " + status.getStatusCode() + " " +
status.getReasonPhrase());
}
} catch (final FedoraException e) {
throw e;
} catch (final Exception e) {
LOGGER.error("Error executing request", e);
throw new FedoraException(e);
} finally {
delete.releaseConnection();
}
} | java | {
"resource": ""
} |
q19080 | FedoraResourceImpl.getPropertyValues | train | protected Collection<String> getPropertyValues(final Property property) {
final ExtendedIterator<Triple> iterator = graph.find(Node.ANY,
property.asNode(),
Node.ANY);
final Set<String> set = new HashSet<>();
while (iterator.hasNext()) {
final Node object = iterator.next().getObject();
if (object.isLiteral()) {
set.add(object.getLiteralValue().toString());
} else if (object.isURI()) {
set.add(object.getURI().toString());
} else {
set.add(object.toString());
}
}
return set;
} | java | {
"resource": ""
} |
q19081 | SAMLUtils.generateRequestId | train | public static String generateRequestId() {
/* compute a random 256-bit string and hex-encode it */
final SecureRandom sr = new SecureRandom();
final byte[] bytes = new byte[32];
sr.nextBytes(bytes);
return hexEncode(bytes);
} | java | {
"resource": ""
} |
q19082 | MimeType.isAssignableTo | train | public final boolean isAssignableTo(MimeType mimeType) {
if (mimeType.getPrimaryType().equals("*")) {
// matches all
return true;
}
if (!mimeType.getPrimaryType().equalsIgnoreCase(getPrimaryType())) {
return false;
}
String mtSec = mimeType.getSecondaryType();
return mtSec.equals("*") || mtSec.equalsIgnoreCase(getSecondaryType());
} | java | {
"resource": ""
} |
q19083 | SpringControllerBundleProcessor.initJawrSpringServlets | train | @SuppressWarnings("rawtypes")
public List<ServletDefinition> initJawrSpringServlets(ServletContext servletContext) throws ServletException{
List<ServletDefinition> jawrServletDefinitions = new ArrayList<ServletDefinition>();
ContextLoader contextLoader = new ContextLoader();
WebApplicationContext applicationCtx = contextLoader.initWebApplicationContext(servletContext);
Map<?, ?> jawrControllersMap = applicationCtx.getBeansOfType(JawrSpringController.class);
Iterator<?> entrySetIterator = jawrControllersMap.entrySet().iterator();
while(entrySetIterator.hasNext()){
JawrSpringController jawrController = (JawrSpringController) ((Map.Entry) entrySetIterator.next()).getValue();
Map<String, Object> initParams = new HashMap<String, Object>();
initParams.putAll(jawrController.getInitParams());
ServletConfig servletConfig = new MockServletConfig(SPRING_DISPATCHER_SERVLET,servletContext, initParams);
MockJawrSpringServlet servlet = new MockJawrSpringServlet(jawrController, servletConfig);
ServletDefinition servletDefinition = new ServletDefinition(servlet, servletConfig) ;
jawrServletDefinitions.add(servletDefinition);
}
contextLoader.closeWebApplicationContext(servletContext);
return jawrServletDefinitions;
} | java | {
"resource": ""
} |
q19084 | RDFSinkFilter.filterTriples | train | public static Graph filterTriples (
final Iterator<Triple> triples,
final Node... properties) {
final Graph filteredGraph = new RandomOrderGraph(RandomOrderGraph.createDefaultGraph());
final Sink<Triple> graphOutput = new SinkTriplesToGraph(true, filteredGraph);
final RDFSinkFilter rdfFilter = new RDFSinkFilter(graphOutput, properties);
rdfFilter.start();
while (triples.hasNext()) {
final Triple triple = triples.next();
rdfFilter.triple(triple);
}
rdfFilter.finish();
return filteredGraph;
} | java | {
"resource": ""
} |
q19085 | TypesImpl.directSupertypes | train | @Override
public List<? extends TypeMirror> directSupertypes(TypeMirror t)
{
switch (t.getKind())
{
case DECLARED:
DeclaredType dt = (DeclaredType) t;
TypeElement te = (TypeElement) dt.asElement();
List<TypeMirror> list = new ArrayList<>();
TypeElement superclass = (TypeElement) asElement(te.getSuperclass());
if (superclass != null)
{
list.add(0, superclass.asType());
}
list.addAll(te.getInterfaces());
return list;
case EXECUTABLE:
case PACKAGE:
throw new IllegalArgumentException(t.getKind().name());
default:
throw new UnsupportedOperationException(t.getKind().name()+" not supported yet");
}
} | java | {
"resource": ""
} |
q19086 | ServerModule.getJacksonProvider | train | protected Provider<ObjectMapper> getJacksonProvider()
{
return new Provider<ObjectMapper>()
{
@Override
public ObjectMapper get()
{
final ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JodaModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
return mapper;
}
};
} | java | {
"resource": ""
} |
q19087 | SetupServer.injector | train | public Injector injector(final ServletContextEvent event)
{
return (Injector) event.getServletContext().getAttribute(Injector.class.getName());
} | java | {
"resource": ""
} |
q19088 | RDFDatabaseWriter.writeParent | train | private void writeParent(Account account, XmlStreamWriter writer)
throws Exception {
// Sequence block
writer.writeStartElement("RDF:Seq");
writer.writeAttribute("RDF:about", account.getId());
for (Account child : account.getChildren()) {
logger.fine(" Write-RDF:li: " + child.getId());
writer.writeStartElement("RDF:li");
writer.writeAttribute("RDF:resource", child.getId());
writer.writeEndElement();
}
writer.writeEndElement();
// Descriptions of all elements including the parent
writeDescription(account, writer);
for (Account child : account.getChildren()) {
logger.fine("Write-RDF:Desc: " + child.getName());
writeDescription(child, writer);
}
// Recurse into the children
for (Account child : account.getChildren()) {
if (child.getChildren().size() > 0) {
writeParent(child, writer);
}
}
} | java | {
"resource": ""
} |
q19089 | RDFDatabaseWriter.writeFFGlobalSettings | train | private void writeFFGlobalSettings(Database db, XmlStreamWriter writer)
throws Exception {
writer.writeStartElement("RDF:Description");
writer.writeAttribute("RDF:about", RDFDatabaseReader.FF_GLOBAL_SETTINGS_URI);
for (String key : db.getGlobalSettings().keySet()) {
writer.writeAttribute(key, db.getGlobalSettings().get(key));
}
writer.writeEndElement();
} | java | {
"resource": ""
} |
q19090 | MathService.intersectsLineSegment | train | public static boolean intersectsLineSegment(Coordinate a, Coordinate b, Coordinate c, Coordinate d) {
// check single-point segment: these never intersect
if ((a.getX() == b.getX() && a.getY() == b.getY()) || (c.getX() == d.getX() && c.getY() == d.getY())) {
return false;
}
double c1 = cross(a, c, a, b);
double c2 = cross(a, b, c, d);
if (c1 == 0 && c2 == 0) {
// colinear, only intersecting if overlapping (touch is ok)
double xmin = Math.min(a.getX(), b.getX());
double ymin = Math.min(a.getY(), b.getY());
double xmax = Math.max(a.getX(), b.getX());
double ymax = Math.max(a.getY(), b.getY());
// check first point of last segment in bounding box of first segment
if (c.getX() > xmin && c.getX() < xmax && c.getY() > ymin && c.getY() < ymax) {
return true;
// check last point of last segment in bounding box of first segment
} else if (d.getX() > xmin && d.getX() < xmax && d.getY() > ymin && d.getY() < ymax) {
return true;
// check same segment
} else {
return c.getX() >= xmin && c.getX() <= xmax && c.getY() >= ymin && c.getY() <= ymax & d.getX() >= xmin
&& d.getX() <= xmax && d.getY() >= ymin && d.getY() <= ymax;
}
}
if (c2 == 0) {
// segments are parallel but not colinear
return false;
}
// not parallel, classical test
double u = c1 / c2;
double t = cross(a, c, c, d) / c2;
return (t > 0) && (t < 1) && (u > 0) && (u < 1);
} | java | {
"resource": ""
} |
q19091 | MathService.cross | train | private static double cross(Coordinate a1, Coordinate a2, Coordinate b1, Coordinate b2) {
return (a2.getX() - a1.getX()) * (b2.getY() - b1.getY()) - (a2.getY() - a1.getY()) * (b2.getX() - b1.getX());
} | java | {
"resource": ""
} |
q19092 | MathService.distance | train | public static double distance(Coordinate c1, Coordinate c2) {
double a = c1.getX() - c2.getX();
double b = c1.getY() - c2.getY();
return Math.sqrt(a * a + b * b);
} | java | {
"resource": ""
} |
q19093 | MathService.distance | train | public static double distance(Coordinate c1, Coordinate c2, Coordinate c) {
return distance(nearest(c1, c2, c), c);
} | java | {
"resource": ""
} |
q19094 | MathService.nearest | train | public static Coordinate nearest(Coordinate c1, Coordinate c2, Coordinate c) {
double len = distance(c1, c2);
double u = (c.getX() - c1.getX()) * (c2.getX() - c1.getX()) + (c.getY() - c1.getY()) * (c2.getY() - c1.getY());
u = u / (len * len);
if (u < 0.00001 || u > 1) {
// Shortest point not within LineSegment, so take closest end-point.
double len1 = distance(c, c1);
double len2 = distance(c, c2);
if (len1 < len2) {
return c1;
}
return c2;
} else {
// Intersecting point is on the line, use the formula: P = P1 + u (P2 - P1)
double x1 = c1.getX() + u * (c2.getX() - c1.getX());
double y1 = c1.getY() + u * (c2.getY() - c1.getY());
return new Coordinate(x1, y1);
}
} | java | {
"resource": ""
} |
q19095 | HttpConfig.isXForwardedAllowed | train | public static boolean isXForwardedAllowed(String remoteAddr) {
return isXForwardedAllowed() && (S.eq("all", xForwardedAllowed) || xForwardedAllowed.contains(remoteAddr));
} | java | {
"resource": ""
} |
q19096 | Account.createId | train | public static String createId(Account acc)
throws Exception {
return Account.createId(acc.getName() + acc.getDesc() + (new Random()).nextLong() + Runtime.getRuntime().freeMemory());
} | java | {
"resource": ""
} |
q19097 | Account.getChild | train | public Account getChild(int index) throws IndexOutOfBoundsException {
if (index < 0 || index >= children.size())
throw new IndexOutOfBoundsException("Illegal child index, " + index);
return children.get(index);
} | java | {
"resource": ""
} |
q19098 | Account.hasChild | train | public boolean hasChild(Account account) {
for (Account child : children) {
if (child.equals(account))
return true;
}
return false;
} | java | {
"resource": ""
} |
q19099 | Account.compareTo | train | public int compareTo(Account o) {
if (this.isFolder() && !o.isFolder())
return -1;
else if (!this.isFolder() && o.isFolder())
return 1;
// First ignore case, if they equate, use case.
int result = name.compareToIgnoreCase(o.name);
if (result == 0)
return name.compareTo(o.name);
else
return result;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.