code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public static tunnelglobal_tunneltrafficpolicy_binding[] get(nitro_service service) throws Exception{
tunnelglobal_tunneltrafficpolicy_binding obj = new tunnelglobal_tunneltrafficpolicy_binding();
tunnelglobal_tunneltrafficpolicy_binding response[] = (tunnelglobal_tunneltrafficpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static pq_stats get(nitro_service service) throws Exception{
pq_stats obj = new pq_stats();
pq_stats[] response = (pq_stats[])obj.stat_resources(service);
return response[0];
} | java |
public static csvserver_authorizationpolicy_binding[] get(nitro_service service, String name) throws Exception{
csvserver_authorizationpolicy_binding obj = new csvserver_authorizationpolicy_binding();
obj.set_name(name);
csvserver_authorizationpolicy_binding response[] = (csvserver_authorizationpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
@Override
public Tree newTreeNode(Label parentLabel, List<Tree> children) {
return new LabeledScoredTreeNode(lf.newLabel(parentLabel), children);
} | java |
public static policystringmap_binding get(nitro_service service, String name) throws Exception{
policystringmap_binding obj = new policystringmap_binding();
obj.set_name(name);
policystringmap_binding response = (policystringmap_binding) obj.get_resource(service);
return response;
} | java |
public static long count(nitro_service service, clusternodegroup_crvserver_binding obj) throws Exception{
options option = new options();
option.set_count(true);
option.set_args(nitro_util.object_to_string_withoutquotes(obj));
clusternodegroup_crvserver_binding response[] = (clusternodegroup_crvserver_binding[]) obj.get_resources(service,option);
if (response != null) {
return response[0].__count;
}
return 0;
} | java |
public static <T> Set<T> asSet(T[] a) {
return new HashSet<T>(Arrays.asList(a));
} | java |
public static double[] toDouble(float[] a) {
double[] d = new double[a.length];
for (int i = 0; i < a.length; i++) {
d[i] = a[i];
}
return d;
} | java |
public static double[] toDouble(int[] array) {
double[] rv = new double[array.length];
for (int i = 0; i < array.length; i++) {
rv[i] = array[i];
}
return rv;
} | java |
public static base_response add(nitro_service client, vpnsessionpolicy resource) throws Exception {
vpnsessionpolicy addresource = new vpnsessionpolicy();
addresource.name = resource.name;
addresource.rule = resource.rule;
addresource.action = resource.action;
return addresource.add_resource(client);
} | java |
public static base_response update(nitro_service client, vpnsessionpolicy resource) throws Exception {
vpnsessionpolicy updateresource = new vpnsessionpolicy();
updateresource.name = resource.name;
updateresource.rule = resource.rule;
updateresource.action = resource.action;
return updateresource.update_resource(client);
} | java |
public static vpnsessionpolicy[] get(nitro_service service) throws Exception{
vpnsessionpolicy obj = new vpnsessionpolicy();
vpnsessionpolicy[] response = (vpnsessionpolicy[])obj.get_resources(service);
return response;
} | java |
public static vpnsessionpolicy get(nitro_service service, String name) throws Exception{
vpnsessionpolicy obj = new vpnsessionpolicy();
obj.set_name(name);
vpnsessionpolicy response = (vpnsessionpolicy) obj.get_resource(service);
return response;
} | java |
private static Pair<Double, ClassicCounter<Integer>> readModel(File modelFile, boolean multiclass) {
int modelLineCount = 0;
try {
int numLinesToSkip = multiclass ? 13 : 10;
String stopToken = "#";
BufferedReader in = new BufferedReader(new FileReader(modelFile));
for (int i=0; i < numLinesToSkip; i++) {
in.readLine();
modelLineCount ++;
}
List<Pair<Double, ClassicCounter<Integer>>> supportVectors = new ArrayList<Pair<Double, ClassicCounter<Integer>>>();
// Read Threshold
String thresholdLine = in.readLine();
modelLineCount ++;
String[] pieces = thresholdLine.split("\\s+");
double threshold = Double.parseDouble(pieces[0]);
// Read Support Vectors
while (in.ready()) {
String svLine = in.readLine();
modelLineCount ++;
pieces = svLine.split("\\s+");
// First Element is the alpha_i * y_i
double alpha = Double.parseDouble(pieces[0]);
ClassicCounter<Integer> supportVector = new ClassicCounter<Integer>();
for (int i=1; i < pieces.length; ++i) {
String piece = pieces[i];
if (piece.equals(stopToken)) break;
// Each in featureIndex:num class
String[] indexNum = piece.split(":");
String featureIndex = indexNum[0];
// mihai: we may see "qid" as indexNum[0]. just skip this piece. this is the block id useful only for reranking, which we don't do here.
if(! featureIndex.equals("qid")){
double count = Double.parseDouble(indexNum[1]);
supportVector.incrementCount(Integer.valueOf(featureIndex), count);
}
}
supportVectors.add(new Pair<Double, ClassicCounter<Integer>>(alpha, supportVector));
}
in.close();
return new Pair<Double, ClassicCounter<Integer>>(threshold, getWeights(supportVectors));
}
catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Error reading SVM model (line " + modelLineCount + " in file " + modelFile.getAbsolutePath() + ")");
}
} | java |
private ClassicCounter<Pair<F, L>> convertWeights(ClassicCounter<Integer> weights, Index<F> featureIndex, Index<L> labelIndex, boolean multiclass) {
return multiclass ? convertSVMStructWeights(weights, featureIndex, labelIndex) : convertSVMLightWeights(weights, featureIndex, labelIndex);
} | java |
private LinearClassifier<L, L> fitSigmoid(SVMLightClassifier<L, F> classifier, GeneralDataset<L, F> dataset) {
RVFDataset<L, L> plattDataset = new RVFDataset<L, L>();
for (int i = 0; i < dataset.size(); i++) {
RVFDatum<L, F> d = dataset.getRVFDatum(i);
Counter<L> scores = classifier.scoresOf((Datum<L,F>)d);
scores.incrementCount(null);
plattDataset.add(new RVFDatum<L, L>(scores, d.label()));
}
LinearClassifierFactory<L, L> factory = new LinearClassifierFactory<L, L>();
factory.setPrior(new LogPrior(LogPrior.LogPriorType.NULL));
return factory.trainClassifier(plattDataset);
} | java |
public static gslbservice_binding get(nitro_service service, String servicename) throws Exception{
gslbservice_binding obj = new gslbservice_binding();
obj.set_servicename(servicename);
gslbservice_binding response = (gslbservice_binding) obj.get_resource(service);
return response;
} | java |
public Reader getUrl(String prefix, String postfix)
throws MtasParserException {
String url = getString();
if ((url != null) && !url.equals("")) {
if (prefix != null) {
url = prefix + url;
}
if (postfix != null) {
url = url + postfix;
}
if (url.startsWith("http://") || url.startsWith("https://")) {
BufferedReader in = null;
try {
URLConnection connection = new URL(url).openConnection();
connection.setRequestProperty("Accept-Encoding", "gzip");
connection.setReadTimeout(10000);
if (connection.getHeaderField("Content-Encoding") != null
&& connection.getHeaderField("Content-Encoding").equals("gzip")) {
in = new BufferedReader(new InputStreamReader(
new GZIPInputStream(connection.getInputStream()),
StandardCharsets.UTF_8));
} else {
in = new BufferedReader(new InputStreamReader(
connection.getInputStream(), StandardCharsets.UTF_8));
}
return in;
} catch (IOException ex) {
log.debug(ex);
throw new MtasParserException("couldn't get " + url);
}
} else {
throw new MtasParserException("no valid url: " + url);
}
} else {
throw new MtasParserException("no valid url: " + url);
}
} | java |
public Reader getFile(String prefix, String postfix)
throws MtasParserException {
String file = getString();
if ((file != null) && !file.equals("")) {
if (prefix != null) {
file = prefix + file;
}
if (postfix != null) {
file = file + postfix;
}
Path path = (new File(file)).toPath();
if(Files.isReadable(path)) {
try {
return new InputStreamReader(new GZIPInputStream(new FileInputStream(file)), StandardCharsets.UTF_8);
} catch (IOException e1) {
log.debug(e1);
try {
String text = new String(Files.readAllBytes(Paths.get(file)),
StandardCharsets.UTF_8);
return new StringReader(text);
} catch (IOException e2) {
log.debug(e2);
throw new MtasParserException(e2.getMessage());
}
}
} else {
throw new MtasParserException("file '"+file+"' does not exists or not readable");
}
} else {
throw new MtasParserException("no valid file: " + file);
}
} | java |
public static service_binding get(nitro_service service, String name) throws Exception{
service_binding obj = new service_binding();
obj.set_name(name);
service_binding response = (service_binding) obj.get_resource(service);
return response;
} | java |
public static systemglobal_authenticationlocalpolicy_binding[] get(nitro_service service) throws Exception{
systemglobal_authenticationlocalpolicy_binding obj = new systemglobal_authenticationlocalpolicy_binding();
systemglobal_authenticationlocalpolicy_binding response[] = (systemglobal_authenticationlocalpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static auditsyslogpolicy_tmglobal_binding[] get(nitro_service service, String name) throws Exception{
auditsyslogpolicy_tmglobal_binding obj = new auditsyslogpolicy_tmglobal_binding();
obj.set_name(name);
auditsyslogpolicy_tmglobal_binding response[] = (auditsyslogpolicy_tmglobal_binding[]) obj.get_resources(service);
return response;
} | java |
String readLine(boolean ignoreLF) throws IOException {
StringBuffer s = null;
int startChar;
synchronized (lock) {
ensureOpen();
boolean omitLF = ignoreLF || skipLF;
for (;;) {
if (nextChar >= nChars)
fill();
if (nextChar >= nChars) { /* EOF */
if (s != null && s.length() > 0)
return s.toString();
else
return null;
}
boolean eol = false;
char c = 0;
int i;
/* Skip a leftover '\n', if necessary */
if (omitLF && (cb[nextChar] == '\n'))
nextChar++;
skipLF = false;
omitLF = false;
charLoop: for (i = nextChar; i < nChars; i++) {
c = cb[i];
if ((c == '\n') || (c == '\r')) {
eol = true;
break charLoop;
}
}
startChar = nextChar;
nextChar = i;
if (eol) {
String str;
if (s == null) {
str = new String(cb, startChar, i - startChar);
} else {
s.append(cb, startChar, i - startChar);
str = s.toString();
}
nextChar++;
if (c == '\r') {
skipLF = true;
}
return str;
}
if (s == null)
s = new StringBuffer(defaultExpectedLineLength);
s.append(cb, startChar, i - startChar);
}
}
} | java |
public static base_response unset(nitro_service client, vpnparameter resource, String[] args) throws Exception{
vpnparameter unsetresource = new vpnparameter();
return unsetresource.unset_resource(client,args);
} | java |
public static vpnparameter get(nitro_service service, options option) throws Exception{
vpnparameter obj = new vpnparameter();
vpnparameter[] response = (vpnparameter[])obj.get_resources(service,option);
return response[0];
} | java |
public Iterator<List<IN>> getIterator(Reader r) {
Tokenizer<IN> tokenizer = tokenizerFactory.getTokenizer(r);
// PTBTokenizer.newPTBTokenizer(r, false, true);
List<IN> words = new ArrayList<IN>();
IN previous = tokenFactory.makeToken();
StringBuilder prepend = new StringBuilder();
/*
* This changes SGML tags into whitespace -- it should maybe be moved
* elsewhere
*/
while (tokenizer.hasNext()) {
IN w = tokenizer.next();
String word = w.get(CoreAnnotations.TextAnnotation.class);
Matcher m = sgml.matcher(word);
if (m.matches()) {
String before = StringUtils.getNotNullString(w.get(CoreAnnotations.BeforeAnnotation.class));
String after = StringUtils.getNotNullString(w.get(CoreAnnotations.AfterAnnotation.class));
prepend.append(before).append(word);
String previousTokenAfter = StringUtils.getNotNullString(previous.get(CoreAnnotations.AfterAnnotation.class));
previous.set(AfterAnnotation.class, previousTokenAfter + word + after);
// previous.appendAfter(w.word() + w.after());
} else {
String before = StringUtils.getNotNullString(w.get(CoreAnnotations.BeforeAnnotation.class));
if (prepend.length() > 0) {
w.set(BeforeAnnotation.class, prepend.toString() + before);
// w.prependBefore(prepend.toString());
prepend = new StringBuilder();
}
words.add(w);
previous = w;
}
}
List<List<IN>> sentences = wts.process(words);
String after = "";
IN last = null;
for (List<IN> sentence : sentences) {
int pos = 0;
for (IN w : sentence) {
w.set(PositionAnnotation.class, Integer.toString(pos));
after = StringUtils.getNotNullString(w.get(CoreAnnotations.AfterAnnotation.class));
w.remove(AfterAnnotation.class);
last = w;
}
}
if (last != null) {
last.set(AfterAnnotation.class, after);
}
return sentences.iterator();
} | java |
public static lbvserver_dospolicy_binding[] get(nitro_service service, String name) throws Exception{
lbvserver_dospolicy_binding obj = new lbvserver_dospolicy_binding();
obj.set_name(name);
lbvserver_dospolicy_binding response[] = (lbvserver_dospolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static nsrunningconfig get(nitro_service service) throws Exception{
nsrunningconfig obj = new nsrunningconfig();
nsrunningconfig[] response = (nsrunningconfig[])obj.get_resources(service);
return response[0];
} | java |
public static nsrunningconfig[] get(nitro_service service, nsrunningconfig_args args) throws Exception{
nsrunningconfig obj = new nsrunningconfig();
options option = new options();
option.set_args(nitro_util.object_to_string_withoutquotes(args));
nsrunningconfig[] response = (nsrunningconfig[])obj.get_resources(service, option);
return response;
} | java |
public static servicegroup_servicegroupmember_binding[] get(nitro_service service, String servicegroupname) throws Exception{
servicegroup_servicegroupmember_binding obj = new servicegroup_servicegroupmember_binding();
obj.set_servicegroupname(servicegroupname);
servicegroup_servicegroupmember_binding response[] = (servicegroup_servicegroupmember_binding[]) obj.get_resources(service);
return response;
} | java |
public static aaagroup_auditnslogpolicy_binding[] get(nitro_service service, String groupname) throws Exception{
aaagroup_auditnslogpolicy_binding obj = new aaagroup_auditnslogpolicy_binding();
obj.set_groupname(groupname);
aaagroup_auditnslogpolicy_binding response[] = (aaagroup_auditnslogpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static nd6ravariables_onlinkipv6prefix_binding[] get(nitro_service service, Long vlan) throws Exception{
nd6ravariables_onlinkipv6prefix_binding obj = new nd6ravariables_onlinkipv6prefix_binding();
obj.set_vlan(vlan);
nd6ravariables_onlinkipv6prefix_binding response[] = (nd6ravariables_onlinkipv6prefix_binding[]) obj.get_resources(service);
return response;
} | java |
public static double[] exp(double[] a) {
double[] result = new double[a.length];
for (int i = 0; i < a.length; i++) {
result[i] = Math.exp(a[i]);
}
return result;
} | java |
public static void expInPlace(double[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = Math.exp(a[i]);
}
} | java |
public static void addInPlace(double[] a, double b) {
for (int i = 0; i < a.length; i++) {
a[i] = a[i] + b;
}
} | java |
public static void addMultInPlace(double[] a, double[] b, double c) {
for (int i=0; i<a.length; i++) {
a[i] += b[i] * c;
}
} | java |
public static void multiplyInPlace(double[] a, double b) {
for (int i = 0; i < a.length; i++) {
a[i] = a[i] * b;
}
} | java |
public static double[] add(double[] a, double c) {
double[] result = new double[a.length];
for (int i = 0; i < a.length; i++) {
result[i] = a[i] + c;
}
return result;
} | java |
public static double[] pow(double[] a, double c) {
double[] result = new double[a.length];
for (int i = 0; i < a.length; i++) {
result[i] = Math.pow(a[i], c);
}
return result;
} | java |
public static int[] pairwiseAdd(int[] a, int[] b) {
int[] result = new int[a.length];
for (int i = 0; i < a.length; i++) {
result[i] = a[i] + b[i];
}
return result;
} | java |
public static double[] pairwiseMultiply(double[] a, double[] b) {
if (a.length != b.length) {
throw new RuntimeException("Can't pairwise multiple different lengths: a.length=" + a.length + " b.length=" + b.length);
}
double[] result = new double[a.length];
for (int i = 0; i < result.length; i++) {
result[i] = a[i] * b[i];
}
return result;
} | java |
public static double norm_1(double[] a) {
double sum = 0;
for (double anA : a) {
sum += (anA < 0 ? -anA : anA);
}
return sum;
} | java |
public static double norm(double[] a) {
double squaredSum = 0;
for (double anA : a) {
squaredSum += anA * anA;
}
return Math.sqrt(squaredSum);
} | java |
public static double innerProduct(double[] a, double[] b) {
double result = 0.0;
int len = Math.min(a.length, b.length);
for (int i = 0; i < len; i++) {
result += a[i] * b[i];
}
return result;
} | java |
public static void normalize(double[] a) {
double total = sum(a);
if (total == 0.0 || Double.isNaN(total)) {
throw new RuntimeException("Can't normalize an array with sum 0.0 or NaN: " + Arrays.toString(a));
}
multiplyInPlace(a, 1.0/total); // divide each value by total
} | java |
public static void standardize(double[] a) {
double m = mean(a);
if (Double.isNaN(m))
throw new RuntimeException("Can't standardize array whose mean is NaN");
double s = stdev(a);
if(s == 0.0 || Double.isNaN(s))
throw new RuntimeException("Can't standardize array whose standard deviation is 0.0 or NaN");
addInPlace(a, -m); // subtract mean
multiplyInPlace(a, 1.0/s); // divide by standard deviation
} | java |
public static int sampleFromDistribution(double[] d, Random random) {
// sample from the uniform [0,1]
double r = random.nextDouble();
// now compare its value to cumulative values to find what interval it falls in
double total = 0;
for (int i = 0; i < d.length - 1; i++) {
if (Double.isNaN(d[i])) {
throw new RuntimeException("Can't sample from NaN");
}
total += d[i];
if (r < total) {
return i;
}
}
return d.length - 1; // in case the "double-math" didn't total to exactly 1.0
} | java |
public static void sampleWithoutReplacement(int[] array, int numArgClasses, Random rand) {
int[] temp = new int[numArgClasses];
for (int i = 0; i < temp.length; i++) {
temp[i] = i;
}
shuffle(temp, rand);
System.arraycopy(temp, 0, array, 0, array.length);
} | java |
private static double absDiffOfMeans(double[] A, double[] B, boolean randomize) {
Random random = new Random();
double aTotal = 0.0;
double bTotal = 0.0;
for (int i = 0; i < A.length; i++) {
if (randomize && random.nextBoolean()) {
aTotal += B[i];
bTotal += A[i];
} else {
aTotal += A[i];
bTotal += B[i];
}
}
double aMean = aTotal / A.length;
double bMean = bTotal / B.length;
return Math.abs(aMean - bMean);
} | java |
public static appfwpolicy_lbvserver_binding[] get(nitro_service service, String name) throws Exception{
appfwpolicy_lbvserver_binding obj = new appfwpolicy_lbvserver_binding();
obj.set_name(name);
appfwpolicy_lbvserver_binding response[] = (appfwpolicy_lbvserver_binding[]) obj.get_resources(service);
return response;
} | java |
public static Session getSession(String wrapper, Object... parameters) {
// This will be the session loaded depending the selected wrapper
org.riverframework.wrapper.Session<?> _session = null;
// Trying to retrieve the session from the map
Session session = map.get(wrapper);
if (session != null && session.isOpen()) {
// There is an open session
if (parameters.length > 0) {
// and the user is trying to open a new one
throw new RiverException("There is already an open session for the wrapper " + wrapper +
". You must close the current before opening a new one.");
}
// If there are no parameters, we just return the current opened session
} else {
// If not exists or is closed, we create it using the factory
Class<?> clazzFactory = null;
try {
clazzFactory = Class.forName(wrapper + ".DefaultFactory");
} catch (ClassNotFoundException e) {
throw new RiverException("The wrapper '" + wrapper + "' can not be loaded. If you are using an non-official wrapper, " +
"check the wrapper name and its design. Check the CLASSPATH.");
}
try {
Method method = clazzFactory.getDeclaredMethod("getInstance");
method.setAccessible(true);
org.riverframework.wrapper.Factory<?> _factory = (org.riverframework.wrapper.Factory<?>) method.invoke(null);
if (_factory == null)
throw new RiverException("The factory could not be loaded.");
if (parameters.length > 0) {
// There are parameters. So, we try to create a new one.
_session = (org.riverframework.wrapper.Session<?>) _factory.getSession(parameters);
} else {
// There are no parameters. We create a closed session.
_session = null;
}
Constructor<?> constructor = DefaultSession.class.getDeclaredConstructor(org.riverframework.wrapper.Session.class);
constructor.setAccessible(true);
session = (DefaultSession) constructor.newInstance(_session);
} catch (Exception e) {
throw new RiverException("There's a problem opening the session. Maybe, you will need to check the parameters.", e);
}
map.put(wrapper, session);
}
return session;
} | java |
public static void closeSession(String wrapper) {
Session session = map.get(wrapper);
if (session != null) {
Method method;
try {
method = session.getClass().getDeclaredMethod("protectedClose");
method.setAccessible(true);
method.invoke(session);
} catch (InvocationTargetException e) {
throw new RiverException(e.getCause().getMessage(), e);
} catch (Exception e) {
throw new RiverException(e);
}
map.remove(wrapper);
}
} | java |
public static base_response update(nitro_service client, ntpparam resource) throws Exception {
ntpparam updateresource = new ntpparam();
updateresource.authentication = resource.authentication;
updateresource.trustedkey = resource.trustedkey;
updateresource.autokeylogsec = resource.autokeylogsec;
updateresource.revokelogsec = resource.revokelogsec;
return updateresource.update_resource(client);
} | java |
public static base_response unset(nitro_service client, ntpparam resource, String[] args) throws Exception{
ntpparam unsetresource = new ntpparam();
return unsetresource.unset_resource(client,args);
} | java |
public static ntpparam get(nitro_service service) throws Exception{
ntpparam obj = new ntpparam();
ntpparam[] response = (ntpparam[])obj.get_resources(service);
return response[0];
} | java |
public static base_response update(nitro_service client, snmpengineid resource) throws Exception {
snmpengineid updateresource = new snmpengineid();
updateresource.engineid = resource.engineid;
updateresource.ownernode = resource.ownernode;
return updateresource.update_resource(client);
} | java |
public static base_responses update(nitro_service client, snmpengineid resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
snmpengineid updateresources[] = new snmpengineid[resources.length];
for (int i=0;i<resources.length;i++){
updateresources[i] = new snmpengineid();
updateresources[i].engineid = resources[i].engineid;
updateresources[i].ownernode = resources[i].ownernode;
}
result = update_bulk_request(client, updateresources);
}
return result;
} | java |
public static base_response unset(nitro_service client, Long ownernode, String args[]) throws Exception {
snmpengineid unsetresource = new snmpengineid();
unsetresource.ownernode = ownernode;
return unsetresource.unset_resource(client, args);
} | java |
public static base_responses unset(nitro_service client, Long ownernode[], String args[]) throws Exception {
base_responses result = null;
if (ownernode != null && ownernode.length > 0) {
snmpengineid unsetresources[] = new snmpengineid[ownernode.length];
for (int i=0;i<ownernode.length;i++){
unsetresources[i] = new snmpengineid();
unsetresources[i].ownernode = ownernode[i];
}
result = unset_bulk_request(client, unsetresources,args);
}
return result;
} | java |
public static snmpengineid[] get(nitro_service service) throws Exception{
snmpengineid obj = new snmpengineid();
snmpengineid[] response = (snmpengineid[])obj.get_resources(service);
return response;
} | java |
public static snmpengineid get(nitro_service service, Long ownernode) throws Exception{
snmpengineid obj = new snmpengineid();
obj.set_ownernode(ownernode);
snmpengineid response = (snmpengineid) obj.get_resource(service);
return response;
} | java |
public static snmpengineid[] get(nitro_service service, Long ownernode[]) throws Exception{
if (ownernode !=null && ownernode.length>0) {
snmpengineid response[] = new snmpengineid[ownernode.length];
snmpengineid obj[] = new snmpengineid[ownernode.length];
for (int i=0;i<ownernode.length;i++) {
obj[i] = new snmpengineid();
obj[i].set_ownernode(ownernode[i]);
response[i] = (snmpengineid) obj[i].get_resource(service);
}
return response;
}
return null;
} | java |
public static base_response enable(nitro_service client, sslfipssimsource resource) throws Exception {
sslfipssimsource enableresource = new sslfipssimsource();
enableresource.targetsecret = resource.targetsecret;
enableresource.sourcesecret = resource.sourcesecret;
return enableresource.perform_operation(client,"enable");
} | java |
public static base_response init(nitro_service client, sslfipssimsource resource) throws Exception {
sslfipssimsource initresource = new sslfipssimsource();
initresource.certfile = resource.certfile;
return initresource.perform_operation(client,"init");
} | java |
public static base_response renumber(nitro_service client) throws Exception {
nspbrs renumberresource = new nspbrs();
return renumberresource.perform_operation(client,"renumber");
} | java |
public static base_response clear(nitro_service client) throws Exception {
nspbrs clearresource = new nspbrs();
return clearresource.perform_operation(client,"clear");
} | java |
public static base_response apply(nitro_service client) throws Exception {
nspbrs applyresource = new nspbrs();
return applyresource.perform_operation(client,"apply");
} | java |
public static appflowpolicylabel_appflowpolicy_binding[] get(nitro_service service, String labelname) throws Exception{
appflowpolicylabel_appflowpolicy_binding obj = new appflowpolicylabel_appflowpolicy_binding();
obj.set_labelname(labelname);
appflowpolicylabel_appflowpolicy_binding response[] = (appflowpolicylabel_appflowpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
@SuppressWarnings("unchecked")
private void repairPrefixItems(NamedList<Object> mtasResponse) {
// repair prefix lists
try {
ArrayList<NamedList<?>> list = (ArrayList<NamedList<?>>) mtasResponse
.findRecursive(NAME);
// MtasSolrResultUtil.rewrite(list);
if (list != null) {
for (NamedList<?> item : list) {
SortedSet<String> singlePosition = (SortedSet<String>) item
.get("singlePosition");
SortedSet<String> multiplePosition = (SortedSet<String>) item
.get("multiplePosition");
if (singlePosition != null && multiplePosition != null) {
for (String prefix : multiplePosition) {
if (singlePosition.contains(prefix)) {
singlePosition.remove(prefix);
}
}
}
}
}
} catch (ClassCastException e) {
log.debug(e);
}
} | java |
private static Set<String> collectKnownPrefixes(FieldInfo fi)
throws IOException {
if (fi != null) {
HashSet<String> result = new HashSet<>();
String singlePositionPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_SINGLE_POSITION);
String multiplePositionPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_MULTIPLE_POSITION);
String setPositionPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_SET_POSITION);
if (singlePositionPrefixes != null) {
String[] prefixes = singlePositionPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
String item = prefixes[i].trim();
if (!item.equals("")) {
result.add(item);
}
}
}
if (multiplePositionPrefixes != null) {
String[] prefixes = multiplePositionPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
String item = prefixes[i].trim();
if (!item.equals("")) {
result.add(item);
}
}
}
if (setPositionPrefixes != null) {
String[] prefixes = setPositionPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
String item = prefixes[i].trim();
if (!item.equals("")) {
result.add(item);
}
}
}
return result;
} else {
return Collections.emptySet();
}
} | java |
private static Set<String> collectIntersectionPrefixes(FieldInfo fi)
throws IOException {
if (fi != null) {
Set<String> result = new HashSet<>();
String intersectingPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_INTERSECTION);
if (intersectingPrefixes != null) {
String[] prefixes = intersectingPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
String item = prefixes[i].trim();
if (!item.equals("")) {
result.add(item);
}
}
}
return result;
} else {
return Collections.emptySet();
}
} | java |
private static void collectPrefixes(FieldInfos fieldInfos, String field,
ComponentField fieldInfo, Status status) throws IOException {
if (fieldInfo.prefix != null) {
FieldInfo fi = fieldInfos.fieldInfo(field);
if (fi != null) {
String singlePositionPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_SINGLE_POSITION);
String multiplePositionPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_MULTIPLE_POSITION);
String setPositionPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_SET_POSITION);
String intersectingPrefixes = fi.getAttribute(
MtasCodecPostingsFormat.MTAS_FIELDINFO_ATTRIBUTE_PREFIX_INTERSECTION);
if (singlePositionPrefixes != null) {
String[] prefixes = singlePositionPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
fieldInfo.prefix.addSinglePosition(prefixes[i]);
}
}
if (multiplePositionPrefixes != null) {
String[] prefixes = multiplePositionPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
fieldInfo.prefix.addMultiplePosition(prefixes[i]);
}
}
if (setPositionPrefixes != null) {
String[] prefixes = setPositionPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
fieldInfo.prefix.addSetPosition(prefixes[i]);
}
}
if (intersectingPrefixes != null) {
String[] prefixes = intersectingPrefixes
.split(Pattern.quote(MtasToken.DELIMITER));
for (int i = 0; i < prefixes.length; i++) {
fieldInfo.prefix.addIntersecting(prefixes[i]);
}
}
}
}
} | java |
private static Map<GroupHit, Spans> collectSpansForOccurences(
Set<GroupHit> occurences, Set<String> prefixes, String field,
IndexSearcher searcher, LeafReaderContext lrc) throws IOException {
Map<GroupHit, Spans> list = new HashMap<>();
IndexReader reader = searcher.getIndexReader();
final float boost = 0;
for (GroupHit hit : occurences) {
MtasSpanQuery queryHit = createQueryFromGroupHit(prefixes, field, hit);
if (queryHit != null) {
MtasSpanQuery queryHitRewritten = queryHit.rewrite(reader);
SpanWeight weight = queryHitRewritten.createWeight(searcher, false,
boost);
Spans spans = weight.getSpans(lrc, SpanWeight.Postings.POSITIONS);
if (spans != null) {
list.put(hit, spans);
}
}
}
return list;
} | java |
private static MtasSpanQuery createQueryFromGroupHit(Set<String> prefixes,
String field, GroupHit hit) {
// initial check
if (prefixes == null || field == null || hit == null) {
return null;
} else {
MtasSpanQuery query = null;
// check for missing
if (hit.missingLeft != null && hit.missingLeft.length > 0) {
for (int i = 0; i < hit.missingLeft.length; i++) {
if (hit.missingLeft[i].size() != hit.unknownLeft[i].size()) {
return null;
}
}
}
if (hit.missingHit != null && hit.missingHit.length > 0) {
for (int i = 0; i < hit.missingHit.length; i++) {
if (hit.missingHit[i].size() != hit.unknownHit[i].size()) {
return null;
}
}
}
if (hit.missingRight != null && hit.missingRight.length > 0) {
for (int i = 0; i < hit.missingRight.length; i++) {
if (hit.missingRight[i].size() != hit.unknownRight[i].size()) {
return null;
}
}
}
MtasSpanQuery hitQuery = createSubQueryFromGroupHit(hit.dataHit, false,
field);
if (hitQuery != null) {
query = hitQuery;
MtasSpanQuery leftHitQuery = createSubQueryFromGroupHit(hit.dataLeft,
true, field);
MtasSpanQuery rightHitQuery = createSubQueryFromGroupHit(hit.dataRight,
false, field);
if (leftHitQuery != null) {
query = new MtasSpanPrecededByQuery(query, leftHitQuery);
}
if (rightHitQuery != null) {
query = new MtasSpanFollowedByQuery(query, rightHitQuery);
}
}
return query;
}
} | java |
private static MtasSpanQuery createSubQueryFromGroupHit(List<String>[] subHit,
boolean reverse, String field) {
MtasSpanQuery query = null;
if (subHit != null && subHit.length > 0) {
List<MtasSpanSequenceItem> items = new ArrayList<>();
List<String> subHitItem;
for (int i = 0; i < subHit.length; i++) {
MtasSpanQuery item = null;
if (reverse) {
subHitItem = subHit[(subHit.length - i - 1)];
} else {
subHitItem = subHit[i];
}
if (subHitItem.isEmpty()) {
item = new MtasSpanMatchAllQuery(field);
} else if (subHitItem.size() == 1) {
Term term = new Term(field, subHitItem.get(0));
item = new MtasSpanTermQuery(term);
} else {
MtasSpanQuery[] subList = new MtasSpanQuery[subHitItem.size()];
for (int j = 0; j < subHitItem.size(); j++) {
Term term = new Term(field, subHitItem.get(j));
subList[j] = new MtasSpanTermQuery(term);
}
item = new MtasSpanAndQuery(subList);
}
items.add(new MtasSpanSequenceItem(item, false));
}
query = new MtasSpanSequenceQuery(items, null, null);
}
return query;
} | java |
private static Map<Integer, Integer> computePositions(CodecInfo mtasCodecInfo,
LeafReader r, LeafReaderContext lrc, String field, List<Integer> docSet)
throws IOException {
HashMap<Integer, Integer> positionsData;
if (mtasCodecInfo != null) {
// for relatively small numbers, compute only what is needed
if (docSet.size() < Math.log(r.maxDoc())) {
positionsData = new HashMap<>();
for (int docId : docSet) {
positionsData.put(docId,
mtasCodecInfo.getNumberOfPositions(field, (docId - lrc.docBase)));
}
// compute everything, only use what is needed
} else {
positionsData = mtasCodecInfo.getAllNumberOfPositions(field,
lrc.docBase);
for (int docId : docSet) {
if (!positionsData.containsKey(docId)) {
positionsData.put(docId, 0);
}
}
}
} else {
positionsData = new HashMap<>();
for (int docId : docSet) {
positionsData.put(docId, 0);
}
}
return positionsData;
} | java |
private static Map<Integer, long[]> computeArguments(
Map<MtasSpanQuery, Map<Integer, Integer>> spansNumberData,
MtasSpanQuery[] queries, Integer[] docSet) {
Map<Integer, long[]> args = new HashMap<>();
for (int q = 0; q < queries.length; q++) {
Map<Integer, Integer> tmpData = spansNumberData.get(queries[q]);
long[] tmpList = null;
for (int docId : docSet) {
if (tmpData != null && tmpData.containsKey(docId)) {
if (!args.containsKey(docId)) {
tmpList = new long[queries.length];
} else {
tmpList = args.get(docId);
}
tmpList[q] = tmpData.get(docId);
args.put(docId, tmpList);
} else if (!args.containsKey(docId)) {
tmpList = new long[queries.length];
args.put(docId, tmpList);
}
}
}
return args;
} | java |
private static Integer[] intersectedDocList(int[] facetDocList,
Integer[] docSet) {
if (facetDocList != null && docSet != null) {
Integer[] c = new Integer[Math.min(facetDocList.length, docSet.length)];
int ai = 0;
int bi = 0;
int ci = 0;
while (ai < facetDocList.length && bi < docSet.length) {
if (facetDocList[ai] < docSet[bi]) {
ai++;
} else if (facetDocList[ai] > docSet[bi]) {
bi++;
} else {
if (ci == 0 || facetDocList[ai] != c[ci - 1]) {
c[ci++] = facetDocList[ai];
}
ai++;
bi++;
}
}
return Arrays.copyOfRange(c, 0, ci);
}
return new Integer[] {};
} | java |
private static void createPositions(List<ComponentPosition> statsPositionList,
Map<Integer, Integer> positionsData, List<Integer> docSet)
throws IOException {
if (statsPositionList != null) {
for (ComponentPosition position : statsPositionList) {
position.dataCollector.initNewList(1);
Integer tmpValue;
long[] values = new long[docSet.size()];
int value;
int number = 0;
for (int docId : docSet) {
tmpValue = positionsData.get(docId);
value = tmpValue == null ? 0 : tmpValue.intValue();
if (((position.minimumLong == null)
|| (value >= position.minimumLong))
&& ((position.maximumLong == null)
|| (value <= position.maximumLong))) {
values[number] = value;
number++;
}
}
if (number > 0) {
position.dataCollector.add(values, number);
}
position.dataCollector.closeNewList();
}
}
} | java |
private static void createTokens(List<ComponentToken> statsTokenList,
Map<Integer, Integer> tokensData, List<Integer> docSet)
throws IOException {
if (statsTokenList != null) {
for (ComponentToken token : statsTokenList) {
token.dataCollector.initNewList(1);
Integer tmpValue;
long[] values = new long[docSet.size()];
int value;
int number = 0;
if (tokensData != null) {
for (int docId : docSet) {
tmpValue = tokensData.get(docId);
value = tmpValue == null ? 0 : tmpValue.intValue();
if (((token.minimumLong == null) || (value >= token.minimumLong))
&& ((token.maximumLong == null)
|| (value <= token.maximumLong))) {
values[number] = value;
number++;
}
}
}
if (number > 0) {
token.dataCollector.add(values, number);
}
token.dataCollector.closeNewList();
}
}
} | java |
private static boolean availablePrefixes(ComponentGroup group,
Set<String> knownPrefixes) {
if (knownPrefixes != null) {
for (String prefix : group.prefixes) {
if (knownPrefixes.contains(prefix)) {
return true;
}
}
}
return false;
} | java |
private static boolean intersectionPrefixes(ComponentGroup group,
Set<String> intersectionPrefixes) {
if (intersectionPrefixes != null) {
for (String prefix : group.prefixes) {
if (intersectionPrefixes.contains(prefix)) {
return true;
}
}
}
return false;
} | java |
private static IntervalTreeNodeData<String> createPositionHit(Match m,
ComponentGroup group) {
Integer start = null;
Integer end = null;
if (group.hitInside != null || group.hitInsideLeft != null
|| group.hitInsideRight != null) {
start = m.startPosition;
end = m.endPosition - 1;
} else {
start = null;
end = null;
}
if (group.hitLeft != null) {
start = m.startPosition;
end = Math.max(m.startPosition + group.hitLeft.length - 1,
m.endPosition - 1);
}
if (group.hitRight != null) {
start = Math.min(m.endPosition - group.hitRight.length, m.startPosition);
end = end == null ? (m.endPosition - 1)
: Math.max(end, (m.endPosition - 1));
}
if (group.left != null) {
start = start == null ? m.startPosition - group.left.length
: Math.min(m.startPosition - group.left.length, start);
end = end == null ? m.startPosition - 1
: Math.max(m.startPosition - 1, end);
}
if (group.right != null) {
start = start == null ? m.endPosition : Math.min(m.endPosition, start);
end = end == null ? m.endPosition + group.right.length - 1
: Math.max(m.endPosition + group.right.length - 1, end);
}
return new IntervalTreeNodeData<>(start, end, m.startPosition,
m.endPosition - 1);
} | java |
private static void sortMatchList(List<Match> list) {
if (list != null) {
// light sorting on start position
Collections.sort(list, (Match m1,
Match m2) -> (Integer.compare(m1.startPosition, m2.startPosition)));
}
} | java |
private static String groupedKeyName(String key, Double baseRangeSize,
Double baseRangeBase) {
final double precision = 0.000001;
if (baseRangeSize == null || baseRangeSize <= 0) {
return key;
} else {
Double doubleKey;
Double doubleBase;
Double doubleNumber;
Double doubleStart;
Double doubleEnd;
try {
doubleKey = Double.parseDouble(key);
doubleBase = baseRangeBase != null ? baseRangeBase : 0;
doubleNumber = Math.floor((doubleKey - doubleBase) / baseRangeSize);
doubleStart = doubleBase + doubleNumber * baseRangeSize;
doubleEnd = doubleStart + baseRangeSize;
} catch (NumberFormatException e) {
return key;
}
// integer
if (Math.abs(baseRangeSize - Math.floor(baseRangeSize)) < precision
&& Math.abs(doubleBase - Math.floor(doubleBase)) < precision) {
try {
if (baseRangeSize > 1) {
return String.format("%.0f", doubleStart) + "-"
+ String.format("%.0f", doubleEnd - 1);
} else {
return String.format("%.0f", doubleStart);
}
} catch (NumberFormatException e) {
return key;
}
} else {
return "[" + doubleStart + "," + doubleEnd + ")";
}
}
} | java |
private static Integer[] mergeDocLists(Integer[] a, Integer[] b) {
Integer[] answer = new Integer[a.length + b.length];
int i = 0;
int j = 0;
int k = 0;
Integer tmp;
while (i < a.length && j < b.length) {
tmp = a[i] < b[j] ? a[i++] : b[j++];
for (; i < a.length && a[i].equals(tmp); i++)
;
for (; j < b.length && b[j].equals(tmp); j++)
;
answer[k++] = tmp;
}
while (i < a.length) {
tmp = a[i++];
for (; i < a.length && a[i].equals(tmp); i++)
;
answer[k++] = tmp;
}
while (j < b.length) {
tmp = b[j++];
for (; j < b.length && b[j].equals(tmp); j++)
;
answer[k++] = tmp;
}
return Arrays.copyOf(answer, k);
} | java |
private static void createFacet(List<ComponentFacet> facetList,
Map<Integer, Integer> positionsData,
Map<MtasSpanQuery, Map<Integer, Integer>> spansNumberData,
Map<String, SortedMap<String, int[]>> facetData, List<Integer> docSet)
throws IOException {
if (facetList != null) {
for (ComponentFacet cf : facetList) {
if (cf.baseFields.length > 0) {
createFacetBase(cf, 0, cf.dataCollector, positionsData,
spansNumberData, facetData,
docSet.toArray(new Integer[docSet.size()]));
}
}
}
} | java |
private static boolean validateTermWithStartValue(BytesRef term,
ComponentTermVector termVector) {
if (termVector.startValue == null) {
return true;
} else if (termVector.subComponentFunction.sortType
.equals(CodecUtil.SORT_TERM)) {
if (term.length > termVector.startValue.length) {
byte[] zeroBytes = (new BytesRef("\u0000")).bytes;
int n = (int) (Math
.ceil(((double) (term.length - termVector.startValue.length))
/ zeroBytes.length));
byte[] newBytes = new byte[termVector.startValue.length
+ n * zeroBytes.length];
System.arraycopy(termVector.startValue.bytes, 0, newBytes, 0,
termVector.startValue.length);
for (int i = 0; i < n; i++) {
System.arraycopy(zeroBytes, 0, newBytes,
termVector.startValue.length + i * zeroBytes.length,
zeroBytes.length);
}
termVector.startValue = new BytesRef(newBytes);
}
if ((termVector.subComponentFunction.sortDirection.equals(
CodecUtil.SORT_ASC) && (termVector.startValue.compareTo(term) < 0))
|| (termVector.subComponentFunction.sortDirection
.equals(CodecUtil.SORT_DESC)
&& (termVector.startValue.compareTo(term) > 0))) {
return true;
}
}
return false;
} | java |
private static boolean validateTermWithDistance(BytesRef term,
ComponentTermVector termVector) throws IOException {
if (termVector.distances == null || termVector.distances.isEmpty()) {
return true;
} else {
// first check maximum for all distances
for (SubComponentDistance item : termVector.distances) {
if (item.maximum == null) {
continue;
} else {
if (!item.getDistance().validateMaximum(term)) {
return false;
}
}
}
// then check minimum for all distances
for (SubComponentDistance item : termVector.distances) {
if (item.minimum == null) {
continue;
} else {
if (!item.getDistance().validateMinimum(term)) {
return false;
}
}
}
// try {
// System.out.println("ACCEPT: " + term.utf8ToString()+"
// ("+termVector.distances.size()+")");
// for (SubComponentDistance item : termVector.distances) {
// System.out.println(
// item.hashCode() + "\t" +
// term.utf8ToString()+"\t"+item.getDistance().getClass().getName()+"\t"+item.getDistance().minimum+"\t"+item.getDistance().maximum
// + "\t" +
// item.getDistance().validate(term)+"\t"+item.getDistance().compute(term));
// }
// } catch (Exception e) {
// System.out.println("PROBLEEM: "+e.getMessage());
// }
return true;
}
} | java |
private static boolean needSecondRoundTermvector(
List<ComponentTermVector> termVectorList) throws IOException {
boolean needSecondRound = false;
for (ComponentTermVector termVector : termVectorList) {
if (!termVector.full && termVector.list == null) {
boolean doCheck;
doCheck = termVector.subComponentFunction.dataCollector.segmentRegistration != null
&& (termVector.subComponentFunction.dataCollector.segmentRegistration
.equals(MtasDataCollector.SEGMENT_SORT_ASC)
|| termVector.subComponentFunction.dataCollector.segmentRegistration
.equals(MtasDataCollector.SEGMENT_SORT_DESC))
&& termVector.number > 0;
doCheck |= termVector.subComponentFunction.dataCollector.segmentRegistration != null
&& (termVector.subComponentFunction.dataCollector.segmentRegistration
.equals(MtasDataCollector.SEGMENT_BOUNDARY_ASC)
|| termVector.subComponentFunction.dataCollector.segmentRegistration
.equals(MtasDataCollector.SEGMENT_BOUNDARY_DESC))
&& termVector.number > 0;
if (doCheck) {
termVector.subComponentFunction.dataCollector.recomputeSegmentKeys();
if (!termVector.subComponentFunction.dataCollector
.checkExistenceNecessaryKeys()) {
needSecondRound = true;
}
termVector.subComponentFunction.dataCollector.reduceToSegmentKeys();
}
}
}
return needSecondRound;
} | java |
private static boolean preliminaryRegisterValue(BytesRef term,
ComponentTermVector termVector, TermvectorNumberBasic number,
Integer termNumberMaximum, Integer segmentNumber, String[] mutableKey)
throws IOException {
long sortValue = 0;
if (termVector.subComponentFunction.sortDirection
.equals(CodecUtil.SORT_DESC)
&& termVector.subComponentFunction.sortType
.equals(CodecUtil.STATS_TYPE_SUM)) {
sortValue = termVector.subComponentFunction.parserFunction
.getValueLong(number.valueSum, 0);
} else if (termVector.subComponentFunction.sortDirection
.equals(CodecUtil.SORT_DESC)
&& termVector.subComponentFunction.sortType
.equals(CodecUtil.STATS_TYPE_N)) {
sortValue = number.docNumber;
} else {
return true;
}
MtasDataCollector<Long, ?> dataCollector = (MtasDataCollector<Long, ?>) termVector.subComponentFunction.dataCollector;
if (termVector.boundaryRegistration) {
return dataCollector.validateSegmentBoundary(sortValue);
} else {
String segmentStatus = dataCollector.validateSegmentValue(sortValue,
termNumberMaximum, segmentNumber);
if (segmentStatus != null) {
if (segmentStatus.equals(MtasDataCollector.SEGMENT_KEY_OR_NEW)) {
return true;
} else if (segmentStatus
.equals(MtasDataCollector.SEGMENT_POSSIBLE_KEY)) {
mutableKey[0] = MtasToken.getPostfixFromValue(term);
segmentStatus = dataCollector.validateSegmentValue(mutableKey[0],
sortValue, termNumberMaximum, segmentNumber, true);
return segmentStatus != null;
} else {
// should never happen?
return false;
}
} else {
return false;
}
}
} | java |
private static TermvectorNumberFull computeTermvectorNumberFull(
List<Integer> docSet, int termDocId, TermsEnum termsEnum,
LeafReaderContext lrc, PostingsEnum postingsEnum,
Map<Integer, Integer> positionsData) throws IOException {
TermvectorNumberFull result = new TermvectorNumberFull(docSet.size());
Iterator<Integer> docIterator = docSet.iterator();
int localTermDocId = termDocId;
postingsEnum = termsEnum.postings(postingsEnum, PostingsEnum.FREQS);
while (docIterator.hasNext()) {
int docId = docIterator.next() - lrc.docBase;
if (docId >= localTermDocId && ((docId == localTermDocId)
|| ((localTermDocId = postingsEnum.advance(docId)) == docId))) {
result.args[result.docNumber] = postingsEnum.freq();
result.positions[result.docNumber] = (positionsData == null) ? 0
: positionsData.get(docId + lrc.docBase);
result.docNumber++;
}
}
return result;
} | java |
public boolean containsKey(String key) {
key = key.toLowerCase();
key = key.trim();
return map.containsKey(key);
} | java |
public Map<String, Set<String>> getReverseMap() {
Set<Map.Entry<String,Set<String>>> entries = map.entrySet();
Map<String, Set<String>> rMap = new HashMap<String, Set<String>>(entries.size());
for (Map.Entry<String,Set<String>> me : entries) {
String k = me.getKey();
Set<String> transList = me.getValue();
for (String trans : transList) {
Set<String> entry = rMap.get(trans);
if (entry == null) {
// reduce default size as most will be small
Set<String> toAdd = new LinkedHashSet<String>(6);
toAdd.add(k);
rMap.put(trans, toAdd);
} else {
entry.add(k);
}
}
}
return rMap;
} | java |
public int addMap(Map<String, Set<String>> addM) {
int newTrans = 0;
for (Map.Entry<String,Set<String>> me : addM.entrySet()) {
String k = me.getKey();
Set<String> addList = me.getValue();
Set<String> origList = map.get(k);
if (origList == null) {
map.put(k, new LinkedHashSet<String>(addList));
Set<String> newList = map.get(k);
if (newList != null && newList.size() != 0) {
newTrans+=addList.size();
}
} else {
for (String toAdd : addList) {
if (!(origList.contains(toAdd))) {
origList.add(toAdd);
newTrans++;
}
}
}
}
return newTrans;
} | java |
public static base_response add(nitro_service client, dnssoarec resource) throws Exception {
dnssoarec addresource = new dnssoarec();
addresource.domain = resource.domain;
addresource.originserver = resource.originserver;
addresource.contact = resource.contact;
addresource.serial = resource.serial;
addresource.refresh = resource.refresh;
addresource.retry = resource.retry;
addresource.expire = resource.expire;
addresource.minimum = resource.minimum;
addresource.ttl = resource.ttl;
return addresource.add_resource(client);
} | java |
public static base_responses add(nitro_service client, dnssoarec resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
dnssoarec addresources[] = new dnssoarec[resources.length];
for (int i=0;i<resources.length;i++){
addresources[i] = new dnssoarec();
addresources[i].domain = resources[i].domain;
addresources[i].originserver = resources[i].originserver;
addresources[i].contact = resources[i].contact;
addresources[i].serial = resources[i].serial;
addresources[i].refresh = resources[i].refresh;
addresources[i].retry = resources[i].retry;
addresources[i].expire = resources[i].expire;
addresources[i].minimum = resources[i].minimum;
addresources[i].ttl = resources[i].ttl;
}
result = add_bulk_request(client, addresources);
}
return result;
} | java |
public static base_responses delete(nitro_service client, dnssoarec resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
dnssoarec deleteresources[] = new dnssoarec[resources.length];
for (int i=0;i<resources.length;i++){
deleteresources[i] = new dnssoarec();
deleteresources[i].domain = resources[i].domain;
}
result = delete_bulk_request(client, deleteresources);
}
return result;
} | java |
public static base_response update(nitro_service client, dnssoarec resource) throws Exception {
dnssoarec updateresource = new dnssoarec();
updateresource.domain = resource.domain;
updateresource.originserver = resource.originserver;
updateresource.contact = resource.contact;
updateresource.serial = resource.serial;
updateresource.refresh = resource.refresh;
updateresource.retry = resource.retry;
updateresource.expire = resource.expire;
updateresource.minimum = resource.minimum;
updateresource.ttl = resource.ttl;
return updateresource.update_resource(client);
} | java |
public static base_responses update(nitro_service client, dnssoarec resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
dnssoarec updateresources[] = new dnssoarec[resources.length];
for (int i=0;i<resources.length;i++){
updateresources[i] = new dnssoarec();
updateresources[i].domain = resources[i].domain;
updateresources[i].originserver = resources[i].originserver;
updateresources[i].contact = resources[i].contact;
updateresources[i].serial = resources[i].serial;
updateresources[i].refresh = resources[i].refresh;
updateresources[i].retry = resources[i].retry;
updateresources[i].expire = resources[i].expire;
updateresources[i].minimum = resources[i].minimum;
updateresources[i].ttl = resources[i].ttl;
}
result = update_bulk_request(client, updateresources);
}
return result;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.