_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3 values | text stringlengths 73 34.1k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q178900 | WebSheetLoader.refreshCachedCell | test | public final void refreshCachedCell(final String tblName, final int i, final int index, final Cell cell,
final FacesCell fcell) {
if ((cell != null) && (cell.getCellTypeEnum() == CellType.FORMULA) && (tblName != null)) {
try {
processRefreshCell(tblName, i, index, cell, fcell);
} catch (Exception ex) {
LOG.log(Level.SEVERE, "refresh Cached Cell error : " + ex.getLocalizedMessage(), ex);
}
}
} | java | {
"resource": ""
} |
q178901 | WebSheetLoader.processRefreshCell | test | private void processRefreshCell(final String tblName, final int i, final int index, final Cell cell,
final FacesCell fcell) {
String newValue = CellUtility.getCellValueWithFormat(cell, parent.getFormulaEvaluator(),
parent.getDataFormatter());
if (parent.getCachedCells().isValueChanged(cell, newValue)) {
if (fcell.isHasSaveAttr()) {
parent.getCellHelper().saveDataInContext(cell, newValue);
}
RequestContext.getCurrentInstance().update(tblName + ":" + i + ":cocalc" + index);
parent.getCachedCells().put(cell, CellType.FORMULA);
}
} | java | {
"resource": ""
} |
q178902 | WebSheetLoader.createDynamicColumns | test | private void createDynamicColumns(final String tabName) {
SheetConfiguration sheetConfig = parent.getSheetConfigMap().get(tabName);
int left = sheetConfig.getBodyCellRange().getLeftCol();
int right = sheetConfig.getBodyCellRange().getRightCol();
parent.getColumns().clear();
for (int i = left; i <= right; i++) {
parent.getColumns().add("column" + (i - left));
}
} | java | {
"resource": ""
} |
q178903 | WebSheetLoader.addRepeatRow | test | public final void addRepeatRow(final int rowIndex) {
try {
SheetConfiguration sheetConfig = parent.getSheetConfigMap().get(parent.getCurrent().getCurrentTabName());
Sheet sheet = parent.getWb().getSheet(sheetConfig.getSheetName());
ConfigBuildRef configBuildRef = new ConfigBuildRef(parent.getWbWrapper(), sheet, parent.getExpEngine(),
parent.getCellHelper(), sheetConfig.getCachedCells(), parent.getCellAttributesMap(),
sheetConfig.getFinalCommentMap());
// set add mode
configBuildRef.setAddMode(true);
configBuildRef.setCollectionObjNameMap(sheetConfig.getCollectionObjNameMap());
configBuildRef.setCommandIndexMap(sheetConfig.getCommandIndexMap());
configBuildRef.setShiftMap(sheetConfig.getShiftMap());
configBuildRef.setWatchList(sheetConfig.getWatchList());
int length = CommandUtility.addRow(configBuildRef, rowIndex,
parent.getSerialDataContext().getDataContext());
refreshBodyRowsInRange(configBuildRef.getInsertPosition(), length, sheet, sheetConfig);
parent.getCellHelper().reCalc();
} catch (AddRowException e) {
FacesContext.getCurrentInstance().addMessage(null,
new FacesMessage(FacesMessage.SEVERITY_ERROR, "Add Row Error", e.getMessage()));
LOG.log(Level.SEVERE, "Add row error = " + e.getLocalizedMessage(), e);
} catch (Exception ex) {
LOG.log(Level.SEVERE, "Add row error = " + ex.getLocalizedMessage(), ex);
}
} | java | {
"resource": ""
} |
q178904 | WebSheetLoader.refreshBodyRowsInRange | test | private void refreshBodyRowsInRange(final int insertPosition, final int length, final Sheet sheet,
final SheetConfiguration sheetConfig) {
Map<String, CellRangeAddress> cellRangeMap = ConfigurationUtility.indexMergedRegion(sheet);
List<String> skippedRegionCells = ConfigurationUtility.skippedRegionCells(sheet);
int top = sheetConfig.getBodyCellRange().getTopRow();
int left = sheetConfig.getBodyCellRange().getLeftCol();
int right = sheetConfig.getBodyCellRange().getRightCol();
for (int irow = insertPosition; irow < (insertPosition + length); irow++) {
parent.getBodyRows().add(irow - top,
assembleFacesBodyRow(irow, sheet, left, right, sheetConfig, cellRangeMap, skippedRegionCells));
}
for (int irow = insertPosition + length - top; irow < parent.getBodyRows().size(); irow++) {
FacesRow facesrow = parent.getBodyRows().get(irow);
facesrow.setRowIndex(facesrow.getRowIndex() + length);
}
} | java | {
"resource": ""
} |
q178905 | WebSheetLoader.setUnsavedStatus | test | public void setUnsavedStatus(final RequestContext requestContext, final Boolean statusFlag) {
// in client js should have setUnsavedState method
if (requestContext != null) {
LOG.log(Level.FINE, "run setUnsavedState( {} )", statusFlag.toString());
requestContext.execute("setUnsavedState(" + statusFlag.toString() + ")");
}
} | java | {
"resource": ""
} |
q178906 | WebSheetLoader.isUnsavedStatus | test | public final Boolean isUnsavedStatus() {
Map<String, Object> viewMap = FacesContext.getCurrentInstance().getViewRoot().getViewMap();
Boolean flag = (Boolean) viewMap.get(TieConstants.UNSAVEDSTATE);
if (flag == null) {
return false;
}
return flag;
} | java | {
"resource": ""
} |
q178907 | Utils.commonConstructor | test | public static <T> Constructor<T> commonConstructor(Class<T> type)
throws NoMethodForDependency {
Constructor<?>[] cs = type.getDeclaredConstructors();
if (cs.length == 0)
throw new NoMethodForDependency(raw(type));
Constructor<?> mostParamsConstructor = null;
for (Constructor<?> c : cs) {
if (!arrayContains(c.getParameterTypes(), type, (a, b) -> a == b) // avoid self referencing constructors (synthetic) as they cause endless loop
&& (mostParamsConstructor == null //
|| (moreVisible(c, mostParamsConstructor) == c
&& (moreVisible(mostParamsConstructor, c) == c
|| c.getParameterCount() > mostParamsConstructor.getParameterCount())))) {
mostParamsConstructor = c;
}
}
if (mostParamsConstructor == null)
throw new NoMethodForDependency(raw(type));
@SuppressWarnings("unchecked")
Constructor<T> c = (Constructor<T>) mostParamsConstructor;
return c;
} | java | {
"resource": ""
} |
q178908 | BinaryData.writeInputStreamToOutput | test | protected static void writeInputStreamToOutput(final Context context, final InputStream source, final OutputStream output) throws IOException {
BuffersPool pool = BeansManager.get(context).getContainer().getBean(BuffersPool.class);
IoUtils.transfer(source, output, pool);
} | java | {
"resource": ""
} |
q178909 | CacheEntry.writeLong | test | protected static void writeLong(final Writer writer, final long value) throws IOException {
writer.write(new StringBuilder().append(value).append('\n').toString());
} | java | {
"resource": ""
} |
q178910 | CacheEntry.writeString | test | protected final void writeString(final Writer writer, final String line) throws IOException {
if (line != null) {
writer.write(line + '\n');
} else {
writer.write('\n');
}
} | java | {
"resource": ""
} |
q178911 | BaseRequestBuilder.setConvertedTrafficStatsTag | test | protected void setConvertedTrafficStatsTag(final String tag) {
result.statsTag = Utils.getTrafficStatsTag(tag);
if (config.isDebugRest()) {
Log.d(TAG, "TrafficStats tag <" + tag + ">=" + Integer.toHexString(result.statsTag));
}
} | java | {
"resource": ""
} |
q178912 | BaseRequestBuilder.addBitmap | test | protected void addBitmap(final String name, final Bitmap bitmap, final String fileName) {
final BitmapBinaryData bdata = new BitmapBinaryData();
bdata.setName(name);
bdata.setContentName(fileName);
bdata.setBitmap(bitmap);
result.addBinaryData(bdata);
} | java | {
"resource": ""
} |
q178913 | BaseRequestBuilder.addFileDescriptor | test | protected void addFileDescriptor(final String name, final AssetFileDescriptor fd, final String contentType, final String fileName) {
final AssetFdBinaryData bdata = new AssetFdBinaryData();
bdata.setFileDescriptor(fileName, fd);
bdata.setName(name);
bdata.setContentType(contentType);
result.addBinaryData(bdata);
} | java | {
"resource": ""
} |
q178914 | BaseRequestBuilder.removeParameter | test | protected Parameter removeParameter(final String name) {
if (name == null) { throw new IllegalArgumentException("Parameter name cannot be null"); }
final Iterator<Parameter> iter = result.simpleParameters.getChildren().iterator();
while (iter.hasNext()) {
final Parameter p = iter.next();
if (name.equals(p.name)) {
iter.remove();
return p;
}
}
return null;
} | java | {
"resource": ""
} |
q178915 | BaseRequestBuilder.addHeader | test | protected BaseRequestBuilder<MT> addHeader(final String name, final String value) {
result.addHeader(name, value);
return this;
} | java | {
"resource": ""
} |
q178916 | BaseRequestBuilder.clear | test | public void clear() {
final RequestDescription result = this.result;
result.simpleParameters.children.clear();
result.clearBinaryData();
result.contentType = null;
result.clearHeaders();
} | java | {
"resource": ""
} |
q178917 | StreamingPlaybackController.callPlay | test | protected void callPlay(final Uri uri, final int volume, final Bundle params) {
playing = true;
paused = false;
context.startService(
createPlayIntent().setData(uri)
.putExtra(StreamingPlaybackService.EXTRA_VOLUME, volume)
.putExtra(StreamingPlaybackService.EXTRA_TRACK_INFO, params)
);
bind();
onPlayingChanged();
preparing = true;
onPreparingChanged();
} | java | {
"resource": ""
} |
q178918 | StreamingPlaybackController.callStop | test | protected void callStop() {
playing = false;
paused = false;
context.startService(createStopIntent());
onPlayingChanged();
preparing = false;
onPreparingChanged();
} | java | {
"resource": ""
} |
q178919 | StreamingPlaybackController.bind | test | protected final void bind() {
if (bindRequested) { return; }
final boolean result = context.bindService(createBindIntent(), serviceConnection, 0);
if (DEBUG) { Log.v(TAG, "Bind to streaming service: " + result); }
bindRequested = result;
onBind(result);
} | java | {
"resource": ""
} |
q178920 | StreamingPlaybackController.unbind | test | protected final void unbind() {
if (streamingPlayback != null) { dropListener(); }
try {
context.unbindService(serviceConnection);
} catch (final RuntimeException e) {
if (DEBUG) { Log.w(TAG, "Cannot unbind radio", e); }
}
bindRequested = false;
} | java | {
"resource": ""
} |
q178921 | StreamingPlaybackController.dropListener | test | protected final void dropListener() {
if (DEBUG) { Log.v(TAG, "Drop listener"); }
if (streamingPlayback != null) {
try {
streamingPlayback.removeListener();
} catch (final RemoteException e) {
Log.e(TAG, "Cannot remove listener", e);
}
bindRequested = false;
}
} | java | {
"resource": ""
} |
q178922 | ImageRequest.storeToDisk | test | public void storeToDisk() throws IOException {
if (manager.isPresentOnDisk(url)) {
return;
}
if (!hasAllowedSize()) {
IoUtils.consumeStream(getRemoteInputStream(), manager.getBuffersPool());
return;
}
ImageResult result = decodeStream(getRemoteInputStream(), true);
if (result.getType() == ImageSourceType.NETWORK && result.getBitmap() != null) {
// image was scaled
writeBitmapToDisk(result.getBitmap());
}
} | java | {
"resource": ""
} |
q178923 | IoUtils.streamToString | test | public static String streamToString(final InputStream stream, final String charset, final BuffersPool buffersPool) throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
transfer(stream, output, buffersPool);
return new String(output.toByteArray(), charset);
} | java | {
"resource": ""
} |
q178924 | IoUtils.streamToString | test | public static String streamToString(final InputStream stream, final BuffersPool buffersPool) throws IOException {
return streamToString(stream, UTF_8_NAME, buffersPool);
} | java | {
"resource": ""
} |
q178925 | StringPart.sendData | test | @Override
protected void sendData(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendData(OutputStream)"); }
out.write(getContent());
} | java | {
"resource": ""
} |
q178926 | PoolableBufferedInputStream.available | test | @Override
public synchronized int available() throws IOException {
final InputStream localIn = in; // 'in' could be invalidated by close()
if (buf == null || localIn == null) { throw new IOException("Stream is closed"); }
return count - pos + localIn.available();
} | java | {
"resource": ""
} |
q178927 | PoolableBufferedInputStream.close | test | @Override
public void close() throws IOException {
final byte[] localBuf = buf;
buf = null;
final InputStream localIn = in;
in = null;
pool.release(localBuf);
if (localIn != null) { localIn.close(); }
} | java | {
"resource": ""
} |
q178928 | PoolableBufferedInputStream.read | test | @Override
public synchronized int read() throws IOException {
// Use local refs since buf and in may be invalidated by an
// unsynchronized close()
byte[] localBuf = buf;
final InputStream localIn = in;
if (localBuf == null || localIn == null) { throw new IOException("Stream is closed"); }
/* Are there buffered bytes available? */
if (pos >= count && fillbuf(localIn, localBuf) == -1) {
return -1; /* no, fill buffer */
}
// localBuf may have been invalidated by fillbuf
if (localBuf != buf) {
localBuf = buf;
if (localBuf == null) { throw new IOException("Stream is closed"); }
}
/* Did filling the buffer fail with -1 (EOF)? */
final int mask = 0xFF;
if (count - pos > 0) {
return localBuf[pos++] & mask;
}
return -1;
} | java | {
"resource": ""
} |
q178929 | PoolableBufferedInputStream.reset | test | @Override
public synchronized void reset() throws IOException {
// BEGIN android-changed
/*
* These exceptions get thrown in some "normalish" circumstances,
* so it is preferable to avoid loading up the whole big set of
* messages just for these cases.
*/
if (buf == null) {
throw new IOException("Stream is closed");
}
if (-1 == markpos) {
throw new IOException("Mark has been invalidated.");
}
// END android-changed
pos = markpos;
} | java | {
"resource": ""
} |
q178930 | Part.sendStart | test | protected void sendStart(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendStart(OutputStream out)"); }
out.write(EXTRA_BYTES);
out.write(getPartBoundary());
out.write(CRLF_BYTES);
} | java | {
"resource": ""
} |
q178931 | Part.sendDispositionHeader | test | protected void sendDispositionHeader(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendDispositionHeader(OutputStream out)"); }
out.write(CONTENT_DISPOSITION_BYTES);
out.write(QUOTE_BYTES);
out.write(EncodingUtils.getAsciiBytes(getName()));
out.write(QUOTE_BYTES);
} | java | {
"resource": ""
} |
q178932 | Part.sendContentTypeHeader | test | protected void sendContentTypeHeader(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendContentTypeHeader(OutputStream out)"); }
final String contentType = getContentType();
if (contentType != null) {
out.write(CRLF_BYTES);
out.write(CONTENT_TYPE_BYTES);
out.write(EncodingUtils.getAsciiBytes(contentType));
final String charSet = getCharSet();
if (charSet != null) {
out.write(CHARSET_BYTES);
out.write(EncodingUtils.getAsciiBytes(charSet));
}
}
} | java | {
"resource": ""
} |
q178933 | Part.sendTransferEncodingHeader | test | protected void sendTransferEncodingHeader(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendTransferEncodingHeader(OutputStream out)"); }
final String transferEncoding = getTransferEncoding();
if (transferEncoding != null) {
out.write(CRLF_BYTES);
out.write(CONTENT_TRANSFER_ENCODING_BYTES);
out.write(EncodingUtils.getAsciiBytes(transferEncoding));
}
} | java | {
"resource": ""
} |
q178934 | Part.sendEndOfHeader | test | protected void sendEndOfHeader(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendEndOfHeader(OutputStream out)"); }
out.write(CRLF_BYTES);
out.write(CRLF_BYTES);
} | java | {
"resource": ""
} |
q178935 | Part.sendEnd | test | protected void sendEnd(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendEnd(OutputStream out)"); }
out.write(CRLF_BYTES);
} | java | {
"resource": ""
} |
q178936 | Part.sendParts | test | public static void sendParts(final OutputStream out, final Part[] parts, final byte[] partBoundary)
throws IOException {
if (parts == null) {
throw new IllegalArgumentException("Parts may not be null");
}
if (partBoundary == null || partBoundary.length == 0) {
throw new IllegalArgumentException("partBoundary may not be empty");
}
for (int i = 0; i < parts.length; i++) {
// set the part boundary before the part is sent
parts[i].setPartBoundary(partBoundary);
parts[i].send(out);
}
out.write(EXTRA_BYTES);
out.write(partBoundary);
out.write(EXTRA_BYTES);
out.write(CRLF_BYTES);
} | java | {
"resource": ""
} |
q178937 | Part.getLengthOfParts | test | public static long getLengthOfParts(final Part[] parts, final byte[] partBoundary) throws IOException {
if (DEBUG) { Log.v(TAG, "getLengthOfParts(Parts[])"); }
if (parts == null) {
throw new IllegalArgumentException("Parts may not be null");
}
long total = 0;
for (int i = 0; i < parts.length; i++) {
// set the part boundary before we calculate the part's length
parts[i].setPartBoundary(partBoundary);
final long l = parts[i].length();
if (l < 0) {
return -1;
}
total += l;
}
total += EXTRA_BYTES.length;
total += partBoundary.length;
total += EXTRA_BYTES.length;
total += CRLF_BYTES.length;
return total;
} | java | {
"resource": ""
} |
q178938 | WebsockifyProxyHandler.isRedirect | test | private String isRedirect(String uri) throws URISyntaxException, MalformedURLException {
// Decode the path.
URI url = new URI (uri);
if ( REDIRECT_PATH.equals(url.getPath()) ) {
String query = url.getRawQuery();
Map<String, String> params = getQueryMap(query);
String urlParam = params.get(URL_PARAMETER);
if ( urlParam == null ) return null;
try {
return URLDecoder.decode(urlParam, "UTF-8");
} catch (UnsupportedEncodingException e) {
Logger.getLogger(WebsockifyProxyHandler.class.getName()).severe(e.getMessage());
}
}
return null;
} | java | {
"resource": ""
} |
q178939 | WebsockifyProxyHandler.sendNotModified | test | private void sendNotModified(ChannelHandlerContext ctx) {
HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.NOT_MODIFIED);
setDateHeader(response);
// Close the connection as soon as the error message is sent.
ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE);
} | java | {
"resource": ""
} |
q178940 | WebsockifyProxyHandler.setDateHeader | test | private void setDateHeader(HttpResponse response) {
SimpleDateFormat dateFormatter = new SimpleDateFormat(HTTP_DATE_FORMAT, Locale.US);
dateFormatter.setTimeZone(TimeZone.getTimeZone(HTTP_DATE_GMT_TIMEZONE));
Calendar time = new GregorianCalendar();
response.setHeader(HttpHeaders.Names.DATE, dateFormatter.format(time.getTime()));
} | java | {
"resource": ""
} |
q178941 | WebsockifyProxyHandler.setDateAndCacheHeaders | test | private void setDateAndCacheHeaders(HttpResponse response, File fileToCache) {
SimpleDateFormat dateFormatter = new SimpleDateFormat(HTTP_DATE_FORMAT, Locale.US);
dateFormatter.setTimeZone(TimeZone.getTimeZone(HTTP_DATE_GMT_TIMEZONE));
// Date header
Calendar time = new GregorianCalendar();
response.setHeader(HttpHeaders.Names.DATE, dateFormatter.format(time.getTime()));
// Add cache headers
time.add(Calendar.SECOND, HTTP_CACHE_SECONDS);
response.setHeader(HttpHeaders.Names.EXPIRES, dateFormatter.format(time.getTime()));
response.setHeader(HttpHeaders.Names.CACHE_CONTROL, "private, max-age=" + HTTP_CACHE_SECONDS);
response.setHeader(HttpHeaders.Names.LAST_MODIFIED, dateFormatter.format(new Date(fileToCache.lastModified())));
} | java | {
"resource": ""
} |
q178942 | WebsockifyProxyHandler.setContentTypeHeader | test | private void setContentTypeHeader(HttpResponse response, File file) {
MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
response.setHeader(HttpHeaders.Names.CONTENT_TYPE, mimeTypesMap.getContentType(file.getPath()));
} | java | {
"resource": ""
} |
q178943 | WebsockifyProxyHandler.closeOnFlush | test | static void closeOnFlush(Channel ch) {
if (ch.isConnected()) {
ch.write(ChannelBuffers.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
}
} | java | {
"resource": ""
} |
q178944 | FilePart.sendDispositionHeader | test | @Override
protected void sendDispositionHeader(final OutputStream out) throws IOException {
if (DEBUG) { Log.v("FilePart", "enter sendDispositionHeader(OutputStream out)"); }
super.sendDispositionHeader(out);
final String filename = this.source.getFileName();
if (filename != null) {
out.write(FILE_NAME_BYTES);
out.write(QUOTE_BYTES);
out.write(EncodingUtils.getAsciiBytes(filename));
out.write(QUOTE_BYTES);
}
} | java | {
"resource": ""
} |
q178945 | FilePart.sendData | test | @Override
protected void sendData(final OutputStream out) throws IOException {
if (DEBUG) { Log.v(TAG, "enter sendData(OutputStream out)"); }
if (lengthOfData() == 0) {
// this file contains no data, so there is nothing to send.
// we don't want to create a zero length buffer as this will
// cause an infinite loop when reading.
if (DEBUG) { Log.d(TAG, "No data to send."); }
return;
}
final int size = 4096;
final byte[] tmp = new byte[size];
final InputStream instream = source.createInputStream();
try {
int len;
while ((len = instream.read(tmp)) >= 0) {
out.write(tmp, 0, len);
}
} finally {
// we're done with the stream, close it
instream.close();
}
} | java | {
"resource": ""
} |
q178946 | BaseFileResponseCache.install | test | protected void install(final int version) throws IOException {
if (buffersPool == null) {
throw new IllegalStateException("Buffers pool is not resolved");
}
diskCache = DiskLruCache.open(ensureWorkingDirectory(), version, ENTRIES_COUNT, getMaxSize());
onCacheInstalled();
} | java | {
"resource": ""
} |
q178947 | BaseFileResponseCache.ensureWorkingDirectory | test | private synchronized File ensureWorkingDirectory() throws IOException {
File directory = getWorkingDirectory();
if (!directory.exists()) {
if (!directory.mkdirs()) {
throw new IOException("Working directory " + directory + " cannot be created");
}
} else {
if (!directory.isDirectory()) {
if (!directory.delete()) {
throw new IOException(directory + " is not a directory and cannot be deleted");
}
if (!directory.mkdirs()) {
throw new IOException("Working directory " + directory + " cannot be recreated");
}
}
}
return directory;
} | java | {
"resource": ""
} |
q178948 | BaseFileResponseCache.get | test | protected CacheResponse get(final CacheEntry requestInfo) {
if (!checkDiskCache()) { return null; }
final CacheEntry entry = newCacheEntry();
final DiskLruCache.Snapshot snapshot = readCacheInfo(requestInfo, entry);
if (snapshot == null) { return null; }
if (!entry.matches(requestInfo) || !entry.canBeUsed()) {
snapshot.close();
return null;
}
hitCount.incrementAndGet();
final InputStream body = newBodyInputStream(snapshot);
return entry.newCacheResponse(body);
} | java | {
"resource": ""
} |
q178949 | BaseFileResponseCache.newBodyInputStream | test | private InputStream newBodyInputStream(final DiskLruCache.Snapshot snapshot) {
return new FilterInputStream(snapshot.getInputStream(ENTRY_BODY)) {
@Override public void close() throws IOException {
snapshot.close();
super.close();
}
};
} | java | {
"resource": ""
} |
q178950 | BufferBitmapDecorator.reset | test | protected void reset(final int width, final int height) {
Bitmap bitmap = this.bitmap;
// recycle old buffer
if (bitmap != null) { bitmap.recycle(); }
bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); // high quality
this.bitmap = bitmap;
this.bitmapCanvas = new Canvas(bitmap);
} | java | {
"resource": ""
} |
q178951 | WebsockifySslContext.getInstance | test | public static WebsockifySslContext getInstance(String keystore, String password, String keyPassword) {
WebsockifySslContext context = SingletonHolder.INSTANCE_MAP.get(keystore);
if ( context == null )
{
context = new WebsockifySslContext ( keystore, password, keyPassword );
SingletonHolder.INSTANCE_MAP.put(keystore, context);
}
return context;
} | java | {
"resource": ""
} |
q178952 | WebsockifySslContext.validateKeystore | test | public static void validateKeystore ( String keystore, String password, String keyPassword )
throws KeyManagementException, UnrecoverableKeyException, IOException, NoSuchAlgorithmException, CertificateException, KeyStoreException
{
getSSLContext(keystore, password, keyPassword);
} | java | {
"resource": ""
} |
q178953 | ImageView.replaceScaleType | test | public ScaleType replaceScaleType(final ScaleType type) {
blockLayoutRequests = true;
final ScaleType result = getScaleType();
setScaleType(type);
blockLayoutRequests = false;
return result;
} | java | {
"resource": ""
} |
q178954 | LocationBinder.stopListening | test | public void stopListening() {
if (locationManager == null) { return; }
if (DEBUG) { Log.d(TAG, "Stop location listening..."); }
if (listener != null) {
listener.onLocationStop();
}
myHandler.removeMessages(MSG_STOP_FINE_PROVIDER);
locationManager.removeUpdates(coarseListener);
locationManager.removeUpdates(fineListener);
locationManager = null;
} | java | {
"resource": ""
} |
q178955 | ServiceRequestPerformer.getPendingIntent | test | public PendingIntent getPendingIntent(final RequestBuilder<?> requestBuilder, final int flags) {
return PendingIntent.getService(context, 0, getIntent(requestBuilder), flags);
} | java | {
"resource": ""
} |
q178956 | RequestMethod.disconnect | test | protected void disconnect(final URLConnection connection) {
final URLConnection http = UrlConnectionWrapper.unwrap(connection);
if (http instanceof HttpURLConnection) {
((HttpURLConnection) http).disconnect();
}
} | java | {
"resource": ""
} |
q178957 | ApplicationServiceSupport.bind | test | public void bind() {
if (serviceObject != null) { return; }
final Context context = contextRef.get();
if (context == null) { return; }
// TODO make it configurable
final Intent intent = new Intent(context, GoroService.class);
intent.setAction(getInterfaceClass().getName());
if (DEBUG_CALLS) {
Log.v(TAG, "Attempt to bind to service " + this + "/" + context, new RuntimeException());
}
// start manually, so that it will be stopped manually
context.startService(intent);
final boolean bindResult = context.bindService(intent, this, 0);
if (DEBUG) { Log.v(TAG, "Binded to service: " + bindResult + ", " + context + ", interface: " + getInterfaceClass()); }
} | java | {
"resource": ""
} |
q178958 | ApplicationServiceSupport.unbind | test | public void unbind() {
if (serviceObject == null) { return; }
serviceObject = null;
final Context context = contextRef.get();
if (DEBUG) { Log.v(TAG, "Unbind " + context + " from " + getInterfaceClass()); }
if (context == null) { return; }
try {
context.unbindService(this);
} catch (final Exception e) {
if (DEBUG) { Log.e(TAG, "Cannot unbind from application service", e); }
}
} | java | {
"resource": ""
} |
q178959 | ViewImageConsumer.notifyAboutViewChanges | test | public void notifyAboutViewChanges() {
final T view = this.view;
if (view != null && view instanceof ImagesLoadListenerProvider) {
this.listener = ((ImagesLoadListenerProvider)view).getImagesLoadListener();
}
} | java | {
"resource": ""
} |
q178960 | DirectProxyHandler.channelOpen | test | @Override
public void channelOpen(final ChannelHandlerContext ctx, final ChannelStateEvent e)
throws Exception {
try {
// make the proxy connection
ensureTargetConnection ( e.getChannel(), false, null );
} catch (Exception ex) {
// target connection failed, so close the client connection
e.getChannel().close();
ex.printStackTrace();
}
} | java | {
"resource": ""
} |
q178961 | RequestBuilderLoader.onAcceptData | test | protected ResponseData<MT> onAcceptData(final ResponseData<MT> previousData, final ResponseData<MT> responseData) {
return responseData;
} | java | {
"resource": ""
} |
q178962 | RequestBuilderLoader.onReset | test | @Override
protected void onReset() {
if (DEBUG) { Log.v(TAG, "onReset " + this); }
super.onReset();
onStopLoading();
if (receivedResponse != null) {
onReleaseData(receivedResponse);
receivedResponse = null;
}
} | java | {
"resource": ""
} |
q178963 | RequestBuilderLoader.waitForLoader | test | void waitForLoader(final long time) {
try {
done.await(time, TimeUnit.MILLISECONDS);
} catch (final InterruptedException e) {
Log.e(TAG, "waitForLoader() ininterrupted", e);
}
} | java | {
"resource": ""
} |
q178964 | GUIUtils.setTextOrHide | test | public static void setTextOrHide(final TextView view, final CharSequence text, final int hvisibility) {
if (TextUtils.isEmpty(text)) {
view.setVisibility(hvisibility);
} else {
view.setText(text);
view.setVisibility(View.VISIBLE);
}
} | java | {
"resource": ""
} |
q178965 | GUIUtils.hideSoftInput | test | public static void hideSoftInput(final View textView) {
try {
final InputMethodManager imm = (InputMethodManager)textView.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(textView.getWindowToken(), 0);
} catch (final Exception e) {
Log.w(TAG, "Ignore exception", e);
}
} | java | {
"resource": ""
} |
q178966 | GUIUtils.showSoftInput | test | public static void showSoftInput(final View textView) {
try {
final InputMethodManager imm = (InputMethodManager)textView.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(textView, InputMethodManager.SHOW_FORCED);
} catch (final Exception e) {
Log.w(TAG, "Ignore exception", e);
}
} | java | {
"resource": ""
} |
q178967 | GUIUtils.toggleSoftInput | test | public static void toggleSoftInput(final View textView) {
try {
final InputMethodManager imm = (InputMethodManager)textView.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInputFromWindow(textView.getWindowToken(), 0, 0);
} catch (final Exception e) {
Log.w(TAG, "Ignore exception", e);
}
} | java | {
"resource": ""
} |
q178968 | GUIUtils.pixelsWidth | test | public static int pixelsWidth(final DisplayMetrics displayMetrics, final int dip) {
final float scale = displayMetrics.density;
final float alpha = 0.5f;
return (int)(dip * scale + alpha);
} | java | {
"resource": ""
} |
q178969 | PortUnificationHandler.exceptionCaught | test | @Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
throws Exception {
cancelDirectConnectionTimer ( );
Logger.getLogger(PortUnificationHandler.class.getName()).severe("Exception on connection to " + ctx.getChannel().getRemoteAddress() + ": " + e.getCause().getMessage() );
} | java | {
"resource": ""
} |
q178970 | ImagesManager.clearCache | test | public boolean clearCache(final String url) {
memCache.remove(url);
try {
return imagesResponseCache.deleteGetEntry(url);
} catch (final IOException e) {
Log.w(TAG, "Cannot clear disk cache for " + url, e);
return false;
}
} | java | {
"resource": ""
} |
q178971 | ImagesManager.populateImage | test | public void populateImage(final View view, final String url) {
final Object tag = view.getTag();
ImageConsumer consumer = null;
if (tag == null) {
consumer = createImageConsumer(view);
view.setTag(consumer);
} else {
if (!(tag instanceof ImageConsumer)) {
throw new IllegalStateException("View already has a tag " + tag + ". Cannot store consumer");
}
consumer = (ImageConsumer)tag;
}
populateImage(consumer, url);
} | java | {
"resource": ""
} |
q178972 | ImagesManager.cancelImageLoading | test | public void cancelImageLoading(final View view) {
checkThread();
final Object tag = view.getTag();
if (tag != null && tag instanceof ImageConsumer) {
cancelImageLoading((ImageConsumer)tag);
}
} | java | {
"resource": ""
} |
q178973 | ImagesManager.createImageConsumer | test | protected ImageConsumer createImageConsumer(final View view) {
if (this.consumerFactory == null) {
throw new IllegalStateException("Image consumers factory bean not found in container. Take a look at DefaultBeansManager.edit().images() method in assist package.");
}
return consumerFactory.createConsumer(view);
} | java | {
"resource": ""
} |
q178974 | ImagesManager.setResultImage | test | protected final void setResultImage(final ImageConsumer consumer, final ImageResult result, final boolean animate) {
decorateResult(consumer, result);
consumer.setImage(createDrawable(result.getBitmap()), animate);
consumer.reset();
} | java | {
"resource": ""
} |
q178975 | ImagesManager.setLoadingImage | test | private void setLoadingImage(final ImageConsumer consumer) {
if (!consumer.skipLoadingImage()) {
Drawable d = getLoadingDrawable(consumer);
if (!consumer.hasUndefinedSize() || (d.getIntrinsicWidth() != 0 && d.getIntrinsicHeight() != 0)) {
consumer.setLoadingImage(d);
}
}
} | java | {
"resource": ""
} |
q178976 | ImagesManager.startImageLoaderTask | test | private void startImageLoaderTask(final ImageConsumer consumer, final ImageRequest request) {
final String key = request.getKey();
if (debug) { Log.d(TAG, "Key " + key); }
ImageLoader loader = currentLoads.get(key);
if (loader != null) {
final boolean added = loader.addTarget(consumer);
if (!added) { loader = null; }
}
if (loader == null) {
if (debug) { Log.d(TAG, "Start a new task"); }
loader = new ImageLoader(request, this);
if (!loader.addTarget(consumer)) {
throw new IllegalStateException("Cannot add target to the new loader");
}
currentLoads.put(key, loader);
if (debug) { Log.d(TAG, "Current loaders count: " + currentLoads.size()); }
final Executor executor = getImageTaskExecutor();
executor.execute(loader.future);
} else if (debug) {
Log.d(TAG, "Joined to the existing task " + key);
}
} | java | {
"resource": ""
} |
q178977 | ImagesManager.memCacheImage | test | protected void memCacheImage(final String url, final Bitmap bitmap) {
if (debug) { Log.d(TAG, "Memcache for " + url); }
memCache.putElement(url, bitmap);
} | java | {
"resource": ""
} |
q178978 | BuffersPool.release | test | public void release(final byte[] buffer) {
if (buffer == null) {
return;
}
final int capacity = buffer.length;
if (capacity == 0) {
return;
}
synchronized (lock) {
List<Object> bList = buffers.get(capacity);
if (bList == null) {
bList = new LinkedList<Object>();
buffers.put(capacity, bList);
}
bList.add(buffer);
usedBuffersCount--;
}
} | java | {
"resource": ""
} |
q178979 | RequestDescription.onURLConnectionPrepared | test | protected void onURLConnectionPrepared(final Context context, final URLConnection urlConnection) {
if (contentType != null) {
urlConnection.addRequestProperty("Content-Type", contentType);
}
if (contentLanguage != null) {
urlConnection.addRequestProperty("Accept-Language", contentLanguage);
}
urlConnection.addRequestProperty("Accept-Encoding", IoUtils.ENCODING_GZIP);
urlConnection.addRequestProperty("User-Agent", buildUserAgent(context));
if (headers != null) {
for (String name : headers.keySet()) {
urlConnection.addRequestProperty(name, headers.getString(name));
}
}
} | java | {
"resource": ""
} |
q178980 | SimpleRequestBuilder.addParam | test | public SimpleRequestBuilder<MT> addParam(final String name, final String value) {
addSimpleParameter(name, value);
return this;
} | java | {
"resource": ""
} |
q178981 | CacheControlUrlConnection.connectWithWorkaround | test | private void connectWithWorkaround() throws IOException {
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.GINGERBREAD_MR1) {
super.connect();
return;
}
URLConnection coreConnection = UrlConnectionWrapper.unwrap(getCore());
if (coreConnection instanceof HttpsURLConnection) {
// CHECKSTYLE:OFF
try {
super.connect();
} catch (NullPointerException e) {
// ignore this NP
}
// CHECKSTYLE:ON
} else {
super.connect();
}
} | java | {
"resource": ""
} |
q178982 | Md5.getMd5 | test | public static String getMd5(final String text) {
try {
final MessageDigest md = MessageDigest.getInstance("MD5");
final byte[] utf8Bytes = text.getBytes(UTF_8_NAME);
md.update(utf8Bytes, 0, utf8Bytes.length);
final byte[] md5hash = md.digest();
final int radix = 16;
final int length = 32;
final StringBuilder result = new StringBuilder(length).append(new BigInteger(1, md5hash).toString(radix));
final int zeroBeginLen = length - result.length();
if (zeroBeginLen > 0) {
final char [] zeroBegin = new char[zeroBeginLen];
Arrays.fill(zeroBegin, Character.forDigit(0, radix));
result.insert(0, zeroBegin);
}
return result.toString();
} catch (final NoSuchAlgorithmException|UnsupportedEncodingException e) {
throw new AssertionError(e);
}
} | java | {
"resource": ""
} |
q178983 | cublasGemmAlgo.stringFor | test | public static String stringFor(int n)
{
switch (n)
{
case CUBLAS_GEMM_DEFAULT: return "CUBLAS_GEMM_DEFAULT";
case CUBLAS_GEMM_ALGO0: return "CUBLAS_GEMM_ALGO0";
case CUBLAS_GEMM_ALGO1: return "CUBLAS_GEMM_ALGO1";
case CUBLAS_GEMM_ALGO2: return "CUBLAS_GEMM_ALGO2";
case CUBLAS_GEMM_ALGO3: return "CUBLAS_GEMM_ALGO3";
case CUBLAS_GEMM_ALGO4: return "CUBLAS_GEMM_ALGO4";
case CUBLAS_GEMM_ALGO5: return "CUBLAS_GEMM_ALGO5";
case CUBLAS_GEMM_ALGO6: return "CUBLAS_GEMM_ALGO6";
case CUBLAS_GEMM_ALGO7: return "CUBLAS_GEMM_ALGO7";
case CUBLAS_GEMM_ALGO8: return "CUBLAS_GEMM_ALGO8";
case CUBLAS_GEMM_ALGO9: return "CUBLAS_GEMM_ALGO9";
case CUBLAS_GEMM_ALGO10: return "CUBLAS_GEMM_ALGO10";
case CUBLAS_GEMM_ALGO11: return "CUBLAS_GEMM_ALGO11";
case CUBLAS_GEMM_ALGO12: return "CUBLAS_GEMM_ALGO12";
case CUBLAS_GEMM_ALGO13: return "CUBLAS_GEMM_ALGO13";
case CUBLAS_GEMM_ALGO14: return "CUBLAS_GEMM_ALGO14";
case CUBLAS_GEMM_ALGO15: return "CUBLAS_GEMM_ALGO15";
case CUBLAS_GEMM_ALGO16: return "CUBLAS_GEMM_ALGO16";
case CUBLAS_GEMM_ALGO17: return "CUBLAS_GEMM_ALGO17";
case CUBLAS_GEMM_ALGO18: return "CUBLAS_GEMM_ALGO18";
case CUBLAS_GEMM_ALGO19: return "CUBLAS_GEMM_ALGO19";
case CUBLAS_GEMM_ALGO20: return "CUBLAS_GEMM_ALGO20";
case CUBLAS_GEMM_ALGO21: return "CUBLAS_GEMM_ALGO21";
case CUBLAS_GEMM_ALGO22: return "CUBLAS_GEMM_ALGO22";
case CUBLAS_GEMM_ALGO23: return "CUBLAS_GEMM_ALGO23";
case CUBLAS_GEMM_DEFAULT_TENSOR_OP: return "CUBLAS_GEMM_DEFAULT_TENSOR_OP";
case CUBLAS_GEMM_ALGO0_TENSOR_OP: return "CUBLAS_GEMM_ALGO0_TENSOR_OP";
case CUBLAS_GEMM_ALGO1_TENSOR_OP: return "CUBLAS_GEMM_ALGO1_TENSOR_OP";
case CUBLAS_GEMM_ALGO2_TENSOR_OP: return "CUBLAS_GEMM_ALGO2_TENSOR_OP";
case CUBLAS_GEMM_ALGO3_TENSOR_OP: return "CUBLAS_GEMM_ALGO3_TENSOR_OP";
case CUBLAS_GEMM_ALGO4_TENSOR_OP: return "CUBLAS_GEMM_ALGO4_TENSOR_OP";
case CUBLAS_GEMM_ALGO5_TENSOR_OP: return "CUBLAS_GEMM_ALGO5_TENSOR_OP";
case CUBLAS_GEMM_ALGO6_TENSOR_OP: return "CUBLAS_GEMM_ALGO6_TENSOR_OP";
case CUBLAS_GEMM_ALGO7_TENSOR_OP: return "CUBLAS_GEMM_ALGO7_TENSOR_OP";
case CUBLAS_GEMM_ALGO8_TENSOR_OP: return "CUBLAS_GEMM_ALGO8_TENSOR_OP";
case CUBLAS_GEMM_ALGO9_TENSOR_OP: return "CUBLAS_GEMM_ALGO9_TENSOR_OP";
case CUBLAS_GEMM_ALGO10_TENSOR_OP: return "CUBLAS_GEMM_ALGO10_TENSOR_OP";
case CUBLAS_GEMM_ALGO11_TENSOR_OP: return "CUBLAS_GEMM_ALGO11_TENSOR_OP";
case CUBLAS_GEMM_ALGO12_TENSOR_OP: return "CUBLAS_GEMM_ALGO12_TENSOR_OP";
case CUBLAS_GEMM_ALGO13_TENSOR_OP: return "CUBLAS_GEMM_ALGO13_TENSOR_OP";
case CUBLAS_GEMM_ALGO14_TENSOR_OP: return "CUBLAS_GEMM_ALGO14_TENSOR_OP";
}
return "INVALID cublasGemmAlgo: "+n;
} | java | {
"resource": ""
} |
q178984 | cublasStatus.stringFor | test | public static String stringFor(int n)
{
switch (n)
{
case CUBLAS_STATUS_SUCCESS : return "CUBLAS_STATUS_SUCCESS";
case CUBLAS_STATUS_NOT_INITIALIZED : return "CUBLAS_STATUS_NOT_INITIALIZED";
case CUBLAS_STATUS_ALLOC_FAILED : return "CUBLAS_STATUS_ALLOC_FAILED";
case CUBLAS_STATUS_INVALID_VALUE : return "CUBLAS_STATUS_INVALID_VALUE";
case CUBLAS_STATUS_ARCH_MISMATCH : return "CUBLAS_STATUS_ARCH_MISMATCH";
case CUBLAS_STATUS_MAPPING_ERROR : return "CUBLAS_STATUS_MAPPING_ERROR";
case CUBLAS_STATUS_EXECUTION_FAILED : return "CUBLAS_STATUS_EXECUTION_FAILED";
case CUBLAS_STATUS_INTERNAL_ERROR : return "CUBLAS_STATUS_INTERNAL_ERROR";
case CUBLAS_STATUS_NOT_SUPPORTED : return "CUBLAS_STATUS_NOT_SUPPORTED";
case JCUBLAS_STATUS_INTERNAL_ERROR : return "JCUBLAS_STATUS_INTERNAL_ERROR";
}
return "INVALID cublasStatus: "+n;
} | java | {
"resource": ""
} |
q178985 | JCublas2.checkResult | test | private static int checkResult(int result)
{
if (exceptionsEnabled && result != cublasStatus.CUBLAS_STATUS_SUCCESS)
{
throw new CudaException(cublasStatus.stringFor(result));
}
return result;
} | java | {
"resource": ""
} |
q178986 | JCublas.checkResultBLAS | test | private static void checkResultBLAS()
{
if (exceptionsEnabled)
{
lastResult = cublasGetErrorNative();
if (lastResult != cublasStatus.CUBLAS_STATUS_SUCCESS)
{
throw new CudaException(cublasStatus.stringFor(lastResult));
}
}
} | java | {
"resource": ""
} |
q178987 | Statistics.addLexeme | test | public void addLexeme(int lexemeId) {
int count = 1;
if (lexemeFrequency.get(lexemeId) != null)
count = lexemeFrequency.get(lexemeId) + 1;
lexemeFrequency.put(lexemeId, count);
} | java | {
"resource": ""
} |
q178988 | Statistics.addEnding | test | public void addEnding(int endingId) {
int count = 1;
if (endingFrequency.get(endingId) != null)
count = endingFrequency.get(endingId) + 1;
endingFrequency.put(endingId, count);
} | java | {
"resource": ""
} |
q178989 | Statistics.getEstimate | test | public double getEstimate(AttributeValues wordform) {
double estimate = 0.1;
String endingIdStr = wordform.getValue(AttributeNames.i_EndingID);
int endingId = (endingIdStr == null) ? -1 : Integer.parseInt(endingIdStr);
if (endingFrequency.get(endingId) != null) estimate += endingFrequency.get(endingId);
String lexemeIdStr = wordform.getValue(AttributeNames.i_LexemeID);
int lexemeId = (lexemeIdStr == null) ? -1 : Integer.parseInt(lexemeIdStr);
if (lexemeFrequency.get(lexemeId) != null) estimate += lexemeFrequency.get(lexemeId) * lexemeWeight;
return estimate;
} | java | {
"resource": ""
} |
q178990 | Wordform.longDescription | test | public void longDescription(PrintStream out)
{
out.println(this.token + ":");
for (String s : this.attributes.keySet())
{
out.println(s + "\t" + attributes.get(s));
}
} | java | {
"resource": ""
} |
q178991 | MarkupConverter.verifyAndSetKamolsAttribute | test | private static void verifyAndSetKamolsAttribute(
AttributeValues avs, StringBuilder tag, int index,
char tagValue, String attribute, String attributeValue) {
if (avs.isMatchingStrong(attribute, attributeValue))
tag.setCharAt(index, tagValue);
} | java | {
"resource": ""
} |
q178992 | MarkupConverter.toKamolsMarkup | test | public static String toKamolsMarkup(AttributeValues avs) {
StringBuilder res = toKamolsMarkup(avs, defaulti);
if (res.length() < 1) return res.toString();
// if (res.charAt(0) == 'v' && res.charAt(1) == '_') res.setCharAt(1, 'm'); PP 2012.12.07 - nezinu kāpēc tas te ir, bet tas čakarē tagošanu (jo tagsvm.... neatbilst nevienam varēt vai būt verbam)
// if (res.charAt(0) == 'p' && res.charAt(6) == '_') res.setCharAt(6, 'n');
// if (res.charAt(0) == 'v' && res.charAt(3) != 'p' && res.charAt(10) == '_') res.setCharAt(10, 'n');
return res.toString();
} | java | {
"resource": ""
} |
q178993 | MarkupConverter.verifyAndSetAVSAttribute | test | private static void verifyAndSetAVSAttribute(
String tag, FeatureStructure avs, int index, char tagValue,
String attribute, String attributeValue) {
//TODO - šī metode 'silently fails' uz jauniem variantiem/simboliem
//marķējumā. Normāli atrisinās tikai šīs klases pāreja uz xml
//konfigfaila apstrādi
if (index >= tag.length()) return;
if (tag.charAt(index) == tagValue)
avs.addAttribute(attribute, attributeValue);
} | java | {
"resource": ""
} |
q178994 | MarkupConverter.removeKamolsMarkupFormating | test | public static String removeKamolsMarkupFormating(String tag){
String result = "";
if (!tag.contains(",")) return "x";
int depth = 0;
int commas = 0;
for (char c : tag.toCharArray()) {
if (c=='[') depth++;
if (c==']') depth--;
if (depth == 1 && c==',') commas++;
if (commas == 2) result = result + c;
}
result = result.replaceAll("_[A-Z0-9]*" , "_");
result = result.replaceAll("(\\[|\\]|\\,| )","");
return result;
} | java | {
"resource": ""
} |
q178995 | MetricDataRequest.get | test | public List<MetricData> get() throws RequestException, UnauthorizedException {
HttpResponse<String> response;
try {
response = Unirest.get(
this.appdURL + "/controller/rest/applications/" + appName + "/metric-data")
.header("accept", "application/json")
.basicAuth(this.appdUsername, this.appdPassword)
.queryString(getQueryString())
.queryString("output", "json")
.asString();
} catch (UnirestException e) {
throw new RequestException("Something was wrong with sending request.", e);
}
if (response == null) {
throw new RequestException("Response is empty.");
}
switch (response.getStatus()) {
case 200: {
return process(new JsonNode(response.getBody()));
}
case 401: {
throw new UnauthorizedException("Authentication failed");
}
default: {
throw new RequestException("Unhandled response code " + response.getStatus());
}
}
} | java | {
"resource": ""
} |
q178996 | MetricDataRequest.getQueryString | test | protected Map<String, Object> getQueryString() {
Map<String, Object> qs = new HashMap<>();
if (timeParams != null) {
qs.put("time-range-type", timeParams.type);
if (timeParams.duration > 0) {
qs.put("duration-in-mins", timeParams.duration);
}
if (timeParams.startTime > 0) {
qs.put("start-time", timeParams.startTime);
}
if (timeParams.endTime > 0) {
qs.put("end-time", timeParams.endTime);
}
}
qs.put("rollup", false);
if (metricPath != null) {
qs.put("metric-path", metricPath);
}
return qs;
} | java | {
"resource": ""
} |
q178997 | MetricDataRequest.process | test | protected List<MetricData> process(JsonNode node) {
JSONArray dataArray = node.getArray();
List<MetricData> list = new LinkedList<>();
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
MetricData metricData =
new MetricData(data.getString("frequency"), data.getLong("metricId"),
data.getString("metricName"), data.getString("metricPath"));
list.add(metricData);
JSONArray valueArray = data.getJSONArray("metricValues");
for (int j = 0; j < valueArray.length(); j++) {
JSONObject value = valueArray.getJSONObject(j);
metricData.metricValues.add(
new MetricValue(value.getLong("count"), value.getLong("value"),
value.getLong("max"), value.getLong("min"), value.getLong("sum"),
value.getLong("startTimeInMillis")));
}
}
return list;
} | java | {
"resource": ""
} |
q178998 | InfoParser.parseInfo | test | public static List<AppInfo> parseInfo(String jsonString) throws IOException {
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(jsonString, new TypeReference<List<AppInfo>>() {});
} | java | {
"resource": ""
} |
q178999 | Config.getConnectionConfig | test | public static ConnectionConfig getConnectionConfig() {
boolean isValid = true;
String appdUsername = getPropertyOrEnv("com.signalfx.appd.username", "APPD_USERNAME");
if (StringUtils.isEmpty(appdUsername)) {
log.error("AppDynamics username not specified.");
isValid = false;
}
String appdPassword = getPropertyOrEnv("com.signalfx.appd.password", "APPD_PASSWORD");
if (StringUtils.isEmpty(appdPassword)) {
log.error("AppDynamics password not specified.");
isValid = false;
}
String appdURL = getPropertyOrEnv("com.signalfx.appd.host", "APPD_HOST");
if (StringUtils.isEmpty(appdURL)) {
log.error("AppDynamics host not specified.");
isValid = false;
}
String fxToken = getPropertyOrEnv("com.signalfx.api.token", "SIGNALFX_TOKEN");
if (StringUtils.isEmpty(fxToken)) {
log.error("SignalFx token not specified.");
isValid = false;
}
if (isValid) {
return new ConnectionConfig(appdUsername, appdPassword, appdURL, fxToken);
} else {
return null;
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.