code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public void closeSegmentKeyValueRegistration() throws IOException {
if (!closed) {
if (segmentRegistration != null) {
Map<String, T1> keyValueList = segmentKeyValueList.get(segmentName);
T1 tmpSegmentValueBoundary = segmentValuesBoundary.get(segmentName);
for (Entry<String, T1> entry : keyValueList.entrySet()) {
if (tmpSegmentValueBoundary == null || compareWithBoundary(
entry.getValue(), tmpSegmentValueBoundary)) {
segmentKeys.add(entry.getKey());
}
}
}
} else {
throw new IOException("already closed");
}
} | java |
public void recomputeSegmentKeys() throws IOException {
if (!closed && segmentRegistration != null) {
if (segmentRegistration.equals(SEGMENT_SORT_ASC)
|| segmentRegistration.equals(SEGMENT_SORT_DESC)
|| segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)
|| segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
if (segmentRegistration.equals(SEGMENT_SORT_ASC)
|| segmentRegistration.equals(SEGMENT_SORT_DESC)) {
segmentKeys.clear();
// recompute boundaries
for (Entry<String, Map<String, T1>> entry : segmentKeyValueList
.entrySet()) {
T1 tmpSegmentValueBoundary = boundaryForSegment(entry.getKey());
segmentValuesBoundary.put(entry.getKey(), tmpSegmentValueBoundary);
}
// compute adjusted boundaries and compute keys
for (Entry<String, Map<String, T1>> entry : segmentKeyValueList
.entrySet()) {
this.segmentName = entry.getKey();
Map<String, T1> keyValueList = entry.getValue();
T1 tmpSegmentValueBoundaryForComputing = boundaryForSegmentComputing(
entry.getKey());
for (Entry<String, T1> subEntry : keyValueList.entrySet()) {
if (tmpSegmentValueBoundaryForComputing == null
|| compareWithBoundary(subEntry.getValue(),
tmpSegmentValueBoundaryForComputing)) {
if (!segmentKeys.contains(subEntry.getKey())) {
segmentKeys.add(subEntry.getKey());
}
}
}
}
}
Map<String, T1> keyValueList;
Set<String> recomputeKeyList;
segmentRecomputeKeyList = new LinkedHashMap<>();
for (String key : segmentKeys) {
for (Entry<String, Map<String, T1>> entry : segmentKeyValueList
.entrySet()) {
keyValueList = entry.getValue();
if (!keyValueList.containsKey(key)) {
if (!segmentRecomputeKeyList.containsKey(entry.getKey())) {
recomputeKeyList = new HashSet<>();
segmentRecomputeKeyList.put(entry.getKey(), recomputeKeyList);
} else {
recomputeKeyList = segmentRecomputeKeyList.get(entry.getKey());
}
recomputeKeyList.add(key);
}
}
}
this.segmentName = null;
} else {
throw new IOException(
"not for segmentRegistration " + segmentRegistration);
}
} else {
throw new IOException("already closed or no segmentRegistration ("
+ segmentRegistration + ")");
}
} | java |
protected boolean validateWithSegmentBoundary(T1 value) throws IOException {
if (!closed && segmentRegistration != null) {
T1 tmpSegmentValueBoundary = segmentValuesBoundary.get(segmentName);
if (tmpSegmentValueBoundary == null
|| compareWithBoundary(value, tmpSegmentValueBoundary)) {
return true;
}
}
return false;
} | java |
private boolean sortedAndUnique(String[] keyList, int size)
throws IOException {
if (!closed) {
for (int i = 1; i < size; i++) {
if (keyList[(i - 1)].compareTo(keyList[i]) >= 0) {
return false;
}
}
return true;
} else {
throw new IOException("already closed");
}
} | java |
private int[][] computeSortAndUniqueMapping(String[] keyList, int size)
throws IOException {
if (!closed) {
if (size > 0) {
SortedMap<String, int[]> sortedMap = new TreeMap<>();
for (int i = 0; i < size; i++) {
if (sortedMap.containsKey(keyList[i])) {
int[] previousList = sortedMap.get(keyList[i]);
int[] newList = new int[previousList.length + 1];
System.arraycopy(previousList, 0, newList, 0, previousList.length);
newList[previousList.length] = i;
sortedMap.put(keyList[i], newList);
} else {
sortedMap.put(keyList[i], new int[] { i });
}
}
Collection<int[]> values = sortedMap.values();
int[][] result = new int[sortedMap.size()][];
return values.toArray(result);
} else {
return null;
}
} else {
throw new IOException("already closed");
}
} | java |
public void closeNewList() throws IOException {
if (!closed) {
if (segmentRegistration != null) {
this.segmentName = null;
}
if (newSize > 0) {
// add remaining old
while (position < getSize()) {
if (newPosition == newSize) {
increaseNewListSize();
}
newKeyList[newPosition] = keyList[position];
newSourceNumberList[newPosition] = sourceNumberList[position];
newErrorNumber[newPosition] = errorNumber[position];
newErrorList[newPosition] = errorList[position];
if (hasSub) {
newSubCollectorListNextLevel[newPosition] = subCollectorListNextLevel[position];
}
copyToNew(position, newPosition);
position++;
newPosition++;
}
// copy
keyList = newKeyList;
sourceNumberList = newSourceNumberList;
errorNumber = newErrorNumber;
errorList = newErrorList;
subCollectorListNextLevel = newSubCollectorListNextLevel;
copyFromNew();
size = newPosition;
// sort and merge
if (!sortedAndUnique(keyList, getSize())) {
remapData(computeSortAndUniqueMapping(keyList, getSize()));
}
}
position = 0;
newSize = 0;
newPosition = 0;
newCurrentPosition = 0;
}
} | java |
public void setWithTotal() throws IOException {
if (collectorType.equals(DataCollector.COLLECTOR_TYPE_LIST)) {
if (segmentName != null) {
throw new IOException("can't get total with segmentRegistration");
} else {
withTotal = true;
}
} else {
throw new IOException(
"can't get total for dataCollector of type " + collectorType);
}
} | java |
public static dnsrecords_stats[] get(nitro_service service) throws Exception{
dnsrecords_stats obj = new dnsrecords_stats();
dnsrecords_stats[] response = (dnsrecords_stats[])obj.stat_resources(service);
return response;
} | java |
public static dnsrecords_stats get(nitro_service service, String dnsrecordtype) throws Exception{
dnsrecords_stats obj = new dnsrecords_stats();
obj.set_dnsrecordtype(dnsrecordtype);
dnsrecords_stats response = (dnsrecords_stats) obj.stat_resource(service);
return response;
} | java |
public static lbvserver_tmtrafficpolicy_binding[] get(nitro_service service, String name) throws Exception{
lbvserver_tmtrafficpolicy_binding obj = new lbvserver_tmtrafficpolicy_binding();
obj.set_name(name);
lbvserver_tmtrafficpolicy_binding response[] = (lbvserver_tmtrafficpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static base_response update(nitro_service client, gslbparameter resource) throws Exception {
gslbparameter updateresource = new gslbparameter();
updateresource.ldnsentrytimeout = resource.ldnsentrytimeout;
updateresource.rtttolerance = resource.rtttolerance;
updateresource.ldnsmask = resource.ldnsmask;
updateresource.v6ldnsmasklen = resource.v6ldnsmasklen;
updateresource.ldnsprobeorder = resource.ldnsprobeorder;
updateresource.dropldnsreq = resource.dropldnsreq;
return updateresource.update_resource(client);
} | java |
public static base_response unset(nitro_service client, gslbparameter resource, String[] args) throws Exception{
gslbparameter unsetresource = new gslbparameter();
return unsetresource.unset_resource(client,args);
} | java |
public static gslbparameter get(nitro_service service) throws Exception{
gslbparameter obj = new gslbparameter();
gslbparameter[] response = (gslbparameter[])obj.get_resources(service);
return response[0];
} | java |
public void setList(long now, List<SimpleOrderedMap<Object>> list)
throws IOException {
if (action.equals(ComponentCollection.ACTION_LIST)) {
this.now = now;
this.list = list;
} else {
throw new IOException("not allowed with action '" + action + "'");
}
} | java |
public void setCheck(long now, SimpleOrderedMap<Object> status)
throws IOException {
if (action.equals(ComponentCollection.ACTION_CHECK)) {
this.now = now;
this.status = status;
} else {
throw new IOException("not allowed with action '" + action + "'");
}
} | java |
public void setGet(long now, SimpleOrderedMap<Object> status,
HashSet<String> stringValues) throws IOException {
if (action.equals(ComponentCollection.ACTION_GET)) {
this.now = now;
this.status = status;
this.values = stringValues;
} else {
throw new IOException("not allowed with action '" + action + "'");
}
} | java |
public void setPost(long now, SimpleOrderedMap<Object> status)
throws IOException {
if (action.equals(ComponentCollection.ACTION_POST)) {
this.now = now;
this.status = status;
} else {
throw new IOException("not allowed with action '" + action + "'");
}
} | java |
public void setImport(long now, SimpleOrderedMap<Object> status)
throws IOException {
if (action.equals(ComponentCollection.ACTION_IMPORT)) {
this.now = now;
this.status = status;
} else {
throw new IOException("not allowed with action '" + action + "'");
}
} | java |
public void setCreate(long now, SimpleOrderedMap<Object> status)
throws IOException {
if (action.equals(ComponentCollection.ACTION_CREATE)) {
this.now = now;
this.status = status;
} else {
throw new IOException("not allowed with action '" + action + "'");
}
} | java |
public static sslservicegroup_binding get(nitro_service service, String servicegroupname) throws Exception{
sslservicegroup_binding obj = new sslservicegroup_binding();
obj.set_servicegroupname(servicegroupname);
sslservicegroup_binding response = (sslservicegroup_binding) obj.get_resource(service);
return response;
} | java |
public static sslservicegroup_binding[] get(nitro_service service, String servicegroupname[]) throws Exception{
if (servicegroupname !=null && servicegroupname.length>0) {
sslservicegroup_binding response[] = new sslservicegroup_binding[servicegroupname.length];
sslservicegroup_binding obj[] = new sslservicegroup_binding[servicegroupname.length];
for (int i=0;i<servicegroupname.length;i++) {
obj[i] = new sslservicegroup_binding();
obj[i].set_servicegroupname(servicegroupname[i]);
response[i] = (sslservicegroup_binding) obj[i].get_resource(service);
}
return response;
}
return null;
} | java |
public static aaagroup_intranetip_binding[] get(nitro_service service, String groupname) throws Exception{
aaagroup_intranetip_binding obj = new aaagroup_intranetip_binding();
obj.set_groupname(groupname);
aaagroup_intranetip_binding response[] = (aaagroup_intranetip_binding[]) obj.get_resources(service);
return response;
} | java |
public void addItem(String term, Integer offsetStart, Integer offsetEnd,
Integer posIncr, BytesRef payload, Integer flags) {
if (!closed) {
tokenNumber++;
MtasUpdateRequestProcessorResultItem item = new MtasUpdateRequestProcessorResultItem(
term, offsetStart, offsetEnd, posIncr, payload, flags);
try {
objectOutputStream.writeObject(item);
objectOutputStream.reset();
objectOutputStream.flush();
} catch (IOException e) {
forceCloseAndDelete();
log.debug(e);
}
}
} | java |
public void forceCloseAndDelete() {
try {
if (objectOutputStream != null) {
objectOutputStream.close();
objectOutputStream = null;
}
if (fileOutputStream != null) {
fileOutputStream.close();
fileOutputStream = null;
}
} catch (IOException e) {
log.debug(e);
}
closed = true;
tokenNumber = 0;
if (file != null) {
if (file.exists() && file.canWrite() && !file.delete()) {
log.debug("couldn't delete " + file.getName());
}
file = null;
}
} | java |
public static clusternodegroup_streamidentifier_binding[] get(nitro_service service, String name) throws Exception{
clusternodegroup_streamidentifier_binding obj = new clusternodegroup_streamidentifier_binding();
obj.set_name(name);
clusternodegroup_streamidentifier_binding response[] = (clusternodegroup_streamidentifier_binding[]) obj.get_resources(service);
return response;
} | java |
public static qos_stats get(nitro_service service) throws Exception{
qos_stats obj = new qos_stats();
qos_stats[] response = (qos_stats[])obj.stat_resources(service);
return response[0];
} | java |
public static appflowpolicy_csvserver_binding[] get(nitro_service service, String name) throws Exception{
appflowpolicy_csvserver_binding obj = new appflowpolicy_csvserver_binding();
obj.set_name(name);
appflowpolicy_csvserver_binding response[] = (appflowpolicy_csvserver_binding[]) obj.get_resources(service);
return response;
} | java |
public static vpnvserver_sharefileserver_binding[] get(nitro_service service, String name) throws Exception{
vpnvserver_sharefileserver_binding obj = new vpnvserver_sharefileserver_binding();
obj.set_name(name);
vpnvserver_sharefileserver_binding response[] = (vpnvserver_sharefileserver_binding[]) obj.get_resources(service);
return response;
} | java |
private static String capitalise(String s) {
if(s.length()==0){return s;}
StringBuilder s1=new StringBuilder(s);
if (Character.isLowerCase(s1.charAt(0))){
s1.setCharAt(0,Character.toUpperCase(s1.charAt(0)));
}
for(int j=1;j<s1.length();j++){
if(Character.isUpperCase(s1.charAt(j))){
s1.setCharAt(j,Character.toLowerCase(s1.charAt(j)));
}
}
return s1.toString();
} | java |
private Set<String> loadVerbStemSet(String[] verbStems) {
HashSet<String> set = new HashSet<String>(verbStems.length);
for (String stem : verbStems) {
set.add(stem);
}
return set;
} | java |
private String stem(int del, String add, String affix) {
int stem_length = yylength() - del;
int i = 0;
String result=yytext().substring(0,stem_length);
if (option(change_case)) { result=result.toLowerCase(); }
if (!(add.length()==0)) result+=add;
if(option(print_affixes)) { result+=("+"+affix); }
return result;
} | java |
public boolean crosses(Constituent c) {
return (start() < c.start() && c.start() < end() && end() < c.end()) || (c.start() < start() && start() < c.end() && c.end() < end());
} | java |
public boolean crosses(Collection<Constituent> constColl) {
for (Constituent c : constColl) {
if (crosses(c)) {
return true;
}
}
return false;
} | java |
public MtasSpanQuery getPositiveQuery(int index) {
if ((index >= 0) && (index < positiveQueryList.size())) {
return positiveQueryList.get(index);
} else {
return null;
}
} | java |
public MtasSpanQuery getNegativeQuery(int index) {
if ((index >= 0) && (index < negativeQueryList.size())) {
return negativeQueryList.get(index);
} else {
return null;
}
} | java |
public boolean isSingle() {
// assume simplified
if ((positiveQueryList.size() == 1) && (negativeQueryList.size() == 0)) {
return true;
} else if ((positiveQueryList.size() == 0)
&& (negativeQueryList.size() == 1)) {
return true;
}
return false;
} | java |
public void swapType() {
if (type.equals(TYPE_AND)) {
type = TYPE_OR;
} else if (type.equals(TYPE_OR)) {
type = TYPE_AND;
} else {
throw new Error("unknown type");
}
swapNot();
List<MtasSpanQuery> queryList = positiveQueryList;
positiveQueryList = negativeQueryList;
negativeQueryList = queryList;
for (MtasCQLParserWordCondition c : conditionList) {
c.swapNot();
}
simplified = false;
} | java |
public static base_response add(nitro_service client, nsacl resource) throws Exception {
nsacl addresource = new nsacl();
addresource.aclname = resource.aclname;
addresource.aclaction = resource.aclaction;
addresource.td = resource.td;
addresource.srcip = resource.srcip;
addresource.srcipop = resource.srcipop;
addresource.srcipval = resource.srcipval;
addresource.srcport = resource.srcport;
addresource.srcportop = resource.srcportop;
addresource.srcportval = resource.srcportval;
addresource.destip = resource.destip;
addresource.destipop = resource.destipop;
addresource.destipval = resource.destipval;
addresource.destport = resource.destport;
addresource.destportop = resource.destportop;
addresource.destportval = resource.destportval;
addresource.ttl = resource.ttl;
addresource.srcmac = resource.srcmac;
addresource.protocol = resource.protocol;
addresource.protocolnumber = resource.protocolnumber;
addresource.vlan = resource.vlan;
addresource.Interface = resource.Interface;
addresource.established = resource.established;
addresource.icmptype = resource.icmptype;
addresource.icmpcode = resource.icmpcode;
addresource.priority = resource.priority;
addresource.state = resource.state;
addresource.logstate = resource.logstate;
addresource.ratelimit = resource.ratelimit;
return addresource.add_resource(client);
} | java |
public static base_responses add(nitro_service client, nsacl resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nsacl addresources[] = new nsacl[resources.length];
for (int i=0;i<resources.length;i++){
addresources[i] = new nsacl();
addresources[i].aclname = resources[i].aclname;
addresources[i].aclaction = resources[i].aclaction;
addresources[i].td = resources[i].td;
addresources[i].srcip = resources[i].srcip;
addresources[i].srcipop = resources[i].srcipop;
addresources[i].srcipval = resources[i].srcipval;
addresources[i].srcport = resources[i].srcport;
addresources[i].srcportop = resources[i].srcportop;
addresources[i].srcportval = resources[i].srcportval;
addresources[i].destip = resources[i].destip;
addresources[i].destipop = resources[i].destipop;
addresources[i].destipval = resources[i].destipval;
addresources[i].destport = resources[i].destport;
addresources[i].destportop = resources[i].destportop;
addresources[i].destportval = resources[i].destportval;
addresources[i].ttl = resources[i].ttl;
addresources[i].srcmac = resources[i].srcmac;
addresources[i].protocol = resources[i].protocol;
addresources[i].protocolnumber = resources[i].protocolnumber;
addresources[i].vlan = resources[i].vlan;
addresources[i].Interface = resources[i].Interface;
addresources[i].established = resources[i].established;
addresources[i].icmptype = resources[i].icmptype;
addresources[i].icmpcode = resources[i].icmpcode;
addresources[i].priority = resources[i].priority;
addresources[i].state = resources[i].state;
addresources[i].logstate = resources[i].logstate;
addresources[i].ratelimit = resources[i].ratelimit;
}
result = add_bulk_request(client, addresources);
}
return result;
} | java |
public static base_response update(nitro_service client, nsacl resource) throws Exception {
nsacl updateresource = new nsacl();
updateresource.aclname = resource.aclname;
updateresource.aclaction = resource.aclaction;
updateresource.srcip = resource.srcip;
updateresource.srcipop = resource.srcipop;
updateresource.srcipval = resource.srcipval;
updateresource.srcport = resource.srcport;
updateresource.srcportop = resource.srcportop;
updateresource.srcportval = resource.srcportval;
updateresource.destip = resource.destip;
updateresource.destipop = resource.destipop;
updateresource.destipval = resource.destipval;
updateresource.destport = resource.destport;
updateresource.destportop = resource.destportop;
updateresource.destportval = resource.destportval;
updateresource.srcmac = resource.srcmac;
updateresource.protocol = resource.protocol;
updateresource.protocolnumber = resource.protocolnumber;
updateresource.icmptype = resource.icmptype;
updateresource.icmpcode = resource.icmpcode;
updateresource.vlan = resource.vlan;
updateresource.Interface = resource.Interface;
updateresource.priority = resource.priority;
updateresource.logstate = resource.logstate;
updateresource.ratelimit = resource.ratelimit;
updateresource.established = resource.established;
return updateresource.update_resource(client);
} | java |
public static base_responses update(nitro_service client, nsacl resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nsacl updateresources[] = new nsacl[resources.length];
for (int i=0;i<resources.length;i++){
updateresources[i] = new nsacl();
updateresources[i].aclname = resources[i].aclname;
updateresources[i].aclaction = resources[i].aclaction;
updateresources[i].srcip = resources[i].srcip;
updateresources[i].srcipop = resources[i].srcipop;
updateresources[i].srcipval = resources[i].srcipval;
updateresources[i].srcport = resources[i].srcport;
updateresources[i].srcportop = resources[i].srcportop;
updateresources[i].srcportval = resources[i].srcportval;
updateresources[i].destip = resources[i].destip;
updateresources[i].destipop = resources[i].destipop;
updateresources[i].destipval = resources[i].destipval;
updateresources[i].destport = resources[i].destport;
updateresources[i].destportop = resources[i].destportop;
updateresources[i].destportval = resources[i].destportval;
updateresources[i].srcmac = resources[i].srcmac;
updateresources[i].protocol = resources[i].protocol;
updateresources[i].protocolnumber = resources[i].protocolnumber;
updateresources[i].icmptype = resources[i].icmptype;
updateresources[i].icmpcode = resources[i].icmpcode;
updateresources[i].vlan = resources[i].vlan;
updateresources[i].Interface = resources[i].Interface;
updateresources[i].priority = resources[i].priority;
updateresources[i].logstate = resources[i].logstate;
updateresources[i].ratelimit = resources[i].ratelimit;
updateresources[i].established = resources[i].established;
}
result = update_bulk_request(client, updateresources);
}
return result;
} | java |
public static base_response unset(nitro_service client, nsacl resource, String[] args) throws Exception{
nsacl unsetresource = new nsacl();
unsetresource.aclname = resource.aclname;
return unsetresource.unset_resource(client,args);
} | java |
public static base_responses unset(nitro_service client, String aclname[], String args[]) throws Exception {
base_responses result = null;
if (aclname != null && aclname.length > 0) {
nsacl unsetresources[] = new nsacl[aclname.length];
for (int i=0;i<aclname.length;i++){
unsetresources[i] = new nsacl();
unsetresources[i].aclname = aclname[i];
}
result = unset_bulk_request(client, unsetresources,args);
}
return result;
} | java |
public static base_response enable(nitro_service client, String aclname) throws Exception {
nsacl enableresource = new nsacl();
enableresource.aclname = aclname;
return enableresource.perform_operation(client,"enable");
} | java |
public static base_responses enable(nitro_service client, nsacl resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nsacl enableresources[] = new nsacl[resources.length];
for (int i=0;i<resources.length;i++){
enableresources[i] = new nsacl();
enableresources[i].aclname = resources[i].aclname;
}
result = perform_operation_bulk_request(client, enableresources,"enable");
}
return result;
} | java |
public static base_response disable(nitro_service client, String aclname) throws Exception {
nsacl disableresource = new nsacl();
disableresource.aclname = aclname;
return disableresource.perform_operation(client,"disable");
} | java |
public static base_responses disable(nitro_service client, String aclname[]) throws Exception {
base_responses result = null;
if (aclname != null && aclname.length > 0) {
nsacl disableresources[] = new nsacl[aclname.length];
for (int i=0;i<aclname.length;i++){
disableresources[i] = new nsacl();
disableresources[i].aclname = aclname[i];
}
result = perform_operation_bulk_request(client, disableresources,"disable");
}
return result;
} | java |
public static base_response rename(nitro_service client, nsacl resource, String new_aclname) throws Exception {
nsacl renameresource = new nsacl();
renameresource.aclname = resource.aclname;
return renameresource.rename_resource(client,new_aclname);
} | java |
public static nsacl[] get(nitro_service service, options option) throws Exception{
nsacl obj = new nsacl();
nsacl[] response = (nsacl[])obj.get_resources(service,option);
return response;
} | java |
public static nsacl get(nitro_service service, String aclname) throws Exception{
nsacl obj = new nsacl();
obj.set_aclname(aclname);
nsacl response = (nsacl) obj.get_resource(service);
return response;
} | java |
public void printAnswers(List<CoreLabel> doc, PrintWriter out) {
for (CoreLabel wi : doc) {
String answer = wi.get(AnswerAnnotation.class);
String goldAnswer = wi.get(GoldAnswerAnnotation.class);
out.println(wi.word() + "\t" + goldAnswer + "\t" + answer);
}
out.println();
} | java |
public static base_response Force(nitro_service client, hasync resource) throws Exception {
hasync Forceresource = new hasync();
Forceresource.force = resource.force;
Forceresource.save = resource.save;
return Forceresource.perform_operation(client,"Force");
} | java |
public boolean isAncestor(GrammaticalRelation gr) {
while (gr != null) {
// Changed this test from this == gr (mrsmith)
if (this.equals(gr)) { return true; }
gr = gr.parent;
}
return false;
} | java |
public static clusterinstance_clusternode_binding[] get(nitro_service service, Long clid) throws Exception{
clusterinstance_clusternode_binding obj = new clusterinstance_clusternode_binding();
obj.set_clid(clid);
clusterinstance_clusternode_binding response[] = (clusterinstance_clusternode_binding[]) obj.get_resources(service);
return response;
} | java |
public static long count(nitro_service service, Long clid) throws Exception{
clusterinstance_clusternode_binding obj = new clusterinstance_clusternode_binding();
obj.set_clid(clid);
options option = new options();
option.set_count(true);
clusterinstance_clusternode_binding response[] = (clusterinstance_clusternode_binding[]) obj.get_resources(service,option);
if (response != null) {
return response[0].__count;
}
return 0;
} | java |
public static rewritepolicylabel_stats[] get(nitro_service service) throws Exception{
rewritepolicylabel_stats obj = new rewritepolicylabel_stats();
rewritepolicylabel_stats[] response = (rewritepolicylabel_stats[])obj.stat_resources(service);
return response;
} | java |
public static rewritepolicylabel_stats get(nitro_service service, String labelname) throws Exception{
rewritepolicylabel_stats obj = new rewritepolicylabel_stats();
obj.set_labelname(labelname);
rewritepolicylabel_stats response = (rewritepolicylabel_stats) obj.stat_resource(service);
return response;
} | java |
public static cachepolicy_lbvserver_binding[] get(nitro_service service, String policyname) throws Exception{
cachepolicy_lbvserver_binding obj = new cachepolicy_lbvserver_binding();
obj.set_policyname(policyname);
cachepolicy_lbvserver_binding response[] = (cachepolicy_lbvserver_binding[]) obj.get_resources(service);
return response;
} | java |
public static systemgroup_binding get(nitro_service service, String groupname) throws Exception{
systemgroup_binding obj = new systemgroup_binding();
obj.set_groupname(groupname);
systemgroup_binding response = (systemgroup_binding) obj.get_resource(service);
return response;
} | java |
public void addSentenceAsFirstOption(MtasCQLParserSentenceCondition s)
throws ParseException {
if (!simplified) {
MtasCQLParserSentenceCondition sentenceCurrent;
List<MtasCQLParserSentenceCondition> sentenceSequence;
if (isBasic()) {
if (basicSentence == null) {
sentenceSequence = new ArrayList<MtasCQLParserSentenceCondition>();
sentenceCurrent = s;
sentenceSequence.add(sentenceCurrent);
sequenceList.add(sentenceSequence);
// not simple anymore
basic = false;
} else {
// add sentence as first option
sentenceSequence = new ArrayList<MtasCQLParserSentenceCondition>();
sentenceCurrent = s;
sentenceSequence.add(sentenceCurrent);
sequenceList.add(sentenceSequence);
// add previous basic sentence as new option
sentenceSequence = new ArrayList<MtasCQLParserSentenceCondition>();
sentenceCurrent = new MtasCQLParserSentenceCondition(basicSentence,
ignore, maximumIgnoreLength);
sentenceSequence.add(sentenceCurrent);
sequenceList.add(sentenceSequence);
basicSentence = null;
// not simple anymore
basic = false;
}
} else {
sentenceSequence = new ArrayList<MtasCQLParserSentenceCondition>();
sentenceCurrent = s;
sentenceSequence.add(sentenceCurrent);
List<List<MtasCQLParserSentenceCondition>> newsequenceList = new ArrayList<List<MtasCQLParserSentenceCondition>>();
newsequenceList.add(sentenceSequence);
newsequenceList.addAll(sequenceList);
sequenceList = newsequenceList;
}
} else {
throw new ParseException("already simplified");
}
} | java |
private void simplifySequence(List<MtasCQLParserSentenceCondition> sequence)
throws ParseException {
List<MtasCQLParserSentenceCondition> newSequence = new ArrayList<MtasCQLParserSentenceCondition>();
MtasCQLParserSentenceCondition lastSentence = null;
for (MtasCQLParserSentenceCondition sentence : sequence) {
sentence.simplify();
if (lastSentence == null) {
lastSentence = sentence;
} else if (lastSentence.isBasic() && sentence.isBasic()) {
if (!lastSentence.isOptional() && !sentence.isOptional()
&& sentence.getMaximumOccurence() == 1
&& lastSentence.getMaximumOccurence() == 1) {
lastSentence.basicSentence.addBasicSentence(sentence.basicSentence);
} else {
newSequence.add(lastSentence);
lastSentence = sentence;
}
} else if (lastSentence.isBasic() && !sentence.isBasic()) {
if (sentence.isSingle() && !sentence.isOptional()
&& sentence.getMaximumOccurence() == 1
&& lastSentence.getMaximumOccurence() == 1) {
// add all items from (first) sequenceList potentially to the new
// sequence
for (MtasCQLParserSentenceCondition subSentence : sentence.sequenceList
.get(0)) {
newSequence.add(lastSentence);
lastSentence = subSentence;
}
} else {
// add sentence potentially to the new sequence
newSequence.add(lastSentence);
lastSentence = sentence;
}
} else if (!lastSentence.isBasic() && sentence.isBasic()) {
if (lastSentence.isSingle() && !lastSentence.isOptional()
&& sentence.getMaximumOccurence() == 1
&& lastSentence.getMaximumOccurence() == 1) {
// add basic sentence to end latest sequence
lastSentence
.addBasicSentenceToEndLatestSequence(sentence.basicSentence);
} else {
// add sentence potentially to the new sequence
newSequence.add(lastSentence);
lastSentence = sentence;
}
} else {
if (sentence.isSingle() && !sentence.isOptional()
&& lastSentence.isSingle() && !lastSentence.isOptional()
&& sentence.getMaximumOccurence() == 1
&& lastSentence.getMaximumOccurence() == 1) {
// combine sentences
for (MtasCQLParserSentenceCondition subSentence : sentence.sequenceList
.get(0)) {
lastSentence.sequenceList.get(0).add(subSentence);
}
} else {
// add sentence potentially to the new sequence (both not basic)
newSequence.add(lastSentence);
lastSentence = sentence;
}
}
}
// add last to newSequence
if (lastSentence != null) {
newSequence.add(lastSentence);
}
// replace content sequence with newSequence
sequence.clear();
sequence.addAll(newSequence);
} | java |
public PrintWriter pw(OutputStream o) {
String encoding = outputEncoding;
if (!java.nio.charset.Charset.isSupported(encoding)) {
System.out.println("Warning: desired encoding " + encoding + " not accepted. ");
System.out.println("Using UTF-8 to construct PrintWriter");
encoding = "UTF-8";
}
try {
return new PrintWriter(new OutputStreamWriter(o, encoding), true);
} catch (UnsupportedEncodingException e) {
System.out.println("Warning: desired encoding " + outputEncoding + " not accepted. " + e);
try {
return new PrintWriter(new OutputStreamWriter(o, "UTF-8"), true);
} catch (UnsupportedEncodingException e1) {
System.out.println("Something is really wrong. Your system doesn't even support UTF-8!" + e1);
return new PrintWriter(o, true);
}
}
} | java |
public static Collection<List<String>> untypedDependencyObjectify(Tree t, HeadFinder hf, TreeTransformer collinizer) {
return dependencyObjectify(t, hf, collinizer, new UntypedDependencyTyper(hf));
} | java |
public static Collection<List<String>> typedDependencyObjectify(Tree t, HeadFinder hf, TreeTransformer collinizer) {
return dependencyObjectify(t, hf, collinizer, new TypedDependencyTyper(hf));
} | java |
public static EquivalenceClasser<List<String>, String> typedDependencyClasser() {
return new EquivalenceClasser<List<String>, String>() {
public String equivalenceClass(List<String> s) {
if(s.get(5).equals(leftHeaded))
return s.get(2) + '(' + s.get(3) + "->" + s.get(4) + ')';
return s.get(2) + '(' + s.get(4) + "<-" + s.get(3) + ')';
}
};
} | java |
public static netbridge_nsip_binding[] get(nitro_service service, String name) throws Exception{
netbridge_nsip_binding obj = new netbridge_nsip_binding();
obj.set_name(name);
netbridge_nsip_binding response[] = (netbridge_nsip_binding[]) obj.get_resources(service);
return response;
} | java |
public static transformprofile_transformaction_binding[] get(nitro_service service, String name) throws Exception{
transformprofile_transformaction_binding obj = new transformprofile_transformaction_binding();
obj.set_name(name);
transformprofile_transformaction_binding response[] = (transformprofile_transformaction_binding[]) obj.get_resources(service);
return response;
} | java |
public static <E> Distribution<E> getDistributionFromLogValues(Counter<E> counter) {
ClassicCounter<E> c = new ClassicCounter<E>();
// go through once to get the max
// shift all by max so as to minimize the possibility of underflow
double max = Counters.max(counter); // Thang 17Feb12: max should operate on counter instead of c, fixed!
for (E key : counter.keySet()) {
double count = Math.exp(counter.getCount(key) - max);
c.setCount(key, count);
}
return getDistribution(c);
} | java |
public static <E> Distribution<E> laplaceSmoothedDistribution(Counter<E> counter, int numberOfKeys) {
return laplaceSmoothedDistribution(counter, numberOfKeys, 1.0);
} | java |
public static <E> Distribution<E> laplaceWithExplicitUnknown(Counter<E> counter, double lambda, E UNK) {
Distribution<E> norm = new Distribution<E>();
norm.counter = new ClassicCounter<E>();
double total = counter.totalCount() + (lambda * (counter.size() - 1));
norm.numberOfKeys = counter.size();
norm.reservedMass = 0.0;
for (E key : counter.keySet()) {
if (key.equals(UNK)) {
norm.counter.setCount(key, counter.getCount(key) / total);
} else {
norm.counter.setCount(key, (counter.getCount(key) + lambda) / total);
}
}
return norm;
} | java |
public static <E> Distribution<E> goodTuringSmoothedCounter(Counter<E> counter, int numberOfKeys) {
// gather count-counts
int[] countCounts = getCountCounts(counter);
// if count-counts are unreliable, we shouldn't be using G-T
// revert to laplace
for (int i = 1; i <= 10; i++) {
if (countCounts[i] < 3) {
return laplaceSmoothedDistribution(counter, numberOfKeys, 0.5);
}
}
double observedMass = counter.totalCount();
double reservedMass = countCounts[1] / observedMass;
// calculate and cache adjusted frequencies
// also adjusting total mass of observed items
double[] adjustedFreq = new double[10];
for (int freq = 1; freq < 10; freq++) {
adjustedFreq[freq] = (double) (freq + 1) * (double) countCounts[freq + 1] / countCounts[freq];
observedMass -= (freq - adjustedFreq[freq]) * countCounts[freq];
}
double normFactor = (1.0 - reservedMass) / observedMass;
Distribution<E> norm = new Distribution<E>();
norm.counter = new ClassicCounter<E>();
// fill in the new Distribution, renormalizing as we go
for (E key : counter.keySet()) {
int origFreq = (int) Math.round(counter.getCount(key));
if (origFreq < 10) {
norm.counter.setCount(key, adjustedFreq[origFreq] * normFactor);
} else {
norm.counter.setCount(key, origFreq * normFactor);
}
}
norm.numberOfKeys = numberOfKeys;
norm.reservedMass = reservedMass;
return norm;
} | java |
public static <E> Distribution<E> simpleGoodTuring(Counter<E> counter, int numberOfKeys) {
// check arguments
validateCounter(counter);
int numUnseen = numberOfKeys - counter.size();
if (numUnseen < 1)
throw new IllegalArgumentException(String.format("ERROR: numberOfKeys %d must be > size of counter %d!", numberOfKeys, counter.size()));
// do smoothing
int[][] cc = countCounts2IntArrays(collectCountCounts(counter));
int[] r = cc[0]; // counts
int[] n = cc[1]; // counts of counts
SimpleGoodTuring sgt = new SimpleGoodTuring(r, n);
// collate results
Counter<Integer> probsByCount = new ClassicCounter<Integer>();
double[] probs = sgt.getProbabilities();
for (int i = 0; i < probs.length; i++) {
probsByCount.setCount(r[i], probs[i]);
}
// make smoothed distribution
Distribution<E> dist = new Distribution<E>();
dist.counter = new ClassicCounter<E>();
for (Map.Entry<E, Double> entry : counter.entrySet()) {
E item = entry.getKey();
Integer count = (int) Math.round(entry.getValue());
dist.counter.setCount(item, probsByCount.getCount(count));
}
dist.numberOfKeys = numberOfKeys;
dist.reservedMass = sgt.getProbabilityForUnseen();
return dist;
} | java |
public static <E> Distribution<E> dynamicCounterWithDirichletPrior(Counter<E> c, Distribution<E> prior, double weight) {
double totalWeight = c.totalCount() + weight;
Distribution<E> norm = new DynamicDistribution<E>(prior, weight / totalWeight);
norm.counter = new ClassicCounter<E>();
// this might be done more efficiently with entrySet but there isn't a way to get
// the entrySet from a Counter now. In most cases c will be small(-ish) anyway
for (E key : c.keySet()) {
double count = c.getCount(key) / totalWeight;
prior.addToKeySet(key);
norm.counter.setCount(key, count);
}
norm.numberOfKeys = prior.numberOfKeys;
return norm;
} | java |
public static <E> Distribution<E> distributionFromLogisticCounter(Counter<E> cntr) {
double expSum = 0.0;
int numKeys = 0;
for (E key : cntr.keySet()) {
expSum += Math.exp(cntr.getCount(key));
numKeys++;
}
Distribution<E> probs = new Distribution<E>();
probs.counter = new ClassicCounter<E>();
probs.reservedMass = 0.0;
probs.numberOfKeys = numKeys;
for (E key : cntr.keySet()) {
probs.counter.setCount(key, Math.exp(cntr.getCount(key)) / expSum);
}
return probs;
} | java |
public double probabilityOf(E key) {
if (counter.containsKey(key)) {
return counter.getCount(key);
} else {
int remainingKeys = numberOfKeys - counter.size();
if (remainingKeys <= 0) {
return 0.0;
} else {
return (reservedMass / remainingKeys);
}
}
} | java |
public static appfwprofile_contenttype_binding[] get(nitro_service service, String name) throws Exception{
appfwprofile_contenttype_binding obj = new appfwprofile_contenttype_binding();
obj.set_name(name);
appfwprofile_contenttype_binding response[] = (appfwprofile_contenttype_binding[]) obj.get_resources(service);
return response;
} | java |
public static appflowglobal_appflowpolicy_binding[] get(nitro_service service) throws Exception{
appflowglobal_appflowpolicy_binding obj = new appflowglobal_appflowpolicy_binding();
appflowglobal_appflowpolicy_binding response[] = (appflowglobal_appflowpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static base_response clear(nitro_service client) throws Exception {
locationdata clearresource = new locationdata();
return clearresource.perform_operation(client,"clear");
} | java |
public static base_response create(nitro_service client, ssldsakey resource) throws Exception {
ssldsakey createresource = new ssldsakey();
createresource.keyfile = resource.keyfile;
createresource.bits = resource.bits;
createresource.keyform = resource.keyform;
createresource.des = resource.des;
createresource.des3 = resource.des3;
createresource.password = resource.password;
return createresource.perform_operation(client,"create");
} | java |
public static base_response update(nitro_service client, lacp resource) throws Exception {
lacp updateresource = new lacp();
updateresource.syspriority = resource.syspriority;
updateresource.ownernode = resource.ownernode;
return updateresource.update_resource(client);
} | java |
public static base_responses update(nitro_service client, lacp resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
lacp updateresources[] = new lacp[resources.length];
for (int i=0;i<resources.length;i++){
updateresources[i] = new lacp();
updateresources[i].syspriority = resources[i].syspriority;
updateresources[i].ownernode = resources[i].ownernode;
}
result = update_bulk_request(client, updateresources);
}
return result;
} | java |
public static lacp[] get(nitro_service service) throws Exception{
lacp obj = new lacp();
lacp[] response = (lacp[])obj.get_resources(service);
return response;
} | java |
public static lacp get(nitro_service service, Long ownernode) throws Exception{
lacp obj = new lacp();
obj.set_ownernode(ownernode);
lacp response = (lacp) obj.get_resource(service);
return response;
} | java |
public static GrammaticalRelation getConj(String conjunctionString) {
GrammaticalRelation result = conjs.get(conjunctionString);
if (result == null) {
synchronized(conjs) {
result = conjs.get(conjunctionString);
if (result == null) {
result = new GrammaticalRelation(Language.English, "conj", "conj_collapsed", null, CONJUNCT, conjunctionString);
conjs.put(conjunctionString, result);
threadSafeAddRelation(result);
}
}
}
return result;
} | java |
public static base_response add(nitro_service client, nat64 resource) throws Exception {
nat64 addresource = new nat64();
addresource.name = resource.name;
addresource.acl6name = resource.acl6name;
addresource.netprofile = resource.netprofile;
return addresource.add_resource(client);
} | java |
public static base_responses add(nitro_service client, nat64 resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nat64 addresources[] = new nat64[resources.length];
for (int i=0;i<resources.length;i++){
addresources[i] = new nat64();
addresources[i].name = resources[i].name;
addresources[i].acl6name = resources[i].acl6name;
addresources[i].netprofile = resources[i].netprofile;
}
result = add_bulk_request(client, addresources);
}
return result;
} | java |
public static base_response update(nitro_service client, nat64 resource) throws Exception {
nat64 updateresource = new nat64();
updateresource.name = resource.name;
updateresource.acl6name = resource.acl6name;
updateresource.netprofile = resource.netprofile;
return updateresource.update_resource(client);
} | java |
public static nat64[] get(nitro_service service) throws Exception{
nat64 obj = new nat64();
nat64[] response = (nat64[])obj.get_resources(service);
return response;
} | java |
public static nat64 get(nitro_service service, String name) throws Exception{
nat64 obj = new nat64();
obj.set_name(name);
nat64 response = (nat64) obj.get_resource(service);
return response;
} | java |
public static base_response add(nitro_service client, nstimer resource) throws Exception {
nstimer addresource = new nstimer();
addresource.name = resource.name;
addresource.interval = resource.interval;
addresource.unit = resource.unit;
addresource.comment = resource.comment;
return addresource.add_resource(client);
} | java |
public static base_responses add(nitro_service client, nstimer resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nstimer addresources[] = new nstimer[resources.length];
for (int i=0;i<resources.length;i++){
addresources[i] = new nstimer();
addresources[i].name = resources[i].name;
addresources[i].interval = resources[i].interval;
addresources[i].unit = resources[i].unit;
addresources[i].comment = resources[i].comment;
}
result = add_bulk_request(client, addresources);
}
return result;
} | java |
public static base_response update(nitro_service client, nstimer resource) throws Exception {
nstimer updateresource = new nstimer();
updateresource.name = resource.name;
updateresource.interval = resource.interval;
updateresource.unit = resource.unit;
updateresource.comment = resource.comment;
return updateresource.update_resource(client);
} | java |
public static base_responses update(nitro_service client, nstimer resources[]) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nstimer updateresources[] = new nstimer[resources.length];
for (int i=0;i<resources.length;i++){
updateresources[i] = new nstimer();
updateresources[i].name = resources[i].name;
updateresources[i].interval = resources[i].interval;
updateresources[i].unit = resources[i].unit;
updateresources[i].comment = resources[i].comment;
}
result = update_bulk_request(client, updateresources);
}
return result;
} | java |
public static base_response unset(nitro_service client, nstimer resource, String[] args) throws Exception{
nstimer unsetresource = new nstimer();
unsetresource.name = resource.name;
unsetresource.interval = resource.interval;
unsetresource.unit = resource.unit;
unsetresource.comment = resource.comment;
return unsetresource.unset_resource(client,args);
} | java |
public static base_responses unset(nitro_service client, nstimer resources[], String[] args) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
nstimer unsetresources[] = new nstimer[resources.length];
for (int i=0;i<resources.length;i++){
unsetresources[i] = new nstimer();
unsetresources[i].name = resources[i].name;
unsetresources[i].interval = resources[i].interval;
unsetresources[i].unit = resources[i].unit;
unsetresources[i].comment = resources[i].comment;
}
result = unset_bulk_request(client, unsetresources,args);
}
return result;
} | java |
public static nstimer[] get(nitro_service service) throws Exception{
nstimer obj = new nstimer();
nstimer[] response = (nstimer[])obj.get_resources(service);
return response;
} | java |
public static nstimer get(nitro_service service, String name) throws Exception{
nstimer obj = new nstimer();
obj.set_name(name);
nstimer response = (nstimer) obj.get_resource(service);
return response;
} | java |
public static appfwpolicylabel_appfwpolicy_binding[] get(nitro_service service, String labelname) throws Exception{
appfwpolicylabel_appfwpolicy_binding obj = new appfwpolicylabel_appfwpolicy_binding();
obj.set_labelname(labelname);
appfwpolicylabel_appfwpolicy_binding response[] = (appfwpolicylabel_appfwpolicy_binding[]) obj.get_resources(service);
return response;
} | java |
public static auditnslogpolicy_binding get(nitro_service service, String name) throws Exception{
auditnslogpolicy_binding obj = new auditnslogpolicy_binding();
obj.set_name(name);
auditnslogpolicy_binding response = (auditnslogpolicy_binding) obj.get_resource(service);
return response;
} | java |
public static base_response add(nitro_service client, filterhtmlinjectionvariable resource) throws Exception {
filterhtmlinjectionvariable addresource = new filterhtmlinjectionvariable();
addresource.variable = resource.variable;
addresource.value = resource.value;
return addresource.add_resource(client);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.