Datasets:

google

/

code_x_glue_cc_code_to_code_trans

like 8

public UpdateRepoBuildRuleRequest() {super("cr", "2016-06-07", "UpdateRepoBuildRule", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/rules/[BuildRuleId]");setMethod(MethodType.POST);}

public UpdateRepoBuildRuleRequest(): base("cr", "2016-06-07", "UpdateRepoBuildRule", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/rules/[BuildRuleId]";Method = MethodType.POST;}

public boolean contains(Object o) {return map.containsKey(o);}

public virtual bool Contains(string cs){return map.ContainsKey(cs);}

public DescribeAutoScalingInstancesResult describeAutoScalingInstances() {return describeAutoScalingInstances(new DescribeAutoScalingInstancesRequest());}

public virtual DescribeAutoScalingInstancesResponse DescribeAutoScalingInstances(){return DescribeAutoScalingInstances(new DescribeAutoScalingInstancesRequest());}

public NLPTokenizerOp() {tokenizer = null;}

public NLPTokenizerOp(){tokenizer = null;}

public int size() {synchronized (mutex) {return delegate().size();}}

public virtual int size(){lock (mutex){return c.size();}}

public boolean retainAll(final IntList c){boolean rval = false;for (int j = 0; j < _limit; ){if (!c.contains(_array[ j ])){remove(j);rval = true;}else{j++;}}return rval;}

public bool RetainAll(IntList c){bool rval = false;for (int j = 0; j < _limit; ){if (!c.Contains(_array[j])){Remove(j);rval = true;}else{j++;}}return rval;}

public String getPath() {return path.getPath();}

public virtual string GetPath(){return path.GetPath();}

public UpdateSecurityGroupRuleDescriptionsEgressResult updateSecurityGroupRuleDescriptionsEgress(UpdateSecurityGroupRuleDescriptionsEgressRequest request) {request = beforeClientExecution(request);return executeUpdateSecurityGroupRuleDescriptionsEgress(request);}

public virtual UpdateSecurityGroupRuleDescriptionsEgressResponse UpdateSecurityGroupRuleDescriptionsEgress(UpdateSecurityGroupRuleDescriptionsEgressRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateSecurityGroupRuleDescriptionsEgressRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateSecurityGroupRuleDescriptionsEgressResponseUnmarshaller.Instance;return Invoke<UpdateSecurityGroupRuleDescriptionsEgressResponse>(request, options);}

public SetVaultAccessPolicyResult setVaultAccessPolicy(SetVaultAccessPolicyRequest request) {request = beforeClientExecution(request);return executeSetVaultAccessPolicy(request);}

public virtual SetVaultAccessPolicyResponse SetVaultAccessPolicy(SetVaultAccessPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetVaultAccessPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = SetVaultAccessPolicyResponseUnmarshaller.Instance;return Invoke<SetVaultAccessPolicyResponse>(request, options);}

public PutAutoScalingPolicyResult putAutoScalingPolicy(PutAutoScalingPolicyRequest request) {request = beforeClientExecution(request);return executePutAutoScalingPolicy(request);}

public virtual PutAutoScalingPolicyResponse PutAutoScalingPolicy(PutAutoScalingPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutAutoScalingPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutAutoScalingPolicyResponseUnmarshaller.Instance;return Invoke<PutAutoScalingPolicyResponse>(request, options);}

public CancelReservedInstancesListingResult cancelReservedInstancesListing(CancelReservedInstancesListingRequest request) {request = beforeClientExecution(request);return executeCancelReservedInstancesListing(request);}

public virtual CancelReservedInstancesListingResponse CancelReservedInstancesListing(CancelReservedInstancesListingRequest request){var options = new InvokeOptions();options.RequestMarshaller = CancelReservedInstancesListingRequestMarshaller.Instance;options.ResponseUnmarshaller = CancelReservedInstancesListingResponseUnmarshaller.Instance;return Invoke<CancelReservedInstancesListingResponse>(request, options);}

public String getSignerName() {return null;}

public override string GetSignerName(){return "BearerTokenSigner";}

public ListTagsForDeliveryStreamResult listTagsForDeliveryStream(ListTagsForDeliveryStreamRequest request) {request = beforeClientExecution(request);return executeListTagsForDeliveryStream(request);}

public virtual ListTagsForDeliveryStreamResponse ListTagsForDeliveryStream(ListTagsForDeliveryStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTagsForDeliveryStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTagsForDeliveryStreamResponseUnmarshaller.Instance;return Invoke<ListTagsForDeliveryStreamResponse>(request, options);}

public RegisterDomainResult registerDomain(RegisterDomainRequest request) {request = beforeClientExecution(request);return executeRegisterDomain(request);}

public virtual RegisterDomainResponse RegisterDomain(RegisterDomainRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterDomainRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterDomainResponseUnmarshaller.Instance;return Invoke<RegisterDomainResponse>(request, options);}

public ListEntityRecognizersResult listEntityRecognizers(ListEntityRecognizersRequest request) {request = beforeClientExecution(request);return executeListEntityRecognizers(request);}

public virtual ListEntityRecognizersResponse ListEntityRecognizers(ListEntityRecognizersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListEntityRecognizersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListEntityRecognizersResponseUnmarshaller.Instance;return Invoke<ListEntityRecognizersResponse>(request, options);}

public void setTimeout(int millis) {if (millis < 0)throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidTimeout, Integer.valueOf(millis)));timeout = millis;}

public virtual void SetTimeout(int millis){if (millis < 0){throw new ArgumentException(MessageFormat.Format(JGitText.Get().invalidTimeout, Sharpen.Extensions.ValueOf(millis)));}timeout = millis;}

public GetRepoSourceRepoRequest() {super("cr", "2016-06-07", "GetRepoSourceRepo", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/sourceRepo");setMethod(MethodType.GET);}

public GetRepoSourceRepoRequest(): base("cr", "2016-06-07", "GetRepoSourceRepo", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/sourceRepo";Method = MethodType.GET;}

public DescribeBatchInferenceJobResult describeBatchInferenceJob(DescribeBatchInferenceJobRequest request) {request = beforeClientExecution(request);return executeDescribeBatchInferenceJob(request);}

public virtual DescribeBatchInferenceJobResponse DescribeBatchInferenceJob(DescribeBatchInferenceJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeBatchInferenceJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeBatchInferenceJobResponseUnmarshaller.Instance;return Invoke<DescribeBatchInferenceJobResponse>(request, options);}

public CreateSecurityGroupRequest(String groupName, String description) {setGroupName(groupName);setDescription(description);}

public CreateSecurityGroupRequest(string groupName, string description){_groupName = groupName;_description = description;}

public final int serialize(int offset, byte[] data) {SerializingRecordVisitor srv = new SerializingRecordVisitor(data, offset);visitContainedRecords(srv);return srv.countBytesWritten();}

public override int Serialize(int offset, byte[] data){SerializingRecordVisitor srv = new SerializingRecordVisitor(data, offset);VisitContainedRecords(srv);return srv.CountBytesWritten();}

public BatchGetImageResult batchGetImage(BatchGetImageRequest request) {request = beforeClientExecution(request);return executeBatchGetImage(request);}

public virtual BatchGetImageResponse BatchGetImage(BatchGetImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchGetImageRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchGetImageResponseUnmarshaller.Instance;return Invoke<BatchGetImageResponse>(request, options);}

public int read() throws IOException {try {beginRead();return super.read();} catch (InterruptedIOException e) {throw readTimedOut(e);} finally {endRead();}}

public override int Read(){try{BeginRead();return base.Read();}catch (ThreadInterruptedException){throw ReadTimedOut();}finally{EndRead();}}

public ActivityTask pollForActivityTask(PollForActivityTaskRequest request) {request = beforeClientExecution(request);return executePollForActivityTask(request);}

public virtual PollForActivityTaskResponse PollForActivityTask(PollForActivityTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = PollForActivityTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = PollForActivityTaskResponseUnmarshaller.Instance;return Invoke<PollForActivityTaskResponse>(request, options);}

public int execute(StringBuilder buf) {if ( text!=null ) {buf.append(text);}return lastIndex+1;}

public virtual int Execute(StringBuilder buf){return index;}

public float overheadPerValue(int bitsPerValue) {assert isSupported(bitsPerValue);return 0f;}

public virtual float OverheadPerValue(int bitsPerValue){Debug.Assert(IsSupported(bitsPerValue));return 0f;}

public String toString() {return buf.toString();}

public override string ToString(){return buf.ToString();}

public PrecedenceQueryParser(Analyzer analyer) {super(analyer);setQueryNodeProcessor(new PrecedenceQueryNodeProcessorPipeline(getQueryConfigHandler()));}

public PrecedenceQueryParser(Analyzer analyer): base(analyer){SetQueryNodeProcessor(new PrecedenceQueryNodeProcessorPipeline(QueryConfigHandler));}

public final int position() {return position;}

public int position(){return _position;}

public boolean equals(Object o) {return this.getClass() == o.getClass();}

public override bool Equals(object o){return this.GetType() == o.GetType();}

public IntBuffer compact() {throw new ReadOnlyBufferException();}

public override java.nio.IntBuffer compact(){throw new java.nio.ReadOnlyBufferException();}

public void writeByte(int v) {writeContinueIfRequired(1);_ulrOutput.writeByte(v);}

public void WriteByte(int v){_out.WriteByte(v);_size += 1;}

public ExpireSessionResult expireSession(ExpireSessionRequest request) {request = beforeClientExecution(request);return executeExpireSession(request);}

public virtual ExpireSessionResponse ExpireSession(ExpireSessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = ExpireSessionRequestMarshaller.Instance;options.ResponseUnmarshaller = ExpireSessionResponseUnmarshaller.Instance;return Invoke<ExpireSessionResponse>(request, options);}

public GetSubscriptionAttributesRequest(String subscriptionArn) {setSubscriptionArn(subscriptionArn);}

public GetSubscriptionAttributesRequest(string subscriptionArn){_subscriptionArn = subscriptionArn;}

public GetMetricDataResult getMetricData(GetMetricDataRequest request) {request = beforeClientExecution(request);return executeGetMetricData(request);}

public virtual GetMetricDataResponse GetMetricData(GetMetricDataRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetMetricDataRequestMarshaller.Instance;options.ResponseUnmarshaller = GetMetricDataResponseUnmarshaller.Instance;return Invoke<GetMetricDataResponse>(request, options);}

public DescribeDhcpOptionsResult describeDhcpOptions(DescribeDhcpOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeDhcpOptions(request);}

public virtual DescribeDhcpOptionsResponse DescribeDhcpOptions(DescribeDhcpOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDhcpOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDhcpOptionsResponseUnmarshaller.Instance;return Invoke<DescribeDhcpOptionsResponse>(request, options);}

public NavigableSet<E> subSet(E start, boolean startInclusive, E end,boolean endInclusive) {Comparator<? super E> c = backingMap.comparator();int compare = (c == null) ? ((Comparable<E>) start).compareTo(end) : c.compare(start, end);if (compare <= 0) {return new TreeSet<E>(backingMap.subMap(start, startInclusive, end,endInclusive));}throw new IllegalArgumentException();}

public virtual java.util.NavigableSet<E> subSet(E start, bool startInclusive, E end, bool endInclusive){java.util.Comparator<E> c = backingMap.comparator();int compare = (c == null) ? ((java.lang.Comparable<E>)start).compareTo(end) : c.compare(start, end);if (compare <= 0){return new java.util.TreeSet<E>(backingMap.subMap(start, startInclusive, end, endInclusive));}throw new System.ArgumentException();}

public SendEmailResult sendEmail(SendEmailRequest request) {request = beforeClientExecution(request);return executeSendEmail(request);}

public virtual SendEmailResponse SendEmail(SendEmailRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendEmailRequestMarshaller.Instance;options.ResponseUnmarshaller = SendEmailResponseUnmarshaller.Instance;return Invoke<SendEmailResponse>(request, options);}

public String toString(){return String.valueOf(_value);}

public override string ToString(){return Convert.ToString(this._value, CultureInfo.CurrentCulture);}

public static double getExcelDate(LocalDate date) {return getExcelDate(date, false);}

public static double GetExcelDate(DateTime date){return GetExcelDate(date, false);}

public boolean equals( Object o ) {return o instanceof ItalianStemmer;}

public override bool Equals(object o){return o is ItalianStemmer;}

public ListenerHandle addIndexChangedListener(IndexChangedListener listener) {return addListener(IndexChangedListener.class, listener);}

public virtual ListenerHandle AddIndexChangedListener(IndexChangedListener listener){return AddListener<IndexChangedListener>(listener);}

public SynthesizeSpeechResult synthesizeSpeech(SynthesizeSpeechRequest request) {request = beforeClientExecution(request);return executeSynthesizeSpeech(request);}

public virtual SynthesizeSpeechResponse SynthesizeSpeech(SynthesizeSpeechRequest request){var options = new InvokeOptions();options.RequestMarshaller = SynthesizeSpeechRequestMarshaller.Instance;options.ResponseUnmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance;return Invoke<SynthesizeSpeechResponse>(request, options);}

public void merge(TextFragment frag2){textEndPos = frag2.textEndPos;score=Math.max(score,frag2.score);}

public virtual void Merge(TextFragment frag2){TextEndPos = frag2.TextEndPos;Score = Math.Max(Score, frag2.Score);}

public CreateLedgerResult createLedger(CreateLedgerRequest request) {request = beforeClientExecution(request);return executeCreateLedger(request);}

public virtual CreateLedgerResponse CreateLedger(CreateLedgerRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLedgerRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLedgerResponseUnmarshaller.Instance;return Invoke<CreateLedgerResponse>(request, options);}

public DescribeFleetPortSettingsResult describeFleetPortSettings(DescribeFleetPortSettingsRequest request) {request = beforeClientExecution(request);return executeDescribeFleetPortSettings(request);}

public virtual DescribeFleetPortSettingsResponse DescribeFleetPortSettings(DescribeFleetPortSettingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetPortSettingsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetPortSettingsResponseUnmarshaller.Instance;return Invoke<DescribeFleetPortSettingsResponse>(request, options);}

public String getHost() {return host;}

public string getHost(){return host;}

public short get() {if (position == limit) {throw new BufferUnderflowException();}return byteBuffer.getShort(position++ * SizeOf.SHORT);}

public override short get(){if (_position == _limit){throw new java.nio.BufferUnderflowException();}return byteBuffer.getShort(_position++ * libcore.io.SizeOf.SHORT);}

public void ReInit(CharStream stream){jjmatchedPos = jjnewStateCnt = 0;curLexState = defaultLexState;input_stream = stream;ReInitRounds();}

public void ReInit(ICharStream stream){jjmatchedPos = jjnewStateCnt = 0;curLexState = defaultLexState;m_input_stream = stream;ReInitRounds();}

public void set(int index, long value) {final int o = index / 12;final int b = index % 12;final int shift = b * 5;blocks[o] = (blocks[o] & ~(31L << shift)) | (value << shift);}

public override void Set(int index, long value){int o = index / 12;int b = index % 12;int shift = b * 5;blocks[o] = (blocks[o] & ~(31L << shift)) | (value << shift);}

public ByteSequencesWriter(IndexOutput out) {this.out = out;}

public ByteSequencesWriter(DataOutput os){this.os = os;}

public MultiTermsEnum(ReaderSlice[] slices) {queue = new TermMergeQueue(slices.length);top = new TermsEnumWithSlice[slices.length];subs = new TermsEnumWithSlice[slices.length];subDocs = new MultiPostingsEnum.EnumWithSlice[slices.length];for(int i=0;i<slices.length;i++) {subs[i] = new TermsEnumWithSlice(i, slices[i]);subDocs[i] = new MultiPostingsEnum.EnumWithSlice();subDocs[i].slice = slices[i];}currentSubs = new TermsEnumWithSlice[slices.length];}

public MultiTermsEnum(ReaderSlice[] slices){queue = new TermMergeQueue(slices.Length);top = new TermsEnumWithSlice[slices.Length];subs = new TermsEnumWithSlice[slices.Length];subDocs = new MultiDocsEnum.EnumWithSlice[slices.Length];subDocsAndPositions = new MultiDocsAndPositionsEnum.EnumWithSlice[slices.Length];for (int i = 0; i < slices.Length; i++){subs[i] = new TermsEnumWithSlice(i, slices[i]);subDocs[i] = new MultiDocsEnum.EnumWithSlice();subDocs[i].Slice = slices[i];subDocsAndPositions[i] = new MultiDocsAndPositionsEnum.EnumWithSlice();subDocsAndPositions[i].Slice = slices[i];}currentSubs = new TermsEnumWithSlice[slices.Length];}

public char last() {if (start == end) {return DONE;}offset = end - 1;return string.charAt(offset);}

public char last(){if (start == end){return java.text.CharacterIteratorClass.DONE;}offset = end - 1;return @string[offset];}

public AttributeSource(AttributeFactory factory) {this.attributes = new LinkedHashMap<>();this.attributeImpls = new LinkedHashMap<>();this.currentState = new State[1];this.factory = Objects.requireNonNull(factory, "AttributeFactory must not be null");}

public AttributeSource(AttributeFactory factory){this.attributes = new JCG.LinkedDictionary<Type, Util.Attribute>();this.attributeImpls = new JCG.LinkedDictionary<Type, Util.Attribute>();this.currentState = new State[1];this.factory = factory;}

public Matcher reset(CharSequence input) {return reset(input, 0, input.length());}

public java.util.regex.Matcher reset(java.lang.CharSequence input){return reset(input, 0, input.Length);}

public GetConfigurationProfileResult getConfigurationProfile(GetConfigurationProfileRequest request) {request = beforeClientExecution(request);return executeGetConfigurationProfile(request);}

public virtual GetConfigurationProfileResponse GetConfigurationProfile(GetConfigurationProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetConfigurationProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = GetConfigurationProfileResponseUnmarshaller.Instance;return Invoke<GetConfigurationProfileResponse>(request, options);}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex) {return new NumberEval(srcColumnIndex+1);}

public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex){return new NumberEval(srcColumnIndex + 1);}

public static double[] grow(double[] array, int minSize) {assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";if (array.length < minSize) {return growExact(array, oversize(minSize, Double.BYTES));} elsereturn array;}

public static float[] Grow(float[] array, int minSize){Debug.Assert(minSize >= 0, "size must be positive (got " + minSize + "): likely integer overflow?");if (array.Length < minSize){float[] newArray = new float[Oversize(minSize, RamUsageEstimator.NUM_BYTES_SINGLE)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}

public DescribeVpcPeeringConnectionsResult describeVpcPeeringConnections(DescribeVpcPeeringConnectionsRequest request) {request = beforeClientExecution(request);return executeDescribeVpcPeeringConnections(request);}

public virtual DescribeVpcPeeringConnectionsResponse DescribeVpcPeeringConnections(DescribeVpcPeeringConnectionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcPeeringConnectionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcPeeringConnectionsResponseUnmarshaller.Instance;return Invoke<DescribeVpcPeeringConnectionsResponse>(request, options);}

public FloatBuffer put(float c) {throw new ReadOnlyBufferException();}

public override java.nio.FloatBuffer put(float c){throw new java.nio.ReadOnlyBufferException();}

public int sumTokenSizes(int fromIx, int toIx) {int result = 0;for (int i=fromIx; i<toIx; i++) {result += _ptgs[i].getSize();}return result;}

public int sumTokenSizes(int fromIx, int ToIx){int result = 0;for (int i = fromIx; i < ToIx; i++){result += _ptgs[i].Size;}return result;}

public DirectBytesStartArray(int initSize, Counter counter) {this.bytesUsed = counter;this.initSize = initSize;}

public DirectBytesStartArray(int initSize, Counter counter){this.bytesUsed = counter;this.m_initSize = initSize;}

public void clear() {for (T[] block : directory) {if (block != null)Arrays.fill(block, null);}size = 0;tailDirIdx = 0;tailBlkIdx = 0;tailBlock = directory[0];}

public override void Clear(){foreach (T[] block in directory){if (block != null){Arrays.Fill(block, default(T));}}size = 0;tailDirIdx = 0;tailBlkIdx = 0;tailBlock = directory[0];}

public UploadMultipartPartResult uploadMultipartPart(UploadMultipartPartRequest request) {request = beforeClientExecution(request);return executeUploadMultipartPart(request);}

public virtual UploadMultipartPartResponse UploadMultipartPart(UploadMultipartPartRequest request){var options = new InvokeOptions();options.RequestMarshaller = UploadMultipartPartRequestMarshaller.Instance;options.ResponseUnmarshaller = UploadMultipartPartResponseUnmarshaller.Instance;return Invoke<UploadMultipartPartResponse>(request, options);}

public HCenterRecord(RecordInputStream in) {field_1_hcenter = in.readShort();}

public HCenterRecord(RecordInputStream in1){field_1_hcenter = in1.ReadShort();}

public CreateDBClusterEndpointResult createDBClusterEndpoint(CreateDBClusterEndpointRequest request) {request = beforeClientExecution(request);return executeCreateDBClusterEndpoint(request);}

public virtual CreateDBClusterEndpointResponse CreateDBClusterEndpoint(CreateDBClusterEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDBClusterEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDBClusterEndpointResponseUnmarshaller.Instance;return Invoke<CreateDBClusterEndpointResponse>(request, options);}

public boolean hasNext() {return iterator.nextIndex() < end;}

public bool hasNext(){return iterator.nextIndex() < end;}

public CredentialItem(String promptText, boolean maskValue) {this.promptText = promptText;this.valueSecure = maskValue;}

public CredentialItem(string promptText, bool maskValue){this.promptText = promptText;this.valueSecure = maskValue;}

public DescribeCustomAvailabilityZonesResult describeCustomAvailabilityZones(DescribeCustomAvailabilityZonesRequest request) {request = beforeClientExecution(request);return executeDescribeCustomAvailabilityZones(request);}

public virtual DescribeCustomAvailabilityZonesResponse DescribeCustomAvailabilityZones(DescribeCustomAvailabilityZonesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeCustomAvailabilityZonesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeCustomAvailabilityZonesResponseUnmarshaller.Instance;return Invoke<DescribeCustomAvailabilityZonesResponse>(request, options);}

public DescribeClusterParameterGroupsResult describeClusterParameterGroups() {return describeClusterParameterGroups(new DescribeClusterParameterGroupsRequest());}

public virtual DescribeClusterParameterGroupsResponse DescribeClusterParameterGroups(){return DescribeClusterParameterGroups(new DescribeClusterParameterGroupsRequest());}

public Item(char p, char c) {parent = p;child = c;}

public Item(char p, char c){parent = p;child = c;}

public void reset(int[] docs, int[] freqs) {this.docs = docs;this.freqs = freqs;if (freqs != null && tmpFreqs == null) {tmpFreqs = new int[tmpDocs.length];}}

public void Reset(int[] docs, int[] freqs){this.docs = docs;this.freqs = freqs;if (freqs != null && tmpFreqs == null){tmpFreqs = new int[tmpDocs.Length];}}

public ChangeMessageVisibilityResult changeMessageVisibility(String queueUrl, String receiptHandle, Integer visibilityTimeout) {return changeMessageVisibility(new ChangeMessageVisibilityRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle).withVisibilityTimeout(visibilityTimeout));}

public virtual ChangeMessageVisibilityResponse ChangeMessageVisibility(string queueUrl, string receiptHandle, int visibilityTimeout){var request = new ChangeMessageVisibilityRequest();request.QueueUrl = queueUrl;request.ReceiptHandle = receiptHandle;request.VisibilityTimeout = visibilityTimeout;return ChangeMessageVisibility(request);}

public boolean contains(Object o) {return this.processors.contains(o);}

public virtual bool Contains(object o){return this.processors.Contains(o);}

public int getReturnState(int index) {return returnState;}

public override int GetReturnState(int index){return returnState;}

public ModifyVolumeAttributeResult modifyVolumeAttribute(ModifyVolumeAttributeRequest request) {request = beforeClientExecution(request);return executeModifyVolumeAttribute(request);}

public virtual ModifyVolumeAttributeResponse ModifyVolumeAttribute(ModifyVolumeAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyVolumeAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyVolumeAttributeResponseUnmarshaller.Instance;return Invoke<ModifyVolumeAttributeResponse>(request, options);}

public DeleteVolumeResult deleteVolume(DeleteVolumeRequest request) {request = beforeClientExecution(request);return executeDeleteVolume(request);}

public virtual DeleteVolumeResponse DeleteVolume(DeleteVolumeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVolumeRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVolumeResponseUnmarshaller.Instance;return Invoke<DeleteVolumeResponse>(request, options);}

public ByteBuffer putLong(int index, long value) {checkIndex(index, SizeOf.LONG);Memory.pokeLong(backingArray, offset + index, value, order);return this;}

public override java.nio.ByteBuffer putLong(int index, long value){checkIndex(index, libcore.io.SizeOf.LONG);libcore.io.Memory.pokeLong(backingArray, offset + index, value, _order);return this;}

public boolean hasMetaDataChanges() {return changeType != ChangeType.MODIFY || newMode != oldMode;}

public virtual bool HasMetaDataChanges(){return changeType != DiffEntry.ChangeType.MODIFY || newMode != oldMode;}

public void newField(FieldInfo fieldInfo) {count = interval;}

public override void NewField(FieldInfo fieldInfo){count = interval;}

public TokenStream create(TokenStream input) {return new JapaneseReadingFormFilter(input, useRomaji);}

public override TokenStream Create(TokenStream input){return new JapaneseReadingFormFilter(input, useRomaji);}

public static CellRangeAddress valueOf(String ref) {int sep = ref.indexOf(":");CellReference a;CellReference b;if (sep == -1) {a = new CellReference(ref);b = a;} else {a = new CellReference(ref.substring(0, sep));b = new CellReference(ref.substring(sep + 1));}return new CellRangeAddress(a.getRow(), b.getRow(), a.getCol(), b.getCol());}

public static CellRangeAddress ValueOf(String reference){int sep = reference.IndexOf(":", StringComparison.Ordinal);CellReference a;CellReference b;if (sep == -1){a = new CellReference(reference);b = a;}else{a = new CellReference(reference.Substring(0, sep));b = new CellReference(reference.Substring(sep + 1));}return new CellRangeAddress(a.Row, b.Row, a.Col, b.Col);}

public ModifySelfservicePermissionsResult modifySelfservicePermissions(ModifySelfservicePermissionsRequest request) {request = beforeClientExecution(request);return executeModifySelfservicePermissions(request);}

public virtual ModifySelfservicePermissionsResponse ModifySelfservicePermissions(ModifySelfservicePermissionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifySelfservicePermissionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifySelfservicePermissionsResponseUnmarshaller.Instance;return Invoke<ModifySelfservicePermissionsResponse>(request, options);}

public int getTokenType(String tokenName) {Integer ttype = getTokenTypeMap().get(tokenName);if ( ttype!=null ) return ttype;return Token.INVALID_TYPE;}

public virtual int GetTokenType(string tokenName){int ttype;if (TokenTypeMap.TryGetValue(tokenName, out ttype)){return ttype;}return TokenConstants.InvalidType;}

public int compareTo(LongBuffer otherBuffer) {int compareRemaining = (remaining() < otherBuffer.remaining()) ? remaining(): otherBuffer.remaining();int thisPos = position;int otherPos = otherBuffer.position;long thisLong, otherLong;while (compareRemaining > 0) {thisLong = get(thisPos);otherLong = otherBuffer.get(otherPos);if (thisLong != otherLong) {return thisLong < otherLong ? -1 : 1;}thisPos++;otherPos++;compareRemaining--;}return remaining() - otherBuffer.remaining();}

public virtual int compareTo(java.nio.LongBuffer otherBuffer){int compareRemaining = (remaining() < otherBuffer.remaining()) ? remaining() : otherBuffer.remaining();int thisPos = _position;int otherPos = otherBuffer._position;long thisLong;long otherLong;while (compareRemaining > 0){thisLong = get(thisPos);otherLong = otherBuffer.get(otherPos);if (thisLong != otherLong){return thisLong < otherLong ? -1 : 1;}thisPos++;otherPos++;compareRemaining--;}return remaining() - otherBuffer.remaining();}

public ApproveSkillResult approveSkill(ApproveSkillRequest request) {request = beforeClientExecution(request);return executeApproveSkill(request);}

public virtual ApproveSkillResponse ApproveSkill(ApproveSkillRequest request){var options = new InvokeOptions();options.RequestMarshaller = ApproveSkillRequestMarshaller.Instance;options.ResponseUnmarshaller = ApproveSkillResponseUnmarshaller.Instance;return Invoke<ApproveSkillResponse>(request, options);}

public void writeContinueIfRequired(int requiredContinuousSize) {if (_ulrOutput.getAvailableSpace() < requiredContinuousSize) {writeContinue();}}

public void WriteContinueIfRequired(int requiredContinuousSize){if (_ulrOutput.AvailableSpace < requiredContinuousSize){WriteContinue();}}

public GetApiKeysResult getApiKeys(GetApiKeysRequest request) {request = beforeClientExecution(request);return executeGetApiKeys(request);}

public virtual GetApiKeysResponse GetApiKeys(GetApiKeysRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetApiKeysRequestMarshaller.Instance;options.ResponseUnmarshaller = GetApiKeysResponseUnmarshaller.Instance;return Invoke<GetApiKeysResponse>(request, options);}

public Iterator<Entry<K, V>> iterator() {return newEntryIterator();}

public override java.util.Iterator<java.util.MapClass.Entry<K, V>> iterator(){return new java.util.Hashtable<K, V>.EntryIterator(this._enclosing);}

public int compareTo(RowColKey o) {int cmp = _rowIndex - o._rowIndex;if (cmp != 0) {return cmp;}return _columnIndex - o._columnIndex;}

public int CompareTo(RowColKey o){int cmp = _rowIndex - o._rowIndex;if (cmp != 0){return cmp;}return _columnIndex - o._columnIndex;}

public ATNConfig(ATNConfig c, ATNState state,PredictionContext context,SemanticContext semanticContext){this.state = state;this.alt = c.alt;this.context = context;this.semanticContext = semanticContext;this.reachesIntoOuterContext = c.reachesIntoOuterContext;}

public ATNConfig(ATNConfig c, ATNState state,PredictionContext context,SemanticContext semanticContext){this.state = state;this.alt = c.alt;this.context = context;this.semanticContext = semanticContext;this.reachesIntoOuterContext = c.reachesIntoOuterContext;}

public void updateNamesAfterCellShift(FormulaShifter shifter) {for (int i = 0 ; i < getNumNames() ; ++i){NameRecord nr = getNameRecord(i);Ptg[] ptgs = nr.getNameDefinition();if (shifter.adjustFormula(ptgs, nr.getSheetNumber())) {nr.setNameDefinition(ptgs);}}}

public void UpdateNamesAfterCellShift(FormulaShifter shifter){for (int i = 0; i < NumNames; ++i){NameRecord nr = GetNameRecord(i);Ptg[] ptgs = nr.NameDefinition;if (shifter.AdjustFormula(ptgs, nr.SheetNumber)){nr.NameDefinition = ptgs;}}}

public ListReviewPolicyResultsForHITResult listReviewPolicyResultsForHIT(ListReviewPolicyResultsForHITRequest request) {request = beforeClientExecution(request);return executeListReviewPolicyResultsForHIT(request);}

public virtual ListReviewPolicyResultsForHITResponse ListReviewPolicyResultsForHIT(ListReviewPolicyResultsForHITRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListReviewPolicyResultsForHITRequestMarshaller.Instance;options.ResponseUnmarshaller = ListReviewPolicyResultsForHITResponseUnmarshaller.Instance;return Invoke<ListReviewPolicyResultsForHITResponse>(request, options);}

public GetExportResult getExport(GetExportRequest request) {request = beforeClientExecution(request);return executeGetExport(request);}

public virtual GetExportResponse GetExport(GetExportRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetExportRequestMarshaller.Instance;options.ResponseUnmarshaller = GetExportResponseUnmarshaller.Instance;return Invoke<GetExportResponse>(request, options);}

public void setHyperbolicTfFactors(float min, float max,double base, float xoffset) {tf_hyper_min = min;tf_hyper_max = max;tf_hyper_base = base;tf_hyper_xoffset = xoffset;}

public virtual void SetHyperbolicTfFactors(float min, float max, double @base, float xoffset){tf_hyper_min = min;tf_hyper_max = max;tf_hyper_base = @base;tf_hyper_xoffset = xoffset;}

public CharBuffer slice() {return new ReadWriteCharArrayBuffer(remaining(), backingArray, offset + position);}

public override java.nio.CharBuffer slice(){return new java.nio.ReadWriteCharArrayBuffer(remaining(), backingArray, offset +_position);}

public LexerNoViableAltException(Lexer lexer,CharStream input,int startIndex,ATNConfigSet deadEndConfigs) {super(lexer, input, null);this.startIndex = startIndex;this.deadEndConfigs = deadEndConfigs;}

public LexerNoViableAltException(Lexer lexer, ICharStream input, int startIndex, ATNConfigSet deadEndConfigs): base(lexer, input){this.startIndex = startIndex;this.deadEndConfigs = deadEndConfigs;}

public CreateCompilationJobResult createCompilationJob(CreateCompilationJobRequest request) {request = beforeClientExecution(request);return executeCreateCompilationJob(request);}

public virtual CreateCompilationJobResponse CreateCompilationJob(CreateCompilationJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateCompilationJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateCompilationJobResponseUnmarshaller.Instance;return Invoke<CreateCompilationJobResponse>(request, options);}

public int getPosition() {return position;}

public virtual int GetPosition(){return position;}

public boolean canEncode(CharSequence sequence) {CharBuffer cb;if (sequence instanceof CharBuffer) {cb = ((CharBuffer) sequence).duplicate();} else {cb = CharBuffer.wrap(sequence);}return implCanEncode(cb);}

public virtual bool canEncode(java.lang.CharSequence sequence){java.nio.CharBuffer cb;if (sequence is java.nio.CharBuffer){cb = ((java.nio.CharBuffer)sequence).duplicate();}else{cb = java.nio.CharBuffer.wrap(sequence);}return implCanEncode(cb);}

public synchronized void add(int index, E e) {Object[] newElements = new Object[elements.length + 1];System.arraycopy(elements, 0, newElements, 0, index);newElements[index] = e;System.arraycopy(elements, index, newElements, index + 1, elements.length - index);elements = newElements;}

public virtual void add(int index, E e){lock (this){object[] newElements = new object[elements.Length + 1];System.Array.Copy(elements, 0, newElements, 0, index);newElements[index] = e;System.Array.Copy(elements, index, newElements, index + 1, elements.Length - index);elements = newElements;}}