code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public void indexDocument(final ODocument iDocument) {
modificationLock.requestModificationLock();
try {
Object fieldValue;
for (final String fieldName : iDocument.fieldNames()) {
fieldValue = iDocument.field(fieldName);
put(fieldValue, iDocument);
}
acquireExclusiveLock();
try {
map.save();
} finally {
releaseExclusiveLock();
}
} finally {
modificationLock.releaseModificationLock();
}
} | java |
@Override
public OIndexFullText put(final Object iKey, final OIdentifiable iSingleValue) {
if (iKey == null)
return this;
modificationLock.requestModificationLock();
try {
final List<String> words = splitIntoWords(iKey.toString());
// FOREACH WORD CREATE THE LINK TO THE CURRENT DOCUMENT
for (final String word : words) {
acquireExclusiveLock();
try {
Set<OIdentifiable> refs;
// SEARCH FOR THE WORD
refs = map.get(word);
if (refs == null)
// WORD NOT EXISTS: CREATE THE KEYWORD CONTAINER THE FIRST TIME THE WORD IS FOUND
refs = new OMVRBTreeRIDSet().setAutoConvert(false);
// ADD THE CURRENT DOCUMENT AS REF FOR THAT WORD
refs.add(iSingleValue);
// SAVE THE INDEX ENTRY
map.put(word, refs);
} finally {
releaseExclusiveLock();
}
}
return this;
} finally {
modificationLock.releaseModificationLock();
}
} | java |
@Override
public boolean remove(final Object iKey, final OIdentifiable value) {
modificationLock.requestModificationLock();
try {
final List<String> words = splitIntoWords(iKey.toString());
boolean removed = false;
for (final String word : words) {
acquireExclusiveLock();
try {
final Set<OIdentifiable> recs = map.get(word);
if (recs != null && !recs.isEmpty()) {
if (recs.remove(value)) {
if (recs.isEmpty())
map.remove(word);
else
map.put(word, recs);
removed = true;
}
}
} finally {
releaseExclusiveLock();
}
}
return removed;
} finally {
modificationLock.releaseModificationLock();
}
} | java |
public List<ORecordOperation> getRecordEntriesByClass(final String iClassName) {
final List<ORecordOperation> result = new ArrayList<ORecordOperation>();
if (iClassName == null || iClassName.length() == 0)
// RETURN ALL THE RECORDS
for (ORecordOperation entry : recordEntries.values()) {
result.add(entry);
}
else
// FILTER RECORDS BY CLASSNAME
for (ORecordOperation entry : recordEntries.values()) {
if (entry.getRecord() != null && entry.getRecord() instanceof ODocument
&& iClassName.equals(((ODocument) entry.getRecord()).getClassName()))
result.add(entry);
}
return result;
} | java |
public List<ORecordOperation> getRecordEntriesByClusterIds(final int[] iIds) {
final List<ORecordOperation> result = new ArrayList<ORecordOperation>();
if (iIds == null)
// RETURN ALL THE RECORDS
for (ORecordOperation entry : recordEntries.values()) {
result.add(entry);
}
else
// FILTER RECORDS BY ID
for (ORecordOperation entry : recordEntries.values()) {
for (int id : iIds) {
if (entry.getRecord() != null && entry.getRecord().getIdentity().getClusterId() == id) {
result.add(entry);
break;
}
}
}
return result;
} | java |
protected static int getValueByBinStr(String binaryString, boolean signed) {
Integer value = Integer.parseInt(binaryString, 2);
if (signed && binaryString.charAt(0) == '1') {
char[] invert = new char[binaryString.length()];
Arrays.fill(invert, '1');
value ^= Integer.parseInt(new String(invert), 2);
value += 1;
value = -value;
}
return value;
} | java |
@VisibleForTesting
static byte[] ascii8To6bitBin(byte[] toDecBytes) {
byte[] convertedBytes = new byte[toDecBytes.length];
int sum = 0;
int _6bitBin = 0;
for (int i = 0; i < toDecBytes.length; i++) {
sum = 0;
_6bitBin = 0;
if (toDecBytes[i] < 48) {
throw new AisParseException(AisParseException.INVALID_CHARACTER + " "
+ (char) toDecBytes[i]);
} else {
if (toDecBytes[i] > 119) {
throw new AisParseException(AisParseException.INVALID_CHARACTER + " "
+ (char) toDecBytes[i]);
} else {
if (toDecBytes[i] > 87) {
if (toDecBytes[i] < 96) {
throw new AisParseException(AisParseException.INVALID_CHARACTER + " "
+ (char) toDecBytes[i]);
} else {
sum = toDecBytes[i] + 40;
}
} else {
sum = toDecBytes[i] + 40;
}
if (sum != 0) {
if (sum > 128) {
sum += 32;
} else {
sum += 40;
}
_6bitBin = sum & 0x3F;
convertedBytes[i] = (byte) _6bitBin;
}
}
}
}
return convertedBytes;
} | java |
private static String getDecodedStr(byte[] decBytes) {
// prepare StringBuilder with capacity being the smallest power of 2
// greater than decBytes.length*6
int n = decBytes.length * 6;
int capacity = leastPowerOf2GreaterThanOrEqualTo(n);
StringBuilder decStr = new StringBuilder(capacity);
for (int i = 0; i < decBytes.length; i++) {
int decByte = decBytes[i];
String bitStr = Integer.toBinaryString(decByte);
int padding = Math.max(0, 6 - bitStr.length());
for (int j = 0; j < padding; j++) {
decStr.append('0');
}
for (int j = 0; j < 6 - padding; j++) {
decStr.append(bitStr.charAt(j));
}
}
return decStr.toString();
} | java |
protected static String getAsciiStringFrom6BitStr(String str) {
StringBuilder txt = new StringBuilder();
for (int i = 0; i < str.length(); i = i + 6) {
byte _byte = (byte) Integer.parseInt(str.substring(i, i + 6), 2);
_byte = convert6BitCharToStandardAscii(_byte);
char convChar = (char) _byte;
if (convChar == '@') {
break;
}
txt.append((char) _byte);
}
return txt.toString().trim();
} | java |
@VisibleForTesting
static byte convert6BitCharToStandardAscii(byte byteToConvert) {
byte b = 0;
if (byteToConvert < 32) {
b = (byte) (byteToConvert + 64);
} else if (byteToConvert < 63) {
b = byteToConvert;
}
return b;
} | java |
public static void checkLatLong(double lat, double lon) {
checkArgument(lon <= 181.0, "longitude out of range " + lon);
checkArgument(lon > -180.0, "longitude out of range " + lon);
checkArgument(lat <= 91.0, "latitude out of range " + lat);
checkArgument(lat > -90.0, "latitude out of range " + lat);
} | java |
public static void checkMessageId(int messageId, AisMessageType... messageTypes) {
boolean found = false;
for (AisMessageType messageType : messageTypes) {
if (messageType.getId() == messageId)
found = true;
}
if (!found) {
StringBuffer s = new StringBuffer();
for (AisMessageType messageType : messageTypes) {
if (s.length() > 0)
s.append(",");
s.append(messageType.getId() + "");
}
checkArgument(found, "messageId must be in [" + s + "] but was " + messageId);
}
} | java |
public static OMMapManager getInstance() {
if (instanceRef.get() == null) {
synchronized (instanceRef) {
if (instanceRef.compareAndSet(null, createInstance())) {
instanceRef.get().init();
}
}
}
return instanceRef.get();
} | java |
public void addArrayIdentity(String array, String... identities) {
arrayIdentities.put(array, new ArrayIdentityFields(identities));
} | java |
public Difference<BaseType> compareNodes(BaseType node1, BaseType node2)
throws InvalidArrayIdentity, DuplicateArrayIdentity {
return compareNodes(new ArrayList<String>(), node1, new ArrayList<String>(), node2);
} | java |
public Difference<BaseType> compareObjects(List<String> field1,
ObjectType node1,
List<String> field2,
ObjectType node2)
throws InvalidArrayIdentity, DuplicateArrayIdentity {
Difference<BaseType> ret = new Difference<>();
// Field by field comparison of obj1 to obj2.
for (Iterator<Map.Entry<String, BaseType>> fields = getFields(node1); fields.hasNext();) {
Map.Entry<String, BaseType> field = fields.next();
String fieldName = field.getKey();
field1.add(fieldName);
BaseType value1 = field.getValue();
if (hasField(node2, fieldName)) {
// If both obj1 and obj2 have the same field, compare recursively
field2.add(fieldName);
BaseType value2 = getField(node2, fieldName);
ret.add(compareNodes(field1, value1, field2, value2));
pop(field2);
} else {
// obj1.field1 exists, obj2.field1 does not, so it is removed
ret.add(new Removal(field1, value1));
}
pop(field1);
}
// Now compare any new nodes added to obj2
for (Iterator<Map.Entry<String, BaseType>> fields = getFields(node2); fields.hasNext();) {
Map.Entry<String, BaseType> field = fields.next();
String fieldName = field.getKey();
if (!hasField(node1, fieldName)) {
field2.add(fieldName);
ret.add(new Addition(field2, field.getValue()));
pop(field2);
}
}
return ret;
} | java |
public Difference<BaseType> compareArraysWithId(List<String> field1,
ArrayType node1,
List<String> field2,
ArrayType node2,
IdentityExtractor idex)
throws InvalidArrayIdentity, DuplicateArrayIdentity {
Difference<BaseType> ret = new Difference<>();
// Build a map of identity -> index for both arrays
final Map<Object, Integer> identities1 = getIdentityMap(field1, node1, idex);
final Map<Object, Integer> identities2 = getIdentityMap(field2, node2, idex);
// Iterate all elements of array 1
for (Map.Entry<Object, Integer> entry1 : identities1.entrySet()) {
// Append index to the field name
field1.add(Integer.toString(entry1.getValue()));
// If array2 doesn't have an element with the same ID, this is a deletion
Integer index2 = identities2.get(entry1.getKey());
if (index2 == null) {
ret.add(new Removal(field1, getElement(node1, entry1.getValue())));
} else {
field2.add(Integer.toString(index2));
// array2 has the same element
// If it is at a different index, this is a move
if (index2 != entry1.getValue()) {
ret.add(new Move(field1, field2, getElement(node1, entry1.getValue())));
}
// Recursively compare contents to get detailed diff
ret.add(compareNodes(field1, getElement(node1, entry1.getValue()),
field2, getElement(node2, index2)));
pop(field2);
}
pop(field1);
}
// Now check elements of array 2 that are not in array 1
for (Map.Entry<Object, Integer> entry2 : identities2.entrySet()) {
if (!identities1.containsKey(entry2.getKey())) {
// entry2 is not in array 1: addition
field2.add(Integer.toString(entry2.getValue()));
ret.add(new Addition(field2, getElement(node2, entry2.getValue())));
pop(field2);
}
}
return ret;
} | java |
@Deprecated
public OPropertyImpl dropIndexes() {
getDatabase().checkSecurity(ODatabaseSecurityResources.SCHEMA, ORole.PERMISSION_DELETE);
final OIndexManager indexManager = getDatabase().getMetadata().getIndexManager();
final ArrayList<OIndex<?>> relatedIndexes = new ArrayList<OIndex<?>>();
for (final OIndex<?> index : indexManager.getClassIndexes(owner.getName())) {
final OIndexDefinition definition = index.getDefinition();
if (OCollections.indexOf(definition.getFields(), name, new OCaseIncentiveComparator()) > -1) {
if (definition instanceof OPropertyIndexDefinition) {
relatedIndexes.add(index);
} else {
throw new IllegalArgumentException("This operation applicable only for property indexes. " + index.getName() + " is "
+ index.getDefinition());
}
}
}
for (final OIndex<?> index : relatedIndexes) {
getDatabase().getMetadata().getIndexManager().dropIndex(index.getName());
}
return this;
} | java |
@Deprecated
public OIndex<?> getIndex() {
Set<OIndex<?>> indexes = owner.getInvolvedIndexes(name);
if (indexes != null && !indexes.isEmpty())
return indexes.iterator().next();
return null;
} | java |
public OClass getLinkedClass() {
if (linkedClass == null && linkedClassName != null)
linkedClass = owner.owner.getClass(linkedClassName);
return linkedClass;
} | java |
public void setTypeInternal(final OType iType) {
getDatabase().checkSecurity(ODatabaseSecurityResources.SCHEMA, ORole.PERMISSION_UPDATE);
if (iType == type)
// NO CHANGES
return;
boolean ok = false;
switch (type) {
case LINKLIST:
ok = iType == OType.LINKSET;
break;
case LINKSET:
ok = iType == OType.LINKLIST;
break;
}
if (!ok)
throw new IllegalArgumentException("Cannot change property type from " + type + " to " + iType);
type = iType;
} | java |
@Override
public void putAll(final Map<? extends K, ? extends V> map) {
int mapSize = map.size();
if (size() == 0 && mapSize != 0 && map instanceof SortedMap) {
Comparator<?> c = ((SortedMap<? extends K, ? extends V>) map).comparator();
if (c == comparator || (c != null && c.equals(comparator))) {
++modCount;
try {
buildFromSorted(mapSize, map.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return;
}
}
super.putAll(map);
} | java |
@Override
public V remove(final Object key) {
OMVRBTreeEntry<K, V> p = getEntry(key, PartialSearchMode.NONE);
setLastSearchNode(null, null);
if (p == null)
return null;
V oldValue = p.getValue();
deleteEntry(p);
return oldValue;
} | java |
public static <K, V> OMVRBTreeEntry<K, V> next(final OMVRBTreeEntry<K, V> t) {
if (t == null)
return null;
final OMVRBTreeEntry<K, V> succ;
if (t.tree.pageIndex < t.getSize() - 1) {
// ITERATE INSIDE THE NODE
succ = t;
t.tree.pageIndex++;
} else {
// GET THE NEXT NODE
succ = OMVRBTree.successor(t);
t.tree.pageIndex = 0;
}
return succ;
} | java |
public static <K, V> OMVRBTreeEntry<K, V> previous(final OMVRBTreeEntry<K, V> t) {
if (t == null)
return null;
final int index = t.getTree().getPageIndex();
final OMVRBTreeEntry<K, V> prev;
if (index <= 0) {
prev = predecessor(t);
if (prev != null)
t.tree.pageIndex = prev.getSize() - 1;
else
t.tree.pageIndex = 0;
} else {
prev = t;
t.tree.pageIndex = index - 1;
}
return prev;
} | java |
OMVRBTreeEntry<K, V> deleteEntry(OMVRBTreeEntry<K, V> p) {
setSizeDelta(-1);
modCount++;
if (pageIndex > -1) {
// DELETE INSIDE THE NODE
p.remove();
if (p.getSize() > 0)
return p;
}
final OMVRBTreeEntry<K, V> next = successor(p);
// DELETE THE ENTIRE NODE, RE-BUILDING THE STRUCTURE
removeNode(p);
// RETURN NEXT NODE
return next;
} | java |
protected OMVRBTreeEntry<K, V> removeNode(OMVRBTreeEntry<K, V> p) {
modCount++;
// If strictly internal, copy successor's element to p and then make p
// point to successor.
if (p.getLeft() != null && p.getRight() != null) {
OMVRBTreeEntry<K, V> s = next(p);
p.copyFrom(s);
p = s;
} // p has 2 children
// Start fixup at replacement node, if it exists.
final OMVRBTreeEntry<K, V> replacement = (p.getLeft() != null ? p.getLeft() : p.getRight());
if (replacement != null) {
// Link replacement to parent
replacement.setParent(p.getParent());
if (p.getParent() == null)
setRoot(replacement);
else if (p == p.getParent().getLeft())
p.getParent().setLeft(replacement);
else
p.getParent().setRight(replacement);
// Null out links so they are OK to use by fixAfterDeletion.
p.setLeft(null);
p.setRight(null);
p.setParent(null);
// Fix replacement
if (p.getColor() == BLACK)
fixAfterDeletion(replacement);
} else if (p.getParent() == null) { // return if we are the only node.
clear();
} else { // No children. Use self as phantom replacement and unlink.
if (p.getColor() == BLACK)
fixAfterDeletion(p);
if (p.getParent() != null) {
if (p == p.getParent().getLeft())
p.getParent().setLeft(null);
else if (p == p.getParent().getRight())
p.getParent().setRight(null);
p.setParent(null);
}
}
return p;
} | java |
void readOTreeSet(int iSize, ObjectInputStream s, V defaultVal) throws java.io.IOException, ClassNotFoundException {
buildFromSorted(iSize, null, s, defaultVal);
} | java |
void addAllForOTreeSet(SortedSet<? extends K> set, V defaultVal) {
try {
buildFromSorted(set.size(), set.iterator(), null, defaultVal);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
} | java |
public static Observable<Fix> from(final File file, BinaryFixesFormat format) {
Func0<InputStream> resourceFactory = new Func0<InputStream>() {
@Override
public InputStream call() {
try {
if (file.getName().endsWith(".gz"))
return new GZIPInputStream(new FileInputStream(file));
else
return new FileInputStream(file);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
};
Func1<InputStream, Observable<Fix>> obsFactory = new Func1<InputStream, Observable<Fix>>() {
@Override
public Observable<Fix> call(InputStream is) {
Optional<Integer> mmsi;
if (format == BinaryFixesFormat.WITH_MMSI)
mmsi = Optional.absent();
else
mmsi = Optional.of(BinaryFixesUtil.getMmsi(file));
return Observable.create(new BinaryFixesOnSubscribeWithBackp(is, mmsi, format));
}
};
Action1<InputStream> disposeAction = new Action1<InputStream>() {
@Override
public void call(InputStream is) {
try {
is.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
};
return Observable.using(resourceFactory, obsFactory, disposeAction, true);
} | java |
protected String parserOptionalWord(final boolean iUpperCase) {
previousPos = currentPos;
parserNextWord(iUpperCase);
if (parserLastWord.length() == 0)
return null;
return parserLastWord.toString();
} | java |
protected String parseOptionalWord(final boolean iUpperCase, final String... iWords) {
parserNextWord(iUpperCase);
if (iWords.length > 0) {
if (parserLastWord.length() == 0)
return null;
boolean found = false;
for (String w : iWords) {
if (parserLastWord.toString().equals(w)) {
found = true;
break;
}
}
if (!found)
throwSyntaxErrorException("Found unexpected keyword '" + parserLastWord + "' while it was expected '"
+ Arrays.toString(iWords) + "'");
}
return parserLastWord.toString();
} | java |
protected String parserRequiredWord(final boolean iUpperCase, final String iCustomMessage, String iSeparators) {
if (iSeparators == null)
iSeparators = " =><(),\r\n";
parserNextWord(iUpperCase, iSeparators);
if (parserLastWord.length() == 0)
throwSyntaxErrorException(iCustomMessage);
return parserLastWord.toString();
} | java |
protected void parserNextWord(final boolean iForceUpperCase, final String iSeparatorChars) {
previousPos = currentPos;
parserLastWord.setLength(0);
parserSkipWhiteSpaces();
if (currentPos == -1)
return;
char stringBeginChar = ' ';
final String text2Use = iForceUpperCase ? textUpperCase : text;
while (currentPos < text2Use.length()) {
final char c = text2Use.charAt(currentPos);
boolean found = false;
for (int sepIndex = 0; sepIndex < iSeparatorChars.length(); ++sepIndex) {
if (iSeparatorChars.charAt(sepIndex) == c) {
// SEPARATOR AT THE BEGINNING: JUMP IT
found = true;
break;
}
}
if (!found)
break;
currentPos++;
}
try {
while (currentPos < text2Use.length()) {
final char c = text2Use.charAt(currentPos);
if (c == '\'' || c == '"') {
if (stringBeginChar != ' ') {
// CLOSE THE STRING?
if (stringBeginChar == c) {
// SAME CHAR AS THE BEGIN OF THE STRING: CLOSE IT AND PUSH
stringBeginChar = ' ';
}
} else {
// START STRING
stringBeginChar = c;
}
} else if (stringBeginChar == ' ') {
for (int sepIndex = 0; sepIndex < iSeparatorChars.length(); ++sepIndex) {
if (iSeparatorChars.charAt(sepIndex) == c && parserLastWord.length() > 0) {
// SEPARATOR (OUTSIDE A STRING): PUSH
parserLastSeparator = c;
return;
}
}
}
parserLastWord.append(c);
currentPos++;
}
parserLastSeparator = ' ';
} finally {
if (currentPos >= text2Use.length())
// END OF TEXT
currentPos = -1;
}
} | java |
public HandlerBuilder<ContextHandler> createRootContextHandler(String subPath) {
ContextHandler contextHandler = new ContextHandler();
HandlerBuilder<ContextHandler> e = new HandlerBuilder<>(contextHandler);
String usePath = contextPath + subPath;
setPath(contextHandler, usePath);
handlers.add(e);
return e;
} | java |
public Optional<List<NmeaMessage>> add(NmeaMessage nmea) {
// use compare-and-swap semantics instead of synchronizing to squeak a
// bit more performance out of this. Contention is expected to be low so
// this should help.
while (true) {
if (adding.compareAndSet(false, true)) {
Optional<List<NmeaMessage>> result = doAdd(nmea);
adding.set(false);
return result;
}
}
} | java |
public static String getServiceName(MuleEventContext event) {
// Mule 2.2 implementation
// Service service = (event == null)? null : event.getService();
FlowConstruct service = (event == null)? null : event.getFlowConstruct();
String name = (service == null)? "" : service.getName();
return name;
} | java |
public static ImmutableEndpoint getImmutableEndpoint(MuleContext muleContext, String endpointName) throws IOException {
ImmutableEndpoint endpoint = null;
Object o = muleContext.getRegistry().lookupObject(endpointName);
if (o instanceof ImmutableEndpoint) {
// For Inbound and Outbound Endpoints
endpoint = (ImmutableEndpoint) o;
} else if (o instanceof EndpointBuilder) {
// For Endpoint-references
EndpointBuilder eb = (EndpointBuilder) o;
try {
endpoint = eb.buildInboundEndpoint();
} catch (Exception e) {
throw new IOException(e.getMessage());
}
}
return endpoint;
} | java |
@Override
public OMVRBTreeEntryMemory<K, V> getNextInMemory() {
OMVRBTreeEntryMemory<K, V> t = this;
OMVRBTreeEntryMemory<K, V> p = null;
if (t.right != null) {
p = t.right;
while (p.left != null)
p = p.left;
} else {
p = t.parent;
while (p != null && t == p.right) {
t = p;
p = p.parent;
}
}
return p;
} | java |
public V setValue(final V value) {
V oldValue = this.getValue();
this.values[tree.pageIndex] = value;
return oldValue;
} | java |
private void convertLink2Record(final int iIndex) {
if (ridOnly || !autoConvertToRecord)
// PRECONDITIONS
return;
final OIdentifiable o = super.get(iIndex);
if (contentType == MULTIVALUE_CONTENT_TYPE.ALL_RECORDS && !o.getIdentity().isNew())
// ALL RECORDS AND THE OBJECT IS NOT NEW, DO NOTHING
return;
if (o != null && o instanceof ORecordId) {
final ORecordId rid = (ORecordId) o;
marshalling = true;
try {
super.set(iIndex, rid.getRecord());
} catch (ORecordNotFoundException e) {
// IGNORE THIS
} finally {
marshalling = false;
}
}
} | java |
private boolean convertRecord2Link(final int iIndex) {
if (contentType == MULTIVALUE_CONTENT_TYPE.ALL_RIDS)
// PRECONDITIONS
return true;
final Object o = super.get(iIndex);
if (o != null) {
if (o instanceof ORecord<?> && !((ORecord<?>) o).isDirty()) {
marshalling = true;
try {
super.set(iIndex, ((ORecord<?>) o).getIdentity());
// CONVERTED
return true;
} catch (ORecordNotFoundException e) {
// IGNORE THIS
} finally {
marshalling = false;
}
} else if (o instanceof ORID)
// ALREADY CONVERTED
return true;
}
return false;
} | java |
public static String convertStreamToString(InputStream is, String charset) {
if (is == null) return null;
StringBuilder sb = new StringBuilder();
String line;
long linecount = 0;
long size = 0;
try {
// TODO: Can this be a performance killer if many many lines or is BufferedReader handling that in a good way?
boolean emptyBuffer = true;
BufferedReader reader = new BufferedReader(new InputStreamReader(new BOMStripperInputStream(is), charset));
while ((line = reader.readLine()) != null) {
// Skip adding line break before the first line
if (emptyBuffer) {
emptyBuffer = false;
} else {
sb.append('\n');
size++;
}
sb.append(line);
linecount++;
size += line.length();
if (logger.isTraceEnabled()) {
if (linecount % 50000 == 0) {
logger.trace("Lines read: {}, {} characters and counting...", linecount, size);
printMemUsage();
}
}
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (logger.isTraceEnabled()) {
logger.trace("Lines read: {}, {} characters", linecount, size);
printMemUsage();
}
// Ignore exceptions on call to the close method
try {if (is != null) is.close();} catch (IOException e) {}
}
return sb.toString();
} | java |
static Properties convertResourceBundleToProperties(ResourceBundle resource) {
Properties properties = new Properties();
Enumeration<String> keys = resource.getKeys();
while (keys.hasMoreElements()) {
String key = keys.nextElement();
properties.put(key, resource.getString(key));
}
return properties;
} | java |
protected Map<Method, Object> getConsoleMethods() {
// search for declared command collections
final Iterator<OConsoleCommandCollection> ite = ServiceRegistry.lookupProviders(OConsoleCommandCollection.class);
final Collection<Object> candidates = new ArrayList<Object>();
candidates.add(this);
while (ite.hasNext()) {
try {
// make a copy and set it's context
final OConsoleCommandCollection cc = ite.next().getClass().newInstance();
cc.setContext(this);
candidates.add(cc);
} catch (InstantiationException ex) {
Logger.getLogger(OConsoleApplication.class.getName()).log(Level.WARNING, ex.getMessage());
} catch (IllegalAccessException ex) {
Logger.getLogger(OConsoleApplication.class.getName()).log(Level.WARNING, ex.getMessage());
}
}
final Map<Method, Object> consoleMethods = new TreeMap<Method, Object>(new Comparator<Method>() {
public int compare(Method o1, Method o2) {
return o1.getName().compareTo(o2.getName());
}
});
for (final Object candidate : candidates) {
final Method[] methods = candidate.getClass().getMethods();
for (Method m : methods) {
if (Modifier.isAbstract(m.getModifiers()) || Modifier.isStatic(m.getModifiers()) || !Modifier.isPublic(m.getModifiers())) {
continue;
}
if (m.getReturnType() != Void.TYPE) {
continue;
}
consoleMethods.put(m, candidate);
}
}
return consoleMethods;
} | java |
static public List<String> listFilesInDirectory(MuleContext muleContext, String endpointName) {
logger.info("List endpoint: {}", endpointName);
FTPClient ftpClient = null;
List<String> fileNames = new ArrayList<String>();
try {
ftpClient = getFtpClient(muleContext, endpointName);
EndpointURI endpointURI = getImmutableEndpoint(muleContext, endpointName).getEndpointURI();
String path = endpointURI.getPath();
logger.info("List directory: {}", path);
FTPFile[] ftpFiles = ftpClient.listFiles(path);
logger.debug("Number of files and sub-folders found: {}", ftpFiles.length);
for (FTPFile ftpFile : ftpFiles){
if (ftpFile.getType() == FTPFile.FILE_TYPE) {
String filename = path + "/" + ftpFile.getName();
fileNames.add(filename);
logger.debug("Added file {}", filename);
}
}
logger.debug("Found {} files in {}", fileNames.size(), path);
} catch (Exception e) {
if (logger.isErrorEnabled()) logger.error("Failed to list files in endpoint " + endpointName, e);
throw new RuntimeException(e);
} finally {
if (ftpClient != null) {
try {
ftpClient.disconnect();
} catch (IOException e) {}
}
}
return fileNames;
} | java |
static public void recursiveDeleteDirectory(FTPClient ftpClient, String path) throws IOException {
logger.info("Delete directory: {}", path);
FTPFile[] ftpFiles = ftpClient.listFiles(path);
logger.debug("Number of files that will be deleted: {}", ftpFiles.length);
for (FTPFile ftpFile : ftpFiles){
String filename = path + "/" + ftpFile.getName();
if (ftpFile.getType() == FTPFile.FILE_TYPE) {
boolean deleted = ftpClient.deleteFile(filename);
logger.debug("Deleted {}? {}", filename, deleted);
} else {
recursiveDeleteDirectory(ftpClient, filename);
}
}
boolean dirDeleted = ftpClient.deleteFile(path);
logger.debug("Directory {} deleted: {}", path, dirDeleted);
} | java |
static public void recursiveCreateDirectory(FTPClient ftpClient, String path) throws IOException {
logger.info("Create Directory: {}", path);
int createDirectoryStatus = ftpClient.mkd(path); // makeDirectory...
logger.debug("Create Directory Status: {}", createDirectoryStatus);
if (createDirectoryStatus == FTP_FILE_NOT_FOUND) {
int sepIdx = path.lastIndexOf('/');
if (sepIdx > -1) {
String parentPath = path.substring(0, sepIdx);
recursiveCreateDirectory(ftpClient, parentPath);
logger.debug("2'nd CreateD irectory: {}", path);
createDirectoryStatus = ftpClient.mkd(path); // makeDirectory...
logger.debug("2'nd Create Directory Status: {}", createDirectoryStatus);
}
}
} | java |
private void insertLinks(Theme theme) {
if (theme != null) {
for (CssLink link : theme.getLinks()) {
this.getHead().appendChild(link.getLink());
}
}
} | java |
private void removeCssLinks() {
if (this.isInit) {
return;
}
this.isInit = true;
// Remove all existing link element
NodeList<Element> links = this.getHead().getElementsByTagName(LinkElement.TAG);
int size = links.getLength();
for (int i = 0; i < size; i++) {
LinkElement elem = LinkElement.as(links.getItem(0));
if ("stylesheet".equals(elem.getRel())) {
elem.removeFromParent();
}
}
} | java |
protected HeadElement getHead() {
if (this.head == null) {
Element elt = Document.get().getElementsByTagName("head").getItem(0);
assert elt != null : "The host HTML page does not have a <head> element" + " which is required by this injector";
this.head = HeadElement.as(elt);
}
return this.head;
} | java |
public static void reset() {
deactivateLogging();
deactivateReporting();
defaultLogLevel = Constants.INFO;
defaultReportLevel = Constants.INFO;
detectWTFMethods();
logLevels.clear();
maxOfEntriesInReports = 25;
enableLogEntryCollection = false;
entries = null;
reporters.clear();
reportTriggerLevel = Constants.ASSERT;
Thread.setDefaultUncaughtExceptionHandler(originalHandler);
originalHandler = null;
} | java |
private static Integer getLogLevel(String tag) {
Integer result = logLevels.get(tag);
if (tag != null && result == null) {
int index = tag.lastIndexOf(".");
while (result == null && index > -1) {
result = logLevels.get(tag.substring(0, index));
index = tag.lastIndexOf(".", index - 1);
}
}
return result;
} | java |
public static boolean report(String message, Throwable error) {
boolean acc = true;
for (Reporter reporter : reporters) {
if (reportFactory != null && reporter instanceof EnhancedReporter) {
Report report = reportFactory.create(context, message, error);
acc = acc && ((EnhancedReporter) reporter).send(context, report);
} else {
acc = acc && reporter.send(context, message, error);
}
}
return acc;
} | java |
private static synchronized void collectLogEntry(int level, String tag, final String message,
final Throwable err) {
if (!isReportable(level)) {
return;
}
if (maxOfEntriesInReports > 0
&& entries.size() == maxOfEntriesInReports) {
entries.remove(0); // Remove the first element.
}
entries.add(LogHelper.print(level, tag, message, err, addTimestampToReportLogs));
if (level >= reportTriggerLevel) {
// Must be in another thread
new Thread(new Runnable() {
public void run() {
try {
report(message, err);
} catch (Throwable e) {
// Ignore
}
}
}).start();
}
} | java |
public void grant(final String iResource, final int iOperation) {
final Byte current = rules.get(iResource);
byte currentValue = current == null ? PERMISSION_NONE : current.byteValue();
currentValue |= (byte) iOperation;
rules.put(iResource, currentValue);
document.field("rules", rules);
} | java |
public static String permissionToString(final int iPermission) {
int permission = iPermission;
final StringBuilder returnValue = new StringBuilder();
for (Entry<Integer, String> p : PERMISSION_BIT_NAMES.entrySet()) {
if ((permission & p.getKey()) == p.getKey()) {
if (returnValue.length() > 0)
returnValue.append(", ");
returnValue.append(p.getValue());
permission &= ~p.getKey();
}
}
if (permission != 0) {
if (returnValue.length() > 0)
returnValue.append(", ");
returnValue.append("Unknown 0x");
returnValue.append(Integer.toHexString(permission));
}
return returnValue.toString();
} | java |
public void start() {
try {
while (keepGoing) {
try {
// this is a blocking call so it hogs a thread
final Socket socket = ss.accept();
final String socketName = socket.getInetAddress().getHostAddress() + ":"
+ socket.getPort();
log.info("accepted socket connection from " + socketName);
try {
final OutputStream out = socket.getOutputStream();
Subscriber<String> subscriber = createSubscriber(socket, socketName, out);
subscriptions.add(subscriber);
source.subscribeOn(Schedulers.io())
// remove subscriber from subscriptions on unsub
.doOnUnsubscribe(() -> subscriptions.remove(subscriber))
// write each line to the socket OutputStream
.subscribe(subscriber);
} catch (IOException e) {
// could not get output stream (could have closed very
// quickly after connecting)
// dont' care
log.warn(e.getClass().getSimpleName() + ": " + e.getMessage());
}
} catch (SocketTimeoutException e) {
// don't care
log.warn(e.getClass().getSimpleName() + ": " + e.getMessage());
}
}
} catch (IOException e) {
if (keepGoing) {
log.warn(e.getMessage(), e);
throw new RuntimeException(e);
} else
log.info("server stopped");
} finally {
closeServerSocket();
}
} | java |
protected static int getLevel(String level, int defaultLogLevel) {
try {
return Integer.parseInt(level);
} catch (NumberFormatException e) {
// Try to read the string.
if ("VERBOSE".equalsIgnoreCase(level)) {
return Constants.VERBOSE;
} else if ("DEBUG".equalsIgnoreCase(level)) {
return Constants.DEBUG;
} else if ("INFO".equalsIgnoreCase(level)) {
return Constants.INFO;
} else if ("WARN".equalsIgnoreCase(level)) {
return Constants.WARN;
} else if ("ERROR".equalsIgnoreCase(level)) {
return Constants.ERROR;
} else if ("ASSERT".equalsIgnoreCase(level)) {
return Constants.ASSERT;
}
}
return defaultLogLevel;
} | java |
public static String getCaller() {
StackTraceElement[] stacks = Thread.currentThread().getStackTrace();
if (stacks != null) {
for (int i = 0; i < stacks.length; i++) {
String cn = stacks[i].getClassName();
if (cn != null && !Constants.CLASSNAME_TO_ESCAPE.contains(cn)) {
return cn;
}
}
}
return null;
} | java |
protected static InputStream getConfigurationFileFromSDCard(String fileName) {
File sdcard = Environment.getExternalStorageDirectory();
if (sdcard == null || !sdcard.exists() || !sdcard.canRead()) {
return null;
}
String sdCardPath = sdcard.getAbsolutePath();
File propFile = new File(sdCardPath + "/" + fileName);
if (!propFile.exists()) {
return null;
}
FileInputStream fileIs = null;
try {
fileIs = new FileInputStream(propFile);
} catch (FileNotFoundException e) {
// should not happen, we check that above
return null;
}
return fileIs;
} | java |
protected static InputStream getConfigurationFileFromAssets(Context context,
String fileName) {
if (context == null) {
return null;
}
AssetManager assets = context.getAssets();
if (assets == null) {
return null;
}
try {
return assets.open(fileName);
} catch (IOException e) {
return null;
}
} | java |
public static String print(int priority, String tag, String msg, Throwable tr, boolean addTimestamp) {
// Compute the letter for the given priority
String p = "X"; // X => Unknown
switch (priority) {
case Constants.DEBUG:
p = "D";
break;
case Constants.INFO:
p = "I";
break;
case Constants.WARN:
p = "W";
break;
case Constants.ERROR:
p = "E";
break;
case Constants.ASSERT:
p = "F";
break;
}
CharSequence timestamp = addTimestamp ? new SimpleDateFormat(TIMESTAMP_PATTERN).format(new Date()) : "";
String base = p + "/" + timestamp + tag + ": " + msg;
return tr == null ? base : base + "\n" + getStackTraceString(tr);
} | java |
public int readLength() throws IOException {
int length = 0;
byte b = (byte) this.read();
// This is short form. The short form can be used if the number of
// octets in the Value part is less than or
// equal to 127, and can be used whether the Value part is primitive or
// constructed. This form is identified by
// encoding bit 8 as zero, with the length count in bits 7 to 1 (as
// usual, with bit 7 the most significant bit
// of the length).
if ((b & 0x80) == 0) {
return b;
}
// This is indefinite form. The indefinite form of length can only be
// used (but does not have to be) if the V
// part is constructed, that
// is to say, consists of a series of TLVs. In the indefinite form of
// length the first bit of the first octet is
// set to 1, as for the long form, but the value N is set to zero.
b = (byte) (b & 0x7F);
if (b == 0) {
return Tag.Indefinite_Length;
}
// If bit 8 of the first length octet is set to 1, then we have the long
// form of length. In long form, the first
// octet encodes in its remaining seven bits a value N which is the
// length of a series of octets that themselves
// encode the length of the Value part.
byte temp;
for (int i = 0; i < b; i++) {
temp = (byte) this.read();
length = (length << 8) | (0x00FF & temp);
}
return length;
} | java |
public AsnInputStream readSequenceStreamData(int length) throws AsnException, IOException {
if (length == Tag.Indefinite_Length) {
return this.readSequenceIndefinite();
} else {
int startPos = this.pos;
this.advance(length);
return new AsnInputStream(this, startPos, length);
}
} | java |
public byte[] readSequenceData(int length) throws AsnException, IOException {
AsnInputStream ais = this.readSequenceStreamData(length);
byte[] res = new byte[ais.length];
System.arraycopy(ais.buffer, ais.start + ais.pos, res, 0, ais.length);
return res;
} | java |
public void addPages() {
page = new CreateComponentStartPage(selection);
addPage(page);
integrationComponentPage = new CreateIntegrationComponentPage(selection);
addPage(integrationComponentPage);
serviceDescriptionComponentPage = new CreateServiceDescriptionComponentPage(selection);
addPage(serviceDescriptionComponentPage);
page3 = new StatusPage(selection);
addPage(page3);
} | java |
@SuppressWarnings("unchecked")
public REC next() {
checkDirection(true);
ORecordInternal<?> record = getRecord();
// ITERATE UNTIL THE NEXT GOOD RECORD
while (hasNext()) {
record = getTransactionEntry();
if (record != null)
return (REC) record;
if ((record = readCurrentRecord(null, +1)) != null)
// FOUND
return (REC) record;
}
throw new NoSuchElementException();
} | java |
public ORecordIteratorCluster<REC> setRange(final long iFrom, final long iEnd) {
firstClusterPosition = iFrom;
rangeTo = iEnd;
current.clusterPosition = firstClusterPosition;
return this;
} | java |
public long getRangeFrom() {
final long limit = (liveUpdated ? database.getStorage().getClusterDataRange(current.clusterId)[1] : firstClusterPosition) - 1;
if (rangeFrom > -1)
return Math.max(rangeFrom, limit);
return limit;
} | java |
public long getRangeTo() {
final long limit = (liveUpdated ? database.getStorage().getClusterDataRange(current.clusterId)[1] : lastClusterPosition) + 1;
if (rangeTo > -1)
return Math.min(rangeTo, limit);
return limit;
} | java |
public AisMessage getMessage() {
AisMessage m = aisParser.parse(aisMessage, nmea.getSource(), padBits);
return m;
} | java |
public Object command(final OCommandRequestText iCommand) {
final OCommandExecutor executor = OCommandManager.instance().getExecutor(iCommand);
executor.setProgressListener(iCommand.getProgressListener());
executor.parse(iCommand);
return executeCommand(iCommand, executor);
} | java |
public long pushPosition(final long iPosition) throws IOException {
final int position = getHoles() * RECORD_SIZE;
file.allocateSpace(RECORD_SIZE);
file.writeLong(position, iPosition);
if (OLogManager.instance().isDebugEnabled())
OLogManager.instance().debug(this, "Pushed new hole %s/#%d -> #%d:%d", owner.getName(), position / RECORD_SIZE,
owner.getId(), iPosition);
return position;
} | java |
public long popLastEntryPosition() throws IOException {
// BROWSE IN ASCENDING ORDER UNTIL A GOOD POSITION IS FOUND (!=-1)
for (int pos = getHoles() - 1; pos >= 0; --pos) {
final long recycledPosition = file.readLong(pos * RECORD_SIZE);
if (recycledPosition > -1) {
if (OLogManager.instance().isDebugEnabled())
OLogManager.instance().debug(this, "Recycled hole %s/#%d -> #%d:%d", owner.getName(), pos, owner.getId(),
recycledPosition);
// SHRINK THE FILE
file.removeTail((getHoles() - pos) * RECORD_SIZE);
return recycledPosition;
}
}
return -1;
} | java |
public boolean removeEntryWithPosition(final long iPosition) throws IOException {
// BROWSE IN ASCENDING ORDER UNTIL THE REQUESTED POSITION IS FOUND
boolean canShrink = true;
for (int pos = getHoles() - 1; pos >= 0; --pos) {
final long recycledPosition = file.readLong(pos * RECORD_SIZE);
if (recycledPosition == iPosition) {
if (OLogManager.instance().isDebugEnabled())
OLogManager.instance().debug(this, "Removing hole #%d containing the position #%d:%d", pos, owner.getId(),
recycledPosition);
file.writeLong(pos * RECORD_SIZE, -1);
if (canShrink)
// SHRINK THE FILE
file.removeTail((getHoles() - pos) * RECORD_SIZE);
return true;
} else if (iPosition != -1)
// NO NULL ENTRY: CAN'T SHRINK WITHOUT LOST OF ENTRIES
canShrink = false;
}
return false;
} | java |
public void requestModificationLock() {
lock.readLock().lock();
if (!veto)
return;
if (throwException) {
lock.readLock().unlock();
throw new OModificationOperationProhibitedException("Modification requests are prohibited");
}
boolean wasInterrupted = false;
Thread thread = Thread.currentThread();
waiters.add(thread);
while (veto) {
LockSupport.park(this);
if (Thread.interrupted())
wasInterrupted = true;
}
waiters.remove(thread);
if (wasInterrupted)
thread.interrupt();
} | java |
public OClass setSuperClass(final OClass iSuperClass) {
getDatabase().checkSecurity(ODatabaseSecurityResources.SCHEMA, ORole.PERMISSION_UPDATE);
final String cmd = String.format("alter class %s superclass %s", name, iSuperClass.getName());
getDatabase().command(new OCommandSQL(cmd)).execute();
setSuperClassInternal(iSuperClass);
return this;
} | java |
private OClass addBaseClasses(final OClass iBaseClass) {
if (baseClasses == null)
baseClasses = new ArrayList<OClass>();
if (baseClasses.contains(iBaseClass))
return this;
baseClasses.add(iBaseClass);
// ADD CLUSTER IDS OF BASE CLASS TO THIS CLASS AND ALL SUPER-CLASSES
OClassImpl currentClass = this;
while (currentClass != null) {
currentClass.addPolymorphicClusterIds((OClassImpl) iBaseClass);
currentClass = (OClassImpl) currentClass.getSuperClass();
}
return this;
} | java |
public void truncate() throws IOException {
getDatabase().checkSecurity(ODatabaseSecurityResources.CLASS, ORole.PERMISSION_UPDATE);
getDatabase().getStorage().callInLock(new Callable<Object>() {
public Object call() throws Exception {
for (int id : clusterIds) {
getDatabase().getStorage().getClusterById(id).truncate();
}
for (OIndex<?> index : getClassIndexes()) {
index.clear();
}
return null;
}
}, true);
} | java |
private void addPolymorphicClusterIds(final OClassImpl iBaseClass) {
boolean found;
for (int i : iBaseClass.polymorphicClusterIds) {
found = false;
for (int k : polymorphicClusterIds) {
if (i == k) {
found = true;
break;
}
}
if (!found) {
// ADD IT
polymorphicClusterIds = OArrays.copyOf(polymorphicClusterIds, polymorphicClusterIds.length + 1);
polymorphicClusterIds[polymorphicClusterIds.length - 1] = i;
Arrays.sort(polymorphicClusterIds);
}
}
} | java |
protected long[] allocateSpace(final int iRecordSize) throws IOException {
// IT'S PREFEREABLE TO FIND SPACE WITHOUT ENLARGE ANY FILES: FIND THE FIRST FILE WITH FREE SPACE TO USE
OFile file;
for (int i = 0; i < files.length; ++i) {
file = files[i];
if (file.getFreeSpace() >= iRecordSize)
// FOUND: RETURN THIS OFFSET
return new long[] { i, file.allocateSpace(iRecordSize) };
}
// NOT FOUND: CHECK IF CAN OVERSIZE SOME FILES
for (int i = 0; i < files.length; ++i) {
file = files[i];
if (file.canOversize(iRecordSize)) {
// FOUND SPACE: ENLARGE IT
return new long[] { i, file.allocateSpace(iRecordSize) };
}
}
// TRY TO CREATE A NEW FILE
if (maxSize > 0 && getSize() >= maxSize)
// OUT OF MAX SIZE
throw new OStorageException("Unable to allocate the requested space of " + iRecordSize
+ " bytes because the segment is full: max-Size=" + maxSize + ", currentSize=" + getFilledUpTo());
// COPY THE OLD ARRAY TO THE NEW ONE
OFile[] newFiles = new OFile[files.length + 1];
for (int i = 0; i < files.length; ++i)
newFiles[i] = files[i];
files = newFiles;
// CREATE THE NEW FILE AND PUT IT AS LAST OF THE ARRAY
file = createNewFile();
file.allocateSpace(iRecordSize);
config.root.update();
return new long[] { files.length - 1, 0 };
} | java |
private void deleteHoleRecords() {
listener.onMessage("\nDelete temporary records...");
final ORecordId rid = new ORecordId();
final ODocument doc = new ODocument(rid);
for (String recId : recordToDelete) {
doc.reset();
rid.fromString(recId);
doc.delete();
}
listener.onMessage("OK (" + recordToDelete.size() + " records)");
} | java |
public PrintStream createStatusPrintStream() {
return new PrintStream(new OutputStream() {
StringBuffer sb = new StringBuffer();
@Override
public void write(int b) throws IOException {
if (b == '\n') {
String str = sb.toString();
sb.delete(0, sb.length());
writeLine(str);
} else {
sb.append(Character.toString((char) b));
}
}
});
} | java |
protected void writeLine(final String line) {
getContainer().getShell().getDisplay().syncExec(
new Runnable() {
public void run() {
if (statusTextArea != null) {
statusTextArea.setText(line + '\n' + statusTextArea.getText());
}
}
}
);
} | java |
public Object attemptTrade(String summonerInternalName, int championId) {
return client.sendRpcAndWait(SERVICE, "attemptTrade", summonerInternalName, championId, false);
} | java |
public Object acceptTrade(String summonerInternalName, int championId) {
return client.sendRpcAndWait(SERVICE, "attemptTrade", summonerInternalName, championId, true);
} | java |
public MigrationConfiguration getMigrationConfiguration(String configurationName)
throws IOException, LightblueException {
DataFindRequest findRequest = new DataFindRequest("migrationConfiguration", null);
findRequest.where(Query.and(
Query.withValue("configurationName", Query.eq, configurationName),
Query.withValue("consistencyCheckerName", Query.eq, cfg.getName()))
);
findRequest.select(Projection.includeFieldRecursively("*"));
LOGGER.debug("Loading configuration:{}", findRequest.getBody());
return lightblueClient.data(findRequest, MigrationConfiguration.class);
} | java |
public MigrationConfiguration loadMigrationConfiguration(String migrationConfigurationId)
throws IOException, LightblueException {
DataFindRequest findRequest = new DataFindRequest("migrationConfiguration", null);
findRequest.where(Query.withValue("_id", Query.eq, migrationConfigurationId));
findRequest.select(Projection.includeFieldRecursively("*"));
LOGGER.debug("Loading configuration");
return lightblueClient.data(findRequest, MigrationConfiguration.class);
} | java |
public void createControllers(MigrationConfiguration[] configurations) throws Exception {
for (MigrationConfiguration cfg : configurations) {
MigrationProcess process = migrationMap.get(cfg.get_id());
if (process == null) {
LOGGER.debug("Creating a controller thread for configuration {}: {}", cfg.get_id(), cfg.getConfigurationName());
MigratorController c = new MigratorController(this, cfg);
if (c instanceof MonitoredThread) {
((MonitoredThread) c).registerThreadMonitor(threadMonitor);
}
AbstractController ccc = getConsistencyCheckerController(cfg);;
if (ccc instanceof MonitoredThread) {
((MonitoredThread) ccc).registerThreadMonitor(threadMonitor);
}
migrationMap.put(cfg.get_id(), new MigrationProcess(cfg, c, ccc));
c.start();
if (ccc != null) {
ccc.start();
}
} else {
healthcheck(cfg);
}
}
} | java |
public OIdentifiable getKeyAt(final int iIndex) {
if (rids != null && rids[iIndex] != null)
return rids[iIndex];
final ORecordId rid = itemFromStream(iIndex);
if (rids != null)
rids[iIndex] = rid;
return rid;
} | java |
public void close() {
if (indexManager != null)
indexManager.flush();
if (schema != null)
schema.close();
if (security != null)
security.close();
} | java |
public MuleMessage doHttpSendRequest(String url, String method, String payload, String contentType) {
Map<String, String> properties = new HashMap<String, String>();
properties.put("http.method", method);
properties.put("Content-Type", contentType);
MuleMessage response = send(url, payload, properties);
return response;
} | java |
public MuleMessage doHttpReceiveRequest(String url, String method, String acceptConentType, String acceptCharSet) {
Map<String, String> properties = new HashMap<String, String>();
properties.put("http.method", method);
properties.put("Accept", acceptConentType);
properties.put("Accept-Charset", acceptCharSet);
MuleMessage response = send(url, null, properties);
return response;
} | java |
public byte[] toByteArray() {
if (this.pos == this.length)
return this.buffer;
else {
byte[] res = new byte[this.pos];
System.arraycopy(this.buffer, 0, res, 0, this.pos);
return res;
}
} | java |
@Override
public void write(byte[] b, int off, int len) {
this.checkIncreaseArray(len);
System.arraycopy(b, off, this.buffer, this.pos, len);
this.pos += len;
} | java |
public void writeTag(int tagClass, boolean primitive, int tag) throws AsnException {
if (tag < 0)
throw new AsnException("Tag must not be negative");
if (tag <= 30) {
int toEncode = (tagClass & 0x03) << 6;
toEncode |= (primitive ? 0 : 1) << 5;
toEncode |= tag & 0x1F;
this.write(toEncode);
} else {
int toEncode = (tagClass & 0x03) << 6;
toEncode |= (primitive ? 0 : 1) << 5;
toEncode |= 0x1F;
this.write(toEncode);
int byteArr = 8;
byte[] buf = new byte[byteArr];
int pos = byteArr;
while (true) {
int dd;
if (tag <= 0x7F) {
dd = tag;
if (pos != byteArr)
dd = dd | 0x80;
buf[--pos] = (byte) dd;
break;
} else {
dd = (tag & 0x7F);
tag >>= 7;
if (pos != byteArr)
dd = dd | 0x80;
buf[--pos] = (byte) dd;
}
}
this.write(buf, pos, byteArr - pos);
}
} | java |
public void writeLength(int v) throws IOException {
if (v == Tag.Indefinite_Length) {
this.write(0x80);
return;
} else if (v > 0x7F) {
int count;
byte[] buf = new byte[4];
if ((v & 0xFF000000) > 0) {
buf[0] = (byte)((v >> 24) & 0xFF);
buf[1] = (byte)((v >> 16) & 0xFF);
buf[2] = (byte)((v >> 8) & 0xFF);
buf[3] = (byte)(v & 0xFF);
count = 4;
} else if ((v & 0x00FF0000) > 0) {
buf[0] = (byte)((v >> 16) & 0xFF);
buf[1] = (byte)((v >> 8) & 0xFF);
buf[2] = (byte)(v & 0xFF);
count = 3;
} else if ((v & 0x0000FF00) > 0) {
buf[0] = (byte)((v >> 8) & 0xFF);
buf[1] = (byte)(v & 0xFF);
count = 2;
} else {
buf[0] = (byte)(v & 0xFF);
count = 1;
}
this.buffer[pos] = (byte) (0x80 | count);
for (int i1 = 0; i1 < count; i1++) {
this.buffer[pos + i1 + 1] = buf[i1];
}
this.pos += count + 1;
// int posLen = this.pos;
// this.write(0);
// int count = this.writeIntegerData(v);
// this.buffer[posLen] = (byte) (count | 0x80);
} else { // short
this.write(v);
}
} | java |
public void FinalizeContent( int lenPos ) {
if (lenPos == Tag.Indefinite_Length) {
this.write(0);
this.write(0);
} else {
int length = this.pos - lenPos - 1;
if (length <= 0x7F) {
this.buffer[lenPos] = (byte) length;
} else {
int count;
byte[] buf = new byte[4];
if ((length & 0xFF000000) > 0) {
buf[0] = (byte)((length >> 24) & 0xFF);
buf[1] = (byte)((length >> 16) & 0xFF);
buf[2] = (byte)((length >> 8) & 0xFF);
buf[3] = (byte)(length & 0xFF);
count = 4;
} else if ((length & 0x00FF0000) > 0) {
buf[0] = (byte)((length >> 16) & 0xFF);
buf[1] = (byte)((length >> 8) & 0xFF);
buf[2] = (byte)(length & 0xFF);
count = 3;
} else if ((length & 0x0000FF00) > 0) {
buf[0] = (byte)((length >> 8) & 0xFF);
buf[1] = (byte)(length & 0xFF);
count = 2;
} else {
buf[0] = (byte)(length & 0xFF);
count = 1;
}
this.checkIncreaseArray(count);
System.arraycopy(this.buffer, lenPos + 1, this.buffer, lenPos + 1 + count, length);
this.pos += count;
this.buffer[lenPos] = (byte) (0x80 | count);
for (int i1 = 0; i1 < count; i1++) {
this.buffer[lenPos + i1 + 1] = buf[i1];
}
}
}
} | java |
private static byte _getByte(int startIndex, BitSetStrictLength set)
throws AsnException {
int count = 8;
byte data = 0;
// if (set.length() - 1 < startIndex) {
// throw new AsnException();
// }
while (count > 0) {
if (set.length() - 1 < startIndex) {
break;
} else {
boolean lit = set.get(startIndex);
if (lit) {
data |= (0x01 << (count - 1));
}
startIndex++;
count--;
}
}
return data;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.