code stringlengths 73 34.1k | label stringclasses 1
value |
|---|---|
public static <T> void gauge(MetricNameDetails nameDetails, final Callable<T> impl) {
gauge(nameDetails, new Gauge<T>() {
@Override
public T getValue() {
try {
return impl.call();
}
catch (Exception ex) {
... | java |
public static byte[][] getSplitKeys(Pair<byte[][],byte[][]> regionStartsEnds) {
byte[][] starts = regionStartsEnds.getFirst();
List<byte[]> splitKeys = new ArrayList<byte[]>();
for(int i=1; i<starts.length; i++) {
splitKeys.add(starts[i]);
}
return splitKeys.... | java |
private Map<BoxedByteArray, byte[]> processBatchCallresults(List<Map.Entry<BoxedByteArray, T>> entries, Object[] objects) {
Map<BoxedByteArray, byte[]> successes = new HashMap<>();
for (int i = 0; i < objects.length; ++i) {
if (objects[i] != null && objects[i] instanceof Result) {
... | java |
private Future<?> runBatch(Batch<T> batch) throws InterruptedException {
while (true) {
try {
runBatchMeter.mark();
if (perRollupMetrics) {
batch.getMap().forEach((addr, op) -> {
if (addr.getSourceRollup().isPresent()) {
... | java |
@Override
public Future<?> runBatchAsync(Batch<T> batch, AfterExecute<T> afterExecute) throws FullQueueException {
/*
* Since ThreadPoolExecutor throws RejectedExecutionException when its queue is full,
* we have to backoff and retry if execute() throws RejectedExecutionHandler.
... | java |
public Batch<T> getWrites(WriteBuilder writeBuilder, T op) {
Map<Address, T> outputMap = Maps.newHashMap();
for (Rollup rollup : rollups) {
List<Set<byte[]>> coordSets =
new ArrayList<Set<byte[]>>(rollup.getComponents().size());
boolean dimensionHadNoBucket... | java |
public static List<Scan> scansThisCubeOnly(byte[] keyPrefix,
byte[][] splitKeys) throws IOException {
Scan copyScan = new Scan();
copyScan.setCaching(5000);
copyScan.setCacheBlocks(false);
// Hack: generate a key that probably comes after a... | java |
private static final Scan truncateScan(Scan scan, byte[] rangeStart, byte[] rangeEnd) {
byte[] scanStart = scan.getStartRow();
byte[] scanEnd = scan.getStopRow();
if (scanEnd.length > 0 && bytesCompare(scanEnd, rangeStart) <= 0) {
// The entire scan range is before the entire cube k... | java |
@SuppressWarnings("unchecked")
@Override
public Future<?> runBatchAsync(Batch<T> batch, AfterExecute<T> afterExecute) {
for (Map.Entry<Address, T> entry : batch.getMap().entrySet()) {
Address address = entry.getKey();
T opFromBatch = entry.getValue();
BoxedByteArray... | java |
@Override
public ListMultimap<Iterator<T>, T> next() {
ListMultimap<Iterator<T>, T> results = ArrayListMultimap.create();
while (true) {
HeapEntry heapEntry = heap.poll();
if (heapEntry == null) {
break; // heap is empty
}
results.put(i... | java |
private T nextWrapper(Iterator<T> it) {
try {
if (trace != null) {
trace.add(new TraceEntry(System.nanoTime(), System.currentTimeMillis(),
NextOrHasNext.NEXT, debugLabels.get(it)));
}
return it.next();
} catch (RuntimeException ... | java |
private ObjectName createMetrics3Name(String domain, String name) throws MalformedObjectNameException {
try {
return new ObjectName(domain, "name", name);
} catch (MalformedObjectNameException e) {
return new ObjectName(domain, "name", ObjectName.quote(name));
}
} | java |
@SuppressWarnings("unchecked")
private static Deserializer<?> getDeserializer(Configuration conf) {
String deserializerClassName = conf.get(HBaseBackfillMerger.CONFKEY_DESERIALIZER);
if (deserializerClassName == null) {
throw new RuntimeException("Configuration didn't set " + deserialize... | java |
public static byte[] intToBytesWithLen(int x, int len) {
if(len <= 4) {
return trailingBytes(intToBytes(x), len);
} else {
ByteBuffer bb = ByteBuffer.allocate(len);
bb.position(len-4);
bb.putInt(x);
assert bb.remaining() == 0;
retur... | java |
public static byte hashByteArray(byte[] array, int startInclusive, int endExclusive) {
if (array == null) {
return 0;
}
int range = endExclusive - startInclusive;
if (range < 0) {
throw new IllegalArgumentException(startInclusive + " > " + endExclusive);
... | java |
public void close() {
if(nativeProxy!=0) {
new Task<Void>() {
public Void call() {
Native.unadvise(nativeProxy);
return null;
}
}.execute();
nativeProxy = 0;
}
} | java |
private static <T> EventInterfaceDescriptor<T> getDescriptor(Class<T> t) {
EventInterfaceDescriptor<T> r = descriptors.get(t);
if(r==null) {
r = new EventInterfaceDescriptor<T>(t);
descriptors.put(t,r);
}
return r;
} | java |
private void collectGarbage() {
// dispose unused objects if any
NativePointerPhantomReference toCollect;
while((toCollect = (NativePointerPhantomReference)collectableObjects.poll()) != null) {
liveComObjects.remove(toCollect);
toCollect.clear();
toCollect.releaseNative();
}
} | java |
private static String getTypeString(IType t) {
if(t==null)
return "null";
IPtrType pt = t.queryInterface(IPtrType.class);
if(pt!=null)
return getTypeString(pt.getPointedAtType())+"*";
IPrimitiveType prim = t.queryInterface(IPrimitiveType.class);
if(prim!... | java |
public void commit() throws IOException {
if(!marked) throw new IllegalStateException();
marked = false;
super.append(buffer);
buffer.setLength(0);
} | java |
public void generate( IWTypeLib lib ) throws BindingException, IOException {
LibBinder tli = getTypeLibInfo(lib);
if(referenceResolver.suppress(lib))
return; // skip code generation
if(generatedTypeLibs.add(tli))
tli.generate();
} | java |
public void finish() throws IOException {
//Map<String,Set<TypeLibInfo>> byPackage = new HashMap<String,Set<TypeLibInfo>>();
//for( TypeLibInfo tli : generatedTypeLibs ) {
// Set<TypeLibInfo> s = byPackage.get(tli.packageName);
// if(s==null)
// byPackage.put(tli.pac... | java |
ITypeDecl getDefaultInterface( ICoClassDecl t ) {
final int count = t.countImplementedInterfaces();
// look for the default interface first.
for( int i=0; i<count; i++ ) {
IImplementedInterfaceDecl impl = t.getImplementedInterface(i);
if(impl.isSource())
c... | java |
@SuppressWarnings("unchecked")
protected void messageParameters(Object[] args){
for( int i=0; i<args.length; i++ ) {
if(args[i] instanceof Holder && params[i].getNoByRef()!=null) {
// massage the value of Holder, not the Holder itself
Holder h = (Holder)args[i];
... | java |
static NativeType getDefaultConversion(Type t) {
if( t instanceof Class ) {
Class<?> c = (Class<?>)t;
NativeType r = defaultConversions.get(c);
if(r!=null) return r;
if(Com4jObject.class.isAssignableFrom(c))
return NativeType.ComObject;
... | java |
public static <T extends Enum<T>>
EnumDictionary<T> get( Class<T> clazz ) {
EnumDictionary<T> dic = registry.get(clazz);
if(dic==null) {
boolean sparse = ComEnum.class.isAssignableFrom(clazz);
if(sparse)
dic = new Sparse<T>(clazz);
else
... | java |
static <T extends Enum<T>>
T get( Class<T> clazz, int v ) {
return get(clazz).constant(v);
} | java |
public static<T extends Com4jObject>
T wrap( final Class<T> primaryInterface, final long ptr ) throws ComException {
return new Task<T>() {
@Override
public T call() {
return Wrapper.create(primaryInterface,ptr);
}
}.execute();
} | java |
public static <T extends Com4jObject> T getActiveObject(Class<T> primaryInterface, GUID clsid ) {
return new GetActiveObjectTask<T>(clsid,primaryInterface).execute();
} | java |
public static <T extends Com4jObject> T getActiveObject(Class<T> primaryInterface, String clsid ) {
return getActiveObject(primaryInterface,new GUID(clsid));
} | java |
public static <T extends Com4jObject> T getObject(Class<T> primaryInterface, String fileName, String progId ) {
return new GetObjectTask<T>(fileName,progId,primaryInterface).execute();
} | java |
public static GUID getIID( Class<?> _interface ) {
IID iid = _interface.getAnnotation(IID.class);
if(iid==null)
throw new IllegalArgumentException(_interface.getName()+" doesn't have @IID annotation");
return new GUID(iid.value());
} | java |
public Type getType() {
int varType = image.getInt(0) & 0xFFFF;
return EnumDictionary.get(Type.class).constant(varType);
} | java |
public String getParseableString(){
// TODO expand this
switch (this.getType()) {
case VT_I1:
case VT_I2:
case VT_I4:
case VT_INT:
return Integer.toString(this.intValue());
case VT_I8:
return Long.toString(this.longValue());
case VT_R4:
... | java |
public <T extends Com4jObject> T object( final Class<T> type ) {
// native method invocation changeType needs to happen in the COM thread, that is responsible for this variant
// @see ComCollection#fetch
ComThread t = thread != null ? thread : ComThread.get();
return t.execute(new Task<T... | java |
static Date toDate(double d) {
GregorianCalendar ret = new GregorianCalendar(1899,11,30);
int days = (int)d;
d -= days;
ret.add(Calendar.DATE,days);
d *= 24;
int hours = (int)d;
ret.add(Calendar.HOUR,hours);
d -= hours;
d *= 60;
// d += 0.5;... | java |
private static String cutEOL( String s ) {
if(s==null)
return "(Unknown error)";
if(s.endsWith("\r\n"))
return s.substring(0,s.length()-2);
else
return s;
} | java |
private void fetch() {
next.clear();
// We need to remember for what thread the IEnumVARIANT was marshaled. Because if we want to interpret this
// VARIANT as an interface pointer later on, we need to do this in the same thread!
next.thread = e.getComThread();
int r = e.next(1,next)... | java |
private int getReturnParam() {
// look for [retval] attribute
for (int i = 0; i < params.length; i++) {
if (params[i].isRetval()) {
return i;
}
}
// sometimes a COM method has only one [out] param.
// treat that as the return value.
// this is seen frequently in MSHTML (... | java |
private void declare(IndentingWriter o, IParam p) throws BindingException {
TypeBinding vb = TypeBinding.bind(g, p.getType(), p.getName());
String javaType = vb.javaType;
if (method.isVarArg() && p == params[params.length - 1]) {
// use varargs if applicable
if (javaType.endsWith("[]"))
... | java |
protected final void declareReturnType(IndentingWriter o, List<IType> intermediates, boolean usesDefaltValues) throws BindingException {
generateAccessModifier(o);
if (returnType == null && intermediates == null) {
o.print("void ");
} else {
// we assume that the [retval] param to be passed by ... | java |
protected final IType getDispInterfaceReturnType() {
IType r = method.getReturnType();
// if the return type is HRESULT, bind it to 'void'.
// dispinterfaces defined by C++ often uses HRESULT
// as the return value
IPrimitiveType pt = r.queryInterface(IPrimitiveType.class);
if (pt != null && pt... | java |
private void checkEnv() throws MojoExecutionException {
// check OS
String osName = System.getProperty("os.name");
if (!osName.startsWith("Windows")) {
getLog().warn("Wrong OS: " + osName);
throw new MojoExecutionException(
"Com4j can only be run on a Windows operating system, and you're running: "
... | java |
private void validate() throws MojoExecutionException {
if ((file == null && libId == null) || (file != null && libId != null)) {
getLog()
.warn(
"You specified <file> and <libId>. The <libId> always wins.");
}
// check that COM target exists
if (file != null && !file.exists()) {
getLog().wa... | java |
static Version parseValidSemVer(String version) {
VersionParser parser = new VersionParser(version);
return parser.parseValidSemVer();
} | java |
static NormalVersion parseVersionCore(String versionCore) {
VersionParser parser = new VersionParser(versionCore);
return parser.parseVersionCore();
} | java |
static MetadataVersion parsePreRelease(String preRelease) {
VersionParser parser = new VersionParser(preRelease);
return parser.parsePreRelease();
} | java |
static MetadataVersion parseBuild(String build) {
VersionParser parser = new VersionParser(build);
return parser.parseBuild();
} | java |
private Character consumeNextCharacter(CharType... expected) {
try {
return chars.consume(expected);
} catch (UnexpectedElementException e) {
throw new UnexpectedCharacterException(e);
}
} | java |
private void ensureValidLookahead(CharType... expected) {
if (!chars.positiveLookahead(expected)) {
throw new UnexpectedCharacterException(
chars.lookahead(1),
chars.currentOffset(),
expected
);
}
} | java |
@Override
public Expression parse(String input) {
tokens = lexer.tokenize(input);
Expression expr = parseSemVerExpression();
consumeNextToken(EOI);
return expr;
} | java |
private boolean isVersionFollowedBy(ElementType<Token> type) {
EnumSet<Token.Type> expected = EnumSet.of(NUMERIC, DOT);
Iterator<Token> it = tokens.iterator();
Token lookahead = null;
while (it.hasNext()) {
lookahead = it.next();
if (!expected.contains(lookahead.t... | java |
private Token consumeNextToken(Token.Type... expected) {
try {
return tokens.consume(expected);
} catch (UnexpectedElementException e) {
throw new UnexpectedTokenException(e);
}
} | java |
Stream<Token> tokenize(String input) {
List<Token> tokens = new ArrayList<Token>();
int tokenPos = 0;
while (!input.isEmpty()) {
boolean matched = false;
for (Token.Type tokenType : Token.Type.values()) {
Matcher matcher = tokenType.pattern.matcher(input);... | java |
public Version incrementMajorVersion(String preRelease) {
return new Version(
normal.incrementMajor(),
VersionParser.parsePreRelease(preRelease)
);
} | java |
public Version incrementMinorVersion(String preRelease) {
return new Version(
normal.incrementMinor(),
VersionParser.parsePreRelease(preRelease)
);
} | java |
public Version incrementPatchVersion(String preRelease) {
return new Version(
normal.incrementPatch(),
VersionParser.parsePreRelease(preRelease)
);
} | java |
public Version setBuildMetadata(String build) {
return new Version(normal, preRelease, VersionParser.parseBuild(build));
} | java |
@Override
public int compareTo(Version other) {
int result = normal.compareTo(other.normal);
if (result == 0) {
result = preRelease.compareTo(other.preRelease);
}
return result;
} | java |
MetadataVersion increment() {
String[] ids = idents;
String lastId = ids[ids.length - 1];
if (isInt(lastId)) {
int intId = Integer.parseInt(lastId);
ids[ids.length - 1] = String.valueOf(++intId);
} else {
ids = Arrays.copyOf(ids, ids.length + 1);
... | java |
private int compareIdentifierArrays(String[] otherIdents) {
int result = 0;
int length = getLeastCommonArrayLength(idents, otherIdents);
for (int i = 0; i < length; i++) {
result = compareIdentifiers(idents[i], otherIdents[i]);
if (result != 0) {
break;
... | java |
private int getLeastCommonArrayLength(String[] arr1, String[] arr2) {
return arr1.length <= arr2.length ? arr1.length : arr2.length;
} | java |
private int compareIdentifiers(String ident1, String ident2) {
if (isInt(ident1) && isInt(ident2)) {
return Integer.parseInt(ident1) - Integer.parseInt(ident2);
} else {
return ident1.compareTo(ident2);
}
} | java |
private boolean isInt(String str) {
try {
Integer.parseInt(str);
} catch (NumberFormatException e) {
return false;
}
return true;
} | java |
public <T extends ElementType<E>> boolean positiveLookahead(T... expected) {
for (ElementType<E> type : expected) {
if (type.isMatchedBy(lookahead(1))) {
return true;
}
}
return false;
} | java |
public <T extends ElementType<E>> boolean positiveLookaheadUntil(
int until,
T... expected
) {
for (int i = 1; i <= until; i++) {
for (ElementType<E> type : expected) {
if (type.isMatchedBy(lookahead(i))) {
return true;
}
... | java |
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
/**
* The index to indicate the current position
* of this iterator.
*
* The starting point is set to the current
* value of this stream's offset, so that it
... | java |
public void start(int restartableId) {
stop(restartableId);
requested.add(restartableId);
restartableSubscriptions.put(restartableId, restartables.get(restartableId).call());
} | java |
public void stop(int restartableId) {
requested.remove((Integer) restartableId);
Subscription subscription = restartableSubscriptions.get(restartableId);
if (subscription != null)
subscription.unsubscribe();
} | java |
public boolean isUnsubscribed(int restartableId) {
Subscription subscription = restartableSubscriptions.get(restartableId);
return subscription == null || subscription.isUnsubscribed();
} | java |
public Activity getActivity() {
Context context = getContext();
while (!(context instanceof Activity) && context instanceof ContextWrapper)
context = ((ContextWrapper) context).getBaseContext();
if (!(context instanceof Activity))
throw new IllegalStateException("Expected... | java |
public void push(Fragment fragment) {
Fragment top = peek();
if (top != null) {
manager.beginTransaction()
.setCustomAnimations(R.anim.enter_from_right, R.anim.exit_to_left, R.anim.enter_from_left, R.anim.exit_to_right)
.remove(top)
.add(conta... | java |
public void replace(Fragment fragment) {
manager.popBackStackImmediate(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
manager.beginTransaction()
.replace(containerId, fragment, indexToTag(0))
.commit();
manager.executePendingTransactions();
} | java |
@SuppressWarnings("unchecked")
public <T> T findCallback(Fragment fragment, Class<T> callbackType) {
Fragment back = getBackFragment(fragment);
if (back != null && callbackType.isAssignableFrom(back.getClass()))
return (T)back;
if (callbackType.isAssignableFrom(activity.getCla... | java |
public void setCoilStatus(int index, boolean b) {
if (index < 0) {
throw new IllegalArgumentException(index + " < 0");
}
if (index > coils.size()) {
throw new IndexOutOfBoundsException(index + " > " + coils.size());
}
coils.setBit(index, b);
} | java |
private boolean responseIsInValid() {
if (response == null) {
return true;
}
else if (!response.isHeadless() && validityCheck) {
return request.getTransactionID() != response.getTransactionID();
}
else {
return false;
}
} | java |
ModbusResponse updateResponseWithHeader(ModbusResponse response, boolean ignoreFunctionCode) {
// transfer header data
response.setHeadless(isHeadless());
if (!isHeadless()) {
response.setTransactionID(getTransactionID());
response.setProtocolID(getProtocolID());
... | java |
public synchronized byte[] getBufferBytes() {
byte[] dest = new byte[count];
System.arraycopy(buf, 0, dest, 0, dest.length);
return dest;
} | java |
public void initPool(String name) {
running = true;
for (int i = size; --i >= 0; ) {
PoolThread thread = new PoolThread();
threadPool.add(thread);
thread.setName(String.format("%s Handler", name));
thread.start();
}
} | java |
public void close() {
if (running) {
taskPool.clear();
running = false;
for (PoolThread thread : threadPool) {
thread.interrupt();
}
}
} | java |
public synchronized void setReconnecting(boolean b) {
reconnecting = b;
if (transaction != null) {
((ModbusTCPTransaction)transaction).setReconnecting(b);
}
} | java |
public void readData(DataInput din) throws IOException {
// skip all following bytes
int length = getDataLength();
for (int i = 0; i < length; i++) {
din.readByte();
}
} | java |
public void setEncoding(String enc) {
if (!ModbusUtil.isBlank(enc) &&
(enc.equalsIgnoreCase(Modbus.SERIAL_ENCODING_ASCII) || enc.equalsIgnoreCase(Modbus.SERIAL_ENCODING_RTU))) {
encoding = enc;
}
else {
encoding = Modbus.DEFAULT_SERIAL_ENCODING;
}
... | java |
void checkValidity() throws ModbusException {
if (request != null && response != null) {
if (request.getUnitID() != response.getUnitID()) {
throw new ModbusIOException("Unit ID mismatch - Request [%s] Response [%s]", request.getHexMessage(), response.getHexMessage());
}
... | java |
public void toByteArray(byte[] toBuf, int offset) {
int toLen = (toBuf.length > count) ? count : toBuf.length;
System.arraycopy(buf, offset, toBuf, offset, toLen - offset);
} | java |
public void makeSpace(int sizeNeeded) {
int needed = count + sizeNeeded - buf.length;
if (needed > 0) {
bump(needed);
}
} | java |
private void readRequestData(int byteCount, BytesOutputStream out) throws IOException {
byteCount += 2;
byte inpBuf[] = new byte[byteCount];
readBytes(inpBuf, byteCount);
out.write(inpBuf, 0, byteCount);
} | java |
private void getRequest(int function, BytesOutputStream out) throws IOException {
int byteCount;
byte inpBuf[] = new byte[256];
try {
if ((function & 0x80) == 0) {
switch (function) {
case Modbus.READ_EXCEPTION_STATUS:
case Modb... | java |
protected void writeMessageOut(ModbusMessage msg) throws ModbusIOException {
try {
int len;
synchronized (byteOutputStream) {
// first clear any input from the receive buffer to prepare
// for the reply since RTU doesn't have message delimiters
... | java |
protected ModbusResponse readResponseIn() throws ModbusIOException {
boolean done;
ModbusResponse response;
int dlength;
try {
do {
// 1. read to function code, create request and read function
// specific bytes
synchronized (b... | java |
public static synchronized ModbusSlave createUDPSlave(InetAddress address, int port) throws ModbusException {
String key = ModbusSlaveType.UDP.getKey(port);
if (slaves.containsKey(key)) {
return slaves.get(key);
}
else {
ModbusSlave slave = new ModbusSlave(address... | java |
public static synchronized ModbusSlave createSerialSlave(SerialParameters serialParams) throws ModbusException {
ModbusSlave slave = null;
if (serialParams == null) {
throw new ModbusException("Serial parameters are null");
}
else if (ModbusUtil.isBlank(serialParams.getPortNa... | java |
public static void close(ModbusSlave slave) {
if (slave != null) {
slave.closeListener();
slaves.remove(slave.getType().getKey(slave.getPort()));
}
} | java |
public static ModbusSlave getSlave(String port) {
return ModbusUtil.isBlank(port) ? null : slaves.get(port);
} | java |
public static synchronized ModbusSlave getSlave(AbstractModbusListener listener) {
for (ModbusSlave slave : slaves.values()) {
if (slave.getListener().equals(listener)) {
return slave;
}
}
return null;
} | java |
public synchronized byte[] getBuffer() {
byte[] dest = new byte[buf.length];
System.arraycopy(buf, 0, dest, 0, dest.length);
return dest;
} | java |
public void setBitCount(int count) {
bitCount = count;
discretes = new BitVector(count);
//set correct length, without counting unitid and fc
setDataLength(discretes.byteSize() + 1);
} | java |
public synchronized String[] getFields() {
String[] dest = new String[fields.length];
System.arraycopy(fields, 0, dest, 0, dest.length);
return dest;
} | java |
public synchronized InputRegister[] getRegisters() {
InputRegister[] dest = new InputRegister[registers.length];
System.arraycopy(registers, 0, dest, 0, dest.length);
return dest;
} | java |
public void setRegisters(InputRegister[] registers) {
byteCount = registers.length * 2;
setDataLength(byteCount + 1);
this.registers = Arrays.copyOf(registers, registers.length);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.