Datasets:

CM

/

codexglue_codetrans

like 1

public SearchGroup<T> next() {assert iter.hasNext();final SearchGroup<T> group = iter.next();if (group.sortValues == null) {throw new IllegalArgumentException("group.sortValues is null; you must pass fillFields=true to the first pass collector");}return group;}

public ISearchGroup<T> Next(){ISearchGroup<T> group = iter.Current;if (group.SortValues == null){throw new ArgumentException("group.sortValues is null; you must pass fillFields=true to the first pass collector");}return group;}

public UpdateMLModelResult updateMLModel(UpdateMLModelRequest request) {request = beforeClientExecution(request);return executeUpdateMLModel(request);}

public virtual UpdateMLModelResponse UpdateMLModel(UpdateMLModelRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMLModelRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMLModelResponseUnmarshaller.Instance;return Invoke<UpdateMLModelResponse>(request, options);}

public CreateIPSetResult createIPSet(CreateIPSetRequest request) {request = beforeClientExecution(request);return executeCreateIPSet(request);}

public virtual CreateIPSetResponse CreateIPSet(CreateIPSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateIPSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateIPSetResponseUnmarshaller.Instance;return Invoke<CreateIPSetResponse>(request, options);}

public FieldDateResolutionFCListener(QueryConfigHandler config) {this.config = config;}

public FieldDateResolutionFCListener(QueryConfigHandler config){this.config = config;}

@Override public boolean containsValue(Object value) {HashMapEntry[] tab = table;int len = tab.length;if (value == null) {for (int i = 0; i < len; i++) {for (HashMapEntry e = tab[i]; e != null; e = e.next) {if (e.value == null) {return true;}}}return entryForNullKey != null && entryForNullKey.value == null;}for (int i = 0; i < len; i++) {for (HashMapEntry e = tab[i]; e != null; e = e.next) {if (value.equals(e.value)) {return true;}}}return entryForNullKey != null && value.equals(entryForNullKey.value);}

public override bool containsValue(object value){java.util.HashMap.HashMapEntry<K, V>[] tab = table;int len = tab.Length;if (value == null){{for (int i = 0; i < len; i++){{for (java.util.HashMap.HashMapEntry<K, V> e = tab[i]; e != null; e = e.next){if (e.value == null){return true;}}}}}return entryForNullKey != null && (object)entryForNullKey.value == null;}{for (int i_1 = 0; i_1 < len; i_1++){{for (java.util.HashMap.HashMapEntry<K, V> e = tab[i_1]; e != null; e = e.next){if (value.Equals(e.value)){return true;}}}}}return entryForNullKey != null && value.Equals(entryForNullKey.value);}

public DescribeWorkspaceBundlesResult describeWorkspaceBundles(DescribeWorkspaceBundlesRequest request) {request = beforeClientExecution(request);return executeDescribeWorkspaceBundles(request);}

public virtual DescribeWorkspaceBundlesResponse DescribeWorkspaceBundles(DescribeWorkspaceBundlesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeWorkspaceBundlesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeWorkspaceBundlesResponseUnmarshaller.Instance;return Invoke<DescribeWorkspaceBundlesResponse>(request, options);}

public PostingsEnum reset(int[] postings) {this.postings = postings;upto = -1;return this;}

public DocsEnum Reset(int[] postings){this.postings = postings;upto = -1;return this;}

public void serialize(LittleEndianOutput out) {out.writeShort(sid); out.writeShort(_reserved0);out.writeInt(_engineId);}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(sid); out1.WriteShort(_reserved0);out1.WriteInt(_engineId);}

public static CharBuffer allocate(int capacity) {if (capacity < 0) {throw new IllegalArgumentException();}return new ReadWriteCharArrayBuffer(capacity);}

public static java.nio.CharBuffer allocate(int capacity_1){if (capacity_1 < 0){throw new System.ArgumentException();}return new java.nio.ReadWriteCharArrayBuffer(capacity_1);}

public String toFormulaString(String[] operands) {StringBuilder buffer = new StringBuilder();buffer.append(operands[ 0 ]);buffer.append(">=");buffer.append(operands[ 1 ]);return buffer.toString();}

public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append(">=");buffer.Append(operands[1]);return buffer.ToString();}

public DeletePipelineResult deletePipeline(DeletePipelineRequest request) {request = beforeClientExecution(request);return executeDeletePipeline(request);}

public virtual DeletePipelineResponse DeletePipeline(DeletePipelineRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeletePipelineRequestMarshaller.Instance;options.ResponseUnmarshaller = DeletePipelineResponseUnmarshaller.Instance;return Invoke<DeletePipelineResponse>(request, options);}

public InterfaceHdrRecord(int codePage) {_codepage = codePage;}

public InterfaceHdrRecord(int codePage){_codepage = codePage;}

public DescribeScalingParametersResult describeScalingParameters(DescribeScalingParametersRequest request) {request = beforeClientExecution(request);return executeDescribeScalingParameters(request);}

public virtual DescribeScalingParametersResponse DescribeScalingParameters(DescribeScalingParametersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeScalingParametersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeScalingParametersResponseUnmarshaller.Instance;return Invoke<DescribeScalingParametersResponse>(request, options);}

public Entry<K, V> higherEntry(K key) {return immutableCopy(findBounded(key, HIGHER));}

public java.util.MapClass.Entry<K, V> higherEntry(K key){return this._enclosing.immutableCopy(this.findBounded(key, java.util.TreeMap.Relation.HIGHER));}

public CreateSpotDatafeedSubscriptionRequest(String bucket) {setBucket(bucket);}

public CreateSpotDatafeedSubscriptionRequest(string bucket){_bucket = bucket;}

public String getLocalizedMessage() {return getLocalizedMessage(Locale.getDefault());}

public virtual string GetLocalizedMessage(){return GetLocalizedMessage(CultureInfo.InvariantCulture);}

public UDFFinder getUDFFinder(){return _uBook.getUDFFinder();}

public UDFFinder GetUDFFinder(){return _uBook.GetUDFFinder();}

public ExternalName getExternalName(String nameName, String sheetName, int externalWorkbookNumber) {throw new IllegalStateException("XSSF-style external names are not supported for HSSF");}

public ExternalName GetExternalName(String nameName, String sheetName, int externalWorkbookNumber){throw new InvalidOperationException("XSSF-style external names are not supported for HSSF");}

public OldFormulaRecord(RecordInputStream ris) {super(ris, ris.getSid() == biff2_sid);if (isBiff2()) {field_4_value = ris.readDouble();} else {long valueLongBits = ris.readLong();specialCachedValue = FormulaSpecialCachedValue.create(valueLongBits);if (specialCachedValue == null) {field_4_value = Double.longBitsToDouble(valueLongBits);}}if (isBiff2()) {field_5_options = (short)ris.readUByte();} else {field_5_options = ris.readShort();}int expression_len = ris.readShort();int nBytesAvailable = ris.available();field_6_parsed_expr = Formula.read(expression_len, ris, nBytesAvailable);}

public OldFormulaRecord(RecordInputStream ris) :base(ris, ris.Sid == biff2_sid){;if (IsBiff2){field_4_value = ris.ReadDouble();}else{long valueLongBits = ris.ReadLong();specialCachedValue = SpecialCachedValue.Create(valueLongBits);if (specialCachedValue == null){field_4_value = BitConverter.Int64BitsToDouble(valueLongBits);}}if (IsBiff2){field_5_options = (short)ris.ReadUByte();}else{field_5_options = ris.ReadShort();}int expression_len = ris.ReadShort();int nBytesAvailable = ris.Available();field_6_Parsed_expr = Formula.Read(expression_len, ris, nBytesAvailable);}

public int stem(char s[], int len) {assert s.length >= len + 1 : "this stemmer requires an oversized array of at least 1";len = plural.apply(s, len);len = unification.apply(s, len);len = adverb.apply(s, len);int oldlen;do {oldlen = len;len = augmentative.apply(s, len);} while (len != oldlen);oldlen = len;len = noun.apply(s, len);if (len == oldlen) { len = verb.apply(s, len);}len = vowel.apply(s, len);for (int i = 0; i < len; i++)switch(s[i]) {case 'á': s[i] = 'a'; break;case 'é':case 'ê': s[i] = 'e'; break;case 'í': s[i] = 'i'; break;case 'ó': s[i] = 'o'; break;case 'ú': s[i] = 'u'; break;}return len;}

public virtual int Stem(char[] s, int len){Debug.Assert(s.Length >= len + 1, "this stemmer requires an oversized array of at least 1");len = plural.Apply(s, len);len = unification.Apply(s, len);len = adverb.Apply(s, len);int oldlen;do{oldlen = len;len = augmentative.Apply(s, len);} while (len != oldlen);oldlen = len;len = noun.Apply(s, len);if (len == oldlen) {len = verb.Apply(s, len);}len = vowel.Apply(s, len);for (int i = 0; i < len; i++){switch (s[i]){case 'á':s[i] = 'a';break;case 'é':case 'ê':s[i] = 'e';break;case 'í':s[i] = 'i';break;case 'ó':s[i] = 'o';break;case 'ú':s[i] = 'u';break;}}return len;}

public boolean sameProperties(FontRecord other) {returnfield_1_font_height == other.field_1_font_height &&field_2_attributes == other.field_2_attributes &&field_3_color_palette_index == other.field_3_color_palette_index &&field_4_bold_weight == other.field_4_bold_weight &&field_5_super_sub_script == other.field_5_super_sub_script &&field_6_underline == other.field_6_underline &&field_7_family == other.field_7_family &&field_8_charset == other.field_8_charset &&field_9_zero == other.field_9_zero &&Objects.equals(this.field_11_font_name, other.field_11_font_name);}

public bool SameProperties(FontRecord other){returnfield_1_font_height == other.field_1_font_height &&field_2_attributes == other.field_2_attributes &&field_3_color_palette_index == other.field_3_color_palette_index &&field_4_bold_weight == other.field_4_bold_weight &&field_5_base_sub_script == other.field_5_base_sub_script &&field_6_underline == other.field_6_underline &&field_7_family == other.field_7_family &&field_8_charset == other.field_8_charset &&field_9_zero == other.field_9_zero &&field_11_font_name.Equals(other.field_11_font_name);}

public String toFormulaString() {return FormulaError.REF.getString();}

public override String ToFormulaString(){return HSSFErrorConstants.GetText(HSSFErrorConstants.ERROR_REF);}

public StartTextDetectionResult startTextDetection(StartTextDetectionRequest request) {request = beforeClientExecution(request);return executeStartTextDetection(request);}

public virtual StartTextDetectionResponse StartTextDetection(StartTextDetectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartTextDetectionRequestMarshaller.Instance;options.ResponseUnmarshaller = StartTextDetectionResponseUnmarshaller.Instance;return Invoke<StartTextDetectionResponse>(request, options);}

public DeleteMessageBatchRequestEntry(String id, String receiptHandle) {setId(id);setReceiptHandle(receiptHandle);}

public DeleteMessageBatchRequestEntry(string id, string receiptHandle){_id = id;_receiptHandle = receiptHandle;}

public PatternCaptureGroupTokenFilter create(TokenStream input) {return new PatternCaptureGroupTokenFilter(input, preserveOriginal, pattern);}

public override TokenStream Create(TokenStream input){return new PatternCaptureGroupTokenFilter(input, preserveOriginal, pattern);}

public SigningCertificate(String userName, String certificateId, String certificateBody, StatusType status) {setUserName(userName);setCertificateId(certificateId);setCertificateBody(certificateBody);setStatus(status.toString());}

public SigningCertificate(string userName, string certificateId, string certificateBody, StatusType status){_userName = userName;_certificateId = certificateId;_certificateBody = certificateBody;_status = status;}

public DistributionConfig(String callerReference, Boolean enabled) {setCallerReference(callerReference);setEnabled(enabled);}

public DistributionConfig(string callerReference, bool enabled){_callerReference = callerReference;_enabled = enabled;}

public FastCharStream(Reader r) {input = r;}

public FastCharStream(TextReader r){input = r;}

public int end(int group) {ensureMatch();return matchOffsets[(group * 2) + 1];}

public int end(int group_1){ensureMatch();return matchOffsets[(group_1 * 2) + 1];}

public final Map.Entry<K, V> next() { return nextEntry(); }

public override java.util.MapClass.Entry<K, V> next(){return this.nextEntry();}

public BlameCommand setTextComparator(RawTextComparator textComparator) {this.textComparator = textComparator;return this;}

public virtual NGit.Api.BlameCommand SetTextComparator(RawTextComparator textComparator){this.textComparator = textComparator;return this;}

public final T pop() {if (size > 0) {T result = heap[1]; heap[1] = heap[size]; heap[size] = null; size--;downHeap(1); return result;} else {return null;}}

public T Pop(){if (size > 0){T result = heap[1]; heap[1] = heap[size]; heap[size] = default(T); size--;DownHeap(); return result;}else{return default(T);}}

public String toString() {return getClass().getSimpleName() + "(fields=" + fields.size() + ",delegate=" + postingsReader + ")";}

public override string ToString(){return "arc=" + fstArc + " state=" + fsaState;}

public static String shortenRefName(String noteRefName) {if (noteRefName.startsWith(Constants.R_NOTES))return noteRefName.substring(Constants.R_NOTES.length());return noteRefName;}

public static string ShortenRefName(string noteRefName){if (noteRefName.StartsWith(Constants.R_NOTES)){return Sharpen.Runtime.Substring(noteRefName, Constants.R_NOTES.Length);}return noteRefName;}

public DescribeDomainsResult describeDomains() {return describeDomains(new DescribeDomainsRequest());}

public virtual DescribeDomainsResponse DescribeDomains(){return DescribeDomains(new DescribeDomainsRequest());}

public int available() {return ccis.available();}

public int Available(){return _le.Available();}

public GetContentModerationResult getContentModeration(GetContentModerationRequest request) {request = beforeClientExecution(request);return executeGetContentModeration(request);}

public virtual GetContentModerationResponse GetContentModeration(GetContentModerationRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetContentModerationRequestMarshaller.Instance;options.ResponseUnmarshaller = GetContentModerationResponseUnmarshaller.Instance;return Invoke<GetContentModerationResponse>(request, options);}

public PrintStream(OutputStream out) {super(out);if (out == null) {throw new NullPointerException();}}

public PrintStream(java.io.OutputStream @out) : base(@out){if (@out == null){throw new System.ArgumentNullException();}}

public long ramBytesUsed() {long ramBytesUsed = postingsReader.ramBytesUsed();for (TermsReader r : fields.values()) {ramBytesUsed += r.ramBytesUsed();}return ramBytesUsed;}

public override long RamBytesUsed(){long ramBytesUsed = 0;foreach (TermsReader r in fields.Values){ramBytesUsed += r.dict == null ? 0 : r.dict.GetSizeInBytes();}return ramBytesUsed;}

public GetIntegrationResult getIntegration(GetIntegrationRequest request) {request = beforeClientExecution(request);return executeGetIntegration(request);}

public virtual GetIntegrationResponse GetIntegration(GetIntegrationRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetIntegrationRequestMarshaller.Instance;options.ResponseUnmarshaller = GetIntegrationResponseUnmarshaller.Instance;return Invoke<GetIntegrationResponse>(request, options);}

public void setVisibility(int v) {if (getVisibility() != v) {super.setVisibility(v);if (mIndeterminate) {if (v == GONE || v == INVISIBLE) {stopAnimation();} else {startAnimation();}}}}

public override void setVisibility(int v){if (getVisibility() != v){base.setVisibility(v);if (mIndeterminate){if (v == GONE || v == INVISIBLE){stopAnimation();}else{startAnimation();}}}}

public boolean matches(char s[], int len) {if (!super.matches(s, len))return false;for (int i = 0; i < exceptions.length; i++)if (endsWith(s, len, exceptions[i]))return false;return true;}

public override bool Matches(char[] s, int len){if (!base.Matches(s, len)){return false;}for (int i = 0; i < m_exceptions.Length; i++){if (StemmerUtil.EndsWith(s, len, m_exceptions[i])){return false;}}return true;}

public DescribeFleetCapacityResult describeFleetCapacity(DescribeFleetCapacityRequest request) {request = beforeClientExecution(request);return executeDescribeFleetCapacity(request);}

public virtual DescribeFleetCapacityResponse DescribeFleetCapacity(DescribeFleetCapacityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetCapacityRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetCapacityResponseUnmarshaller.Instance;return Invoke<DescribeFleetCapacityResponse>(request, options);}

public UploadPackInternalServerErrorException(Throwable why) {initCause(why);}

public UploadPackInternalServerErrorException(Exception why){Sharpen.Extensions.InitCause(this, why);}

public GetNetworkResult getNetwork(GetNetworkRequest request) {request = beforeClientExecution(request);return executeGetNetwork(request);}

public virtual GetNetworkResponse GetNetwork(GetNetworkRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetNetworkRequestMarshaller.Instance;options.ResponseUnmarshaller = GetNetworkResponseUnmarshaller.Instance;return Invoke<GetNetworkResponse>(request, options);}

public AllocatePrivateVirtualInterfaceResult allocatePrivateVirtualInterface(AllocatePrivateVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeAllocatePrivateVirtualInterface(request);}

public virtual AllocatePrivateVirtualInterfaceResponse AllocatePrivateVirtualInterface(AllocatePrivateVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = AllocatePrivateVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = AllocatePrivateVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<AllocatePrivateVirtualInterfaceResponse>(request, options);}

public GetDeploymentResult getDeployment(GetDeploymentRequest request) {request = beforeClientExecution(request);return executeGetDeployment(request);}

public virtual GetDeploymentResponse GetDeployment(GetDeploymentRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDeploymentRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDeploymentResponseUnmarshaller.Instance;return Invoke<GetDeploymentResponse>(request, options);}

public UpdateRepoAuthorizationRequest() {super("cr", "2016-06-07", "UpdateRepoAuthorization", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/authorizations/[AuthorizeId]");setMethod(MethodType.POST);}

public UpdateRepoAuthorizationRequest(): base("cr", "2016-06-07", "UpdateRepoAuthorization", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/authorizations/[AuthorizeId]";Method = MethodType.POST;}

public void foldToASCII(char[] input, int length){final int maxSizeNeeded = 4 * length;if (output.length < maxSizeNeeded) {output = new char[ArrayUtil.oversize(maxSizeNeeded, Character.BYTES)];}outputPos = foldToASCII(input, 0, output, 0, length);if (preserveOriginal && needToPreserve(input, length)) {state = captureState();}}

public void FoldToASCII(char[] input, int length){if (preserveOriginal){state = CaptureState();}int maxSizeNeeded = 4 * length;if (output.Length < maxSizeNeeded){output = new char[ArrayUtil.Oversize(maxSizeNeeded, RamUsageEstimator.NUM_BYTES_CHAR)];}outputPos = FoldToASCII(input, 0, output, 0, length);}

public boolean hasEntry(String name) {if (excludes.contains(name)) {return false;}return directory.hasEntry(name);}

public bool HasEntry(String name){if (excludes.Contains(name)){return false;}return directory.HasEntry(name);}

public void setLockMessage(String msg) {lockMessage = msg;}

public virtual void SetLockMessage(string msg){lockMessage = msg;}

public ReflogCommand reflog() {return new ReflogCommand(repo);}

public virtual ReflogCommand Reflog(){return new ReflogCommand(repo);}

public void serialize(LittleEndianOutput out) {out.writeShort(getFirstRow());out.writeShort(getLastRow());out.writeShort(getFirstColumn());out.writeShort(getLastColumn());}

public void Serialize(ILittleEndianOutput out1){out1.WriteShort(FirstRow);out1.WriteShort(LastRow);out1.WriteShort(FirstColumn);out1.WriteShort(LastColumn);}

public static int response(java.net.HttpURLConnection c)throws IOException {try {return c.getResponseCode();} catch (ConnectException ce) {final URL url = c.getURL();final String host = (url == null) ? "<null>" : url.getHost(); if ("Connection timed out: connect".equals(ce.getMessage())) throw new ConnectException(MessageFormat.format(JGitText.get().connectionTimeOut, host));throw new ConnectException(ce.getMessage() + " " + host); }}

public static int Response(HttpURLConnection c){try{return c.GetResponseCode();}catch (ConnectException ce){string host = c.GetURL().GetHost();if ("Connection timed out: connect".Equals(ce.Message)){throw new ConnectException(MessageFormat.Format(JGitText.Get().connectionTimeOut,host));}throw new ConnectException(ce.Message + " " + host);}}

public static void fill(long[] array, long value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}

public static void fill(long[] array, long value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}

public void serialize(LittleEndianOutput out) {out.writeInt(getPositionOfBof());out.writeShort(field_2_option_flags);String name = field_5_sheetname;out.writeByte(name.length());out.writeByte(field_4_isMultibyteUnicode);if (isMultibyte()) {StringUtil.putUnicodeLE(name, out);} else {StringUtil.putCompressedUnicode(name, out);}}

public override void Serialize(ILittleEndianOutput out1){out1.WriteInt(PositionOfBof);out1.WriteShort(field_2_option_flags);String name = field_5_sheetname;out1.WriteByte(name.Length);out1.WriteByte(field_4_isMultibyteUnicode);if (IsMultibyte){StringUtil.PutUnicodeLE(name, out1);}else{StringUtil.PutCompressedUnicode(name, out1);}}

public static String getNonBlankTextOrFail(Element e) throws ParserException {String v = getText(e);if (null != v)v = v.trim();if (null == v || 0 == v.length()) {throw new ParserException(e.getTagName() + " has no text");}return v;}

public static string GetNonBlankTextOrFail(XmlElement e){string v = GetText(e);if (null != v)v = v.Trim();if (null == v || 0 == v.Length){throw new ParserException(e.ToString() + " has no text");}return v;}

public void buildFieldConfig(FieldConfig fieldConfig) {Map<String, Float> fieldBoostMap = this.config.get(ConfigurationKeys.FIELD_BOOST_MAP);if (fieldBoostMap != null) {Float boost = fieldBoostMap.get(fieldConfig.getField());if (boost != null) {fieldConfig.set(ConfigurationKeys.BOOST, boost);}}}

public virtual void BuildFieldConfig(FieldConfig fieldConfig){IDictionary<string, float?> fieldBoostMap = this.config.Get(ConfigurationKeys.FIELD_BOOST_MAP);if (fieldBoostMap != null){float? boost;if (fieldBoostMap.TryGetValue(fieldConfig.Field, out boost) && boost != null){fieldConfig.Set(ConfigurationKeys.BOOST, boost);}}}

public PutLifecyclePolicyResult putLifecyclePolicy(PutLifecyclePolicyRequest request) {request = beforeClientExecution(request);return executePutLifecyclePolicy(request);}

public virtual PutLifecyclePolicyResponse PutLifecyclePolicy(PutLifecyclePolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutLifecyclePolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutLifecyclePolicyResponseUnmarshaller.Instance;return Invoke<PutLifecyclePolicyResponse>(request, options);}

public SortedSet<E> subSet(E start, E end) {return subSet(start, true, end, false);}

public virtual java.util.SortedSet<E> subSet(E start, E end){return subSet(start, true, end, false);}

public void setParams(String params) {super.setParams(params);if (params != null) {int multiplier;if (params.endsWith("s")) {multiplier = 1;params = params.substring(0, params.length()-1);} else if (params.endsWith("m")) {multiplier = 60;params = params.substring(0, params.length()-1);} else if (params.endsWith("h")) {multiplier = 3600;params = params.substring(0, params.length()-1);} else {multiplier = 1;}waitTimeSec = Double.parseDouble(params) * multiplier;} else {throw new IllegalArgumentException("you must specify the wait time, eg: 10.0s, 4.5m, 2h");}}

public override void SetParams(string @params){base.SetParams(@params);if (@params != null){int multiplier;if (@params.EndsWith("s", StringComparison.Ordinal)){multiplier = 1;@params = @params.Substring(0, @params.Length - 1);}else if (@params.EndsWith("m", StringComparison.Ordinal)){multiplier = 60;@params = @params.Substring(0, @params.Length - 1);}else if (@params.EndsWith("h", StringComparison.Ordinal)){multiplier = 3600;@params = @params.Substring(0, @params.Length - 1);}else{multiplier = 1;}waitTimeSec = double.Parse(@params, CultureInfo.InvariantCulture) * multiplier;}else{throw new ArgumentException("you must specify the wait time, eg: 10.0s, 4.5m, 2h");}}

public PutAttributesRequest(String domainName, String itemName, java.util.List<ReplaceableAttribute> attributes, UpdateCondition expected) {setDomainName(domainName);setItemName(itemName);setAttributes(attributes);setExpected(expected);}

public PutAttributesRequest(string domainName, string itemName, List<ReplaceableAttribute> attributes, UpdateCondition expected){_domainName = domainName;_itemName = itemName;_attributes = attributes;_expected = expected;}

public DescribeStreamConsumerResult describeStreamConsumer(DescribeStreamConsumerRequest request) {request = beforeClientExecution(request);return executeDescribeStreamConsumer(request);}

public virtual DescribeStreamConsumerResponse DescribeStreamConsumer(DescribeStreamConsumerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStreamConsumerRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStreamConsumerResponseUnmarshaller.Instance;return Invoke<DescribeStreamConsumerResponse>(request, options);}

public void freeze() {this.frozen = true;}

public virtual void Freeze(){this.frozen = true;}

public FuzzyLikeThisQueryBuilder(Analyzer analyzer) {this.analyzer = analyzer;}

public FuzzyLikeThisQueryBuilder(Analyzer analyzer){this.analyzer = analyzer;}

public DBClusterSnapshot copyDBClusterSnapshot(CopyDBClusterSnapshotRequest request) {request = beforeClientExecution(request);return executeCopyDBClusterSnapshot(request);}

public virtual CopyDBClusterSnapshotResponse CopyDBClusterSnapshot(CopyDBClusterSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyDBClusterSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyDBClusterSnapshotResponseUnmarshaller.Instance;return Invoke<CopyDBClusterSnapshotResponse>(request, options);}

public OutputStreamDataOutput(OutputStream os) {this.os = os;}

public OutputStreamDataOutput(Stream os){this._writer = new BinaryWriter(os);}

public String findPattern(String pat) {int k = super.find(pat);if (k >= 0) {return unpackValues(k);}return "";}

public virtual string FindPattern(string pat){int k = base.Find(pat);if (k >= 0){return UnpackValues(k);}return "";}

public static int murmurhash3_x86_32(BytesRef bytes, int seed) {return murmurhash3_x86_32(bytes.bytes, bytes.offset, bytes.length, seed);}

public static int Murmurhash3_x86_32(BytesRef bytes, int seed){return Murmurhash3_x86_32(bytes.Bytes, bytes.Offset, bytes.Length, seed);}

public boolean isOverridable() {return overridable;}

public virtual bool IsOverridable(){return overridable;}

public UpdateMemberResult updateMember(UpdateMemberRequest request) {request = beforeClientExecution(request);return executeUpdateMember(request);}

public virtual UpdateMemberResponse UpdateMember(UpdateMemberRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMemberRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMemberResponseUnmarshaller.Instance;return Invoke<UpdateMemberResponse>(request, options);}

public CopyFpgaImageResult copyFpgaImage(CopyFpgaImageRequest request) {request = beforeClientExecution(request);return executeCopyFpgaImage(request);}

public virtual CopyFpgaImageResponse CopyFpgaImage(CopyFpgaImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance;return Invoke<CopyFpgaImageResponse>(request, options);}

public void inform(ResourceLoader loader) {try { OpenNLPOpsFactory.getPOSTaggerModel(posTaggerModelFile, loader);} catch (IOException e) {throw new IllegalArgumentException(e);}}

public virtual void Inform(IResourceLoader loader){try{ OpenNLPOpsFactory.GetPOSTaggerModel(posTaggerModelFile, loader);}catch (IOException e){throw new ArgumentException(e.ToString(), e);}}

public CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol) {super(firstRow, lastRow, firstCol, lastCol);if (lastRow < firstRow || lastCol < firstCol) {throw new IllegalArgumentException("Invalid cell range, having lastRow < firstRow || lastCol < firstCol, " +"had rows " + lastRow + " >= " + firstRow + " or cells " + lastCol + " >= " + firstCol);}}

public CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol): base(firstRow, lastRow, firstCol, lastCol){if (lastRow < firstRow || lastCol < firstCol)throw new ArgumentException("lastRow < firstRow || lastCol < firstCol");}

public boolean equals(ATNConfig a, ATNConfig b) {if ( a==b ) return true;if ( a==null || b==null ) return false;return a.state.stateNumber==b.state.stateNumber&& a.context.equals(b.context);}

public override bool Equals(ATNConfig a, ATNConfig b){if (a == b){return true;}if (a == null || b == null){return false;}return a.state.stateNumber == b.state.stateNumber && a.context.Equals(b.context);}

public PushCommand setPushTags() {refSpecs.add(Transport.REFSPEC_TAGS);return this;}

public virtual NGit.Api.PushCommand SetPushTags(){refSpecs.AddItem(NGit.Transport.Transport.REFSPEC_TAGS);return this;}

public CreateEvaluationResult createEvaluation(CreateEvaluationRequest request) {request = beforeClientExecution(request);return executeCreateEvaluation(request);}

public virtual CreateEvaluationResponse CreateEvaluation(CreateEvaluationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEvaluationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEvaluationResponseUnmarshaller.Instance;return Invoke<CreateEvaluationResponse>(request, options);}

public DescribeOrderableDBInstanceOptionsResult describeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeOrderableDBInstanceOptions(request);}

public virtual DescribeOrderableDBInstanceOptionsResponse DescribeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeOrderableDBInstanceOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeOrderableDBInstanceOptionsResponseUnmarshaller.Instance;return Invoke<DescribeOrderableDBInstanceOptionsResponse>(request, options);}

public long getPosition() {return (long) currentBlockIndex * blockSize + currentBlockUpto;}

public long GetPosition(){return (long)currentBlockIndex * outerInstance.blockSize + currentBlockUpto;}

public TokenStream create(TokenStream input) {return new FrenchLightStemFilter(input);}

public override TokenStream Create(TokenStream input){return new FrenchLightStemFilter(input);}

public AssignPrivateIpAddressesResult assignPrivateIpAddresses(AssignPrivateIpAddressesRequest request) {request = beforeClientExecution(request);return executeAssignPrivateIpAddresses(request);}

public virtual AssignPrivateIpAddressesResponse AssignPrivateIpAddresses(AssignPrivateIpAddressesRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance;options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance;return Invoke<AssignPrivateIpAddressesResponse>(request, options);}

public boolean setExecute(File f, boolean canExec) {return false;}

public override bool SetExecute(FilePath f, bool canExec){return false;}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval lookup_value, ValueEval table_array,ValueEval col_index, ValueEval range_lookup) {try {ValueEval lookupValue = OperandResolver.getSingleValue(lookup_value, srcRowIndex, srcColumnIndex);TwoDEval tableArray = LookupUtils.resolveTableArrayArg(table_array);boolean isRangeLookup;try {isRangeLookup = LookupUtils.resolveRangeLookupArg(range_lookup, srcRowIndex, srcColumnIndex);} catch(RuntimeException e) {isRangeLookup = true;}int rowIndex = LookupUtils.lookupIndexOfValue(lookupValue, LookupUtils.createColumnVector(tableArray, 0), isRangeLookup);int colIndex = LookupUtils.resolveRowOrColIndexArg(col_index, srcRowIndex, srcColumnIndex);ValueVector resultCol = createResultColumnVector(tableArray, colIndex);return resultCol.getItem(rowIndex);} catch (EvaluationException e) {return e.getErrorEval();}}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval lookup_value, ValueEval table_array,ValueEval col_index, ValueEval range_lookup){try{ValueEval lookupValue = OperandResolver.GetSingleValue(lookup_value, srcRowIndex, srcColumnIndex);TwoDEval tableArray = LookupUtils.ResolveTableArrayArg(table_array);bool isRangeLookup = LookupUtils.ResolveRangeLookupArg(range_lookup, srcRowIndex, srcColumnIndex);int rowIndex = LookupUtils.LookupIndexOfValue(lookupValue, LookupUtils.CreateColumnVector(tableArray, 0), isRangeLookup);int colIndex = LookupUtils.ResolveRowOrColIndexArg(col_index, srcRowIndex, srcColumnIndex);ValueVector resultCol = CreateResultColumnVector(tableArray, colIndex);return resultCol.GetItem(rowIndex);}catch (EvaluationException e){return e.GetErrorEval();}}

public CreateGameSessionResult createGameSession(CreateGameSessionRequest request) {request = beforeClientExecution(request);return executeCreateGameSession(request);}

public virtual CreateGameSessionResponse CreateGameSession(CreateGameSessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateGameSessionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateGameSessionResponseUnmarshaller.Instance;return Invoke<CreateGameSessionResponse>(request, options);}

public RowRecord getRow(int rowIndex) {int maxrow = SpreadsheetVersion.EXCEL97.getLastRowIndex();if (rowIndex < 0 || rowIndex > maxrow) {throw new IllegalArgumentException("The row number must be between 0 and " + maxrow + ", but had: " + rowIndex);}return _rowRecords.get(Integer.valueOf(rowIndex));}

public RowRecord GetRow(int rowIndex){if (rowIndex < 0 || rowIndex > 65535){throw new ArgumentException("The row number must be between 0 and 65535");}return (RowRecord)_rowRecords[rowIndex];}

public DescribeClientPropertiesResult describeClientProperties(DescribeClientPropertiesRequest request) {request = beforeClientExecution(request);return executeDescribeClientProperties(request);}

public virtual DescribeClientPropertiesResponse DescribeClientProperties(DescribeClientPropertiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClientPropertiesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClientPropertiesResponseUnmarshaller.Instance;return Invoke<DescribeClientPropertiesResponse>(request, options);}

public Builder(CompositeReader reader) {this.reader = reader;}

public Builder(CompositeReader reader){this.reader = reader;}

public synchronized void mark(int readlimit) {in.mark(readlimit);}

public override void mark(int readlimit){lock (this){@in.mark(readlimit);}}

public void print(int inum) {print(String.valueOf(inum));}

public virtual void print(int inum){print(inum.ToString());}

public static final ObjectId fromRaw(int[] is) {return fromRaw(is, 0);}

public static NGit.ObjectId FromRaw(int[] @is){return FromRaw(@is, 0);}

public String toString() {return slice.toString()+":"+ postingsEnum;}

public override string ToString(){return Slice.ToString() + ":" + DocsEnum;}

public void serialize(LittleEndianOutput out) {out.writeShort(getMode());}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Mode);}

@Override public int size() {return Impl.this.size();}

public override int size(){return this._enclosing.size();}

public static int hashCode(Object... objects) {return Arrays.hashCode(objects);}

public static int hashCode(object o){return (o == null) ? 0 : o.GetHashCode();}

public ByteBuffer putFloat(int index, float value) {throw new ReadOnlyBufferException();}

public override java.nio.ByteBuffer putFloat(int index, float value){throw new java.nio.ReadOnlyBufferException();}

public ListJournalS3ExportsForLedgerResult listJournalS3ExportsForLedger(ListJournalS3ExportsForLedgerRequest request) {request = beforeClientExecution(request);return executeListJournalS3ExportsForLedger(request);}

public virtual ListJournalS3ExportsForLedgerResponse ListJournalS3ExportsForLedger(ListJournalS3ExportsForLedgerRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJournalS3ExportsForLedgerRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJournalS3ExportsForLedgerResponseUnmarshaller.Instance;return Invoke<ListJournalS3ExportsForLedgerResponse>(request, options);}

public DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest request) {request = beforeClientExecution(request);return executeDeleteMessageBatch(request);}

public virtual DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMessageBatchRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMessageBatchResponseUnmarshaller.Instance;return Invoke<DeleteMessageBatchResponse>(request, options);}

public final void write(LittleEndianOutput out) {out.writeByte(getSid() + getPtgClass());writeCoordinates(out);}

public override void Write(ILittleEndianOutput out1){out1.WriteByte(Sid + PtgClass);WriteCoordinates(out1);}

public FSTCompletionBuilder(int buckets, BytesRefSorter sorter, int shareMaxTailLength) {if (buckets < 1 || buckets > 255) {throw new IllegalArgumentException("Buckets must be >= 1 and <= 255: "+ buckets);}if (sorter == null) throw new IllegalArgumentException("BytesRefSorter must not be null.");this.sorter = sorter;this.buckets = buckets;this.shareMaxTailLength = shareMaxTailLength;}

public FSTCompletionBuilder(int buckets, IBytesRefSorter sorter, int shareMaxTailLength){if (buckets < 1 || buckets > 255){throw new System.ArgumentException("Buckets must be >= 1 and <= 255: " + buckets);}if (sorter == null){throw new System.ArgumentException("BytesRefSorter must not be null.");}this.sorter = sorter;this.buckets = buckets;this.shareMaxTailLength = shareMaxTailLength;}

public void incRef() {refCount.incrementAndGet();}

public virtual void IncRef(){refCount.IncrementAndGet();}