code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public static String getDirectoryname(final String pPath, final char pSeparator) {
int index = pPath.lastIndexOf(pSeparator);
if (index < 0) {
return ""; // Assume only filename
}
return pPath.substring(0, index);
} | java |
public static String getFilename(final String pPath, final char pSeparator) {
int index = pPath.lastIndexOf(pSeparator);
if (index < 0) {
return pPath; // Assume only filename
}
return pPath.substring(index + 1);
} | java |
public static boolean isEmpty(File pFile) {
if (pFile.isDirectory()) {
return (pFile.list().length == 0);
}
return (pFile.length() == 0);
} | java |
public static String getTempDir() {
synchronized (FileUtil.class) {
if (TEMP_DIR == null) {
// Get the 'java.io.tmpdir' property
String tmpDir = System.getProperty("java.io.tmpdir");
if (StringUtil.isEmpty(tmpDir)) {
// Stupid fallback...
// TODO: Delegate to FileSystem?
if (new File("/temp").exists()) {
tmpDir = "/temp"; // Windows
}
else {
tmpDir = "/tmp"; // Unix
}
}
TEMP_DIR = tmpDir;
}
}
return TEMP_DIR;
} | java |
public static byte[] read(File pFile) throws IOException {
// Custom implementation, as we know the size of a file
if (!pFile.exists()) {
throw new FileNotFoundException(pFile.toString());
}
byte[] bytes = new byte[(int) pFile.length()];
InputStream in = null;
try {
// Use buffer size two times byte array, to avoid i/o bottleneck
in = new BufferedInputStream(new FileInputStream(pFile), BUF_SIZE * 2);
int off = 0;
int len;
while ((len = in.read(bytes, off, in.available())) != -1 && (off < bytes.length)) {
off += len;
// System.out.println("read:" + len);
}
}
// Just pass any IOException on up the stack
finally {
close(in);
}
return bytes;
} | java |
public static byte[] read(InputStream pInput) throws IOException {
// Create byte array
ByteArrayOutputStream bytes = new FastByteArrayOutputStream(BUF_SIZE);
// Copy from stream to byte array
copy(pInput, bytes);
return bytes.toByteArray();
} | java |
public static boolean write(File pFile, byte[] pData) throws IOException {
boolean success = false;
OutputStream out = null;
try {
out = new BufferedOutputStream(new FileOutputStream(pFile));
success = write(out, pData);
}
finally {
close(out);
}
return success;
} | java |
public static boolean delete(final File pFile, final boolean pForce) throws IOException {
if (pForce && pFile.isDirectory()) {
return deleteDir(pFile);
}
return pFile.exists() && pFile.delete();
} | java |
private static boolean fixProfileXYZTag(final ICC_Profile profile, final int tagSignature) {
byte[] data = profile.getData(tagSignature);
// The CMM expects 0x64 65 73 63 ('XYZ ') but is 0x17 A5 05 B8..?
if (data != null && intFromBigEndian(data, 0) == CORBIS_RGB_ALTERNATE_XYZ) {
intToBigEndian(ICC_Profile.icSigXYZData, data, 0);
profile.setData(tagSignature, data);
return true;
}
return false;
} | java |
private static void buildYCCtoRGBtable() {
if (ColorSpaces.DEBUG) {
System.err.println("Building YCC conversion table");
}
for (int i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
// i is the actual input pixel value, in the range 0..MAXJSAMPLE
// The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE
// Cr=>R value is nearest int to 1.40200 * x
Cr_R_LUT[i] = (int) ((1.40200 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
// Cb=>B value is nearest int to 1.77200 * x
Cb_B_LUT[i] = (int) ((1.77200 * (1 << SCALEBITS) + 0.5) * x + ONE_HALF) >> SCALEBITS;
// Cr=>G value is scaled-up -0.71414 * x
Cr_G_LUT[i] = -(int) (0.71414 * (1 << SCALEBITS) + 0.5) * x;
// Cb=>G value is scaled-up -0.34414 * x
// We also add in ONE_HALF so that need not do it in inner loop
Cb_G_LUT[i] = -(int) ((0.34414) * (1 << SCALEBITS) + 0.5) * x + ONE_HALF;
}
} | java |
private int getOparamCountFromRequest(HttpServletRequest pRequest) {
// Use request.attribute for incrementing oparam counter
Integer count = (Integer) pRequest.getAttribute(COUNTER);
if (count == null) {
count = new Integer(0);
}
else {
count = new Integer(count.intValue() + 1);
}
// ... and set it back
pRequest.setAttribute(COUNTER, count);
return count.intValue();
} | java |
private static int getFilterType(RenderingHints pHints) {
if (pHints == null) {
return FILTER_UNDEFINED;
}
if (pHints.containsKey(KEY_RESAMPLE_INTERPOLATION)) {
Object value = pHints.get(KEY_RESAMPLE_INTERPOLATION);
// NOTE: Workaround for a bug in RenderingHints constructor (Bug id# 5084832)
if (!KEY_RESAMPLE_INTERPOLATION.isCompatibleValue(value)) {
throw new IllegalArgumentException(value + " incompatible with key " + KEY_RESAMPLE_INTERPOLATION);
}
return value != null ? ((Value) value).getFilterType() : FILTER_UNDEFINED;
}
else if (RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR.equals(pHints.get(RenderingHints.KEY_INTERPOLATION))
|| (!pHints.containsKey(RenderingHints.KEY_INTERPOLATION)
&& (RenderingHints.VALUE_RENDER_SPEED.equals(pHints.get(RenderingHints.KEY_RENDERING))
|| RenderingHints.VALUE_COLOR_RENDER_SPEED.equals(pHints.get(RenderingHints.KEY_COLOR_RENDERING))))) {
// Nearest neighbour, or prioritize speed
return FILTER_POINT;
}
else if (RenderingHints.VALUE_INTERPOLATION_BILINEAR.equals(pHints.get(RenderingHints.KEY_INTERPOLATION))) {
// Triangle equals bi-linear interpolation
return FILTER_TRIANGLE;
}
else if (RenderingHints.VALUE_INTERPOLATION_BICUBIC.equals(pHints.get(RenderingHints.KEY_INTERPOLATION))) {
return FILTER_QUADRATIC;// No idea if this is correct..?
}
else if (RenderingHints.VALUE_RENDER_QUALITY.equals(pHints.get(RenderingHints.KEY_RENDERING))
|| RenderingHints.VALUE_COLOR_RENDER_QUALITY.equals(pHints.get(RenderingHints.KEY_COLOR_RENDERING))) {
// Prioritize quality
return FILTER_MITCHELL;
}
// NOTE: Other hints are ignored
return FILTER_UNDEFINED;
} | java |
public String getColumn(String pProperty) {
if (mPropertiesMap == null || pProperty == null)
return null;
return (String) mPropertiesMap.get(pProperty);
} | java |
public String getTable(String pProperty) {
String table = getColumn(pProperty);
if (table != null) {
int dotIdx = 0;
if ((dotIdx = table.lastIndexOf(".")) >= 0)
table = table.substring(0, dotIdx);
else
return null;
}
return table;
} | java |
public String getProperty(String pColumn) {
if (mColumnMap == null || pColumn == null)
return null;
String property = (String) mColumnMap.get(pColumn);
int dotIdx = 0;
if (property == null && (dotIdx = pColumn.lastIndexOf(".")) >= 0)
property = (String) mColumnMap.get(pColumn.substring(dotIdx + 1));
return property;
} | java |
public synchronized Object[] mapObjects(ResultSet pRSet) throws SQLException {
Vector result = new Vector();
ResultSetMetaData meta = pRSet.getMetaData();
int cols = meta.getColumnCount();
// Get colum names
String[] colNames = new String[cols];
for (int i = 0; i < cols; i++) {
colNames[i] = meta.getColumnName(i + 1); // JDBC cols start at 1...
/*
System.out.println(meta.getColumnLabel(i + 1));
System.out.println(meta.getColumnName(i + 1));
System.out.println(meta.getColumnType(i + 1));
System.out.println(meta.getColumnTypeName(i + 1));
// System.out.println(meta.getTableName(i + 1));
// System.out.println(meta.getCatalogName(i + 1));
// System.out.println(meta.getSchemaName(i + 1));
// Last three NOT IMPLEMENTED!!
*/
}
// Loop through rows in resultset
while (pRSet.next()) {
Object obj = null;
try {
obj = mInstanceClass.newInstance(); // Asserts empty constructor!
}
catch (IllegalAccessException iae) {
mLog.logError(iae);
// iae.printStackTrace();
}
catch (InstantiationException ie) {
mLog.logError(ie);
// ie.printStackTrace();
}
// Read each colum from this row into object
for (int i = 0; i < cols; i++) {
String property = (String) mColumnMap.get(colNames[i]);
if (property != null) {
// This column is mapped to a property
mapColumnProperty(pRSet, i + 1, property, obj);
}
}
// Add object to the result Vector
result.addElement(obj);
}
return result.toArray((Object[]) Array.newInstance(mInstanceClass,
result.size()));
} | java |
String buildIdentitySQL(String[] pKeys) {
mTables = new Hashtable();
mColumns = new Vector();
// Get columns to select
mColumns.addElement(getPrimaryKey());
// Get tables to select (and join) from and their joins
tableJoins(null, false);
for (int i = 0; i < pKeys.length; i++) {
tableJoins(getColumn(pKeys[i]), true);
}
// All data read, build SQL query string
return "SELECT " + getPrimaryKey() + " " + buildFromClause()
+ buildWhereClause();
} | java |
public String buildSQL() {
mTables = new Hashtable();
mColumns = new Vector();
String key = null;
for (Enumeration keys = mPropertiesMap.keys(); keys.hasMoreElements();) {
key = (String) keys.nextElement();
// Get columns to select
String column = (String) mPropertiesMap.get(key);
mColumns.addElement(column);
tableJoins(column, false);
}
// All data read, build SQL query string
return buildSelectClause() + buildFromClause()
+ buildWhereClause();
} | java |
private String buildSelectClause() {
StringBuilder sqlBuf = new StringBuilder();
sqlBuf.append("SELECT ");
String column = null;
for (Enumeration select = mColumns.elements(); select.hasMoreElements();) {
column = (String) select.nextElement();
/*
String subColumn = column.substring(column.indexOf(".") + 1);
// System.err.println("DEBUG: col=" + subColumn);
String mapType = (String) mMapTypes.get(mColumnMap.get(subColumn));
*/
String mapType = (String) mMapTypes.get(getProperty(column));
if (mapType == null || mapType.equals(DIRECTMAP)) {
sqlBuf.append(column);
sqlBuf.append(select.hasMoreElements() ? ", " : " ");
}
}
return sqlBuf.toString();
} | java |
private void tableJoins(String pColumn, boolean pWhereJoin) {
String join = null;
String table = null;
if (pColumn == null) {
// Identity
join = getIdentityJoin();
table = getTable(getProperty(getPrimaryKey()));
}
else {
// Normal
int dotIndex = -1;
if ((dotIndex = pColumn.lastIndexOf(".")) <= 0) {
// No table qualifier
return;
}
// Get table qualifier.
table = pColumn.substring(0, dotIndex);
// Don't care about the tables that are not supposed to be selected from
String property = (String) getProperty(pColumn);
if (property != null) {
String mapType = (String) mMapTypes.get(property);
if (!pWhereJoin && mapType != null && !mapType.equals(DIRECTMAP)) {
return;
}
join = (String) mJoins.get(property);
}
}
// If table is not in the tables Hash, add it, and check for joins.
if (mTables.get(table) == null) {
if (join != null) {
mTables.put(table, join);
StringTokenizer tok = new StringTokenizer(join, "= ");
String next = null;
while(tok.hasMoreElements()) {
next = tok.nextToken();
// Don't care about SQL keywords
if (next.equals("AND") || next.equals("OR")
|| next.equals("NOT") || next.equals("IN")) {
continue;
}
// Check for new tables and joins in this join clause.
tableJoins(next, false);
}
}
else {
// No joins for this table.
join = "";
mTables.put(table, join);
}
}
} | java |
public final void seek(long pPosition) throws IOException {
checkOpen();
// TODO: This is correct according to javax.imageio (IndexOutOfBoundsException),
// but it's inconsistent with reset that throws IOException...
if (pPosition < flushedPosition) {
throw new IndexOutOfBoundsException("position < flushedPosition!");
}
seekImpl(pPosition);
position = pPosition;
} | java |
public static String getMIMEType(final String pFileExt) {
List<String> types = sExtToMIME.get(StringUtil.toLowerCase(pFileExt));
return (types == null || types.isEmpty()) ? null : types.get(0);
} | java |
public static List<String> getMIMETypes(final String pFileExt) {
List<String> types = sExtToMIME.get(StringUtil.toLowerCase(pFileExt));
return maskNull(types);
} | java |
private static List<String> getExtensionForWildcard(final String pMIME) {
final String family = pMIME.substring(0, pMIME.length() - 1);
Set<String> extensions = new LinkedHashSet<String>();
for (Map.Entry<String, List<String>> mimeToExt : sMIMEToExt.entrySet()) {
if ("*/".equals(family) || mimeToExt.getKey().startsWith(family)) {
extensions.addAll(mimeToExt.getValue());
}
}
return Collections.unmodifiableList(new ArrayList<String>(extensions));
} | java |
private static List<String> maskNull(List<String> pTypes) {
return (pTypes == null) ? Collections.<String>emptyList() : pTypes;
} | java |
public int decode(final InputStream stream, final ByteBuffer buffer) throws IOException {
while (buffer.remaining() >= 64) {
int val = stream.read();
if (val < 0) {
break; // EOF
}
if ((val & COMPRESSED_RUN_MASK) == COMPRESSED_RUN_MASK) {
int count = val & ~COMPRESSED_RUN_MASK;
int pixel = stream.read();
if (pixel < 0) {
break; // EOF
}
for (int i = 0; i < count; i++) {
buffer.put((byte) pixel);
}
}
else {
buffer.put((byte) val);
}
}
return buffer.position();
} | java |
private boolean buildRegexpParser() {
// Convert wildcard string mask to regular expression
String regexp = convertWildcardExpressionToRegularExpression(mStringMask);
if (regexp == null) {
out.println(DebugUtil.getPrefixErrorMessage(this)
+ "irregularity in regexp conversion - now not able to parse any strings, all strings will be rejected!");
return false;
}
// Instantiate a regular expression parser
try {
mRegexpParser = Pattern.compile(regexp);
}
catch (PatternSyntaxException e) {
if (mDebugging) {
out.println(DebugUtil.getPrefixErrorMessage(this) + "RESyntaxException \"" + e.getMessage()
+ "\" caught - now not able to parse any strings, all strings will be rejected!");
}
if (mDebugging) {
e.printStackTrace(System.err);
}
return false;
}
if (mDebugging) {
out.println(DebugUtil.getPrefixDebugMessage(this) + "regular expression parser from regular expression " + regexp
+ " extracted from wildcard string mask " + mStringMask + ".");
}
return true;
} | java |
private boolean checkStringToBeParsed(final String pStringToBeParsed) {
// Check for nullness
if (pStringToBeParsed == null) {
if (mDebugging) {
out.println(DebugUtil.getPrefixDebugMessage(this) + "string to be parsed is null - rejection!");
}
return false;
}
// Check if valid character (element in alphabet)
for (int i = 0; i < pStringToBeParsed.length(); i++) {
if (!isInAlphabet(pStringToBeParsed.charAt(i))) {
if (mDebugging) {
out.println(DebugUtil.getPrefixDebugMessage(this)
+ "one or more characters in string to be parsed are not legal characters - rejection!");
}
return false;
}
}
return true;
} | java |
public static boolean isInAlphabet(final char pCharToCheck) {
for (int i = 0; i < ALPHABET.length; i++) {
if (pCharToCheck == ALPHABET[i]) {
return true;
}
}
return false;
} | java |
@SuppressWarnings({"UnusedDeclaration", "UnusedAssignment", "unchecked"})
public static void main(String[] pArgs) {
int howMany = 1000;
if (pArgs.length > 0) {
howMany = Integer.parseInt(pArgs[0]);
}
long start;
long end;
/*
int[] intArr1 = new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
};
int[] intArr2 = new int[] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19
};
start = System.currentTimeMillis();
for (int i = 0; i < howMany; i++) {
intArr1 = (int[]) mergeArrays(intArr1, 0, intArr1.length, intArr2, 0, intArr2.length);
}
end = System.currentTimeMillis();
System.out.println("mergeArrays: " + howMany + " * " + intArr2.length + " ints took " + (end - start) + " milliseconds (" + intArr1.length
+ ")");
*/
////////////////////////////////
String[] stringArr1 = new String[]{
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"
};
/*
String[] stringArr2 = new String[] {
"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
};
start = System.currentTimeMillis();
for (int i = 0; i < howMany; i++) {
stringArr1 = (String[]) mergeArrays(stringArr1, 0, stringArr1.length, stringArr2, 0, stringArr2.length);
}
end = System.currentTimeMillis();
System.out.println("mergeArrays: " + howMany + " * " + stringArr2.length + " Strings took " + (end - start) + " milliseconds ("
+ stringArr1.length + ")");
start = System.currentTimeMillis();
while (intArr1.length > stringArr2.length) {
intArr1 = (int[]) subArray(intArr1, 0, intArr1.length - stringArr2.length);
}
end = System.currentTimeMillis();
System.out.println("subArray: " + howMany + " * " + intArr2.length + " ints took " + (end - start) + " milliseconds (" + intArr1.length
+ ")");
start = System.currentTimeMillis();
while (stringArr1.length > stringArr2.length) {
stringArr1 = (String[]) subArray(stringArr1, stringArr2.length);
}
end = System.currentTimeMillis();
System.out.println("subArray: " + howMany + " * " + stringArr2.length + " Strings took " + (end - start) + " milliseconds ("
+ stringArr1.length + ")");
*/
stringArr1 = new String[]{
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
};
System.out.println("\nFilterIterators:\n");
List list = Arrays.asList(stringArr1);
Iterator iter = new FilterIterator(list.iterator(), new FilterIterator.Filter() {
public boolean accept(Object pElement) {
return ((String) pElement).length() > 5;
}
});
while (iter.hasNext()) {
String str = (String) iter.next();
System.out.println(str + " has more than 5 letters!");
}
iter = new FilterIterator(list.iterator(), new FilterIterator.Filter() {
public boolean accept(Object pElement) {
return ((String) pElement).length() <= 5;
}
});
while (iter.hasNext()) {
String str = (String) iter.next();
System.out.println(str + " has less than, or exactly 5 letters!");
}
start = System.currentTimeMillis();
for (int i = 0; i < howMany; i++) {
iter = new FilterIterator(list.iterator(), new FilterIterator.Filter() {
public boolean accept(Object pElement) {
return ((String) pElement).length() <= 5;
}
});
while (iter.hasNext()) {
iter.next();
System.out.print("");
}
}
// end = System.currentTimeMillis();
// System.out.println("Time: " + (end - start) + " ms");
// System.out.println("\nClosureCollection:\n");
// forEach(list, new Closure() {
//
// public void execute(Object pElement) {
//
// String str = (String) pElement;
//
// if (str.length() > 5) {
// System.out.println(str + " has more than 5 letters!");
// }
// else {
// System.out.println(str + " has less than, or exactly 5 letters!");
// }
// }
// });
// start = System.currentTimeMillis();
// for (int i = 0; i < howMany; i++) {
// forEach(list, new Closure() {
//
// public void execute(Object pElement) {
//
// String str = (String) pElement;
//
// if (str.length() <= 5) {
// System.out.print("");
// }
// }
// });
// }
// end = System.currentTimeMillis();
// System.out.println("Time: " + (end - start) + " ms");
} | java |
public static Object mergeArrays(Object pArray1, Object pArray2) {
return mergeArrays(pArray1, 0, Array.getLength(pArray1), pArray2, 0, Array.getLength(pArray2));
} | java |
@SuppressWarnings({"SuspiciousSystemArraycopy"})
public static Object mergeArrays(Object pArray1, int pOffset1, int pLength1, Object pArray2, int pOffset2, int pLength2) {
Class class1 = pArray1.getClass();
Class type = class1.getComponentType();
// Create new array of the new length
Object array = Array.newInstance(type, pLength1 + pLength2);
System.arraycopy(pArray1, pOffset1, array, 0, pLength1);
System.arraycopy(pArray2, pOffset2, array, pLength1, pLength2);
return array;
} | java |
public static <E> void addAll(Collection<E> pCollection, Iterator<? extends E> pIterator) {
while (pIterator.hasNext()) {
pCollection.add(pIterator.next());
}
} | java |
<T> void registerSPIs(final URL pResource, final Class<T> pCategory, final ClassLoader pLoader) {
Properties classNames = new Properties();
try {
classNames.load(pResource.openStream());
}
catch (IOException e) {
throw new ServiceConfigurationError(e);
}
if (!classNames.isEmpty()) {
@SuppressWarnings({"unchecked"})
CategoryRegistry<T> registry = categoryMap.get(pCategory);
Set providerClassNames = classNames.keySet();
for (Object providerClassName : providerClassNames) {
String className = (String) providerClassName;
try {
@SuppressWarnings({"unchecked"})
Class<T> providerClass = (Class<T>) Class.forName(className, true, pLoader);
T provider = providerClass.newInstance();
registry.register(provider);
}
catch (ClassNotFoundException e) {
throw new ServiceConfigurationError(e);
}
catch (IllegalAccessException e) {
throw new ServiceConfigurationError(e);
}
catch (InstantiationException e) {
throw new ServiceConfigurationError(e);
}
catch (IllegalArgumentException e) {
throw new ServiceConfigurationError(e);
}
}
}
} | java |
private <T> CategoryRegistry<T> getRegistry(final Class<T> pCategory) {
@SuppressWarnings({"unchecked"})
CategoryRegistry<T> registry = categoryMap.get(pCategory);
if (registry == null) {
throw new IllegalArgumentException("No such category: " + pCategory.getName());
}
return registry;
} | java |
public boolean register(final Object pProvider) {
Iterator<Class<?>> categories = compatibleCategories(pProvider);
boolean registered = false;
while (categories.hasNext()) {
Class<?> category = categories.next();
if (registerImpl(pProvider, category) && !registered) {
registered = true;
}
}
return registered;
} | java |
public <T> boolean register(final T pProvider, final Class<? super T> pCategory) {
return registerImpl(pProvider, pCategory);
} | java |
public boolean deregister(final Object pProvider) {
Iterator<Class<?>> categories = containingCategories(pProvider);
boolean deregistered = false;
while (categories.hasNext()) {
Class<?> category = categories.next();
if (deregister(pProvider, category) && !deregistered) {
deregistered = true;
}
}
return deregistered;
} | java |
public static boolean isEmpty(String[] pStringArray) {
// No elements to test
if (pStringArray == null) {
return true;
}
// Test all the elements
for (String string : pStringArray) {
if (!isEmpty(string)) {
return false;
}
}
// All elements are empty
return true;
} | java |
public static boolean contains(String pContainer, String pLookFor) {
return ((pContainer != null) && (pLookFor != null) && (pContainer.indexOf(pLookFor) >= 0));
} | java |
public static boolean containsIgnoreCase(String pString, int pChar) {
return ((pString != null)
&& ((pString.indexOf(Character.toLowerCase((char) pChar)) >= 0)
|| (pString.indexOf(Character.toUpperCase((char) pChar)) >= 0)));
// NOTE: I don't convert the string to uppercase, but instead test
// the string (potentially) two times, as this is more efficient for
// long strings (in most cases).
} | java |
public static int indexOfIgnoreCase(String pString, int pChar, int pPos) {
if ((pString == null)) {
return -1;
}
// Get first char
char lower = Character.toLowerCase((char) pChar);
char upper = Character.toUpperCase((char) pChar);
int indexLower;
int indexUpper;
// Test for char
indexLower = pString.indexOf(lower, pPos);
indexUpper = pString.indexOf(upper, pPos);
if (indexLower < 0) {
/* if (indexUpper < 0)
return -1; // First char not found
else */
return indexUpper;// Only upper
}
else if (indexUpper < 0) {
return indexLower;// Only lower
}
else {
// Both found, select first occurence
return (indexLower < indexUpper)
? indexLower
: indexUpper;
}
} | java |
public static int lastIndexOfIgnoreCase(String pString, int pChar) {
return lastIndexOfIgnoreCase(pString, pChar, pString != null ? pString.length() : -1);
} | java |
public static int lastIndexOfIgnoreCase(String pString, int pChar, int pPos) {
if ((pString == null)) {
return -1;
}
// Get first char
char lower = Character.toLowerCase((char) pChar);
char upper = Character.toUpperCase((char) pChar);
int indexLower;
int indexUpper;
// Test for char
indexLower = pString.lastIndexOf(lower, pPos);
indexUpper = pString.lastIndexOf(upper, pPos);
if (indexLower < 0) {
/* if (indexUpper < 0)
return -1; // First char not found
else */
return indexUpper;// Only upper
}
else if (indexUpper < 0) {
return indexLower;// Only lower
}
else {
// Both found, select last occurence
return (indexLower > indexUpper)
? indexLower
: indexUpper;
}
} | java |
public static String ltrim(String pString) {
if ((pString == null) || (pString.length() == 0)) {
return pString;// Null or empty string
}
for (int i = 0; i < pString.length(); i++) {
if (!Character.isWhitespace(pString.charAt(i))) {
if (i == 0) {
return pString;// First char is not whitespace
}
else {
return pString.substring(i);// Return rest after whitespace
}
}
}
// If all whitespace, return empty string
return "";
} | java |
public static String replace(String pSource, String pPattern, String pReplace) {
if (pPattern.length() == 0) {
return pSource;// Special case: No pattern to replace
}
int match;
int offset = 0;
StringBuilder result = new StringBuilder();
// Loop string, until last occurence of pattern, and replace
while ((match = pSource.indexOf(pPattern, offset)) != -1) {
// Append everything until pattern
result.append(pSource.substring(offset, match));
// Append the replace string
result.append(pReplace);
offset = match + pPattern.length();
}
// Append rest of string and return
result.append(pSource.substring(offset));
return result.toString();
} | java |
public static String replaceIgnoreCase(String pSource, String pPattern, String pReplace) {
if (pPattern.length() == 0) {
return pSource;// Special case: No pattern to replace
}
int match;
int offset = 0;
StringBuilder result = new StringBuilder();
while ((match = indexOfIgnoreCase(pSource, pPattern, offset)) != -1) {
result.append(pSource.substring(offset, match));
result.append(pReplace);
offset = match + pPattern.length();
}
result.append(pSource.substring(offset));
return result.toString();
} | java |
public static String capitalize(String pString, int pIndex) {
if (pIndex < 0) {
throw new IndexOutOfBoundsException("Negative index not allowed: " + pIndex);
}
if (pString == null || pString.length() <= pIndex) {
return pString;
}
// This is the fastest method, according to my tests
// Skip array duplication if allready capitalized
if (Character.isUpperCase(pString.charAt(pIndex))) {
return pString;
}
// Convert to char array, capitalize and create new String
char[] charArray = pString.toCharArray();
charArray[pIndex] = Character.toUpperCase(charArray[pIndex]);
return new String(charArray);
/**
StringBuilder buf = new StringBuilder(pString);
buf.setCharAt(pIndex, Character.toUpperCase(buf.charAt(pIndex)));
return buf.toString();
//*/
/**
return pString.substring(0, pIndex)
+ Character.toUpperCase(pString.charAt(pIndex))
+ pString.substring(pIndex + 1);
//*/
} | java |
public static String pad(String pSource, int pRequiredLength, String pPadString, boolean pPrepend) {
if (pPadString == null || pPadString.length() == 0) {
throw new IllegalArgumentException("Pad string: \"" + pPadString + "\"");
}
if (pSource.length() >= pRequiredLength) {
return pSource;
}
// TODO: Benchmark the new version against the old one, to see if it's really faster
// Rewrite to first create pad
// - pad += pad; - until length is >= gap
// then append the pad and cut if too long
int gap = pRequiredLength - pSource.length();
StringBuilder result = new StringBuilder(pPadString);
while (result.length() < gap) {
result.append(result);
}
if (result.length() > gap) {
result.delete(gap, result.length());
}
return pPrepend ? result.append(pSource).toString() : result.insert(0, pSource).toString();
/*
StringBuilder result = new StringBuilder(pSource);
// Concatenation until proper string length
while (result.length() < pRequiredLength) {
// Prepend or append
if (pPrepend) { // Front
result.insert(0, pPadString);
}
else { // Back
result.append(pPadString);
}
}
// Truncate
if (result.length() > pRequiredLength) {
if (pPrepend) {
result.delete(0, result.length() - pRequiredLength);
}
else {
result.delete(pRequiredLength, result.length());
}
}
return result.toString();
*/
} | java |
public static String[] toStringArray(String pString, String pDelimiters) {
if (isEmpty(pString)) {
return new String[0];
}
StringTokenIterator st = new StringTokenIterator(pString, pDelimiters);
List<String> v = new ArrayList<String>();
while (st.hasMoreElements()) {
v.add(st.nextToken());
}
return v.toArray(new String[v.size()]);
} | java |
public static int[] toIntArray(String pString, String pDelimiters, int pBase) {
if (isEmpty(pString)) {
return new int[0];
}
// Some room for improvement here...
String[] temp = toStringArray(pString, pDelimiters);
int[] array = new int[temp.length];
for (int i = 0; i < array.length; i++) {
array[i] = Integer.parseInt(temp[i], pBase);
}
return array;
} | java |
public static long[] toLongArray(String pString, String pDelimiters) {
if (isEmpty(pString)) {
return new long[0];
}
// Some room for improvement here...
String[] temp = toStringArray(pString, pDelimiters);
long[] array = new long[temp.length];
for (int i = 0; i < array.length; i++) {
array[i] = Long.parseLong(temp[i]);
}
return array;
} | java |
public static double[] toDoubleArray(String pString, String pDelimiters) {
if (isEmpty(pString)) {
return new double[0];
}
// Some room for improvement here...
String[] temp = toStringArray(pString, pDelimiters);
double[] array = new double[temp.length];
for (int i = 0; i < array.length; i++) {
array[i] = Double.valueOf(temp[i]);
// Double.parseDouble() is 1.2...
}
return array;
} | java |
public static String toCSVString(Object[] pStringArray, String pDelimiterString) {
if (pStringArray == null) {
return "";
}
if (pDelimiterString == null) {
throw new IllegalArgumentException("delimiter == null");
}
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < pStringArray.length; i++) {
if (i > 0) {
buffer.append(pDelimiterString);
}
buffer.append(pStringArray[i]);
}
return buffer.toString();
} | java |
static void loadLibrary0(String pLibrary, String pResource, ClassLoader pLoader) {
if (pLibrary == null) {
throw new IllegalArgumentException("library == null");
}
// Try loading normal way
UnsatisfiedLinkError unsatisfied;
try {
System.loadLibrary(pLibrary);
return;
}
catch (UnsatisfiedLinkError err) {
// Ignore
unsatisfied = err;
}
final ClassLoader loader = pLoader != null ? pLoader : Thread.currentThread().getContextClassLoader();
final String resource = pResource != null ? pResource : getResourceFor(pLibrary);
// TODO: resource may be null, and that MIGHT be okay, IFF the resource
// is allready unpacked to the user dir... However, we then need another
// way to resolve the library extension...
// Right now we just fail in a predictable way (no NPE)!
if (resource == null) {
throw unsatisfied;
}
// Default to load/store from user.home
File dir = new File(System.getProperty("user.home") + "/.twelvemonkeys/lib");
dir.mkdirs();
//File libraryFile = new File(dir.getAbsolutePath(), pLibrary + LIBRARY_EXTENSION);
File libraryFile = new File(dir.getAbsolutePath(), pLibrary + "." + FileUtil.getExtension(resource));
if (!libraryFile.exists()) {
try {
extractToUserDir(resource, libraryFile, loader);
}
catch (IOException ioe) {
UnsatisfiedLinkError err = new UnsatisfiedLinkError("Unable to extract resource to dir: " + libraryFile.getAbsolutePath());
err.initCause(ioe);
throw err;
}
}
// Try to load the library from the file we just wrote
System.load(libraryFile.getAbsolutePath());
} | java |
public Rational plus(final Rational pOther) {
// special cases
if (equals(ZERO)) {
return pOther;
}
if (pOther.equals(ZERO)) {
return this;
}
// Find gcd of numerators and denominators
long f = gcd(numerator, pOther.numerator);
long g = gcd(denominator, pOther.denominator);
// add cross-product terms for numerator
// multiply back in
return new Rational(
((numerator / f) * (pOther.denominator / g) + (pOther.numerator / f) * (denominator / g)) * f,
lcm(denominator, pOther.denominator)
);
} | java |
public void service(PageContext pContext)
throws ServletException, IOException {
JspWriter writer = pContext.getOut();
writer.print(value);
} | java |
static void main(String[] argv) {
Time time = null;
TimeFormat in = null;
TimeFormat out = null;
if (argv.length >= 3) {
System.out.println("Creating out TimeFormat: \"" + argv[2] + "\"");
out = new TimeFormat(argv[2]);
}
if (argv.length >= 2) {
System.out.println("Creating in TimeFormat: \"" + argv[1] + "\"");
in = new TimeFormat(argv[1]);
}
else {
System.out.println("Using default format for in");
in = DEFAULT_FORMAT;
}
if (out == null)
out = in;
if (argv.length >= 1) {
System.out.println("Parsing: \"" + argv[0] + "\" with format \""
+ in.formatString + "\"");
time = in.parse(argv[0]);
}
else
time = new Time();
System.out.println("Time is \"" + out.format(time) +
"\" according to format \"" + out.formatString + "\"");
} | java |
public String format(Time pTime) {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < formatter.length; i++) {
buf.append(formatter[i].format(pTime));
}
return buf.toString();
} | java |
void registerContent(
final String pCacheURI,
final CacheRequest pRequest,
final CachedResponse pCachedResponse
) throws IOException {
// System.out.println(" ## HTTPCache ## Registering content for " + pCacheURI);
// pRequest.removeAttribute(ATTRIB_IS_STALE);
// pRequest.setAttribute(ATTRIB_CACHED_RESPONSE, pCachedResponse);
if ("HEAD".equals(pRequest.getMethod())) {
// System.out.println(" ## HTTPCache ## Was HEAD request, will NOT store content.");
return;
}
// TODO: Several resources may have same extension...
String extension = MIMEUtil.getExtension(pCachedResponse.getHeaderValue(HEADER_CONTENT_TYPE));
if (extension == null) {
extension = "[NULL]";
}
synchronized (contentCache) {
contentCache.put(pCacheURI + '.' + extension, pCachedResponse);
// This will be the default version
if (!contentCache.containsKey(pCacheURI)) {
contentCache.put(pCacheURI, pCachedResponse);
}
}
// Write the cached content to disk
File content = new File(tempDir, "./" + pCacheURI + '.' + extension);
if (deleteCacheOnExit && !content.exists()) {
content.deleteOnExit();
}
File parent = content.getParentFile();
if (!(parent.exists() || parent.mkdirs())) {
log("Could not create directory " + parent.getAbsolutePath());
// TODO: Make sure vary-info is still created in memory
return;
}
OutputStream mContentStream = new BufferedOutputStream(new FileOutputStream(content));
try {
pCachedResponse.writeContentsTo(mContentStream);
}
finally {
try {
mContentStream.close();
}
catch (IOException e) {
log("Error closing content stream: " + e.getMessage(), e);
}
}
// Write the cached headers to disk (in pseudo-properties-format)
File headers = new File(content.getAbsolutePath() + FILE_EXT_HEADERS);
if (deleteCacheOnExit && !headers.exists()) {
headers.deleteOnExit();
}
FileWriter writer = new FileWriter(headers);
PrintWriter headerWriter = new PrintWriter(writer);
try {
String[] names = pCachedResponse.getHeaderNames();
for (String name : names) {
String[] values = pCachedResponse.getHeaderValues(name);
headerWriter.print(name);
headerWriter.print(": ");
headerWriter.println(StringUtil.toCSVString(values, "\\"));
}
}
finally {
headerWriter.flush();
try {
writer.close();
}
catch (IOException e) {
log("Error closing header stream: " + e.getMessage(), e);
}
}
// TODO: Make this more robust, if some weird entity is not
// consistent in it's vary-headers..
// (sometimes Vary, sometimes not, or somtimes different Vary headers).
// Write extra Vary info to disk
String[] varyHeaders = pCachedResponse.getHeaderValues(HEADER_VARY);
// If no variations, then don't store vary info
if (varyHeaders != null && varyHeaders.length > 0) {
Properties variations = getVaryProperties(pCacheURI);
String vary = StringUtil.toCSVString(varyHeaders);
variations.setProperty(HEADER_VARY, vary);
// Create Vary-key and map to file extension...
String varyKey = createVaryKey(varyHeaders, pRequest);
// System.out.println("varyKey: " + varyKey);
// System.out.println("extension: " + extension);
variations.setProperty(varyKey, extension);
storeVaryProperties(pCacheURI, variations);
}
} | java |
static long getDateHeader(final String pHeaderValue) {
long date = -1L;
if (pHeaderValue != null) {
date = HTTPUtil.parseHTTPDate(pHeaderValue);
}
return date;
} | java |
public void service(ServletRequest pRequest, ServletResponse pResponse) throws IOException, ServletException {
int red = 0;
int green = 0;
int blue = 0;
// Get color parameter and parse color
String rgb = pRequest.getParameter(RGB_PARAME);
if (rgb != null && rgb.length() >= 6 && rgb.length() <= 7) {
int index = 0;
// If the hash ('#') character is included, skip it.
if (rgb.length() == 7) {
index++;
}
try {
// Two digit hex for each color
String r = rgb.substring(index, index += 2);
red = Integer.parseInt(r, 0x10);
String g = rgb.substring(index, index += 2);
green = Integer.parseInt(g, 0x10);
String b = rgb.substring(index, index += 2);
blue = Integer.parseInt(b, 0x10);
}
catch (NumberFormatException nfe) {
log("Wrong color format for ColorDroplet: " + rgb + ". Must be RRGGBB.");
}
}
// Set MIME type for PNG
pResponse.setContentType("image/png");
ServletOutputStream out = pResponse.getOutputStream();
try {
// Write header (and palette chunk length)
out.write(PNG_IMG, 0, PLTE_CHUNK_START);
// Create palette chunk, excl lenght, and write
byte[] palette = makePalette(red, green, blue);
out.write(palette);
// Write image data until end
int pos = PLTE_CHUNK_START + PLTE_CHUNK_LENGTH + 4;
out.write(PNG_IMG, pos, PNG_IMG.length - pos);
}
finally {
out.flush();
}
} | java |
public static String getParameter(final ServletRequest pReq, final String pName, final String pDefault) {
String str = pReq.getParameter(pName);
return str != null ? str : pDefault;
} | java |
static <T> T getParameter(final ServletRequest pReq, final String pName, final Class<T> pType, final String pFormat, final T pDefault) {
// Test if pDefault is either null or instance of pType
if (pDefault != null && !pType.isInstance(pDefault)) {
throw new IllegalArgumentException("default value not instance of " + pType + ": " + pDefault.getClass());
}
String str = pReq.getParameter(pName);
if (str == null) {
return pDefault;
}
try {
return pType.cast(Converter.getInstance().toObject(str, pType, pFormat));
}
catch (ConversionException ce) {
return pDefault;
}
} | java |
static String getScriptName(final HttpServletRequest pRequest) {
String requestURI = pRequest.getRequestURI();
return StringUtil.getLastElement(requestURI, "/");
} | java |
public static String getSessionId(final HttpServletRequest pRequest) {
HttpSession session = pRequest.getSession();
return (session != null) ? session.getId() : null;
} | java |
protected static Object toUpper(final Object pObject) {
if (pObject instanceof String) {
return ((String) pObject).toUpperCase();
}
return pObject;
} | java |
private static long scanForSequence(final ImageInputStream pStream, final byte[] pSequence) throws IOException {
long start = -1l;
int index = 0;
int nullBytes = 0;
for (int read; (read = pStream.read()) >= 0;) {
if (pSequence[index] == (byte) read) {
// If this is the first byte in the sequence, store position
if (start == -1) {
start = pStream.getStreamPosition() - 1;
}
// Inside the sequence, there might be 1 or 3 null bytes, depending on 16/32 byte encoding
if (nullBytes == 1 || nullBytes == 3) {
pStream.skipBytes(nullBytes);
}
index++;
// If we found the entire sequence, we're done, return start position
if (index == pSequence.length) {
return start;
}
}
else if (index == 1 && read == 0 && nullBytes < 3) {
// Skip 1 or 3 null bytes for 16/32 bit encoding
nullBytes++;
}
else if (index != 0) {
// Start over
index = 0;
start = -1;
nullBytes = 0;
}
}
return -1l;
} | java |
private static InputStream getResourceAsStream(ClassLoader pClassLoader, String pName, boolean pGuessSuffix) {
InputStream is;
if (!pGuessSuffix) {
is = pClassLoader.getResourceAsStream(pName);
// If XML, wrap stream
if (is != null && pName.endsWith(XML_PROPERTIES)) {
is = new XMLPropertiesInputStream(is);
}
}
else {
// Try normal properties
is = pClassLoader.getResourceAsStream(pName + STD_PROPERTIES);
// Try XML
if (is == null) {
is = pClassLoader.getResourceAsStream(pName + XML_PROPERTIES);
// Wrap stream
if (is != null) {
is = new XMLPropertiesInputStream(is);
}
}
}
// Return stream
return is;
} | java |
private static InputStream getFileAsStream(String pName, boolean pGuessSuffix) {
InputStream is = null;
File propertiesFile;
try {
if (!pGuessSuffix) {
// Get file
propertiesFile = new File(pName);
if (propertiesFile.exists()) {
is = new FileInputStream(propertiesFile);
// If XML, wrap stream
if (pName.endsWith(XML_PROPERTIES)) {
is = new XMLPropertiesInputStream(is);
}
}
}
else {
// Try normal properties
propertiesFile = new File(pName + STD_PROPERTIES);
if (propertiesFile.exists()) {
is = new FileInputStream(propertiesFile);
}
else {
// Try XML
propertiesFile = new File(pName + XML_PROPERTIES);
if (propertiesFile.exists()) {
// Wrap stream
is = new XMLPropertiesInputStream(new FileInputStream(propertiesFile));
}
}
}
}
catch (FileNotFoundException fnf) {
// Should not happen, as we always test that the file .exists()
// before creating InputStream
// assert false;
}
return is;
} | java |
private static Properties loadProperties(InputStream pInput)
throws IOException {
if (pInput == null) {
throw new IllegalArgumentException("InputStream == null!");
}
Properties mapping = new Properties();
/*if (pInput instanceof XMLPropertiesInputStream) {
mapping = new XMLProperties();
}
else {
mapping = new Properties();
}*/
// Load the properties
mapping.load(pInput);
return mapping;
} | java |
private static char initMaxDelimiter(char[] pDelimiters) {
if (pDelimiters == null) {
return 0;
}
char max = 0;
for (char c : pDelimiters) {
if (max < c) {
max = c;
}
}
return max;
} | java |
private Rectangle getPICTFrame() throws IOException {
if (frame == null) {
// Read in header information
readPICTHeader(imageInput);
if (DEBUG) {
System.out.println("Done reading PICT header!");
}
}
return frame;
} | java |
private void readPICTHeader(final ImageInputStream pStream) throws IOException {
pStream.seek(0l);
try {
readPICTHeader0(pStream);
}
catch (IIOException e) {
// Rest and try again
pStream.seek(0l);
// Skip first 512 bytes
PICTImageReaderSpi.skipNullHeader(pStream);
readPICTHeader0(pStream);
}
} | java |
private void readRectangle(DataInput pStream, Rectangle pDestRect) throws IOException {
int y = pStream.readUnsignedShort();
int x = pStream.readUnsignedShort();
int h = pStream.readUnsignedShort();
int w = pStream.readUnsignedShort();
pDestRect.setLocation(getXPtCoord(x), getYPtCoord(y));
pDestRect.setSize(getXPtCoord(w - x), getYPtCoord(h - y));
} | java |
private Polygon readPoly(DataInput pStream, Rectangle pBounds) throws IOException {
// Get polygon data size
int size = pStream.readUnsignedShort();
// Get poly bounds
readRectangle(pStream, pBounds);
// Initialize the point array to the right size
int points = (size - 10) / 4;
// Get the rest of the polygon points
Polygon polygon = new Polygon();
for (int i = 0; i < points; i++) {
int y = getYPtCoord(pStream.readShort());
int x = getXPtCoord(pStream.readShort());
polygon.addPoint(x, y);
}
if (!pBounds.contains(polygon.getBounds())) {
processWarningOccurred("Bad poly, contains point(s) out of bounds " + pBounds + ": " + polygon);
}
return polygon;
} | java |
public void setMaxConcurrentThreadCount(String pMaxConcurrentThreadCount) {
if (!StringUtil.isEmpty(pMaxConcurrentThreadCount)) {
try {
maxConcurrentThreadCount = Integer.parseInt(pMaxConcurrentThreadCount);
}
catch (NumberFormatException nfe) {
// Use default
}
}
} | java |
private String getContentType(HttpServletRequest pRequest) {
if (responseMessageTypes != null) {
String accept = pRequest.getHeader("Accept");
for (String type : responseMessageTypes) {
// Note: This is not 100% correct way of doing content negotiation
// But we just want a compatible result, quick, so this is okay
if (StringUtil.contains(accept, type)) {
return type;
}
}
}
// If none found, return default
return DEFAULT_TYPE;
} | java |
private String getMessage(String pContentType) {
String fileName = responseMessageNames.get(pContentType);
// Get cached value
CacheEntry entry = responseCache.get(fileName);
if ((entry == null) || entry.isExpired()) {
// Create and add or replace cached value
entry = new CacheEntry(readMessage(fileName));
responseCache.put(fileName, entry);
}
// Return value
return (entry.getValue() != null)
? (String) entry.getValue()
: DEFUALT_RESPONSE_MESSAGE;
} | java |
private String readMessage(String pFileName) {
try {
// Read resource from web app
InputStream is = getServletContext().getResourceAsStream(pFileName);
if (is != null) {
return new String(FileUtil.read(is));
}
else {
log("File not found: " + pFileName);
}
}
catch (IOException ioe) {
log("Error reading file: " + pFileName + " (" + ioe.getMessage() + ")");
}
return null;
} | java |
public void init() throws ServletException {
FilterConfig config = getFilterConfig();
// Default don't delete cache files on exit (persistent cache)
boolean deleteCacheOnExit = "TRUE".equalsIgnoreCase(config.getInitParameter("deleteCacheOnExit"));
// Default expiry time 10 minutes
int expiryTime = 10 * 60 * 1000;
String expiryTimeStr = config.getInitParameter("expiryTime");
if (!StringUtil.isEmpty(expiryTimeStr)) {
try {
// TODO: This is insane.. :-P Let the expiry time be in minutes or seconds..
expiryTime = Integer.parseInt(expiryTimeStr);
}
catch (NumberFormatException e) {
throw new ServletConfigException("Could not parse expiryTime: " + e.toString(), e);
}
}
// Default max mem cache size 10 MB
int memCacheSize = 10;
String memCacheSizeStr = config.getInitParameter("memCacheSize");
if (!StringUtil.isEmpty(memCacheSizeStr)) {
try {
memCacheSize = Integer.parseInt(memCacheSizeStr);
}
catch (NumberFormatException e) {
throw new ServletConfigException("Could not parse memCacheSize: " + e.toString(), e);
}
}
int maxCachedEntites = 10000;
try {
cache = new HTTPCache(
getTempFolder(),
expiryTime,
memCacheSize * 1024 * 1024,
maxCachedEntites,
deleteCacheOnExit,
new ServletContextLoggerAdapter(getFilterName(), getServletContext())
) {
@Override
protected File getRealFile(CacheRequest pRequest) {
String contextRelativeURI = ServletUtil.getContextRelativeURI(((ServletCacheRequest) pRequest).getRequest());
String path = getServletContext().getRealPath(contextRelativeURI);
if (path != null) {
return new File(path);
}
return null;
}
};
log("Created cache: " + cache);
}
catch (IllegalArgumentException e) {
throw new ServletConfigException("Could not create cache: " + e.toString(), e);
}
} | java |
protected Entry<K, V> removeEntry(Entry<K, V> pEntry) {
if (pEntry == null) {
return null;
}
// Find candidate entry for this key
Entry<K, V> candidate = getEntry(pEntry.getKey());
if (candidate == pEntry || (candidate != null && candidate.equals(pEntry))) {
// Remove
remove(pEntry.getKey());
return pEntry;
}
return null;
} | java |
public void writeHtml(JspWriter pOut, String pHtml) throws IOException {
StringTokenizer parser = new StringTokenizer(pHtml, "<>&", true);
while (parser.hasMoreTokens()) {
String token = parser.nextToken();
if (token.equals("<")) {
pOut.print("<");
}
else if (token.equals(">")) {
pOut.print(">");
}
else if (token.equals("&")) {
pOut.print("&");
}
else {
pOut.print(token);
}
}
} | java |
public String getInitParameter(String pName, int pScope) {
switch (pScope) {
case PageContext.PAGE_SCOPE:
return getServletConfig().getInitParameter(pName);
case PageContext.APPLICATION_SCOPE:
return getServletContext().getInitParameter(pName);
default:
throw new IllegalArgumentException("Illegal scope.");
}
} | java |
public Enumeration getInitParameterNames(int pScope) {
switch (pScope) {
case PageContext.PAGE_SCOPE:
return getServletConfig().getInitParameterNames();
case PageContext.APPLICATION_SCOPE:
return getServletContext().getInitParameterNames();
default:
throw new IllegalArgumentException("Illegal scope");
}
} | java |
public InputStream getResourceAsStream(String pPath) {
//throws MalformedURLException {
String path = pPath;
if (pPath != null && !pPath.startsWith("/")) {
path = getContextPath() + pPath;
}
return pageContext.getServletContext().getResourceAsStream(path);
} | java |
public static boolean isCS_sRGB(final ICC_Profile profile) {
Validate.notNull(profile, "profile");
return profile.getColorSpaceType() == ColorSpace.TYPE_RGB && Arrays.equals(getProfileHeaderWithProfileId(profile), sRGB.header);
} | java |
public Object toObject(String pString, Class pType, String pFormat) throws ConversionException {
if (StringUtil.isEmpty(pString))
return null;
try {
DateFormat format;
if (pFormat == null) {
// Use system default format, using default locale
format = DateFormat.getDateTimeInstance();
}
else {
// Get format from cache
format = getDateFormat(pFormat);
}
Date date = StringUtil.toDate(pString, format);
// Allow for conversion to Date subclasses (ie. java.sql.*)
if (pType != Date.class) {
try {
date = (Date) BeanUtil.createInstance(pType, new Long(date.getTime()));
}
catch (ClassCastException e) {
throw new TypeMismathException(pType);
}
catch (InvocationTargetException e) {
throw new ConversionException(e);
}
}
return date;
}
catch (RuntimeException rte) {
throw new ConversionException(rte);
}
} | java |
private static int[] toRGBArray(int pARGB, int[] pBuffer) {
pBuffer[0] = ((pARGB & 0x00ff0000) >> 16);
pBuffer[1] = ((pARGB & 0x0000ff00) >> 8);
pBuffer[2] = ((pARGB & 0x000000ff));
//pBuffer[3] = ((pARGB & 0xff000000) >> 24); // alpha
return pBuffer;
} | java |
protected RenderedImage doFilter(BufferedImage pImage, ServletRequest pRequest, ImageServletResponse pResponse) {
// Get quality setting
// SMOOTH | FAST | REPLICATE | DEFAULT | AREA_AVERAGING
// See Image (mHints)
int quality = getQuality(pRequest.getParameter(PARAM_SCALE_QUALITY));
// Get units, default is pixels
// PIXELS | PERCENT | METRIC | INCHES
int units = getUnits(pRequest.getParameter(PARAM_SCALE_UNITS));
if (units == UNITS_UNKNOWN) {
log("Unknown units for scale, returning original.");
return pImage;
}
// Use uniform scaling? Default is true
boolean uniformScale = ServletUtil.getBooleanParameter(pRequest, PARAM_SCALE_UNIFORM, true);
// Get dimensions
int width = ServletUtil.getIntParameter(pRequest, PARAM_SCALE_X, -1);
int height = ServletUtil.getIntParameter(pRequest, PARAM_SCALE_Y, -1);
// Get dimensions for scaled image
Dimension dim = getDimensions(pImage, width, height, units, uniformScale);
width = (int) dim.getWidth();
height = (int) dim.getHeight();
// Return scaled instance directly
return ImageUtil.createScaled(pImage, width, height, quality);
} | java |
protected int getQuality(String pQualityStr) {
if (!StringUtil.isEmpty(pQualityStr)) {
try {
// Get quality constant from Image using reflection
Class cl = Image.class;
Field field = cl.getField(pQualityStr.toUpperCase());
return field.getInt(null);
}
catch (IllegalAccessException ia) {
log("Unable to get quality.", ia);
}
catch (NoSuchFieldException nsf) {
log("Unable to get quality.", nsf);
}
}
return defaultScaleQuality;
} | java |
protected int getUnits(String pUnitStr) {
if (StringUtil.isEmpty(pUnitStr)
|| pUnitStr.equalsIgnoreCase("PIXELS")) {
return UNITS_PIXELS;
}
else if (pUnitStr.equalsIgnoreCase("PERCENT")) {
return UNITS_PERCENT;
}
else {
return UNITS_UNKNOWN;
}
} | java |
private int getHuffmanValue(final int table[], final int temp[], final int index[]) throws IOException {
int code, input;
final int mask = 0xFFFF;
if (index[0] < 8) {
temp[0] <<= 8;
input = this.input.readUnsignedByte();
if (input == 0xFF) {
marker = this.input.readUnsignedByte();
if (marker != 0) {
markerIndex = 9;
}
}
temp[0] |= input;
}
else {
index[0] -= 8;
}
code = table[temp[0] >> index[0]];
if ((code & MSB) != 0) {
if (markerIndex != 0) {
markerIndex = 0;
return 0xFF00 | marker;
}
temp[0] &= (mask >> (16 - index[0]));
temp[0] <<= 8;
input = this.input.readUnsignedByte();
if (input == 0xFF) {
marker = this.input.readUnsignedByte();
if (marker != 0) {
markerIndex = 9;
}
}
temp[0] |= input;
code = table[((code & 0xFF) * 256) + (temp[0] >> index[0])];
index[0] += 8;
}
index[0] += 8 - (code >> 8);
if (index[0] < 0) {
throw new IIOException("index=" + index[0] + " temp=" + temp[0] + " code=" + code + " in HuffmanValue()");
}
if (index[0] < markerIndex) {
markerIndex = 0;
return 0xFF00 | marker;
}
temp[0] &= (mask >> (16 - index[0]));
return code & 0xFF;
} | java |
public void write(final byte[] pBytes, final int pOffset, final int pLength) throws IOException {
if (!flushOnWrite && pLength < buffer.remaining()) {
// Buffer data
buffer.put(pBytes, pOffset, pLength);
}
else {
// Encode data already in the buffer
encodeBuffer();
// Encode rest without buffering
encoder.encode(out, ByteBuffer.wrap(pBytes, pOffset, pLength));
}
} | java |
private static URL getURLAndSetAuthorization(final String pURL, final Properties pProperties) throws MalformedURLException {
String url = pURL;
// Split user/password away from url
String userPass = null;
String protocolPrefix = HTTP;
int httpIdx = url.indexOf(HTTPS);
if (httpIdx >= 0) {
protocolPrefix = HTTPS;
url = url.substring(httpIdx + HTTPS.length());
}
else {
httpIdx = url.indexOf(HTTP);
if (httpIdx >= 0) {
url = url.substring(httpIdx + HTTP.length());
}
}
// Get authorization part
int atIdx = url.indexOf("@");
if (atIdx >= 0) {
userPass = url.substring(0, atIdx);
url = url.substring(atIdx + 1);
}
// Set authorization if user/password is present
if (userPass != null) {
// System.out.println("Setting password ("+ userPass + ")!");
pProperties.setProperty("Authorization", "Basic " + BASE64.encode(userPass.getBytes()));
}
// Return URL
return new URL(protocolPrefix + url);
} | java |
public static HttpURLConnection createHttpURLConnection(URL pURL, Properties pProperties, boolean pFollowRedirects, int pTimeout)
throws IOException {
// Open the connection, and get the stream
HttpURLConnection conn;
if (pTimeout > 0) {
// Supports timeout
conn = new com.twelvemonkeys.net.HttpURLConnection(pURL, pTimeout);
}
else {
// Faster, more compatible
conn = (HttpURLConnection) pURL.openConnection();
}
// Set user agent
if ((pProperties == null) || !pProperties.containsKey("User-Agent")) {
conn.setRequestProperty("User-Agent",
VERSION_ID
+ " (" + System.getProperty("os.name") + "/" + System.getProperty("os.version") + "; "
+ System.getProperty("os.arch") + "; "
+ System.getProperty("java.vm.name") + "/" + System.getProperty("java.vm.version") + ")");
}
// Set request properties
if (pProperties != null) {
for (Map.Entry<Object, Object> entry : pProperties.entrySet()) {
// Properties key/values can be safely cast to strings
conn.setRequestProperty((String) entry.getKey(), entry.getValue().toString());
}
}
try {
// Breaks with JRE1.2?
conn.setInstanceFollowRedirects(pFollowRedirects);
}
catch (LinkageError le) {
// This is the best we can do...
HttpURLConnection.setFollowRedirects(pFollowRedirects);
System.err.println("You are using an old Java Spec, consider upgrading.");
System.err.println("java.net.HttpURLConnection.setInstanceFollowRedirects(" + pFollowRedirects + ") failed.");
//le.printStackTrace(System.err);
}
conn.setDoInput(true);
conn.setDoOutput(true);
//conn.setUseCaches(true);
return conn;
} | java |
public static String encode(byte[] pData) {
int offset = 0;
int len;
StringBuilder buf = new StringBuilder();
while ((pData.length - offset) > 0) {
byte a, b, c;
if ((pData.length - offset) > 2) {
len = 3;
}
else {
len = pData.length - offset;
}
switch (len) {
case 1:
a = pData[offset];
b = 0;
buf.append(PEM_ARRAY[(a >>> 2) & 0x3F]);
buf.append(PEM_ARRAY[((a << 4) & 0x30) + ((b >>> 4) & 0xf)]);
buf.append('=');
buf.append('=');
offset++;
break;
case 2:
a = pData[offset];
b = pData[offset + 1];
c = 0;
buf.append(PEM_ARRAY[(a >>> 2) & 0x3F]);
buf.append(PEM_ARRAY[((a << 4) & 0x30) + ((b >>> 4) & 0xf)]);
buf.append(PEM_ARRAY[((b << 2) & 0x3c) + ((c >>> 6) & 0x3)]);
buf.append('=');
offset += offset + 2; // ???
break;
default:
a = pData[offset];
b = pData[offset + 1];
c = pData[offset + 2];
buf.append(PEM_ARRAY[(a >>> 2) & 0x3F]);
buf.append(PEM_ARRAY[((a << 4) & 0x30) + ((b >>> 4) & 0xf)]);
buf.append(PEM_ARRAY[((b << 2) & 0x3c) + ((c >>> 6) & 0x3)]);
buf.append(PEM_ARRAY[c & 0x3F]);
offset = offset + 3;
break;
}
}
return buf.toString();
} | java |
public void setSourceSubsampling(int pXSub, int pYSub) {
// Re-fetch everything, if subsampling changed
if (xSub != pXSub || ySub != pYSub) {
dispose();
}
if (pXSub > 1) {
xSub = pXSub;
}
if (pYSub > 1) {
ySub = pYSub;
}
} | java |
public void addProgressListener(ProgressListener pListener) {
if (pListener == null) {
return;
}
if (listeners == null) {
listeners = new CopyOnWriteArrayList<ProgressListener>();
}
listeners.add(pListener);
} | java |
public void removeProgressListener(ProgressListener pListener) {
if (pListener == null) {
return;
}
if (listeners == null) {
return;
}
listeners.remove(pListener);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.