Datasets:

semeru

/

code-code-translation-java-csharp

like 1

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 virtual UpdateMLModelResponse UpdateMLModel(UpdateMLModelRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMLModelRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMLModelResponseUnmarshaller.Instance;return Invoke<UpdateMLModelResponse>(request, options);}

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 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 virtual DescribeWorkspaceBundlesResponse DescribeWorkspaceBundles(DescribeWorkspaceBundlesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeWorkspaceBundlesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeWorkspaceBundlesResponseUnmarshaller.Instance;return Invoke<DescribeWorkspaceBundlesResponse>(request, options);}

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

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

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 override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append(">=");buffer.Append(operands[1]);return buffer.ToString();}

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 virtual DescribeScalingParametersResponse DescribeScalingParameters(DescribeScalingParametersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeScalingParametersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeScalingParametersResponseUnmarshaller.Instance;return Invoke<DescribeScalingParametersResponse>(request, options);}

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){_bucket = bucket;}

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

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

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) :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 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 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 override String ToFormulaString(){return HSSFErrorConstants.GetText(HSSFErrorConstants.ERROR_REF);}

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){_id = id;_receiptHandle = receiptHandle;}

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

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

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

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

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

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

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

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 override string ToString(){return "arc=" + fstArc + " state=" + fsaState;}

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

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

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

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(java.io.OutputStream @out) : base(@out){if (@out == null){throw new System.ArgumentNullException();}}

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

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

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

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 virtual DescribeFleetCapacityResponse DescribeFleetCapacity(DescribeFleetCapacityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetCapacityRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetCapacityResponseUnmarshaller.Instance;return Invoke<DescribeFleetCapacityResponse>(request, options);}

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

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

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

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(): base("cr", "2016-06-07", "UpdateRepoAuthorization", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/authorizations/[AuthorizeId]";Method = MethodType.POST;}

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 bool HasEntry(String name){if (excludes.Contains(name)){return false;}return directory.HasEntry(name);}

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

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

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

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 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(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 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 virtual PutLifecyclePolicyResponse PutLifecyclePolicy(PutLifecyclePolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutLifecyclePolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutLifecyclePolicyResponseUnmarshaller.Instance;return Invoke<PutLifecyclePolicyResponse>(request, options);}

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

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, List<ReplaceableAttribute> attributes, UpdateCondition expected){_domainName = domainName;_itemName = itemName;_attributes = attributes;_expected = expected;}

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

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

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

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(Stream os){this._writer = new BinaryWriter(os);}

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 virtual bool IsOverridable(){return overridable;}

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

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

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): base(firstRow, lastRow, firstCol, lastCol){if (lastRow < firstRow || lastCol < firstCol)throw new ArgumentException("lastRow < firstRow || lastCol < firstCol");}

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 virtual NGit.Api.PushCommand SetPushTags(){refSpecs.AddItem(NGit.Transport.Transport.REFSPEC_TAGS);return this;}

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

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 * outerInstance.blockSize + currentBlockUpto;}

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

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

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

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 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){if (rowIndex < 0 || rowIndex > 65535){throw new ArgumentException("The row number must be between 0 and 65535");}return (RowRecord)_rowRecords[rowIndex];}

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 override void mark(int readlimit){lock (this){@in.mark(readlimit);}}

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

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

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

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

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

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

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

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

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

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

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 virtual void IncRef(){refCount.IncrementAndGet();}