code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public static List<String> readLines(File file, Charset charset) throws IOException {
// don't use asCharSource(file, charset).readLines() because that returns
// an immutable list, which would change the behavior of this method
return readLines(
file,
charset,
new LineProcessor<List<String>>() {
final List<String> result = Lists.newArrayList();
@Override
public boolean processLine(String line) {
result.add(line);
return true;
}
@Override
public List<String> getResult() {
return result;
}
});
} | java |
@CanIgnoreReturnValue // some processors won't return a useful result
public static <T> T readBytes(File file, ByteProcessor<T> processor) throws IOException {
return asByteSource(file).read(processor);
} | java |
static Expression decomposeCondition(Expression e,
HsqlArrayList conditions) {
if (e == null) {
return Expression.EXPR_TRUE;
}
Expression arg1 = e.getLeftNode();
Expression arg2 = e.getRightNode();
int type = e.getType();
if (type == OpTypes.AND) {
arg1 = decomposeCondition(arg1, conditions);
arg2 = decomposeCondition(arg2, conditions);
if (arg1 == Expression.EXPR_TRUE) {
return arg2;
}
if (arg2 == Expression.EXPR_TRUE) {
return arg1;
}
e.setLeftNode(arg1);
e.setRightNode(arg2);
return e;
} else if (type == OpTypes.EQUAL) {
if (arg1.getType() == OpTypes.ROW
&& arg2.getType() == OpTypes.ROW) {
for (int i = 0; i < arg1.nodes.length; i++) {
Expression part = new ExpressionLogical(arg1.nodes[i],
arg2.nodes[i]);
part.resolveTypes(null, null);
conditions.add(part);
}
return Expression.EXPR_TRUE;
}
}
if (e != Expression.EXPR_TRUE) {
conditions.add(e);
}
return Expression.EXPR_TRUE;
} | java |
void assignToLists() {
int lastOuterIndex = -1;
for (int i = 0; i < rangeVariables.length; i++) {
if (rangeVariables[i].isLeftJoin
|| rangeVariables[i].isRightJoin) {
lastOuterIndex = i;
}
if (lastOuterIndex == i) {
joinExpressions[i].addAll(tempJoinExpressions[i]);
} else {
for (int j = 0; j < tempJoinExpressions[i].size(); j++) {
assignToLists((Expression) tempJoinExpressions[i].get(j),
joinExpressions, lastOuterIndex + 1);
}
}
}
for (int i = 0; i < queryExpressions.size(); i++) {
assignToLists((Expression) queryExpressions.get(i),
whereExpressions, lastOuterIndex);
}
} | java |
void assignToLists(Expression e, HsqlArrayList[] expressionLists,
int first) {
set.clear();
e.collectRangeVariables(rangeVariables, set);
int index = rangeVarSet.getLargestIndex(set);
// condition is independent of tables if no range variable is found
if (index == -1) {
index = 0;
}
// condition is assigned to first non-outer range variable
if (index < first) {
index = first;
}
expressionLists[index].add(e);
} | java |
void assignToRangeVariables() {
for (int i = 0; i < rangeVariables.length; i++) {
boolean isOuter = rangeVariables[i].isLeftJoin
|| rangeVariables[i].isRightJoin;
if (isOuter) {
assignToRangeVariable(rangeVariables[i], i,
joinExpressions[i], true);
assignToRangeVariable(rangeVariables[i], i,
whereExpressions[i], false);
} else {
joinExpressions[i].addAll(whereExpressions[i]);
assignToRangeVariable(rangeVariables[i], i,
joinExpressions[i], true);
}
// A VoltDB extension to disable
// Turn off some weird rewriting of in expressions based on index support for the query.
// This makes it simpler to parse on the VoltDB side,
// at the expense of HSQL performance.
// Also fixed an apparent join/where confusion?
if (inExpressions[i] != null) {
if (!flags[i] && isOuter) {
rangeVariables[i].addJoinCondition(inExpressions[i]);
} else {
rangeVariables[i].addWhereCondition(inExpressions[i]);
}
/* disable 7 lines ...
if (rangeVariables[i].hasIndexCondition()
&& inExpressions[i] != null) {
if (!flags[i] && isOuter) {
rangeVariables[i].addWhereCondition(inExpressions[i]);
} else {
rangeVariables[i].addJoinCondition(inExpressions[i]);
}
... disabled 7 lines */
// End of VoltDB extension
inExpressions[i] = null;
inExpressionCount--;
}
}
if (inExpressionCount != 0) {
// A VoltDB extension to disable
// This will never be called because of the change made to the block above
assert(false);
// End of VoltDB extension
setInConditionsAsTables();
}
} | java |
void setInConditionsAsTables() {
for (int i = rangeVariables.length - 1; i >= 0; i--) {
RangeVariable rangeVar = rangeVariables[i];
Expression in = inExpressions[i];
if (in != null) {
Index index = rangeVar.rangeTable.getIndexForColumn(
in.getLeftNode().nodes[0].getColumnIndex());
RangeVariable newRangeVar =
new RangeVariable(in.getRightNode().subQuery.getTable(),
null, null, null, compileContext);
RangeVariable[] newList =
new RangeVariable[rangeVariables.length + 1];
ArrayUtil.copyAdjustArray(rangeVariables, newList,
newRangeVar, i, 1);
rangeVariables = newList;
// make two columns as arg
ColumnSchema left = rangeVar.rangeTable.getColumn(
in.getLeftNode().nodes[0].getColumnIndex());
ColumnSchema right = newRangeVar.rangeTable.getColumn(0);
Expression e = new ExpressionLogical(rangeVar, left,
newRangeVar, right);
rangeVar.addIndexCondition(e, index, flags[i]);
}
}
} | java |
public static LargeBlockTask getStoreTask(BlockId blockId, ByteBuffer block) {
return new LargeBlockTask() {
@Override
public LargeBlockResponse call() throws Exception {
Exception theException = null;
try {
LargeBlockManager.getInstance().storeBlock(blockId, block);
}
catch (Exception exc) {
theException = exc;
}
return new LargeBlockResponse(theException);
}
};
} | java |
public static LargeBlockTask getReleaseTask(BlockId blockId) {
return new LargeBlockTask() {
@Override
public LargeBlockResponse call() throws Exception {
Exception theException = null;
try {
LargeBlockManager.getInstance().releaseBlock(blockId);
}
catch (Exception exc) {
theException = exc;
}
return new LargeBlockResponse(theException);
}
};
} | java |
public static LargeBlockTask getLoadTask(BlockId blockId, ByteBuffer block) {
return new LargeBlockTask() {
@Override
public LargeBlockResponse call() throws Exception {
Exception theException = null;
try {
LargeBlockManager.getInstance().loadBlock(blockId, block);
}
catch (Exception exc) {
theException = exc;
}
return new LargeBlockResponse(theException);
}
};
} | java |
public static <T, U> Pair<T, U> of(T x, U y) {
return new Pair<T, U>(x, y);
} | java |
public static Routine newRoutine(Method method) {
Routine routine = new Routine(SchemaObject.FUNCTION);
int offset = 0;
Class[] params = method.getParameterTypes();
String className = method.getDeclaringClass().getName();
StringBuffer sb = new StringBuffer();
sb.append("CLASSPATH:");
sb.append(method.getDeclaringClass().getName()).append('.');
sb.append(method.getName());
if (params.length > 0 && params[0].equals(java.sql.Connection.class)) {
offset = 1;
}
String name = sb.toString();
if (className.equals("org.hsqldb_voltpatches.Library")
|| className.equals("java.lang.Math")) {
routine.isLibraryRoutine = true;
}
for (int j = offset; j < params.length; j++) {
Type methodParamType = Type.getDefaultTypeWithSize(
Types.getParameterSQLTypeNumber(params[j]));
ColumnSchema param = new ColumnSchema(null, methodParamType,
!params[j].isPrimitive(),
false, null);
routine.addParameter(param);
}
routine.setLanguage(Routine.LANGUAGE_JAVA);
routine.setMethod(method);
routine.setMethodURL(name);
routine.setDataImpact(Routine.NO_SQL);
Type methodReturnType = Type.getDefaultTypeWithSize(
Types.getParameterSQLTypeNumber(method.getReturnType()));
routine.javaMethodWithConnection = offset == 1;;
routine.setReturnType(methodReturnType);
routine.resolve();
return routine;
} | java |
public ByteBuffer saveToBuffer(InstanceId instId)
throws IOException
{
if (instId == null) {
throw new IOException("Null instance ID.");
}
if (m_serData == null) {
throw new IOException("Uninitialized hashinator snapshot data.");
}
// Assume config data is the last field.
ByteBuffer buf = ByteBuffer.allocate(m_serData.length + OFFSET_DATA);
// Make sure the CRC starts at zero since those bytes figure into the CRC calculation.
buf.putLong(OFFSET_CRC, 0);
buf.putInt(OFFSET_INSTID_COORD, instId.getCoord());
buf.putLong(OFFSET_INSTID_TIMESTAMP, instId.getTimestamp());
buf.putLong(OFFSET_VERSION, m_version);
buf.position(OFFSET_DATA);
buf.put(m_serData);
// Finalize the CRC based on the entire buffer and reset the current position.
final PureJavaCrc32 crc = new PureJavaCrc32();
crc.update(buf.array());
buf.putLong(OFFSET_CRC, crc.getValue());
buf.rewind();
return buf;
} | java |
public InstanceId restoreFromBuffer(ByteBuffer buf)
throws IOException
{
buf.rewind();
// Assumes config data is the last field.
int dataSize = buf.remaining() - OFFSET_DATA;
if (dataSize <= 0) {
throw new IOException("Hashinator snapshot data is too small.");
}
// Get the CRC, zero out its buffer field, and compare to calculated CRC.
long crcHeader = buf.getLong(OFFSET_CRC);
buf.putLong(OFFSET_CRC, 0);
final PureJavaCrc32 crcBuffer = new PureJavaCrc32();
assert(buf.hasArray());
crcBuffer.update(buf.array());
if (crcHeader != crcBuffer.getValue()) {
throw new IOException("Hashinator snapshot data CRC mismatch.");
}
// Slurp the data.
int coord = buf.getInt(OFFSET_INSTID_COORD);
long timestamp = buf.getLong(OFFSET_INSTID_TIMESTAMP);
InstanceId instId = new InstanceId(coord, timestamp);
m_version = buf.getLong(OFFSET_VERSION);
m_serData = new byte[dataSize];
buf.position(OFFSET_DATA);
buf.get(m_serData);
return instId;
} | java |
public void restoreFromFile(File file) throws IOException
{
byte[] rawData = new byte[(int) file.length()];
ByteBuffer bufData = null;
FileInputStream fis = null;
DataInputStream dis = null;
try {
fis = new FileInputStream(file);
dis = new DataInputStream(fis);
dis.readFully(rawData);
bufData = ByteBuffer.wrap(rawData);
restoreFromBuffer(bufData);
}
finally {
if (dis != null) {
dis.close();
}
if (fis != null) {
fis.close();
}
}
} | java |
public static File createFileForSchema(String ddlText) throws IOException {
File temp = File.createTempFile("literalschema", ".sql");
temp.deleteOnExit();
FileWriter out = new FileWriter(temp);
out.write(ddlText);
out.close();
return temp;
} | java |
public void addLiteralSchema(String ddlText) throws IOException {
File temp = createFileForSchema(ddlText);
addSchema(URLEncoder.encode(temp.getAbsolutePath(), "UTF-8"));
} | java |
public void addStmtProcedure(String name, String sql, String partitionInfoString) {
addProcedures(new ProcedureInfo(new String[0], name, sql,
ProcedurePartitionData.fromPartitionInfoString(partitionInfoString)));
} | java |
public static byte[] hexStringToByteArray(String s) throws IOException {
int l = s.length();
byte[] data = new byte[l / 2 + (l % 2)];
int n,
b = 0;
boolean high = true;
int i = 0;
for (int j = 0; j < l; j++) {
char c = s.charAt(j);
if (c == ' ') {
continue;
}
n = getNibble(c);
if (n == -1) {
throw new IOException(
"hexadecimal string contains non hex character"); //NOI18N
}
if (high) {
b = (n & 0xf) << 4;
high = false;
} else {
b += (n & 0xf);
high = true;
data[i++] = (byte) b;
}
}
if (!high) {
throw new IOException(
"hexadecimal string with odd number of characters"); //NOI18N
}
if (i < data.length) {
data = (byte[]) ArrayUtil.resizeArray(data, i);
}
return data;
} | java |
public static BitMap sqlBitStringToBitMap(String s) throws IOException {
int l = s.length();
int n;
int bitIndex = 0;
BitMap map = new BitMap(l);
for (int j = 0; j < l; j++) {
char c = s.charAt(j);
if (c == ' ') {
continue;
}
n = getNibble(c);
if (n != 0 && n != 1) {
throw new IOException(
"hexadecimal string contains non hex character"); //NOI18N
}
if (n == 1) {
map.set(bitIndex);
}
bitIndex++;
}
map.setSize(bitIndex);
return map;
} | java |
public static String byteArrayToBitString(byte[] bytes, int bitCount) {
char[] s = new char[bitCount];
for (int j = 0; j < bitCount; j++) {
byte b = bytes[j / 8];
s[j] = BitMap.isSet(b, j % 8) ? '1'
: '0';
}
return new String(s);
} | java |
public static String byteArrayToSQLBitString(byte[] bytes, int bitCount) {
char[] s = new char[bitCount + 3];
s[0] = 'B';
s[1] = '\'';
int pos = 2;
for (int j = 0; j < bitCount; j++) {
byte b = bytes[j / 8];
s[pos++] = BitMap.isSet(b, j % 8) ? '1'
: '0';
}
s[pos] = '\'';
return new String(s);
} | java |
public static void writeHexBytes(byte[] o, int from, byte[] b) {
int len = b.length;
for (int i = 0; i < len; i++) {
int c = ((int) b[i]) & 0xff;
o[from++] = HEXBYTES[c >> 4 & 0xf];
o[from++] = HEXBYTES[c & 0xf];
}
} | java |
public static int stringToUTFBytes(String str,
HsqlByteArrayOutputStream out) {
int strlen = str.length();
int c,
count = 0;
if (out.count + strlen + 8 > out.buffer.length) {
out.ensureRoom(strlen + 8);
}
char[] arr = str.toCharArray();
for (int i = 0; i < strlen; i++) {
c = arr[i];
if (c >= 0x0001 && c <= 0x007F) {
out.buffer[out.count++] = (byte) c;
count++;
} else if (c > 0x07FF) {
out.buffer[out.count++] = (byte) (0xE0 | ((c >> 12) & 0x0F));
out.buffer[out.count++] = (byte) (0x80 | ((c >> 6) & 0x3F));
out.buffer[out.count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
count += 3;
} else {
out.buffer[out.count++] = (byte) (0xC0 | ((c >> 6) & 0x1F));
out.buffer[out.count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
count += 2;
}
if (out.count + 8 > out.buffer.length) {
out.ensureRoom(strlen - i + 8);
}
}
return count;
} | java |
public static String inputStreamToString(InputStream x,
String encoding) throws IOException {
InputStreamReader in = new InputStreamReader(x, encoding);
StringWriter writer = new StringWriter();
int blocksize = 8 * 1024;
char[] buffer = new char[blocksize];
for (;;) {
int read = in.read(buffer);
if (read == -1) {
break;
}
writer.write(buffer, 0, read);
}
writer.close();
return writer.toString();
} | java |
static int count(final String s, final char c) {
int pos = 0;
int count = 0;
if (s != null) {
while ((pos = s.indexOf(c, pos)) > -1) {
count++;
pos++;
}
}
return count;
} | java |
public static void registerLog4jMBeans() throws JMException {
if (Boolean.getBoolean("zookeeper.jmx.log4j.disable") == true) {
return;
}
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
// Create and Register the top level Log4J MBean
HierarchyDynamicMBean hdm = new HierarchyDynamicMBean();
ObjectName mbo = new ObjectName("log4j:hiearchy=default");
mbs.registerMBean(hdm, mbo);
// Add the root logger to the Hierarchy MBean
Logger rootLogger = Logger.getRootLogger();
hdm.addLoggerMBean(rootLogger.getName());
// Get each logger from the Log4J Repository and add it to
// the Hierarchy MBean created above.
LoggerRepository r = LogManager.getLoggerRepository();
Enumeration enumer = r.getCurrentLoggers();
Logger logger = null;
while (enumer.hasMoreElements()) {
logger = (Logger) enumer.nextElement();
hdm.addLoggerMBean(logger.getName());
}
} | java |
public void create(final String path, byte data[], List<ACL> acl,
CreateMode createMode, StringCallback cb, Object ctx) {
verbotenThreadCheck();
final String clientPath = path;
PathUtils.validatePath(clientPath, createMode.isSequential());
final String serverPath = prependChroot(clientPath);
RequestHeader h = new RequestHeader();
h.setType(ZooDefs.OpCode.create);
CreateRequest request = new CreateRequest();
CreateResponse response = new CreateResponse();
ReplyHeader r = new ReplyHeader();
request.setData(data);
request.setFlags(createMode.toFlag());
request.setPath(serverPath);
request.setAcl(acl);
cnxn.queuePacket(h, r, request, response, cb, clientPath, serverPath,
ctx, null);
} | java |
public void delete(final String path, int version, VoidCallback cb,
Object ctx) {
verbotenThreadCheck();
final String clientPath = path;
PathUtils.validatePath(clientPath);
final String serverPath;
// maintain semantics even in chroot case
// specifically - root cannot be deleted
// I think this makes sense even in chroot case.
if (clientPath.equals("/")) {
// a bit of a hack, but delete(/) will never succeed and ensures
// that the same semantics are maintained
serverPath = clientPath;
} else {
serverPath = prependChroot(clientPath);
}
RequestHeader h = new RequestHeader();
h.setType(ZooDefs.OpCode.delete);
DeleteRequest request = new DeleteRequest();
request.setPath(serverPath);
request.setVersion(version);
cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
serverPath, ctx, null);
} | java |
public void setData(final String path, byte data[], int version,
StatCallback cb, Object ctx) {
verbotenThreadCheck();
final String clientPath = path;
PathUtils.validatePath(clientPath);
final String serverPath = prependChroot(clientPath);
RequestHeader h = new RequestHeader();
h.setType(ZooDefs.OpCode.setData);
SetDataRequest request = new SetDataRequest();
request.setPath(serverPath);
request.setData(data);
request.setVersion(version);
SetDataResponse response = new SetDataResponse();
cnxn.queuePacket(h, new ReplyHeader(), request, response, cb,
clientPath, serverPath, ctx, null);
} | java |
public void getACL(final String path, Stat stat, ACLCallback cb, Object ctx) {
verbotenThreadCheck();
final String clientPath = path;
PathUtils.validatePath(clientPath);
final String serverPath = prependChroot(clientPath);
RequestHeader h = new RequestHeader();
h.setType(ZooDefs.OpCode.getACL);
GetACLRequest request = new GetACLRequest();
request.setPath(serverPath);
GetACLResponse response = new GetACLResponse();
cnxn.queuePacket(h, new ReplyHeader(), request, response, cb,
clientPath, serverPath, ctx, null);
} | java |
public void setACL(final String path, List<ACL> acl, int version,
StatCallback cb, Object ctx) {
verbotenThreadCheck();
final String clientPath = path;
PathUtils.validatePath(clientPath);
final String serverPath = prependChroot(clientPath);
RequestHeader h = new RequestHeader();
h.setType(ZooDefs.OpCode.setACL);
SetACLRequest request = new SetACLRequest();
request.setPath(serverPath);
request.setAcl(acl);
request.setVersion(version);
SetACLResponse response = new SetACLResponse();
cnxn.queuePacket(h, new ReplyHeader(), request, response, cb,
clientPath, serverPath, ctx, null);
} | java |
public void sync(final String path, VoidCallback cb, Object ctx) {
verbotenThreadCheck();
final String clientPath = path;
PathUtils.validatePath(clientPath);
final String serverPath = prependChroot(clientPath);
RequestHeader h = new RequestHeader();
h.setType(ZooDefs.OpCode.sync);
SyncRequest request = new SyncRequest();
SyncResponse response = new SyncResponse();
request.setPath(serverPath);
cnxn.queuePacket(h, new ReplyHeader(), request, response, cb,
clientPath, serverPath, ctx, null);
} | java |
@Override
public final boolean callProcedureWithTimeout(
ProcedureCallback callback,
int batchTimeout,
String procName,
Object... parameters)
throws IOException, NoConnectionsException
{
//Time unit doesn't matter in this case since the timeout isn't being specifie
return callProcedureWithClientTimeout(
callback,
batchTimeout,
false,
procName,
Distributer.USE_DEFAULT_CLIENT_TIMEOUT,
TimeUnit.NANOSECONDS,
parameters);
} | java |
private Object[] getUpdateCatalogParams(File catalogPath, File deploymentPath)
throws IOException {
Object[] params = new Object[2];
if (catalogPath != null) {
params[0] = ClientUtils.fileToBytes(catalogPath);
}
else {
params[0] = null;
}
if (deploymentPath != null) {
params[1] = new String(ClientUtils.fileToBytes(deploymentPath), Constants.UTF8ENCODING);
}
else {
params[1] = null;
}
return params;
} | java |
@Override
public void close() throws InterruptedException {
if (m_blessedThreadIds.contains(Thread.currentThread().getId())) {
throw new RuntimeException("Can't invoke backpressureBarrier from within the client callback thread " +
" without deadlocking the client library");
}
m_isShutdown = true;
synchronized (m_backpressureLock) {
m_backpressureLock.notifyAll();
}
if (m_reconnectStatusListener != null) {
m_distributer.removeClientStatusListener(m_reconnectStatusListener);
m_reconnectStatusListener.close();
}
if (m_ex != null) {
m_ex.shutdown();
if (CoreUtils.isJunitTest()) {
m_ex.awaitTermination(1, TimeUnit.SECONDS);
} else {
m_ex.awaitTermination(365, TimeUnit.DAYS);
}
}
m_distributer.shutdown();
ClientFactory.decreaseClientNum();
} | java |
public boolean backpressureBarrier(final long start, long timeoutNanos) throws InterruptedException {
if (m_isShutdown) {
return false;
}
if (m_blessedThreadIds.contains(Thread.currentThread().getId())) {
throw new RuntimeException("Can't invoke backpressureBarrier from within the client callback thread " +
" without deadlocking the client library");
}
if (m_backpressure) {
synchronized (m_backpressureLock) {
if (m_backpressure) {
while (m_backpressure && !m_isShutdown) {
if (start != 0) {
if (timeoutNanos <= 0) {
// timeout nano value is negative or zero, indicating it timed out.
return true;
}
//Wait on the condition for the specified timeout remaining
m_backpressureLock.wait(timeoutNanos / TimeUnit.MILLISECONDS.toNanos(1), (int)(timeoutNanos % TimeUnit.MILLISECONDS.toNanos(1)));
//Condition is true, break and return false
if (!m_backpressure) {
break;
}
//Calculate whether the timeout should be triggered
final long nowNanos = System.nanoTime();
final long deltaNanos = Math.max(1, nowNanos - start);
if (deltaNanos >= timeoutNanos) {
return true;
}
//Reassigning timeout nanos with remainder of timeout
timeoutNanos -= deltaNanos;
} else {
m_backpressureLock.wait();
}
}
}
}
}
return false;
} | java |
public Object[] readData(Type[] colTypes)
throws IOException, HsqlException {
int l = colTypes.length;
Object[] data = new Object[l];
Object o;
Type type;
for (int i = 0; i < l; i++) {
if (checkNull()) {
continue;
}
o = null;
type = colTypes[i];
switch (type.typeCode) {
case Types.SQL_ALL_TYPES :
case Types.SQL_CHAR :
case Types.SQL_VARCHAR :
case Types.VARCHAR_IGNORECASE :
o = readChar(type);
break;
case Types.TINYINT :
case Types.SQL_SMALLINT :
o = readSmallint();
break;
case Types.SQL_INTEGER :
o = readInteger();
break;
case Types.SQL_BIGINT :
o = readBigint();
break;
//fredt although REAL is now Double, it is read / written in
//the old format for compatibility
case Types.SQL_REAL :
case Types.SQL_FLOAT :
case Types.SQL_DOUBLE :
o = readReal();
break;
case Types.SQL_NUMERIC :
case Types.SQL_DECIMAL :
o = readDecimal(type);
break;
case Types.SQL_DATE :
o = readDate(type);
break;
case Types.SQL_TIME :
case Types.SQL_TIME_WITH_TIME_ZONE :
o = readTime(type);
break;
case Types.SQL_TIMESTAMP :
case Types.SQL_TIMESTAMP_WITH_TIME_ZONE :
o = readTimestamp(type);
break;
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
o = readYearMonthInterval(type);
break;
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
o = readDaySecondInterval(type);
break;
case Types.SQL_BOOLEAN :
o = readBoole();
break;
case Types.OTHER :
o = readOther();
break;
case Types.SQL_CLOB :
o = readClob();
break;
case Types.SQL_BLOB :
o = readBlob();
break;
case Types.SQL_BINARY :
case Types.SQL_VARBINARY :
o = readBinary();
break;
case Types.SQL_BIT :
case Types.SQL_BIT_VARYING :
o = readBit();
break;
default :
throw Error.runtimeError(ErrorCode.U_S0500,
"RowInputBase "
+ type.getNameString());
}
data[i] = o;
}
return data;
} | java |
public static int matchGenreDescription(String description) {
if (description != null && description.length() > 0) {
for (int i = 0; i < ID3v1Genres.GENRES.length; i++) {
if (ID3v1Genres.GENRES[i].equalsIgnoreCase(description)) {
return i;
}
}
}
return -1;
} | java |
private int measureSize(int specType, int contentSize, int measureSpec) {
int result;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
if (specMode == MeasureSpec.EXACTLY) {
result = Math.max(contentSize, specSize);
} else {
result = contentSize;
if (specType == 1) {
// width
result += (getPaddingLeft() + getPaddingRight());
} else {
// height
result += (getPaddingTop() + getPaddingBottom());
}
}
return result;
} | java |
private void initSuffixMargin() {
int defSuffixLRMargin = Utils.dp2px(mContext, DEFAULT_SUFFIX_LR_MARGIN);
boolean isSuffixLRMarginNull = true;
if (mSuffixLRMargin >= 0) {
isSuffixLRMarginNull = false;
}
if (isShowDay && mSuffixDayTextWidth > 0) {
if (mSuffixDayLeftMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixDayLeftMargin = mSuffixLRMargin;
} else {
mSuffixDayLeftMargin = defSuffixLRMargin;
}
}
if (mSuffixDayRightMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixDayRightMargin = mSuffixLRMargin;
} else {
mSuffixDayRightMargin = defSuffixLRMargin;
}
}
} else {
mSuffixDayLeftMargin = 0;
mSuffixDayRightMargin = 0;
}
if (isShowHour && mSuffixHourTextWidth > 0) {
if (mSuffixHourLeftMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixHourLeftMargin = mSuffixLRMargin;
} else {
mSuffixHourLeftMargin = defSuffixLRMargin;
}
}
if (mSuffixHourRightMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixHourRightMargin = mSuffixLRMargin;
} else {
mSuffixHourRightMargin = defSuffixLRMargin;
}
}
} else {
mSuffixHourLeftMargin = 0;
mSuffixHourRightMargin = 0;
}
if (isShowMinute && mSuffixMinuteTextWidth > 0) {
if (mSuffixMinuteLeftMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixMinuteLeftMargin = mSuffixLRMargin;
} else {
mSuffixMinuteLeftMargin = defSuffixLRMargin;
}
}
if (isShowSecond) {
if (mSuffixMinuteRightMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixMinuteRightMargin = mSuffixLRMargin;
} else {
mSuffixMinuteRightMargin = defSuffixLRMargin;
}
}
} else {
mSuffixMinuteRightMargin = 0;
}
} else {
mSuffixMinuteLeftMargin = 0;
mSuffixMinuteRightMargin = 0;
}
if (isShowSecond) {
if (mSuffixSecondTextWidth > 0) {
if (mSuffixSecondLeftMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixSecondLeftMargin = mSuffixLRMargin;
} else {
mSuffixSecondLeftMargin = defSuffixLRMargin;
}
}
if (isShowMillisecond) {
if (mSuffixSecondRightMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixSecondRightMargin = mSuffixLRMargin;
} else {
mSuffixSecondRightMargin = defSuffixLRMargin;
}
}
} else {
mSuffixSecondRightMargin = 0;
}
} else {
mSuffixSecondLeftMargin = 0;
mSuffixSecondRightMargin = 0;
}
if (isShowMillisecond && mSuffixMillisecondTextWidth > 0) {
if (mSuffixMillisecondLeftMargin < 0) {
if (!isSuffixLRMarginNull) {
mSuffixMillisecondLeftMargin = mSuffixLRMargin;
} else {
mSuffixMillisecondLeftMargin = defSuffixLRMargin;
}
}
} else {
mSuffixMillisecondLeftMargin = 0;
}
} else {
mSuffixSecondLeftMargin = 0;
mSuffixSecondRightMargin = 0;
mSuffixMillisecondLeftMargin = 0;
}
} | java |
public int getAllContentWidth() {
float width = getAllContentWidthBase(mTimeTextWidth);
if (!isConvertDaysToHours && isShowDay) {
if (isDayLargeNinetyNine) {
Rect rect = new Rect();
String tempDay = String.valueOf(mDay);
mTimeTextPaint.getTextBounds(tempDay, 0, tempDay.length(), rect);
mDayTimeTextWidth = rect.width();
width += mDayTimeTextWidth;
} else {
mDayTimeTextWidth = mTimeTextWidth;
width += mTimeTextWidth;
}
}
return (int) Math.ceil(width);
} | java |
private float initTimeTextBaselineAndTimeBgTopPadding(int viewHeight, int viewPaddingTop, int viewPaddingBottom, int contentAllHeight) {
float topPaddingSize;
if (viewPaddingTop == viewPaddingBottom) {
// center
topPaddingSize = (viewHeight - contentAllHeight) / 2;
} else {
// padding top
topPaddingSize = viewPaddingTop;
}
if (isShowDay && mSuffixDayTextWidth > 0) {
mSuffixDayTextBaseline = getSuffixTextBaseLine(mSuffixDay, topPaddingSize);
}
if (isShowHour && mSuffixHourTextWidth > 0) {
mSuffixHourTextBaseline = getSuffixTextBaseLine(mSuffixHour, topPaddingSize);
}
if (isShowMinute && mSuffixMinuteTextWidth > 0) {
mSuffixMinuteTextBaseline = getSuffixTextBaseLine(mSuffixMinute, topPaddingSize);
}
if (mSuffixSecondTextWidth > 0) {
mSuffixSecondTextBaseline = getSuffixTextBaseLine(mSuffixSecond, topPaddingSize);
}
if (isShowMillisecond && mSuffixMillisecondTextWidth > 0) {
mSuffixMillisecondTextBaseline = getSuffixTextBaseLine(mSuffixMillisecond, topPaddingSize);
}
return topPaddingSize;
} | java |
public int filterRGB(int pX, int pY, int pARGB) {
// Get color components
int r = pARGB >> 16 & 0xFF;
int g = pARGB >> 8 & 0xFF;
int b = pARGB & 0xFF;
// Scale to new contrast
r = LUT[r];
g = LUT[g];
b = LUT[b];
// Return ARGB pixel, leave transparency as is
return (pARGB & 0xFF000000) | (r << 16) | (g << 8) | b;
} | java |
protected static String buildTimestamp(final Calendar pCalendar) {
if (pCalendar == null) {
return CALENDAR_IS_NULL_ERROR_MESSAGE;
}
// The timestamp format
StringBuilder timestamp = new StringBuilder();
//timestamp.append(DateUtil.getMonthName(new Integer(pCalendar.get(Calendar.MONTH)).toString(), "0", "us", "MEDIUM", false) + " ");
timestamp.append(DateFormat.getDateInstance(DateFormat.MEDIUM).format(pCalendar.getTime()));
//timestamp.append(pCalendar.get(Calendar.DAY_OF_MONTH) + " ");
timestamp.append(" ");
timestamp.append(StringUtil.pad(new Integer(pCalendar.get(Calendar.HOUR_OF_DAY)).toString(), 2, "0", true) + ":");
timestamp.append(StringUtil.pad(new Integer(pCalendar.get(Calendar.MINUTE)).toString(), 2, "0", true) + ":");
timestamp.append(StringUtil.pad(new Integer(pCalendar.get(Calendar.SECOND)).toString(), 2, "0", true) + ":");
timestamp.append(StringUtil.pad(new Integer(pCalendar.get(Calendar.MILLISECOND)).toString(), 3, "0", true));
return timestamp.toString();
} | java |
public static long roundToHour(final long pTime, final TimeZone pTimeZone) {
int offset = pTimeZone.getOffset(pTime);
return ((pTime / HOUR) * HOUR) - offset;
} | java |
public static long roundToDay(final long pTime, final TimeZone pTimeZone) {
int offset = pTimeZone.getOffset(pTime);
return (((pTime + offset) / DAY) * DAY) - offset;
} | java |
private PropertyConverter getConverterForType(Class pType) {
Object converter;
Class cl = pType;
// Loop until we find a suitable converter
do {
// Have a match, return converter
if ((converter = getInstance().converters.get(cl)) != null) {
return (PropertyConverter) converter;
}
}
while ((cl = cl.getSuperclass()) != null);
// No converter found, return null
return null;
} | java |
public Object toObject(String pString, Class pType, String pFormat)
throws ConversionException {
if (pString == null) {
return null;
}
if (pType == null) {
throw new MissingTypeException();
}
// Get converter
PropertyConverter converter = getConverterForType(pType);
if (converter == null) {
throw new NoAvailableConverterException("Cannot convert to object, no converter available for type \"" + pType.getName() + "\"");
}
// Convert and return
return converter.toObject(pString, pType, pFormat);
} | java |
public static void merge(List<File> inputFiles, File outputFile) throws IOException {
ImageOutputStream output = null;
try {
output = ImageIO.createImageOutputStream(outputFile);
for (File file : inputFiles) {
ImageInputStream input = null;
try {
input = ImageIO.createImageInputStream(file);
List<TIFFPage> pages = getPages(input);
writePages(output, pages);
}
finally {
if (input != null) {
input.close();
}
}
}
}
finally {
if (output != null) {
output.flush();
output.close();
}
}
} | java |
public static List<File> split(File inputFile, File outputDirectory) throws IOException {
ImageInputStream input = null;
List<File> outputFiles = new ArrayList<>();
try {
input = ImageIO.createImageInputStream(inputFile);
List<TIFFPage> pages = getPages(input);
int pageNo = 1;
for (TIFFPage tiffPage : pages) {
ArrayList<TIFFPage> outputPages = new ArrayList<TIFFPage>(1);
ImageOutputStream outputStream = null;
try {
File outputFile = new File(outputDirectory, String.format("%04d", pageNo) + ".tif");
outputStream = ImageIO.createImageOutputStream(outputFile);
outputPages.clear();
outputPages.add(tiffPage);
writePages(outputStream, outputPages);
outputFiles.add(outputFile);
}
finally {
if (outputStream != null) {
outputStream.flush();
outputStream.close();
}
}
++pageNo;
}
}
finally {
if (input != null) {
input.close();
}
}
return outputFiles;
} | java |
public static String getStats() {
long total = sCacheHit + sCacheMiss + sCacheUn;
double hit = ((double) sCacheHit / (double) total) * 100.0;
double miss = ((double) sCacheMiss / (double) total) * 100.0;
double un = ((double) sCacheUn / (double) total) * 100.0;
// Default locale
java.text.NumberFormat nf = java.text.NumberFormat.getInstance();
return "Total: " + total + " reads. "
+ "Cache hits: " + sCacheHit + " (" + nf.format(hit) + "%), "
+ "Cache misses: " + sCacheMiss + " (" + nf.format(miss) + "%), "
+ "Unattempted: " + sCacheUn + " (" + nf.format(un) + "%) ";
} | java |
private Object[] readIdentities(Class pObjClass, Hashtable pMapping,
Hashtable pWhere, ObjectMapper pOM)
throws SQLException {
sCacheUn++;
// Build SQL query string
if (pWhere == null)
pWhere = new Hashtable();
String[] keys = new String[pWhere.size()];
int i = 0;
for (Enumeration en = pWhere.keys(); en.hasMoreElements(); i++) {
keys[i] = (String) en.nextElement();
}
// Get SQL for reading identity column
String sql = pOM.buildIdentitySQL(keys)
+ buildWhereClause(keys, pMapping);
// Log?
mLog.logDebug(sql + " (" + pWhere + ")");
// Prepare statement and set values
PreparedStatement statement = mConnection.prepareStatement(sql);
for (int j = 0; j < keys.length; j++) {
Object key = pWhere.get(keys[j]);
if (key instanceof Integer)
statement.setInt(j + 1, ((Integer) key).intValue());
else if (key instanceof BigDecimal)
statement.setBigDecimal(j + 1, (BigDecimal) key);
else
statement.setString(j + 1, key.toString());
}
// Execute query
ResultSet rs = null;
try {
rs = statement.executeQuery();
}
catch (SQLException e) {
mLog.logError(sql + " (" + pWhere + ")", e);
throw e;
}
Vector result = new Vector();
// Map query to objects
while (rs.next()) {
Object obj = null;
try {
obj = pObjClass.newInstance();
}
catch (IllegalAccessException iae) {
iae.printStackTrace();
}
catch (InstantiationException ie) {
ie.printStackTrace();
}
// Map it
pOM.mapColumnProperty(rs, 1,
pOM.getProperty(pOM.getPrimaryKey()), obj);
result.addElement(obj);
}
// Return array of identifiers
return result.toArray((Object[]) Array.newInstance(pObjClass,
result.size()));
} | java |
public Object readObject(DatabaseReadable pReadable) throws SQLException {
return readObject(pReadable.getId(), pReadable.getClass(),
pReadable.getMapping());
} | java |
public Object readObject(Object pId, Class pObjClass, Hashtable pMapping)
throws SQLException {
return readObject(pId, pObjClass, pMapping, null);
} | java |
public Object[] readObjects(DatabaseReadable pReadable)
throws SQLException {
return readObjects(pReadable.getClass(),
pReadable.getMapping(), null);
} | java |
private void setPropertyValue(Object pObj, String pProperty,
Object pValue) {
Method m = null;
Class[] cl = {pValue.getClass()};
try {
//Util.setPropertyValue(pObj, pProperty, pValue);
// Find method
m = pObj.getClass().
getMethod("set" + StringUtil.capitalize(pProperty), cl);
// Invoke it
Object[] args = {pValue};
m.invoke(pObj, args);
}
catch (NoSuchMethodException e) {
e.printStackTrace();
}
catch (IllegalAccessException iae) {
iae.printStackTrace();
}
catch (InvocationTargetException ite) {
ite.printStackTrace();
}
} | java |
private Object getPropertyValue(Object pObj, String pProperty) {
Method m = null;
Class[] cl = new Class[0];
try {
//return Util.getPropertyValue(pObj, pProperty);
// Find method
m = pObj.getClass().
getMethod("get" + StringUtil.capitalize(pProperty),
new Class[0]);
// Invoke it
Object result = m.invoke(pObj, new Object[0]);
return result;
}
catch (NoSuchMethodException e) {
e.printStackTrace();
}
catch (IllegalAccessException iae) {
iae.printStackTrace();
}
catch (InvocationTargetException ite) {
ite.printStackTrace();
}
return null;
} | java |
private void setChildObjects(Object pParent, ObjectMapper pOM)
throws SQLException {
if (pOM == null) {
throw new NullPointerException("ObjectMapper in readChildObjects "
+ "cannot be null!!");
}
for (Enumeration keys = pOM.mMapTypes.keys(); keys.hasMoreElements();) {
String property = (String) keys.nextElement();
String mapType = (String) pOM.mMapTypes.get(property);
if (property.length() <= 0 || mapType == null) {
continue;
}
// Get the id of the parent
Object id = getPropertyValue(pParent,
pOM.getProperty(pOM.getPrimaryKey()));
if (mapType.equals(ObjectMapper.OBJECTMAP)) {
// OBJECT Mapping
// Get the class for this property
Class objectClass = (Class) pOM.mClasses.get(property);
DatabaseReadable dbr = null;
try {
dbr = (DatabaseReadable) objectClass.newInstance();
}
catch (Exception e) {
mLog.logError(e);
}
/*
Properties mapping = readMapping(objectClass);
*/
// Get property mapping for child object
if (pOM.mJoins.containsKey(property))
// mapping.setProperty(".join", (String) pOM.joins.get(property));
dbr.getMapping().put(".join", pOM.mJoins.get(property));
// Find id and put in where hash
Hashtable where = new Hashtable();
// String foreignKey = mapping.getProperty(".foreignKey");
String foreignKey = (String)
dbr.getMapping().get(".foreignKey");
if (foreignKey != null) {
where.put(".foreignKey", id);
}
Object[] child = readObjects(dbr, where);
// Object[] child = readObjects(objectClass, mapping, where);
if (child.length < 1)
throw new SQLException("No child object with foreign key "
+ foreignKey + "=" + id);
else if (child.length != 1)
throw new SQLException("More than one object with foreign "
+ "key " + foreignKey + "=" + id);
// Set child object to the parent
setPropertyValue(pParent, property, child[0]);
}
else if (mapType.equals(ObjectMapper.COLLECTIONMAP)) {
// COLLECTION Mapping
// Get property mapping for child object
Hashtable mapping = pOM.getPropertyMapping(property);
// Find id and put in where hash
Hashtable where = new Hashtable();
String foreignKey = (String) mapping.get(".foreignKey");
if (foreignKey != null) {
where.put(".foreignKey", id);
}
DBObject dbr = new DBObject();
dbr.mapping = mapping; // ugh...
// Read the objects
Object[] objs = readObjects(dbr, where);
// Put the objects in a hash
Hashtable children = new Hashtable();
for (int i = 0; i < objs.length; i++) {
children.put(((DBObject) objs[i]).getId(),
((DBObject) objs[i]).getObject());
}
// Set child properties to parent object
setPropertyValue(pParent, property, children);
}
}
} | java |
private String buildWhereClause(String[] pKeys, Hashtable pMapping) {
StringBuilder sqlBuf = new StringBuilder();
for (int i = 0; i < pKeys.length; i++) {
String column = (String) pMapping.get(pKeys[i]);
sqlBuf.append(" AND ");
sqlBuf.append(column);
sqlBuf.append(" = ?");
}
return sqlBuf.toString();
} | java |
public static Properties loadMapping(Class pClass) {
try {
return SystemUtil.loadProperties(pClass);
}
catch (FileNotFoundException fnf) {
// System.err... err...
System.err.println("ERROR: " + fnf.getMessage());
}
catch (IOException ioe) {
ioe.printStackTrace();
}
return new Properties();
} | java |
protected Class getType(String pType) {
Class cl = (Class) mTypes.get(pType);
if (cl == null) {
// throw new NoSuchTypeException();
}
return cl;
} | java |
protected Object getObject(String pType)
/*throws XxxException*/ {
// Get class
Class cl = getType(pType);
// Return the new instance (requires empty public constructor)
try {
return cl.newInstance();
}
catch (Exception e) {
// throw new XxxException(e);
throw new RuntimeException(e.getMessage());
}
// Can't happen
//return null;
} | java |
protected void checkBounds(int index) throws IOException {
assertInput();
if (index < getMinIndex()) {
throw new IndexOutOfBoundsException("index < minIndex");
}
int numImages = getNumImages(false);
if (numImages != -1 && index >= numImages) {
throw new IndexOutOfBoundsException("index >= numImages (" + index + " >= " + numImages + ")");
}
} | java |
protected static boolean hasExplicitDestination(final ImageReadParam pParam) {
return pParam != null &&
(
pParam.getDestination() != null || pParam.getDestinationType() != null ||
!ORIGIN.equals(pParam.getDestinationOffset())
);
} | java |
public BufferedImage getImage() throws IOException {
if (image == null) {
// No content, no image
if (bufferedOut == null) {
return null;
}
// Read from the byte buffer
InputStream byteStream = bufferedOut.createInputStream();
ImageInputStream input = null;
try {
input = ImageIO.createImageInputStream(byteStream);
Iterator readers = ImageIO.getImageReaders(input);
if (readers.hasNext()) {
// Get the correct reader
ImageReader reader = (ImageReader) readers.next();
try {
reader.setInput(input);
ImageReadParam param = reader.getDefaultReadParam();
// Get default size
int originalWidth = reader.getWidth(0);
int originalHeight = reader.getHeight(0);
//////////////////
// PRE-PROCESS (prepare): param, size, format?, request, response?
// TODO: AOI strategy?
// Extract AOI from request
Rectangle aoi = extractAOIFromRequest(originalWidth, originalHeight, originalRequest);
if (aoi != null) {
param.setSourceRegion(aoi);
originalWidth = aoi.width;
originalHeight = aoi.height;
}
// TODO: Size and subsampling strategy?
// If possible, extract size from request
Dimension size = extractSizeFromRequest(originalWidth, originalHeight, originalRequest);
double readSubSamplingFactor = getReadSubsampleFactorFromRequest(originalRequest);
if (size != null) {
//System.out.println("Size: " + size);
if (param.canSetSourceRenderSize()) {
param.setSourceRenderSize(size);
}
else {
int subX = (int) Math.max(originalWidth / (size.width * readSubSamplingFactor), 1.0);
int subY = (int) Math.max(originalHeight / (size.height * readSubSamplingFactor), 1.0);
if (subX > 1 || subY > 1) {
param.setSourceSubsampling(subX, subY, subX > 1 ? subX / 2 : 0, subY > 1 ? subY / 2 : 0);
}
}
}
// Need base URI for SVG with links/stylesheets etc
maybeSetBaseURIFromRequest(param);
/////////////////////
// Finally, read the image using the supplied parameter
BufferedImage image = reader.read(0, param);
// TODO: If we sub-sampled, it would be a good idea to blur before resampling,
// to avoid jagged lines artifacts
// If reader doesn't support dynamic sizing, scale now
image = resampleImage(image, size);
// Fill bgcolor behind image, if transparent
extractAndSetBackgroundColor(image); // TODO: Move to flush/POST-PROCESS
// Set image
this.image = image;
}
finally {
reader.dispose();
}
}
else {
context.log("ERROR: No suitable image reader found (content-type: " + originalContentType + ").");
context.log("ERROR: Available formats: " + getFormatsString());
throw new IIOException("Unable to transcode image: No suitable image reader found (content-type: " + originalContentType + ").");
}
// Free resources, as the image is now either read, or unreadable
bufferedOut = null;
}
finally {
if (input != null) {
input.close();
}
}
}
// Image is usually a BufferedImage, but may also be a RenderedImage
return image != null ? ImageUtil.toBuffered(image) : null;
} | java |
private static QTDecompressor getDecompressor(final ImageDesc pDescription) {
for (QTDecompressor decompressor : sDecompressors) {
if (decompressor.canDecompress(pDescription)) {
return decompressor;
}
}
return null;
} | java |
public static BufferedImage decompress(final ImageInputStream pStream) throws IOException {
ImageDesc description = ImageDesc.read(pStream);
if (PICTImageReader.DEBUG) {
System.out.println(description);
}
QTDecompressor decompressor = getDecompressor(description);
if (decompressor == null) {
return null;
}
InputStream streamAdapter = IIOUtil.createStreamAdapter(pStream, description.dataSize);
try {
return decompressor.decompress(description, streamAdapter);
}
finally {
streamAdapter.close();
}
} | java |
protected boolean trigger(ServletRequest pRequest) {
boolean trigger = false;
if (pRequest instanceof HttpServletRequest) {
HttpServletRequest request = (HttpServletRequest) pRequest;
String accept = getAcceptedFormats(request);
String originalFormat = getServletContext().getMimeType(request.getRequestURI());
//System.out.println("Accept: " + accept);
//System.out.println("Original format: " + originalFormat);
// Only override original format if it is not accpeted by the client
// Note: Only explicit matches are okay, */* or image/* is not.
if (!StringUtil.contains(accept, originalFormat)) {
trigger = true;
}
}
// Call super, to allow content negotiation even though format is supported
return trigger || super.trigger(pRequest);
} | java |
private static String findBestFormat(Map<String, Float> pFormatQuality) {
String acceptable = null;
float acceptQuality = 0.0f;
for (Map.Entry<String, Float> entry : pFormatQuality.entrySet()) {
float qValue = entry.getValue();
if (qValue > acceptQuality) {
acceptQuality = qValue;
acceptable = entry.getKey();
}
}
//System.out.println("Accepted format: " + acceptable);
//System.out.println("Accepted quality: " + acceptQuality);
return acceptable;
} | java |
private void adjustQualityFromAccept(Map<String, Float> pFormatQuality, HttpServletRequest pRequest) {
// Multiply all q factors with qs factors
// No q=.. should be interpreted as q=1.0
// Apache does some extras; if both explicit types and wildcards
// (without qaulity factor) are present, */* is interpreted as
// */*;q=0.01 and image/* is interpreted as image/*;q=0.02
// See: http://httpd.apache.org/docs-2.0/content-negotiation.html
String accept = getAcceptedFormats(pRequest);
//System.out.println("Accept: " + accept);
float anyImageFactor = getQualityFactor(accept, MIME_TYPE_IMAGE_ANY);
anyImageFactor = (anyImageFactor == 1) ? 0.02f : anyImageFactor;
float anyFactor = getQualityFactor(accept, MIME_TYPE_ANY);
anyFactor = (anyFactor == 1) ? 0.01f : anyFactor;
for (String format : pFormatQuality.keySet()) {
//System.out.println("Trying format: " + format);
String formatMIME = MIME_TYPE_IMAGE_PREFIX + format;
float qFactor = getQualityFactor(accept, formatMIME);
qFactor = (qFactor == 0f) ? Math.max(anyFactor, anyImageFactor) : qFactor;
adjustQuality(pFormatQuality, format, qFactor);
}
} | java |
private static void adjustQualityFromImage(Map<String, Float> pFormatQuality, BufferedImage pImage) {
// NOTE: The values are all made-up. May need tuning.
// If pImage.getColorModel() instanceof IndexColorModel
// JPEG qs*=0.6
// If NOT binary or 2 color index
// WBMP qs*=0.5
// Else
// GIF qs*=0.02
// PNG qs*=0.9 // JPEG is smaller/faster
if (pImage.getColorModel() instanceof IndexColorModel) {
adjustQuality(pFormatQuality, FORMAT_JPEG, 0.6f);
if (pImage.getType() != BufferedImage.TYPE_BYTE_BINARY || ((IndexColorModel) pImage.getColorModel()).getMapSize() != 2) {
adjustQuality(pFormatQuality, FORMAT_WBMP, 0.5f);
}
}
else {
adjustQuality(pFormatQuality, FORMAT_GIF, 0.01f);
adjustQuality(pFormatQuality, FORMAT_PNG, 0.99f); // JPEG is smaller/faster
}
// If pImage.getColorModel().hasTransparentPixels()
// JPEG qs*=0.05
// WBMP qs*=0.05
// If NOT transparency == BITMASK
// GIF qs*=0.8
if (ImageUtil.hasTransparentPixels(pImage, true)) {
adjustQuality(pFormatQuality, FORMAT_JPEG, 0.009f);
adjustQuality(pFormatQuality, FORMAT_WBMP, 0.009f);
if (pImage.getColorModel().getTransparency() != Transparency.BITMASK) {
adjustQuality(pFormatQuality, FORMAT_GIF, 0.8f);
}
}
} | java |
private static void adjustQuality(Map<String, Float> pFormatQuality, String pFormat, float pFactor) {
Float oldValue = pFormatQuality.get(pFormat);
if (oldValue != null) {
pFormatQuality.put(pFormat, oldValue * pFactor);
//System.out.println("New vallue after multiplying with " + pFactor + " is " + pFormatQuality.get(pFormat));
}
} | java |
private float getKnownFormatQuality(String pFormat) {
for (int i = 0; i < sKnownFormats.length; i++) {
if (pFormat.equals(sKnownFormats[i])) {
return knownFormatQuality[i];
}
}
return 0.1f;
} | java |
public void write(final byte pBytes[], final int pOff, final int pLen) throws IOException {
out.write(pBytes, pOff, pLen);
} | java |
public int decode(final InputStream stream, final ByteBuffer buffer) throws IOException {
if (reachedEOF) {
return -1;
}
// TODO: Don't decode more than single runs, because some writers add pad bytes inside the stream...
while (buffer.hasRemaining()) {
int n;
if (splitRun) {
// Continue run
n = leftOfRun;
splitRun = false;
}
else {
// Start new run
int b = stream.read();
if (b < 0) {
reachedEOF = true;
break;
}
n = (byte) b;
}
// Split run at or before max
if (n >= 0 && n + 1 > buffer.remaining()) {
leftOfRun = n;
splitRun = true;
break;
}
else if (n < 0 && -n + 1 > buffer.remaining()) {
leftOfRun = n;
splitRun = true;
break;
}
try {
if (n >= 0) {
// Copy next n + 1 bytes literally
readFully(stream, buffer, sample.length * (n + 1));
}
// Allow -128 for compatibility, see above
else if (disableNoOp || n != -128) {
// Replicate the next byte -n + 1 times
for (int s = 0; s < sample.length; s++) {
sample[s] = readByte(stream);
}
for (int i = -n + 1; i > 0; i--) {
buffer.put(sample);
}
}
// else NOOP (-128)
}
catch (IndexOutOfBoundsException e) {
throw new DecodeException("Error in PackBits decompression, data seems corrupt", e);
}
}
return buffer.position();
} | java |
private float[] LABtoXYZ(float L, float a, float b, float[] xyzResult) {
// Significant speedup: Removing Math.pow
float y = (L + 16.0f) / 116.0f;
float y3 = y * y * y; // Math.pow(y, 3.0);
float x = (a / 500.0f) + y;
float x3 = x * x * x; // Math.pow(x, 3.0);
float z = y - (b / 200.0f);
float z3 = z * z * z; // Math.pow(z, 3.0);
if (y3 > 0.008856f) {
y = y3;
}
else {
y = (y - (16.0f / 116.0f)) / 7.787f;
}
if (x3 > 0.008856f) {
x = x3;
}
else {
x = (x - (16.0f / 116.0f)) / 7.787f;
}
if (z3 > 0.008856f) {
z = z3;
}
else {
z = (z - (16.0f / 116.0f)) / 7.787f;
}
xyzResult[0] = x * whitePoint[0];
xyzResult[1] = y * whitePoint[1];
xyzResult[2] = z * whitePoint[2];
return xyzResult;
} | java |
public Object toObject(final String pString, final Class pType, final String pFormat) throws ConversionException {
if (StringUtil.isEmpty(pString)) {
return null;
}
try {
if (pType.equals(BigInteger.class)) {
return new BigInteger(pString); // No format?
}
if (pType.equals(BigDecimal.class)) {
return new BigDecimal(pString); // No format?
}
NumberFormat format;
if (pFormat == null) {
// Use system default format, using default locale
format = sDefaultFormat;
}
else {
// Get format from cache
format = getNumberFormat(pFormat);
}
Number num;
synchronized (format) {
num = format.parse(pString);
}
if (pType == Integer.TYPE || pType == Integer.class) {
return num.intValue();
}
else if (pType == Long.TYPE || pType == Long.class) {
return num.longValue();
}
else if (pType == Double.TYPE || pType == Double.class) {
return num.doubleValue();
}
else if (pType == Float.TYPE || pType == Float.class) {
return num.floatValue();
}
else if (pType == Byte.TYPE || pType == Byte.class) {
return num.byteValue();
}
else if (pType == Short.TYPE || pType == Short.class) {
return num.shortValue();
}
return num;
}
catch (ParseException pe) {
throw new ConversionException(pe);
}
catch (RuntimeException rte) {
throw new ConversionException(rte);
}
} | java |
public void setPenSize(Dimension2D pSize) {
penSize.setSize(pSize);
graphics.setStroke(getStroke(penSize));
} | java |
protected void setupForFill(final Pattern pPattern) {
graphics.setPaint(pPattern);
graphics.setComposite(getCompositeFor(QuickDraw.PAT_COPY));
} | java |
private static Arc2D.Double toArc(final Rectangle2D pRectangle, int pStartAngle, int pArcAngle, final boolean pClosed) {
return new Arc2D.Double(pRectangle, 90 - pStartAngle, -pArcAngle, pClosed ? Arc2D.PIE : Arc2D.OPEN);
} | java |
public void drawString(String pString) {
setupForText();
graphics.drawString(pString, (float) getPenPosition().getX(), (float) getPenPosition().getY());
} | java |
public static Dimension readDimension(final DataInput pStream) throws IOException {
int h = pStream.readShort();
int v = pStream.readShort();
return new Dimension(h, v);
} | java |
public static String readStr31(final DataInput pStream) throws IOException {
String text = readPascalString(pStream);
int length = 31 - text.length();
if (length < 0) {
throw new IOException("String length exceeds maximum (31): " + text.length());
}
pStream.skipBytes(length);
return text;
} | java |
public static String readPascalString(final DataInput pStream) throws IOException {
// Get as many bytes as indicated by byte count
int length = pStream.readUnsignedByte();
byte[] bytes = new byte[length];
pStream.readFully(bytes, 0, length);
return new String(bytes, ENCODING);
} | java |
protected void doFilterImpl(ServletRequest pRequest, ServletResponse pResponse, FilterChain pChain) throws IOException, ServletException {
// TODO: Max size configuration, to avoid DOS attacks? OutOfMemory
// Size parameters
int width = ServletUtil.getIntParameter(pRequest, sizeWidthParam, -1);
int height = ServletUtil.getIntParameter(pRequest, sizeHeightParam, -1);
if (width > 0 || height > 0) {
pRequest.setAttribute(ImageServletResponse.ATTRIB_SIZE, new Dimension(width, height));
}
// Size uniform/percent
boolean uniform = ServletUtil.getBooleanParameter(pRequest, sizeUniformParam, true);
if (!uniform) {
pRequest.setAttribute(ImageServletResponse.ATTRIB_SIZE_UNIFORM, Boolean.FALSE);
}
boolean percent = ServletUtil.getBooleanParameter(pRequest, sizePercentParam, false);
if (percent) {
pRequest.setAttribute(ImageServletResponse.ATTRIB_SIZE_PERCENT, Boolean.TRUE);
}
// Area of interest parameters
int x = ServletUtil.getIntParameter(pRequest, regionLeftParam, -1); // Default is center
int y = ServletUtil.getIntParameter(pRequest, regionTopParam, -1); // Default is center
width = ServletUtil.getIntParameter(pRequest, regionWidthParam, -1);
height = ServletUtil.getIntParameter(pRequest, regionHeightParam, -1);
if (width > 0 || height > 0) {
pRequest.setAttribute(ImageServletResponse.ATTRIB_AOI, new Rectangle(x, y, width, height));
}
// AOI uniform/percent
uniform = ServletUtil.getBooleanParameter(pRequest, regionUniformParam, false);
if (uniform) {
pRequest.setAttribute(ImageServletResponse.ATTRIB_SIZE_UNIFORM, Boolean.TRUE);
}
percent = ServletUtil.getBooleanParameter(pRequest, regionPercentParam, false);
if (percent) {
pRequest.setAttribute(ImageServletResponse.ATTRIB_SIZE_PERCENT, Boolean.TRUE);
}
super.doFilterImpl(pRequest, pResponse, pChain);
} | java |
public void setTimeout(int pTimeout) {
if (pTimeout < 0) { // Must be positive
throw new IllegalArgumentException("Timeout must be positive.");
}
timeout = pTimeout;
if (socket != null) {
try {
socket.setSoTimeout(pTimeout);
}
catch (SocketException se) {
// Not much to do about that...
}
}
} | java |
public synchronized InputStream getInputStream() throws IOException {
if (!connected) {
connect();
}
// Nothing to return
if (responseCode == HTTP_NOT_FOUND) {
throw new FileNotFoundException(url.toString());
}
int length;
if (inputStream == null) {
return null;
}
// "De-chunk" the output stream
else if ("chunked".equalsIgnoreCase(getHeaderField("Transfer-Encoding"))) {
if (!(inputStream instanceof ChunkedInputStream)) {
inputStream = new ChunkedInputStream(inputStream);
}
}
// Make sure we don't wait forever, if the content-length is known
else if ((length = getHeaderFieldInt("Content-Length", -1)) >= 0) {
if (!(inputStream instanceof FixedLengthInputStream)) {
inputStream = new FixedLengthInputStream(inputStream, length);
}
}
return inputStream;
} | java |
private void connect(final URL pURL, PasswordAuthentication pAuth, String pAuthType, int pRetries) throws IOException {
// Find correct port
final int port = (pURL.getPort() > 0)
? pURL.getPort()
: HTTP_DEFAULT_PORT;
// Create socket if we don't have one
if (socket == null) {
//socket = new Socket(pURL.getHost(), port); // Blocks...
socket = createSocket(pURL, port, connectTimeout);
socket.setSoTimeout(timeout);
}
// Get Socket output stream
OutputStream os = socket.getOutputStream();
// Connect using HTTP
writeRequestHeaders(os, pURL, method, requestProperties, usingProxy(), pAuth, pAuthType);
// Get response input stream
InputStream sis = socket.getInputStream();
BufferedInputStream is = new BufferedInputStream(sis);
// Detatch reponse headers from reponse input stream
InputStream header = detatchResponseHeader(is);
// Parse headers and set response code/message
responseHeaders = parseResponseHeader(header);
responseHeaderFields = parseHeaderFields(responseHeaders);
//System.err.println("Headers fields:");
//responseHeaderFields.list(System.err);
// Test HTTP response code, to see if further action is needed
switch (getResponseCode()) {
case HTTP_OK:
// 200 OK
inputStream = is;
errorStream = null;
break;
/*
case HTTP_PROXY_AUTH:
// 407 Proxy Authentication Required
*/
case HTTP_UNAUTHORIZED:
// 401 Unauthorized
// Set authorization and try again.. Slightly more compatible
responseCode = -1;
// IS THIS REDIRECTION??
//if (instanceFollowRedirects) { ???
String auth = getHeaderField(HEADER_WWW_AUTH);
// Missing WWW-Authenticate header for 401 response is an error
if (StringUtil.isEmpty(auth)) {
throw new ProtocolException("Missing \"" + HEADER_WWW_AUTH + "\" header for response: 401 " + responseMessage);
}
// Get real mehtod from WWW-Authenticate header
int SP = auth.indexOf(" ");
String method;
String realm = null;
if (SP >= 0) {
method = auth.substring(0, SP);
if (auth.length() >= SP + 7) {
realm = auth.substring(SP + 7); // " realm=".lenght() == 7
}
// else no realm
}
else {
// Default mehtod is Basic
method = SimpleAuthenticator.BASIC;
}
// Get PasswordAuthentication
PasswordAuthentication pa = Authenticator.requestPasswordAuthentication(NetUtil.createInetAddressFromURL(pURL), port,
pURL.getProtocol(), realm, method);
// Avoid infinite loop
if (pRetries++ <= 0) {
throw new ProtocolException("Server redirected too many times (" + maxRedirects + ") (Authentication required: " + auth + ")"); // This is what sun.net.www.protocol.http.HttpURLConnection does
}
else if (pa != null) {
connect(pURL, pa, method, pRetries);
}
break;
case HTTP_MOVED_PERM:
// 301 Moved Permanently
case HTTP_MOVED_TEMP:
// 302 Found
case HTTP_SEE_OTHER:
// 303 See Other
/*
case HTTP_USE_PROXY:
// 305 Use Proxy
// How do we handle this?
*/
case HTTP_REDIRECT:
// 307 Temporary Redirect
//System.err.println("Redirecting " + getResponseCode());
if (instanceFollowRedirects) {
// Redirect
responseCode = -1; // Because of the java.net.URLConnection
// getResponseCode implementation...
// ---
// I think redirects must be get?
//setRequestMethod("GET");
// ---
String location = getHeaderField("Location");
URL newLoc = new URL(pURL, location);
// Test if we can reuse the Socket
if (!(newLoc.getAuthority().equals(pURL.getAuthority()) && (newLoc.getPort() == pURL.getPort()))) {
socket.close(); // Close the socket, won't need it anymore
socket = null;
}
if (location != null) {
//System.err.println("Redirecting to " + location);
// Avoid infinite loop
if (--pRetries <= 0) {
throw new ProtocolException("Server redirected too many times (5)");
}
else {
connect(newLoc, pAuth, pAuthType, pRetries);
}
}
break;
}
// ...else, fall through default (if no Location: header)
default :
// Not 200 OK, or any of the redirect responses
// Probably an error...
errorStream = is;
inputStream = null;
}
// --- Need rethinking...
// No further questions, let the Socket wait forever (until the server
// closes the connection)
//socket.setSoTimeout(0);
// Probably not... The timeout should only kick if the read BLOCKS.
// Shutdown output, meaning any writes to the outputstream below will
// probably fail...
//socket.shutdownOutput();
// Not a good idea at all... POSTs need the outputstream to send the
// form-data.
// --- /Need rethinking.
outputStream = os;
} | java |
private Socket createSocket(final URL pURL, final int pPort, int pConnectTimeout) throws IOException {
Socket socket;
final Object current = this;
SocketConnector connector;
Thread t = new Thread(connector = new SocketConnector() {
private IOException mConnectException = null;
private Socket mLocalSocket = null;
public Socket getSocket() throws IOException {
if (mConnectException != null) {
throw mConnectException;
}
return mLocalSocket;
}
// Run method
public void run() {
try {
mLocalSocket = new Socket(pURL.getHost(), pPort); // Blocks...
}
catch (IOException ioe) {
// Store this exception for later
mConnectException = ioe;
}
// Signal that we are done
synchronized (current) {
current.notify();
}
}
});
t.start();
// Wait for connect
synchronized (this) {
try {
/// Only wait if thread is alive!
if (t.isAlive()) {
if (pConnectTimeout > 0) {
wait(pConnectTimeout);
}
else {
wait();
}
}
}
catch (InterruptedException ie) {
// Continue excecution on interrupt? Hmmm..
}
}
// Throw exception if the socket didn't connect fast enough
if ((socket = connector.getSocket()) == null) {
throw new ConnectException("Socket connect timed out!");
}
return socket;
} | java |
private static void writeRequestHeaders(OutputStream pOut, URL pURL, String pMethod, Properties pProps, boolean pUsingProxy,
PasswordAuthentication pAuth, String pAuthType) {
PrintWriter out = new PrintWriter(pOut, true); // autoFlush
if (!pUsingProxy) {
out.println(pMethod + " " + (!StringUtil.isEmpty(pURL.getPath())
? pURL.getPath()
: "/") + ((pURL.getQuery() != null)
? "?" + pURL.getQuery()
: "") + " HTTP/1.1"); // HTTP/1.1
// out.println("Connection: close"); // No persistent connections yet
/*
System.err.println(pMethod + " "
+ (!StringUtil.isEmpty(pURL.getPath()) ? pURL.getPath() : "/")
+ (pURL.getQuery() != null ? "?" + pURL.getQuery() : "")
+ " HTTP/1.1"); // HTTP/1.1
*/
// Authority (Host: HTTP/1.1 field, but seems to work for HTTP/1.0)
out.println("Host: " + pURL.getHost() + ((pURL.getPort() != -1)
? ":" + pURL.getPort()
: ""));
/*
System.err.println("Host: " + pURL.getHost()
+ (pURL.getPort() != -1 ? ":" + pURL.getPort() : ""));
*/
}
else {
////-- PROXY (absolute) VERSION
out.println(pMethod + " " + pURL.getProtocol() + "://" + pURL.getHost() + ((pURL.getPort() != -1)
? ":" + pURL.getPort()
: "") + pURL.getPath() + ((pURL.getQuery() != null)
? "?" + pURL.getQuery()
: "") + " HTTP/1.1");
}
// Check if we have authentication
if (pAuth != null) {
// If found, set Authorization header
byte[] userPass = (pAuth.getUserName() + ":" + new String(pAuth.getPassword())).getBytes();
// "Authorization" ":" credentials
out.println("Authorization: " + pAuthType + " " + BASE64.encode(userPass));
/*
System.err.println("Authorization: " + pAuthType + " "
+ BASE64.encode(userPass));
*/
}
// Iterate over properties
for (Map.Entry<Object, Object> property : pProps.entrySet()) {
out.println(property.getKey() + ": " + property.getValue());
//System.err.println(property.getKey() + ": " + property.getValue());
}
out.println(); // Empty line, marks end of request-header
} | java |
private static int findEndOfHeader(byte[] pBytes, int pEnd) {
byte[] header = HTTP_HEADER_END.getBytes();
// Normal condition, check all bytes
for (int i = 0; i < pEnd - 4; i++) { // Need 4 bytes to match
if ((pBytes[i] == header[0]) && (pBytes[i + 1] == header[1]) && (pBytes[i + 2] == header[2]) && (pBytes[i + 3] == header[3])) {
//System.err.println("FOUND END OF HEADER!");
return i + 4;
}
}
// Check last 3 bytes, to check if we have a partial match
if ((pEnd - 1 >= 0) && (pBytes[pEnd - 1] == header[0])) {
//System.err.println("FOUND LAST BYTE");
return -2; // LAST BYTE
}
else if ((pEnd - 2 >= 0) && (pBytes[pEnd - 2] == header[0]) && (pBytes[pEnd - 1] == header[1])) {
//System.err.println("FOUND LAST TWO BYTES");
return -3; // LAST TWO BYTES
}
else if ((pEnd - 3 >= 0) && (pBytes[pEnd - 3] == header[0]) && (pBytes[pEnd - 2] == header[1]) && (pBytes[pEnd - 1] == header[2])) {
//System.err.println("FOUND LAST THREE BYTES");
return -4; // LAST THREE BYTES
}
return -1; // NO BYTES MATCH
} | java |
private static InputStream detatchResponseHeader(BufferedInputStream pIS) throws IOException {
// Store header in byte array
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
pIS.mark(BUF_SIZE);
byte[] buffer = new byte[BUF_SIZE];
int length;
int headerEnd;
// Read from iput, store in bytes
while ((length = pIS.read(buffer)) != -1) {
// End of header?
headerEnd = findEndOfHeader(buffer, length);
if (headerEnd >= 0) {
// Write rest
bytes.write(buffer, 0, headerEnd);
// Go back to last mark
pIS.reset();
// Position stream to right after header, and exit loop
pIS.skip(headerEnd);
break;
}
else if (headerEnd < -1) {
// Write partial (except matching header bytes)
bytes.write(buffer, 0, length - 4);
// Go back to last mark
pIS.reset();
// Position stream to right before potential header end
pIS.skip(length - 4);
}
else {
// Write all
bytes.write(buffer, 0, length);
}
// Can't read more than BUF_SIZE ahead anyway
pIS.mark(BUF_SIZE);
}
return new ByteArrayInputStream(bytes.toByteArray());
} | java |
private static Properties parseHeaderFields(String[] pHeaders) {
Properties headers = new Properties();
// Get header information
int split;
String field;
String value;
for (String header : pHeaders) {
//System.err.println(pHeaders[i]);
if ((split = header.indexOf(":")) > 0) {
// Read & parse..?
field = header.substring(0, split);
value = header.substring(split + 1);
//System.err.println(field + ": " + value.trim());
headers.setProperty(StringUtil.toLowerCase(field), value.trim());
}
}
return headers;
} | java |
private static String[] parseResponseHeader(InputStream pIS) throws IOException {
List<String> headers = new ArrayList<String>();
// Wrap Stream in Reader
BufferedReader in = new BufferedReader(new InputStreamReader(pIS));
// Get response status
String header;
while ((header = in.readLine()) != null) {
//System.err.println(header);
headers.add(header);
}
return headers.toArray(new String[headers.size()]);
} | java |
public int filterRGB(int pX, int pY, int pARGB) {
// Get color components
int r = pARGB >> 16 & 0xFF;
int g = pARGB >> 8 & 0xFF;
int b = pARGB & 0xFF;
// ITU standard: Gray scale=(222*Red+707*Green+71*Blue)/1000
int gray = (222 * r + 707 * g + 71 * b) / 1000;
//int gray = (int) ((float) (r + g + b) / 3.0f);
if (range != 1.0f) {
// Apply range
gray = low + (int) (gray * range);
}
// Return ARGB pixel
return (pARGB & 0xFF000000) | (gray << 16) | (gray << 8) | gray;
} | java |
public final int decode(final InputStream stream, final ByteBuffer buffer) throws IOException {
// TODO: Allow decoding < row.length at a time and get rid of this assertion...
if (buffer.capacity() < row.length) {
throw new AssertionError("This decoder needs a buffer.capacity() of at least one row");
}
while (buffer.remaining() >= row.length && srcY >= 0) {
// NOTE: Decode only full rows, don't decode if y delta
if (dstX == 0 && srcY == dstY) {
decodeRow(stream);
}
int length = Math.min(row.length - (dstX * bitsPerSample) / 8, buffer.remaining());
buffer.put(row, 0, length);
dstX += (length * 8) / bitsPerSample;
if (dstX == (row.length * 8) / bitsPerSample) {
dstX = 0;
dstY++;
// NOTE: If src Y is > dst Y, we have a delta, and have to fill the
// gap with zero-bytes
if (srcX > dstX) {
Arrays.fill(row, 0, (srcX * bitsPerSample) / 8, (byte) 0);
}
if (srcY > dstY) {
Arrays.fill(row, (byte) 0);
}
}
}
return buffer.position();
} | java |
public void init() throws ServletException {
// Get the name of the upload directory.
String uploadDirParam = getInitParameter("uploadDir");
if (!StringUtil.isEmpty(uploadDirParam)) {
try {
URL uploadDirURL = getServletContext().getResource(uploadDirParam);
uploadDir = FileUtil.toFile(uploadDirURL);
}
catch (MalformedURLException e) {
throw new ServletException(e.getMessage(), e);
}
}
if (uploadDir == null) {
uploadDir = ServletUtil.getTempDir(getServletContext());
}
} | java |
private static boolean copyDir(File pFrom, File pTo, boolean pOverWrite) throws IOException {
if (pTo.exists() && !pTo.isDirectory()) {
throw new IOException("A directory may only be copied to another directory, not to a file");
}
pTo.mkdirs(); // mkdir?
boolean allOkay = true;
File[] files = pFrom.listFiles();
for (File file : files) {
if (!copy(file, new File(pTo, file.getName()), pOverWrite)) {
allOkay = false;
}
}
return allOkay;
} | java |
public static boolean copy(InputStream pFrom, OutputStream pTo) throws IOException {
Validate.notNull(pFrom, "from");
Validate.notNull(pTo, "to");
// TODO: Consider using file channels for faster copy where possible
// Use buffer size two times byte array, to avoid i/o bottleneck
// TODO: Consider letting the client decide as this is sometimes not a good thing!
InputStream in = new BufferedInputStream(pFrom, BUF_SIZE * 2);
OutputStream out = new BufferedOutputStream(pTo, BUF_SIZE * 2);
byte[] buffer = new byte[BUF_SIZE];
int count;
while ((count = in.read(buffer)) != -1) {
out.write(buffer, 0, count);
}
// Flush out stream, to write any remaining buffered data
out.flush();
return true; // If we got here, everything is probably okay.. ;-)
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.