code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public BoxFileUploadSession.Info getStatus() {
URL statusURL = this.sessionInfo.getSessionEndpoints().getStatusEndpoint();
BoxJSONRequest request = new BoxJSONRequest(this.getAPI(), statusURL, HttpMethod.GET);
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject jsonObject = JsonObject.readFrom(response.getJSON());
this.sessionInfo.update(jsonObject);
return this.sessionInfo;
} | java |
public void abort() {
URL abortURL = this.sessionInfo.getSessionEndpoints().getAbortEndpoint();
BoxJSONRequest request = new BoxJSONRequest(this.getAPI(), abortURL, HttpMethod.DELETE);
request.send();
} | java |
public String getHeaderField(String fieldName) {
// headers map is null for all regular response calls except when made as a batch request
if (this.headers == null) {
if (this.connection != null) {
return this.connection.getHeaderField(fieldName);
} else {
return null;
}
} else {
return this.headers.get(fieldName);
}
} | java |
private InputStream getErrorStream() {
InputStream errorStream = this.connection.getErrorStream();
if (errorStream != null) {
final String contentEncoding = this.connection.getContentEncoding();
if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
try {
errorStream = new GZIPInputStream(errorStream);
} catch (IOException e) {
// just return the error stream as is
}
}
}
return errorStream;
} | java |
public void updateInfo(BoxWebLink.Info info) {
URL url = WEB_LINK_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID());
BoxJSONRequest request = new BoxJSONRequest(this.getAPI(), url, "PUT");
request.setBody(info.getPendingChanges());
String body = info.getPendingChanges();
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject jsonObject = JsonObject.readFrom(response.getJSON());
info.update(jsonObject);
} | java |
public static BoxStoragePolicyAssignment.Info create(BoxAPIConnection api, String policyID, String userID) {
URL url = STORAGE_POLICY_ASSIGNMENT_URL_TEMPLATE.build(api.getBaseURL());
BoxJSONRequest request = new BoxJSONRequest(api, url, HttpMethod.POST);
JsonObject requestJSON = new JsonObject()
.add("storage_policy", new JsonObject()
.add("type", "storage_policy")
.add("id", policyID))
.add("assigned_to", new JsonObject()
.add("type", "user")
.add("id", userID));
request.setBody(requestJSON.toString());
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject responseJSON = JsonObject.readFrom(response.getJSON());
BoxStoragePolicyAssignment storagePolicyAssignment = new BoxStoragePolicyAssignment(api,
responseJSON.get("id").asString());
return storagePolicyAssignment.new Info(responseJSON);
} | java |
public static BoxStoragePolicyAssignment.Info getAssignmentForTarget(final BoxAPIConnection api,
String resolvedForType, String resolvedForID) {
QueryStringBuilder builder = new QueryStringBuilder();
builder.appendParam("resolved_for_type", resolvedForType)
.appendParam("resolved_for_id", resolvedForID);
URL url = STORAGE_POLICY_ASSIGNMENT_URL_TEMPLATE.buildWithQuery(api.getBaseURL(), builder.toString());
BoxAPIRequest request = new BoxAPIRequest(api, url, HttpMethod.GET);
BoxJSONResponse response = (BoxJSONResponse) request.send();
BoxStoragePolicyAssignment storagePolicyAssignment = new BoxStoragePolicyAssignment(api,
response.getJsonObject().get("entries").asArray().get(0).asObject().get("id").asString());
BoxStoragePolicyAssignment.Info info = storagePolicyAssignment.new
Info(response.getJsonObject().get("entries").asArray().get(0).asObject());
return info;
} | java |
public void delete() {
URL url = STORAGE_POLICY_ASSIGNMENT_WITH_ID_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID());
BoxAPIRequest request = new BoxAPIRequest(this.getAPI(), url, HttpMethod.DELETE);
request.send();
} | java |
public static Iterable<BoxGroup.Info> getAllGroupsByName(final BoxAPIConnection api, String name) {
final QueryStringBuilder builder = new QueryStringBuilder();
if (name == null || name.trim().isEmpty()) {
throw new BoxAPIException("Searching groups by name requires a non NULL or non empty name");
} else {
builder.appendParam("name", name);
}
return new Iterable<BoxGroup.Info>() {
public Iterator<BoxGroup.Info> iterator() {
URL url = GROUPS_URL_TEMPLATE.buildWithQuery(api.getBaseURL(), builder.toString());
return new BoxGroupIterator(api, url);
}
};
} | java |
public Collection<BoxGroupMembership.Info> getMemberships() {
final BoxAPIConnection api = this.getAPI();
final String groupID = this.getID();
Iterable<BoxGroupMembership.Info> iter = new Iterable<BoxGroupMembership.Info>() {
public Iterator<BoxGroupMembership.Info> iterator() {
URL url = MEMBERSHIPS_URL_TEMPLATE.build(api.getBaseURL(), groupID);
return new BoxGroupMembershipIterator(api, url);
}
};
// We need to iterate all results because this method must return a Collection. This logic should be removed in
// the next major version, and instead return the Iterable directly.
Collection<BoxGroupMembership.Info> memberships = new ArrayList<BoxGroupMembership.Info>();
for (BoxGroupMembership.Info membership : iter) {
memberships.add(membership);
}
return memberships;
} | java |
public BoxGroupMembership.Info addMembership(BoxUser user, Role role) {
BoxAPIConnection api = this.getAPI();
JsonObject requestJSON = new JsonObject();
requestJSON.add("user", new JsonObject().add("id", user.getID()));
requestJSON.add("group", new JsonObject().add("id", this.getID()));
if (role != null) {
requestJSON.add("role", role.toJSONString());
}
URL url = ADD_MEMBERSHIP_URL_TEMPLATE.build(api.getBaseURL());
BoxJSONRequest request = new BoxJSONRequest(api, url, "POST");
request.setBody(requestJSON.toString());
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject responseJSON = JsonObject.readFrom(response.getJSON());
BoxGroupMembership membership = new BoxGroupMembership(api, responseJSON.get("id").asString());
return membership.new Info(responseJSON);
} | java |
public static BoxTermsOfService.Info create(BoxAPIConnection api,
BoxTermsOfService.TermsOfServiceStatus termsOfServiceStatus,
BoxTermsOfService.TermsOfServiceType termsOfServiceType, String text) {
URL url = ALL_TERMS_OF_SERVICES_URL_TEMPLATE.build(api.getBaseURL());
BoxJSONRequest request = new BoxJSONRequest(api, url, "POST");
JsonObject requestJSON = new JsonObject()
.add("status", termsOfServiceStatus.toString())
.add("tos_type", termsOfServiceType.toString())
.add("text", text);
request.setBody(requestJSON.toString());
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject responseJSON = JsonObject.readFrom(response.getJSON());
BoxTermsOfService createdTermsOfServices = new BoxTermsOfService(api, responseJSON.get("id").asString());
return createdTermsOfServices.new Info(responseJSON);
} | java |
public static List<BoxTermsOfService.Info> getAllTermsOfServices(final BoxAPIConnection api,
BoxTermsOfService.TermsOfServiceType
termsOfServiceType) {
QueryStringBuilder builder = new QueryStringBuilder();
if (termsOfServiceType != null) {
builder.appendParam("tos_type", termsOfServiceType.toString());
}
URL url = ALL_TERMS_OF_SERVICES_URL_TEMPLATE.buildWithQuery(api.getBaseURL(), builder.toString());
BoxAPIRequest request = new BoxAPIRequest(api, url, "GET");
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject responseJSON = JsonObject.readFrom(response.getJSON());
int totalCount = responseJSON.get("total_count").asInt();
List<BoxTermsOfService.Info> termsOfServices = new ArrayList<BoxTermsOfService.Info>(totalCount);
JsonArray entries = responseJSON.get("entries").asArray();
for (JsonValue value : entries) {
JsonObject termsOfServiceJSON = value.asObject();
BoxTermsOfService termsOfService = new BoxTermsOfService(api, termsOfServiceJSON.get("id").asString());
BoxTermsOfService.Info info = termsOfService.new Info(termsOfServiceJSON);
termsOfServices.add(info);
}
return termsOfServices;
} | java |
public static Map<String, Map<String, Metadata>> parseAndPopulateMetadataMap(JsonObject jsonObject) {
Map<String, Map<String, Metadata>> metadataMap = new HashMap<String, Map<String, Metadata>>();
//Parse all templates
for (JsonObject.Member templateMember : jsonObject) {
if (templateMember.getValue().isNull()) {
continue;
} else {
String templateName = templateMember.getName();
Map<String, Metadata> scopeMap = metadataMap.get(templateName);
//If templateName doesn't yet exist then create an entry with empty scope map
if (scopeMap == null) {
scopeMap = new HashMap<String, Metadata>();
metadataMap.put(templateName, scopeMap);
}
//Parse all scopes in a template
for (JsonObject.Member scopeMember : templateMember.getValue().asObject()) {
String scope = scopeMember.getName();
Metadata metadataObject = new Metadata(scopeMember.getValue().asObject());
scopeMap.put(scope, metadataObject);
}
}
}
return metadataMap;
} | java |
public static List<Representation> parseRepresentations(JsonObject jsonObject) {
List<Representation> representations = new ArrayList<Representation>();
for (JsonValue representationJson : jsonObject.get("entries").asArray()) {
Representation representation = new Representation(representationJson.asObject());
representations.add(representation);
}
return representations;
} | java |
public void updateInfo(BoxTermsOfServiceUserStatus.Info info) {
URL url = TERMS_OF_SERVICE_USER_STATUSES_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID());
BoxJSONRequest request = new BoxJSONRequest(this.getAPI(), url, "PUT");
request.setBody(info.getPendingChanges());
BoxJSONResponse response = (BoxJSONResponse) request.send();
JsonObject responseJSON = JsonObject.readFrom(response.getJSON());
info.update(responseJSON);
} | java |
public List<BoxAPIResponse> execute(List<BoxAPIRequest> requests) {
this.prepareRequest(requests);
BoxJSONResponse batchResponse = (BoxJSONResponse) send();
return this.parseResponse(batchResponse);
} | java |
protected void prepareRequest(List<BoxAPIRequest> requests) {
JsonObject body = new JsonObject();
JsonArray requestsJSONArray = new JsonArray();
for (BoxAPIRequest request: requests) {
JsonObject batchRequest = new JsonObject();
batchRequest.add("method", request.getMethod());
batchRequest.add("relative_url", request.getUrl().toString().substring(this.api.getBaseURL().length() - 1));
//If the actual request has a JSON body then add it to vatch request
if (request instanceof BoxJSONRequest) {
BoxJSONRequest jsonRequest = (BoxJSONRequest) request;
batchRequest.add("body", jsonRequest.getBodyAsJsonValue());
}
//Add any headers that are in the request, except Authorization
if (request.getHeaders() != null) {
JsonObject batchRequestHeaders = new JsonObject();
for (RequestHeader header: request.getHeaders()) {
if (header.getKey() != null && !header.getKey().isEmpty()
&& !HttpHeaders.AUTHORIZATION.equals(header.getKey())) {
batchRequestHeaders.add(header.getKey(), header.getValue());
}
}
batchRequest.add("headers", batchRequestHeaders);
}
//Add the request to array
requestsJSONArray.add(batchRequest);
}
//Add the requests array to body
body.add("requests", requestsJSONArray);
super.setBody(body);
} | java |
protected List<BoxAPIResponse> parseResponse(BoxJSONResponse batchResponse) {
JsonObject responseJSON = JsonObject.readFrom(batchResponse.getJSON());
List<BoxAPIResponse> responses = new ArrayList<BoxAPIResponse>();
Iterator<JsonValue> responseIterator = responseJSON.get("responses").asArray().iterator();
while (responseIterator.hasNext()) {
JsonObject jsonResponse = responseIterator.next().asObject();
BoxAPIResponse response = null;
//Gather headers
Map<String, String> responseHeaders = new HashMap<String, String>();
if (jsonResponse.get("headers") != null) {
JsonObject batchResponseHeadersObject = jsonResponse.get("headers").asObject();
for (JsonObject.Member member : batchResponseHeadersObject) {
String headerName = member.getName();
String headerValue = member.getValue().asString();
responseHeaders.put(headerName, headerValue);
}
}
// Construct a BoxAPIResponse when response is null, or a BoxJSONResponse when there's a response
// (not anticipating any other response as per current APIs.
// Ideally we should do it based on response header)
if (jsonResponse.get("response") == null || jsonResponse.get("response").isNull()) {
response =
new BoxAPIResponse(jsonResponse.get("status").asInt(), responseHeaders);
} else {
response =
new BoxJSONResponse(jsonResponse.get("status").asInt(), responseHeaders,
jsonResponse.get("response").asObject());
}
responses.add(response);
}
return responses;
} | java |
private static void generateJson(CellScanner cellScanner, Function<Bytes, String> encoder,
PrintStream out) throws JsonIOException {
Gson gson = new GsonBuilder().serializeNulls().setDateFormat(DateFormat.LONG)
.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).setVersion(1.0)
.create();
Map<String, String> json = new LinkedHashMap<>();
for (RowColumnValue rcv : cellScanner) {
json.put(FLUO_ROW, encoder.apply(rcv.getRow()));
json.put(FLUO_COLUMN_FAMILY, encoder.apply(rcv.getColumn().getFamily()));
json.put(FLUO_COLUMN_QUALIFIER, encoder.apply(rcv.getColumn().getQualifier()));
json.put(FLUO_COLUMN_VISIBILITY, encoder.apply(rcv.getColumn().getVisibility()));
json.put(FLUO_VALUE, encoder.apply(rcv.getValue()));
gson.toJson(json, out);
out.append("\n");
if (out.checkError()) {
break;
}
}
out.flush();
} | java |
public static TxInfo getTransactionInfo(Environment env, Bytes prow, Column pcol, long startTs) {
// TODO ensure primary is visible
IteratorSetting is = new IteratorSetting(10, RollbackCheckIterator.class);
RollbackCheckIterator.setLocktime(is, startTs);
Entry<Key, Value> entry = ColumnUtil.checkColumn(env, is, prow, pcol);
TxInfo txInfo = new TxInfo();
if (entry == null) {
txInfo.status = TxStatus.UNKNOWN;
return txInfo;
}
ColumnType colType = ColumnType.from(entry.getKey());
long ts = entry.getKey().getTimestamp() & ColumnConstants.TIMESTAMP_MASK;
switch (colType) {
case LOCK: {
if (ts == startTs) {
txInfo.status = TxStatus.LOCKED;
txInfo.lockValue = entry.getValue().get();
} else {
txInfo.status = TxStatus.UNKNOWN; // locked by another tx
}
break;
}
case DEL_LOCK: {
DelLockValue dlv = new DelLockValue(entry.getValue().get());
if (ts != startTs) {
// expect this to always be false, must be a bug in the iterator
throw new IllegalStateException(prow + " " + pcol + " (" + ts + " != " + startTs + ") ");
}
if (dlv.isRollback()) {
txInfo.status = TxStatus.ROLLED_BACK;
} else {
txInfo.status = TxStatus.COMMITTED;
txInfo.commitTs = dlv.getCommitTimestamp();
}
break;
}
case WRITE: {
long timePtr = WriteValue.getTimestamp(entry.getValue().get());
if (timePtr != startTs) {
// expect this to always be false, must be a bug in the iterator
throw new IllegalStateException(
prow + " " + pcol + " (" + timePtr + " != " + startTs + ") ");
}
txInfo.status = TxStatus.COMMITTED;
txInfo.commitTs = ts;
break;
}
default:
throw new IllegalStateException("unexpected col type returned " + colType);
}
return txInfo;
} | java |
public static boolean oracleExists(CuratorFramework curator) {
boolean exists = false;
try {
exists = curator.checkExists().forPath(ZookeeperPath.ORACLE_SERVER) != null
&& !curator.getChildren().forPath(ZookeeperPath.ORACLE_SERVER).isEmpty();
} catch (Exception nne) {
if (nne instanceof KeeperException.NoNodeException) {
// you'll do nothing
} else {
throw new RuntimeException(nne);
}
}
return exists;
} | java |
public void waitForAsyncFlush() {
long numAdded = asyncBatchesAdded.get();
synchronized (this) {
while (numAdded > asyncBatchesProcessed) {
try {
wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
} | java |
public static Span exact(Bytes row) {
Objects.requireNonNull(row);
return new Span(row, true, row, true);
} | java |
public static Span exact(CharSequence row) {
Objects.requireNonNull(row);
return exact(Bytes.of(row));
} | java |
public static Span prefix(Bytes rowPrefix) {
Objects.requireNonNull(rowPrefix);
Bytes fp = followingPrefix(rowPrefix);
return new Span(rowPrefix, true, fp == null ? Bytes.EMPTY : fp, false);
} | java |
public static Span prefix(CharSequence rowPrefix) {
Objects.requireNonNull(rowPrefix);
return prefix(Bytes.of(rowPrefix));
} | java |
public void load(InputStream in) {
try {
PropertiesConfiguration config = new PropertiesConfiguration();
// disabled to prevent accumulo classpath value from being shortened
config.setDelimiterParsingDisabled(true);
config.load(in);
((CompositeConfiguration) internalConfig).addConfiguration(config);
} catch (ConfigurationException e) {
throw new IllegalArgumentException(e);
}
} | java |
public void load(File file) {
try {
PropertiesConfiguration config = new PropertiesConfiguration();
// disabled to prevent accumulo classpath value from being shortened
config.setDelimiterParsingDisabled(true);
config.load(file);
((CompositeConfiguration) internalConfig).addConfiguration(config);
} catch (ConfigurationException e) {
throw new IllegalArgumentException(e);
}
} | java |
public static long getTxInfoCacheWeight(FluoConfiguration conf) {
long size = conf.getLong(TX_INFO_CACHE_WEIGHT, TX_INFO_CACHE_WEIGHT_DEFAULT);
if (size <= 0) {
throw new IllegalArgumentException("Cache size must be positive for " + TX_INFO_CACHE_WEIGHT);
}
return size;
} | java |
public static long getVisibilityCacheWeight(FluoConfiguration conf) {
long size = conf.getLong(VISIBILITY_CACHE_WEIGHT, VISIBILITY_CACHE_WEIGHT_DEFAULT);
if (size <= 0) {
throw new IllegalArgumentException(
"Cache size must be positive for " + VISIBILITY_CACHE_WEIGHT);
}
return size;
} | java |
public static String parseServers(String zookeepers) {
int slashIndex = zookeepers.indexOf("/");
if (slashIndex != -1) {
return zookeepers.substring(0, slashIndex);
}
return zookeepers;
} | java |
public static String parseRoot(String zookeepers) {
int slashIndex = zookeepers.indexOf("/");
if (slashIndex != -1) {
return zookeepers.substring(slashIndex).trim();
}
return "/";
} | java |
public static long getGcTimestamp(String zookeepers) {
ZooKeeper zk = null;
try {
zk = new ZooKeeper(zookeepers, 30000, null);
// wait until zookeeper is connected
long start = System.currentTimeMillis();
while (!zk.getState().isConnected() && System.currentTimeMillis() - start < 30000) {
Uninterruptibles.sleepUninterruptibly(10, TimeUnit.MILLISECONDS);
}
byte[] d = zk.getData(ZookeeperPath.ORACLE_GC_TIMESTAMP, false, null);
return LongUtil.fromByteArray(d);
} catch (KeeperException | InterruptedException | IOException e) {
log.warn("Failed to get oldest timestamp of Oracle from Zookeeper", e);
return OLDEST_POSSIBLE;
} finally {
if (zk != null) {
try {
zk.close();
} catch (InterruptedException e) {
log.error("Failed to close zookeeper client", e);
}
}
}
} | java |
public static Bytes toBytes(Text t) {
return Bytes.of(t.getBytes(), 0, t.getLength());
} | java |
public static void configure(Job conf, SimpleConfiguration config) {
try {
FluoConfiguration fconfig = new FluoConfiguration(config);
try (Environment env = new Environment(fconfig)) {
long ts =
env.getSharedResources().getTimestampTracker().allocateTimestamp().getTxTimestamp();
conf.getConfiguration().setLong(TIMESTAMP_CONF_KEY, ts);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
config.save(baos);
conf.getConfiguration().set(PROPS_CONF_KEY,
new String(baos.toByteArray(), StandardCharsets.UTF_8));
AccumuloInputFormat.setZooKeeperInstance(conf, fconfig.getAccumuloInstance(),
fconfig.getAccumuloZookeepers());
AccumuloInputFormat.setConnectorInfo(conf, fconfig.getAccumuloUser(),
new PasswordToken(fconfig.getAccumuloPassword()));
AccumuloInputFormat.setInputTableName(conf, env.getTable());
AccumuloInputFormat.setScanAuthorizations(conf, env.getAuthorizations());
}
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java |
private void readUnread(CommitData cd, Consumer<Entry<Key, Value>> locksSeen) {
// TODO make async
// TODO need to keep track of ranges read (not ranges passed in, but actual data read... user
// may not iterate over entire range
Map<Bytes, Set<Column>> columnsToRead = new HashMap<>();
for (Entry<Bytes, Set<Column>> entry : cd.getRejected().entrySet()) {
Set<Column> rowColsRead = columnsRead.get(entry.getKey());
if (rowColsRead == null) {
columnsToRead.put(entry.getKey(), entry.getValue());
} else {
HashSet<Column> colsToRead = new HashSet<>(entry.getValue());
colsToRead.removeAll(rowColsRead);
if (!colsToRead.isEmpty()) {
columnsToRead.put(entry.getKey(), colsToRead);
}
}
}
for (Entry<Bytes, Set<Column>> entry : columnsToRead.entrySet()) {
getImpl(entry.getKey(), entry.getValue(), locksSeen);
}
} | java |
public byte byteAt(int i) {
if (i < 0) {
throw new IndexOutOfBoundsException("i < 0, " + i);
}
if (i >= length) {
throw new IndexOutOfBoundsException("i >= length, " + i + " >= " + length);
}
return data[offset + i];
} | java |
public Bytes subSequence(int start, int end) {
if (start > end || start < 0 || end > length) {
throw new IndexOutOfBoundsException("Bad start and/end start = " + start + " end=" + end
+ " offset=" + offset + " length=" + length);
}
return new Bytes(data, offset + start, end - start);
} | java |
public byte[] toArray() {
byte[] copy = new byte[length];
System.arraycopy(data, offset, copy, 0, length);
return copy;
} | java |
public boolean contentEquals(byte[] bytes, int offset, int len) {
Preconditions.checkArgument(len >= 0 && offset >= 0 && offset + len <= bytes.length);
return contentEqualsUnchecked(bytes, offset, len);
} | java |
private boolean contentEqualsUnchecked(byte[] bytes, int offset, int len) {
if (length != len) {
return false;
}
return compareToUnchecked(bytes, offset, len) == 0;
} | java |
public static final Bytes of(byte[] array) {
Objects.requireNonNull(array);
if (array.length == 0) {
return EMPTY;
}
byte[] copy = new byte[array.length];
System.arraycopy(array, 0, copy, 0, array.length);
return new Bytes(copy);
} | java |
public static final Bytes of(byte[] data, int offset, int length) {
Objects.requireNonNull(data);
if (length == 0) {
return EMPTY;
}
byte[] copy = new byte[length];
System.arraycopy(data, offset, copy, 0, length);
return new Bytes(copy);
} | java |
public static final Bytes of(ByteBuffer bb) {
Objects.requireNonNull(bb);
if (bb.remaining() == 0) {
return EMPTY;
}
byte[] data;
if (bb.hasArray()) {
data = Arrays.copyOfRange(bb.array(), bb.position() + bb.arrayOffset(),
bb.limit() + bb.arrayOffset());
} else {
data = new byte[bb.remaining()];
// duplicate so that it does not change position
bb.duplicate().get(data);
}
return new Bytes(data);
} | java |
public static final Bytes of(CharSequence cs) {
if (cs instanceof String) {
return of((String) cs);
}
Objects.requireNonNull(cs);
if (cs.length() == 0) {
return EMPTY;
}
ByteBuffer bb = StandardCharsets.UTF_8.encode(CharBuffer.wrap(cs));
if (bb.hasArray()) {
// this byte buffer has never escaped so can use its byte array directly
return new Bytes(bb.array(), bb.position() + bb.arrayOffset(), bb.limit());
} else {
byte[] data = new byte[bb.remaining()];
bb.get(data);
return new Bytes(data);
}
} | java |
public static final Bytes of(String s) {
Objects.requireNonNull(s);
if (s.isEmpty()) {
return EMPTY;
}
byte[] data = s.getBytes(StandardCharsets.UTF_8);
return new Bytes(data, s);
} | java |
public static final Bytes of(String s, Charset c) {
Objects.requireNonNull(s);
Objects.requireNonNull(c);
if (s.isEmpty()) {
return EMPTY;
}
byte[] data = s.getBytes(c);
return new Bytes(data);
} | java |
public boolean startsWith(Bytes prefix) {
Objects.requireNonNull(prefix, "startWith(Bytes prefix) cannot have null parameter");
if (prefix.length > this.length) {
return false;
} else {
int end = this.offset + prefix.length;
for (int i = this.offset, j = prefix.offset; i < end; i++, j++) {
if (this.data[i] != prefix.data[j]) {
return false;
}
}
}
return true;
} | java |
public boolean endsWith(Bytes suffix) {
Objects.requireNonNull(suffix, "endsWith(Bytes suffix) cannot have null parameter");
int startOffset = this.length - suffix.length;
if (startOffset < 0) {
return false;
} else {
int end = startOffset + this.offset + suffix.length;
for (int i = startOffset + this.offset, j = suffix.offset; i < end; i++, j++) {
if (this.data[i] != suffix.data[j]) {
return false;
}
}
}
return true;
} | java |
public void copyTo(int start, int end, byte[] dest, int destPos) {
// this.subSequence(start, end).copyTo(dest, destPos) would allocate another Bytes object
arraycopy(start, dest, destPos, end - start);
} | java |
public void copyTo(ColumnBuffer dest, LongPredicate timestampTest) {
dest.clear();
if (key != null) {
dest.key = new Key(key);
}
for (int i = 0; i < timeStamps.size(); i++) {
long time = timeStamps.get(i);
if (timestampTest.test(time)) {
dest.add(time, values.get(i));
}
}
} | java |
public static AccumuloClient getClient(FluoConfiguration config) {
return Accumulo.newClient().to(config.getAccumuloInstance(), config.getAccumuloZookeepers())
.as(config.getAccumuloUser(), config.getAccumuloPassword()).build();
} | java |
public static byte[] encode(byte[] ba, int offset, long v) {
ba[offset + 0] = (byte) (v >>> 56);
ba[offset + 1] = (byte) (v >>> 48);
ba[offset + 2] = (byte) (v >>> 40);
ba[offset + 3] = (byte) (v >>> 32);
ba[offset + 4] = (byte) (v >>> 24);
ba[offset + 5] = (byte) (v >>> 16);
ba[offset + 6] = (byte) (v >>> 8);
ba[offset + 7] = (byte) (v >>> 0);
return ba;
} | java |
public static long decodeLong(byte[] ba, int offset) {
return ((((long) ba[offset + 0] << 56) + ((long) (ba[offset + 1] & 255) << 48)
+ ((long) (ba[offset + 2] & 255) << 40) + ((long) (ba[offset + 3] & 255) << 32)
+ ((long) (ba[offset + 4] & 255) << 24) + ((ba[offset + 5] & 255) << 16)
+ ((ba[offset + 6] & 255) << 8) + ((ba[offset + 7] & 255) << 0)));
} | java |
public static byte[] concat(Bytes... listOfBytes) {
int offset = 0;
int size = 0;
for (Bytes b : listOfBytes) {
size += b.length() + checkVlen(b.length());
}
byte[] data = new byte[size];
for (Bytes b : listOfBytes) {
offset = writeVint(data, offset, b.length());
b.copyTo(0, b.length(), data, offset);
offset += b.length();
}
return data;
} | java |
public static int writeVint(byte[] dest, int offset, int i) {
if (i >= -112 && i <= 127) {
dest[offset++] = (byte) i;
} else {
int len = -112;
if (i < 0) {
i ^= -1L; // take one's complement'
len = -120;
}
long tmp = i;
while (tmp != 0) {
tmp = tmp >> 8;
len--;
}
dest[offset++] = (byte) len;
len = (len < -120) ? -(len + 120) : -(len + 112);
for (int idx = len; idx != 0; idx--) {
int shiftbits = (idx - 1) * 8;
long mask = 0xFFL << shiftbits;
dest[offset++] = (byte) ((i & mask) >> shiftbits);
}
}
return offset;
} | java |
public static int checkVlen(int i) {
int count = 0;
if (i >= -112 && i <= 127) {
return 1;
} else {
int len = -112;
if (i < 0) {
i ^= -1L; // take one's complement'
len = -120;
}
long tmp = i;
while (tmp != 0) {
tmp = tmp >> 8;
len--;
}
count++;
len = (len < -120) ? -(len + 120) : -(len + 112);
while (len != 0) {
count++;
len--;
}
return count;
}
} | java |
private ResourceReport getResourceReport(TwillController controller, int maxWaitMs) {
ResourceReport report = controller.getResourceReport();
int elapsed = 0;
while (report == null) {
report = controller.getResourceReport();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new IllegalStateException(e);
}
elapsed += 500;
if ((maxWaitMs != -1) && (elapsed > maxWaitMs)) {
String msg = String.format("Exceeded max wait time to retrieve ResourceReport from Twill."
+ " Elapsed time = %s ms", elapsed);
log.error(msg);
throw new IllegalStateException(msg);
}
if ((elapsed % 10000) == 0) {
log.info("Waiting for ResourceReport from Twill. Elapsed time = {} ms", elapsed);
}
}
return report;
} | java |
private void verifyApplicationName(String name) {
if (name == null) {
throw new IllegalArgumentException("Application name cannot be null");
}
if (name.isEmpty()) {
throw new IllegalArgumentException("Application name length must be > 0");
}
String reason = null;
char[] chars = name.toCharArray();
char c;
for (int i = 0; i < chars.length; i++) {
c = chars[i];
if (c == 0) {
reason = "null character not allowed @" + i;
break;
} else if (c == '/' || c == '.' || c == ':') {
reason = "invalid character '" + c + "'";
break;
} else if (c > '\u0000' && c <= '\u001f' || c >= '\u007f' && c <= '\u009F'
|| c >= '\ud800' && c <= '\uf8ff' || c >= '\ufff0' && c <= '\uffff') {
reason = "invalid character @" + i;
break;
}
}
if (reason != null) {
throw new IllegalArgumentException(
"Invalid application name \"" + name + "\" caused by " + reason);
}
} | java |
@Deprecated
public FluoConfiguration addObservers(Iterable<ObserverSpecification> observers) {
int next = getNextObserverId();
for (ObserverSpecification oconf : observers) {
addObserver(oconf, next++);
}
return this;
} | java |
@Deprecated
public FluoConfiguration clearObservers() {
Iterator<String> iter1 = getKeys(OBSERVER_PREFIX.substring(0, OBSERVER_PREFIX.length() - 1));
while (iter1.hasNext()) {
String key = iter1.next();
clearProperty(key);
}
return this;
} | java |
public void print() {
Iterator<String> iter = getKeys();
while (iter.hasNext()) {
String key = iter.next();
log.info(key + " = " + getRawString(key));
}
} | java |
public boolean hasRequiredClientProps() {
boolean valid = true;
valid &= verifyStringPropSet(CONNECTION_APPLICATION_NAME_PROP, CLIENT_APPLICATION_NAME_PROP);
valid &= verifyStringPropSet(ACCUMULO_USER_PROP, CLIENT_ACCUMULO_USER_PROP);
valid &= verifyStringPropSet(ACCUMULO_PASSWORD_PROP, CLIENT_ACCUMULO_PASSWORD_PROP);
valid &= verifyStringPropSet(ACCUMULO_INSTANCE_PROP, CLIENT_ACCUMULO_INSTANCE_PROP);
return valid;
} | java |
public boolean hasRequiredAdminProps() {
boolean valid = true;
valid &= hasRequiredClientProps();
valid &= verifyStringPropSet(ACCUMULO_TABLE_PROP, ADMIN_ACCUMULO_TABLE_PROP);
return valid;
} | java |
public boolean hasRequiredMiniFluoProps() {
boolean valid = true;
if (getMiniStartAccumulo()) {
// ensure that client properties are not set since we are using MiniAccumulo
valid &= verifyStringPropNotSet(ACCUMULO_USER_PROP, CLIENT_ACCUMULO_USER_PROP);
valid &= verifyStringPropNotSet(ACCUMULO_PASSWORD_PROP, CLIENT_ACCUMULO_PASSWORD_PROP);
valid &= verifyStringPropNotSet(ACCUMULO_INSTANCE_PROP, CLIENT_ACCUMULO_INSTANCE_PROP);
valid &= verifyStringPropNotSet(ACCUMULO_ZOOKEEPERS_PROP, CLIENT_ACCUMULO_ZOOKEEPERS_PROP);
valid &= verifyStringPropNotSet(CONNECTION_ZOOKEEPERS_PROP, CLIENT_ZOOKEEPER_CONNECT_PROP);
if (valid == false) {
log.error("Client properties should not be set in your configuration if MiniFluo is "
+ "configured to start its own accumulo (indicated by fluo.mini.start.accumulo being "
+ "set to true)");
}
} else {
valid &= hasRequiredClientProps();
valid &= hasRequiredAdminProps();
valid &= hasRequiredOracleProps();
valid &= hasRequiredWorkerProps();
}
return valid;
} | java |
public SimpleConfiguration getClientConfiguration() {
SimpleConfiguration clientConfig = new SimpleConfiguration();
Iterator<String> iter = getKeys();
while (iter.hasNext()) {
String key = iter.next();
if (key.startsWith(CONNECTION_PREFIX) || key.startsWith(ACCUMULO_PREFIX)
|| key.startsWith(CLIENT_PREFIX)) {
clientConfig.setProperty(key, getRawString(key));
}
}
return clientConfig;
} | java |
public static void setDefaultConfiguration(SimpleConfiguration config) {
config.setProperty(CONNECTION_ZOOKEEPERS_PROP, CONNECTION_ZOOKEEPERS_DEFAULT);
config.setProperty(CONNECTION_ZOOKEEPER_TIMEOUT_PROP, CONNECTION_ZOOKEEPER_TIMEOUT_DEFAULT);
config.setProperty(DFS_ROOT_PROP, DFS_ROOT_DEFAULT);
config.setProperty(ACCUMULO_ZOOKEEPERS_PROP, ACCUMULO_ZOOKEEPERS_DEFAULT);
config.setProperty(WORKER_NUM_THREADS_PROP, WORKER_NUM_THREADS_DEFAULT);
config.setProperty(TRANSACTION_ROLLBACK_TIME_PROP, TRANSACTION_ROLLBACK_TIME_DEFAULT);
config.setProperty(LOADER_NUM_THREADS_PROP, LOADER_NUM_THREADS_DEFAULT);
config.setProperty(LOADER_QUEUE_SIZE_PROP, LOADER_QUEUE_SIZE_DEFAULT);
config.setProperty(MINI_START_ACCUMULO_PROP, MINI_START_ACCUMULO_DEFAULT);
config.setProperty(MINI_DATA_DIR_PROP, MINI_DATA_DIR_DEFAULT);
} | java |
public static void configure(Job conf, SimpleConfiguration props) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
props.save(baos);
conf.getConfiguration().set(PROPS_CONF_KEY,
new String(baos.toByteArray(), StandardCharsets.UTF_8));
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java |
public Stamp allocateTimestamp() {
synchronized (this) {
Preconditions.checkState(!closed, "tracker closed ");
if (node == null) {
Preconditions.checkState(allocationsInProgress == 0,
"expected allocationsInProgress == 0 when node == null");
Preconditions.checkState(!updatingZk, "unexpected concurrent ZK update");
createZkNode(getTimestamp().getTxTimestamp());
}
allocationsInProgress++;
}
try {
Stamp ts = getTimestamp();
synchronized (this) {
timestamps.add(ts.getTxTimestamp());
}
return ts;
} catch (RuntimeException re) {
synchronized (this) {
allocationsInProgress--;
}
throw re;
}
} | java |
private static boolean waitTillNoNotifications(Environment env, TableRange range)
throws TableNotFoundException {
boolean sawNotifications = false;
long retryTime = MIN_SLEEP_MS;
log.debug("Scanning tablet {} for notifications", range);
long start = System.currentTimeMillis();
while (hasNotifications(env, range)) {
sawNotifications = true;
long sleepTime = Math.max(System.currentTimeMillis() - start, retryTime);
log.debug("Tablet {} had notfications, will rescan in {}ms", range, sleepTime);
UtilWaitThread.sleep(sleepTime);
retryTime = Math.min(MAX_SLEEP_MS, (long) (retryTime * 1.5));
start = System.currentTimeMillis();
}
return sawNotifications;
} | java |
private static void waitUntilFinished(FluoConfiguration config) {
try (Environment env = new Environment(config)) {
List<TableRange> ranges = getRanges(env);
outer: while (true) {
long ts1 = env.getSharedResources().getOracleClient().getStamp().getTxTimestamp();
for (TableRange range : ranges) {
boolean sawNotifications = waitTillNoNotifications(env, range);
if (sawNotifications) {
ranges = getRanges(env);
// This range had notifications. Processing those notifications may have created
// notifications in previously scanned ranges, so start over.
continue outer;
}
}
long ts2 = env.getSharedResources().getOracleClient().getStamp().getTxTimestamp();
// Check to ensure the Oracle issued no timestamps during the scan for notifications.
if (ts2 - ts1 == 1) {
break;
}
}
} catch (Exception e) {
log.error("An exception was thrown -", e);
System.exit(-1);
}
} | java |
public static Range toRange(Span span) {
return new Range(toKey(span.getStart()), span.isStartInclusive(), toKey(span.getEnd()),
span.isEndInclusive());
} | java |
public static Key toKey(RowColumn rc) {
if ((rc == null) || (rc.getRow().equals(Bytes.EMPTY))) {
return null;
}
Text row = ByteUtil.toText(rc.getRow());
if ((rc.getColumn().equals(Column.EMPTY)) || !rc.getColumn().isFamilySet()) {
return new Key(row);
}
Text cf = ByteUtil.toText(rc.getColumn().getFamily());
if (!rc.getColumn().isQualifierSet()) {
return new Key(row, cf);
}
Text cq = ByteUtil.toText(rc.getColumn().getQualifier());
if (!rc.getColumn().isVisibilitySet()) {
return new Key(row, cf, cq);
}
Text cv = ByteUtil.toText(rc.getColumn().getVisibility());
return new Key(row, cf, cq, cv);
} | java |
public static Span toSpan(Range range) {
return new Span(toRowColumn(range.getStartKey()), range.isStartKeyInclusive(),
toRowColumn(range.getEndKey()), range.isEndKeyInclusive());
} | java |
public static RowColumn toRowColumn(Key key) {
if (key == null) {
return RowColumn.EMPTY;
}
if ((key.getRow() == null) || key.getRow().getLength() == 0) {
return RowColumn.EMPTY;
}
Bytes row = ByteUtil.toBytes(key.getRow());
if ((key.getColumnFamily() == null) || key.getColumnFamily().getLength() == 0) {
return new RowColumn(row);
}
Bytes cf = ByteUtil.toBytes(key.getColumnFamily());
if ((key.getColumnQualifier() == null) || key.getColumnQualifier().getLength() == 0) {
return new RowColumn(row, new Column(cf));
}
Bytes cq = ByteUtil.toBytes(key.getColumnQualifier());
if ((key.getColumnVisibility() == null) || key.getColumnVisibility().getLength() == 0) {
return new RowColumn(row, new Column(cf, cq));
}
Bytes cv = ByteUtil.toBytes(key.getColumnVisibility());
return new RowColumn(row, new Column(cf, cq, cv));
} | java |
public FluoKeyValueGenerator set(RowColumnValue rcv) {
setRow(rcv.getRow());
setColumn(rcv.getColumn());
setValue(rcv.getValue());
return this;
} | java |
public FluoKeyValue[] getKeyValues() {
FluoKeyValue kv = keyVals[0];
kv.setKey(new Key(row, fam, qual, vis, ColumnType.WRITE.encode(1)));
kv.getValue().set(WriteValue.encode(0, false, false));
kv = keyVals[1];
kv.setKey(new Key(row, fam, qual, vis, ColumnType.DATA.encode(0)));
kv.getValue().set(val);
return keyVals;
} | java |
public RowColumn following() {
if (row.equals(Bytes.EMPTY)) {
return RowColumn.EMPTY;
} else if (col.equals(Column.EMPTY)) {
return new RowColumn(followingBytes(row));
} else if (!col.isQualifierSet()) {
return new RowColumn(row, new Column(followingBytes(col.getFamily())));
} else if (!col.isVisibilitySet()) {
return new RowColumn(row, new Column(col.getFamily(), followingBytes(col.getQualifier())));
} else {
return new RowColumn(row,
new Column(col.getFamily(), col.getQualifier(), followingBytes(col.getVisibility())));
}
} | java |
public FluoMutationGenerator put(Column col, CharSequence value) {
return put(col, value.toString().getBytes(StandardCharsets.UTF_8));
} | java |
public static CuratorFramework newAppCurator(FluoConfiguration config) {
return newCurator(config.getAppZookeepers(), config.getZookeeperTimeout(),
config.getZookeeperSecret());
} | java |
public static CuratorFramework newFluoCurator(FluoConfiguration config) {
return newCurator(config.getInstanceZookeepers(), config.getZookeeperTimeout(),
config.getZookeeperSecret());
} | java |
public static CuratorFramework newCurator(String zookeepers, int timeout, String secret) {
final ExponentialBackoffRetry retry = new ExponentialBackoffRetry(1000, 10);
if (secret.isEmpty()) {
return CuratorFrameworkFactory.newClient(zookeepers, timeout, timeout, retry);
} else {
return CuratorFrameworkFactory.builder().connectString(zookeepers)
.connectionTimeoutMs(timeout).sessionTimeoutMs(timeout).retryPolicy(retry)
.authorization("digest", ("fluo:" + secret).getBytes(StandardCharsets.UTF_8))
.aclProvider(new ACLProvider() {
@Override
public List<ACL> getDefaultAcl() {
return CREATOR_ALL_ACL;
}
@Override
public List<ACL> getAclForPath(String path) {
switch (path) {
case ZookeeperPath.ORACLE_GC_TIMESTAMP:
// The garbage collection iterator running in Accumulo tservers needs to read this
// value w/o authenticating.
return PUBLICLY_READABLE_ACL;
default:
return CREATOR_ALL_ACL;
}
}
}).build();
}
} | java |
public static void startAndWait(PersistentNode node, int maxWaitSec) {
node.start();
int waitTime = 0;
try {
while (node.waitForInitialCreate(1, TimeUnit.SECONDS) == false) {
waitTime += 1;
log.info("Waited " + waitTime + " sec for ephemeral node to be created");
if (waitTime > maxWaitSec) {
throw new IllegalStateException("Failed to create ephemeral node");
}
}
} catch (InterruptedException e) {
throw new IllegalStateException(e);
}
} | java |
public static NodeCache startAppIdWatcher(Environment env) {
try {
CuratorFramework curator = env.getSharedResources().getCurator();
byte[] uuidBytes = curator.getData().forPath(ZookeeperPath.CONFIG_FLUO_APPLICATION_ID);
if (uuidBytes == null) {
Halt.halt("Fluo Application UUID not found");
throw new RuntimeException(); // make findbugs happy
}
final String uuid = new String(uuidBytes, StandardCharsets.UTF_8);
final NodeCache nodeCache = new NodeCache(curator, ZookeeperPath.CONFIG_FLUO_APPLICATION_ID);
nodeCache.getListenable().addListener(() -> {
ChildData node = nodeCache.getCurrentData();
if (node == null || !uuid.equals(new String(node.getData(), StandardCharsets.UTF_8))) {
Halt.halt("Fluo Application UUID has changed or disappeared");
}
});
nodeCache.start();
return nodeCache;
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java |
private void readZookeeperConfig() {
try (CuratorFramework curator = CuratorUtil.newAppCurator(config)) {
curator.start();
accumuloInstance =
new String(curator.getData().forPath(ZookeeperPath.CONFIG_ACCUMULO_INSTANCE_NAME),
StandardCharsets.UTF_8);
accumuloInstanceID =
new String(curator.getData().forPath(ZookeeperPath.CONFIG_ACCUMULO_INSTANCE_ID),
StandardCharsets.UTF_8);
fluoApplicationID =
new String(curator.getData().forPath(ZookeeperPath.CONFIG_FLUO_APPLICATION_ID),
StandardCharsets.UTF_8);
table = new String(curator.getData().forPath(ZookeeperPath.CONFIG_ACCUMULO_TABLE),
StandardCharsets.UTF_8);
observers = ObserverUtil.load(curator);
config = FluoAdminImpl.mergeZookeeperConfig(config);
// make sure not to include config passed to env, only want config from zookeeper
appConfig = config.getAppConfiguration();
} catch (Exception e) {
throw new IllegalStateException(e);
}
} | java |
@Override
public void close() {
status = TrStatus.CLOSED;
try {
node.close();
} catch (IOException e) {
log.error("Failed to close ephemeral node");
throw new IllegalStateException(e);
}
} | java |
private static Map<String, Set<String>> expand(Map<String, Set<String>> viewToPropNames) {
Set<String> baseProps = viewToPropNames.get(PropertyView.BASE_VIEW);
if (baseProps == null) {
baseProps = ImmutableSet.of();
}
if (!SquigglyConfig.isFilterImplicitlyIncludeBaseFieldsInView()) {
// make an exception for full view
Set<String> fullView = viewToPropNames.get(PropertyView.FULL_VIEW);
if (fullView != null) {
fullView.addAll(baseProps);
}
return viewToPropNames;
}
for (Map.Entry<String, Set<String>> entry : viewToPropNames.entrySet()) {
String viewName = entry.getKey();
Set<String> propNames = entry.getValue();
if (!PropertyView.BASE_VIEW.equals(viewName)) {
propNames.addAll(baseProps);
}
}
return viewToPropNames;
} | java |
public List<SquigglyNode> parse(String filter) {
filter = StringUtils.trim(filter);
if (StringUtils.isEmpty(filter)) {
return Collections.emptyList();
}
// get it from the cache if we can
List<SquigglyNode> cachedNodes = CACHE.getIfPresent(filter);
if (cachedNodes != null) {
return cachedNodes;
}
SquigglyExpressionLexer lexer = ThrowingErrorListener.overwrite(new SquigglyExpressionLexer(new ANTLRInputStream(filter)));
SquigglyExpressionParser parser = ThrowingErrorListener.overwrite(new SquigglyExpressionParser(new CommonTokenStream(lexer)));
Visitor visitor = new Visitor();
List<SquigglyNode> nodes = Collections.unmodifiableList(visitor.visit(parser.parse()));
CACHE.put(filter, nodes);
return nodes;
} | java |
public static <E> Collection<E> collectify(ObjectMapper mapper, Object source, Class<? extends Collection> targetCollectionType, Class<E> targetElementType) {
CollectionType collectionType = mapper.getTypeFactory().constructCollectionType(targetCollectionType, targetElementType);
return objectify(mapper, convertToCollection(source), collectionType);
} | java |
public static List<Map<String, Object>> listify(ObjectMapper mapper, Object source) {
return (List<Map<String, Object>>) collectify(mapper, source, List.class);
} | java |
public static <E> List<E> listify(ObjectMapper mapper, Object source, Class<E> targetElementType) {
return (List<E>) collectify(mapper, source, List.class, targetElementType);
} | java |
public static Object objectify(ObjectMapper mapper, Object source) {
return objectify(mapper, source, Object.class);
} | java |
public static <T> T objectify(ObjectMapper mapper, Object source, JavaType targetType) {
try {
return mapper.readValue(mapper.writeValueAsBytes(source), targetType);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java |
public static Set<Map<String, Object>> setify(ObjectMapper mapper, Object source) {
return (Set<Map<String, Object>>) collectify(mapper, source, Set.class);
} | java |
public static <E> Set<E> setify(ObjectMapper mapper, Object source, Class<E> targetElementType) {
return (Set<E>) collectify(mapper, source, Set.class, targetElementType);
} | java |
public static String stringify(ObjectMapper mapper, Object object) {
try {
return mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
throw new IllegalArgumentException(e);
}
} | java |
private Path getPath(PropertyWriter writer, JsonStreamContext sc) {
LinkedList<PathElement> elements = new LinkedList<>();
if (sc != null) {
elements.add(new PathElement(writer.getName(), sc.getCurrentValue()));
sc = sc.getParent();
}
while (sc != null) {
if (sc.getCurrentName() != null && sc.getCurrentValue() != null) {
elements.addFirst(new PathElement(sc.getCurrentName(), sc.getCurrentValue()));
}
sc = sc.getParent();
}
return new Path(elements);
} | java |
private boolean pathMatches(Path path, SquigglyContext context) {
List<SquigglyNode> nodes = context.getNodes();
Set<String> viewStack = null;
SquigglyNode viewNode = null;
int pathSize = path.getElements().size();
int lastIdx = pathSize - 1;
for (int i = 0; i < pathSize; i++) {
PathElement element = path.getElements().get(i);
if (viewNode != null && !viewNode.isSquiggly()) {
Class beanClass = element.getBeanClass();
if (beanClass != null && !Map.class.isAssignableFrom(beanClass)) {
Set<String> propertyNames = getPropertyNamesFromViewStack(element, viewStack);
if (!propertyNames.contains(element.getName())) {
return false;
}
}
} else if (nodes.isEmpty()) {
return false;
} else {
SquigglyNode match = findBestSimpleNode(element, nodes);
if (match == null) {
match = findBestViewNode(element, nodes);
if (match != null) {
viewNode = match;
viewStack = addToViewStack(viewStack, viewNode);
}
} else if (match.isAnyShallow()) {
viewNode = match;
} else if (match.isAnyDeep()) {
return true;
}
if (match == null) {
if (isJsonUnwrapped(element)) {
continue;
}
return false;
}
if (match.isNegated()) {
return false;
}
nodes = match.getChildren();
if (i < lastIdx && nodes.isEmpty() && !match.isEmptyNested() && SquigglyConfig.isFilterImplicitlyIncludeBaseFields()) {
nodes = BASE_VIEW_NODES;
}
}
}
return true;
} | java |
public static SortedMap<String, Object> asMap() {
SortedMap<String, Object> metrics = Maps.newTreeMap();
METRICS_SOURCE.applyMetrics(metrics);
return metrics;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.