yijunyu/c-to-rust huggingface dataset:
// Original:
public TerminateWorkspacesResult terminateWorkspaces(TerminateWorkspacesRequest request) {request = beforeClientExecution(request);return executeTerminateWorkspaces(request);}

// Translation:
public virtual TerminateWorkspacesResponse TerminateWorkspaces(TerminateWorkspacesRequest request){var options = new InvokeOptions();options.RequestMarshaller = TerminateWorkspacesRequestMarshaller.Instance;options.ResponseUnmarshaller = TerminateWorkspacesResponseUnmarshaller.Instance;return Invoke<TerminateWorkspacesResponse>(request, options);}
// Original:
public long getEntryLastModified() {return current().getLastModified();}

// Translation:
public virtual long GetEntryLastModified(){return Current().GetLastModified();}
// Original:
public CancelConversionTaskResult cancelConversionTask(CancelConversionTaskRequest request) {request = beforeClientExecution(request);return executeCancelConversionTask(request);}

// Translation:
public virtual CancelConversionTaskResponse CancelConversionTask(CancelConversionTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = CancelConversionTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = CancelConversionTaskResponseUnmarshaller.Instance;return Invoke<CancelConversionTaskResponse>(request, options);}
// Original:
public InfoSubRecord(int streamPos, int bucketSstOffset) {field_1_stream_pos        = streamPos;field_2_bucket_sst_offset = bucketSstOffset;}

// Translation:
public InfoSubRecord(int streamPos, int bucketSstOffset){field_1_stream_pos = streamPos;field_2_bucket_sst_offset = bucketSstOffset;}
// Original:
public boolean contains(Object o) {return map.containsKey(o);}

// Translation:
public virtual bool Contains(char[] text){return map.ContainsKey(text, 0, text.Length);}
// Original:
public String toString() {return "'" + ch + "' @ " + pos;}

// Translation:
public override String ToString(){return "'" + ch + "' @ " + pos;}
// Original:
public Step(String name, Rule rules[], int min, String suffixes[]) {this.name = name;this.rules = rules;if (min == 0) {min = Integer.MAX_VALUE;for (Rule r : rules)min = Math.min(min, r.min + r.suffix.length);}this.min = min;if (suffixes == null || suffixes.length == 0) {this.suffixes = null;} else {this.suffixes = new char[suffixes.length][];for (int i = 0; i < suffixes.length; i++)this.suffixes[i] = suffixes[i].toCharArray();}}

// Translation:
public Step(string name, Rule[] rules, int min, string[] suffixes){this.m_name = name;this.m_rules = rules;if (min == 0){min = int.MaxValue;foreach (Rule r in rules){min = Math.Min(min, r.m_min + r.m_suffix.Length);}}this.m_min = min;if (suffixes == null || suffixes.Length == 0){this.m_suffixes = null;}else{this.m_suffixes = new char[suffixes.Length][];for (int i = 0; i < suffixes.Length; i++){this.m_suffixes[i] = suffixes[i].ToCharArray();}}}
// Original:
public E get(int key, E valueIfKeyNotFound) {int i = binarySearch(mKeys, 0, mSize, key);if (i < 0 || mValues[i] == DELETED) {return valueIfKeyNotFound;} else {return (E) mValues[i];}}

// Translation:
public virtual E get(int key, E valueIfKeyNotFound){int i = binarySearch(mKeys, 0, mSize, key);if (i < 0 || mValues[i] == DELETED){return valueIfKeyNotFound;}else{return (E)mValues[i];}}
// Original:
public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {if (args.length != 0) {return ErrorEval.VALUE_INVALID;}return evaluate(srcRowIndex, srcColumnIndex);}

// Translation:
public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){if (args.Length != 0){return ErrorEval.VALUE_INVALID;}return Evaluate(srcRowIndex, srcColumnIndex);}
// Original:
public void enterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence) {setState(state);_precedenceStack.push(precedence);_ctx = localctx;_ctx.start = _input.LT(1);if (_parseListeners != null) {triggerEnterRuleEvent(); }}

// Translation:
public virtual void EnterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence){State = state;_precedenceStack.Add(precedence);_ctx = localctx;_ctx.Start = _input.LT(1);if (_parseListeners != null){TriggerEnterRuleEvent();}}
// Original:
public GlobalReplicationGroup increaseNodeGroupsInGlobalReplicationGroup(IncreaseNodeGroupsInGlobalReplicationGroupRequest request) {request = beforeClientExecution(request);return executeIncreaseNodeGroupsInGlobalReplicationGroup(request);}

// Translation:
public virtual IncreaseNodeGroupsInGlobalReplicationGroupResponse IncreaseNodeGroupsInGlobalReplicationGroup(IncreaseNodeGroupsInGlobalReplicationGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = IncreaseNodeGroupsInGlobalReplicationGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = IncreaseNodeGroupsInGlobalReplicationGroupResponseUnmarshaller.Instance;return Invoke<IncreaseNodeGroupsInGlobalReplicationGroupResponse>(request, options);}
// Original:
public static String format(String rawSheetName) {StringBuilder sb = new StringBuilder((rawSheetName == null ? 0 : rawSheetName.length()) + 2);appendFormat(sb, rawSheetName);return sb.toString();}

// Translation:
public static String Format(String rawSheetName){StringBuilder sb = new StringBuilder(rawSheetName.Length + 2);AppendFormat(sb, rawSheetName);return sb.ToString();}
// Original:
public DescribeTerminationPolicyTypesResult describeTerminationPolicyTypes(DescribeTerminationPolicyTypesRequest request) {request = beforeClientExecution(request);return executeDescribeTerminationPolicyTypes(request);}

// Translation:
public virtual DescribeTerminationPolicyTypesResponse DescribeTerminationPolicyTypes(DescribeTerminationPolicyTypesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTerminationPolicyTypesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTerminationPolicyTypesResponseUnmarshaller.Instance;return Invoke<DescribeTerminationPolicyTypesResponse>(request, options);}
// Original:
public DescribeScheduledActionsResult describeScheduledActions() {return describeScheduledActions(new DescribeScheduledActionsRequest());}

// Translation:
public virtual DescribeScheduledActionsResponse DescribeScheduledActions(){return DescribeScheduledActions(new DescribeScheduledActionsRequest());}
// Original:
public boolean hasSourceData(int start, int end) {for (; start < end; start++)if (sourceLines[start] == 0)return false;return true;}

// Translation:
public virtual bool HasSourceData(int start, int end){for (; start < end; start++){if (sourceLines[start] == 0){return false;}}return true;}
// Original:
public ListImportsResult listImports(ListImportsRequest request) {request = beforeClientExecution(request);return executeListImports(request);}

// Translation:
public virtual ListImportsResponse ListImports(ListImportsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListImportsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListImportsResponseUnmarshaller.Instance;return Invoke<ListImportsResponse>(request, options);}
// Original:
public DescribeInterconnectsResult describeInterconnects() {return describeInterconnects(new DescribeInterconnectsRequest());}

// Translation:
public virtual DescribeInterconnectsResponse DescribeInterconnects(){return DescribeInterconnects(new DescribeInterconnectsRequest());}
// Original:
public DeleteEventSubscriptionResult deleteEventSubscription(DeleteEventSubscriptionRequest request) {request = beforeClientExecution(request);return executeDeleteEventSubscription(request);}

// Translation:
public virtual DeleteEventSubscriptionResponse DeleteEventSubscription(DeleteEventSubscriptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteEventSubscriptionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteEventSubscriptionResponseUnmarshaller.Instance;return Invoke<DeleteEventSubscriptionResponse>(request, options);}
// Original:
public int serialize( int offset, byte[] data, EscherSerializationListener listener ){listener.beforeRecordSerialize( offset, getRecordId(), this );LittleEndian.putShort(data, offset, getOptions());LittleEndian.putShort(data, offset+2, getRecordId());int remainingBytes = thedata.length;LittleEndian.putInt(data, offset+4, remainingBytes);System.arraycopy(thedata, 0, data, offset+8, thedata.length);int pos = offset+8+thedata.length;listener.afterRecordSerialize( pos, getRecordId(), pos - offset, this );int size = pos - offset;if (size != getRecordSize()) {throw new RecordFormatException(size + " bytes written but getRecordSize() reports " + getRecordSize());}return size;}

// Translation:
public override int Serialize(int offset, byte[] data, EscherSerializationListener listener){listener.BeforeRecordSerialize(offset, RecordId, this);LittleEndian.PutShort(data, offset, Options);LittleEndian.PutShort(data, offset + 2, RecordId);int remainingBytes = _thedata.Length;LittleEndian.PutInt(data, offset + 4, remainingBytes);Array.Copy(_thedata, 0, data, offset + 8, _thedata.Length);int pos = offset + 8 + _thedata.Length;listener.AfterRecordSerialize(pos, RecordId, pos - offset, this);int size = pos - offset;if (size != RecordSize)throw new RecordFormatException(size + " bytes written but RecordSize reports " + RecordSize);return size;}
// Original:
public void write(int oneChar) {synchronized (lock) {expand(1);buf[count++] = (char) oneChar;}}

// Translation:
public override void write(int oneChar){lock (@lock){expand(1);buf[count++] = (char)oneChar;}}
// Original:
public DeletedRef3DPtg(int externSheetIndex) {field_1_index_extern_sheet = externSheetIndex;unused1 = 0;}

// Translation:
public DeletedRef3DPtg(int externSheetIndex){field_1_index_extern_sheet = externSheetIndex;unused1 = 0;}
// Original:
public IndexUpgrader(Directory dir, IndexWriterConfig iwc, boolean deletePriorCommits) {this.dir = dir;this.iwc = iwc;this.deletePriorCommits = deletePriorCommits;}

// Translation:
public IndexUpgrader(Directory dir, IndexWriterConfig iwc, bool deletePriorCommits){this.dir = dir;this.iwc = iwc;this.deletePriorCommits = deletePriorCommits;}
// Original:
public DetachVpnGatewayRequest(String vpnGatewayId, String vpcId) {setVpnGatewayId(vpnGatewayId);setVpcId(vpcId);}

// Translation:
public DetachVpnGatewayRequest(string vpnGatewayId, string vpcId){_vpnGatewayId = vpnGatewayId;_vpcId = vpcId;}
// Original:
public RebootInstancesRequest(java.util.List<String> instanceIds) {setInstanceIds(instanceIds);}

// Translation:
public RebootInstancesRequest(List<string> instanceIds){_instanceIds = instanceIds;}
// Original:
public E remove(int index) {synchronized (mutex) {return delegate().remove(index);}}

// Translation:
public virtual E remove(int location){lock (mutex){return list.remove(location);}}
// Original:
public DescribeInstanceAttributeResult describeInstanceAttribute(DescribeInstanceAttributeRequest request) {request = beforeClientExecution(request);return executeDescribeInstanceAttribute(request);}

// Translation:
public virtual DescribeInstanceAttributeResponse DescribeInstanceAttribute(DescribeInstanceAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeInstanceAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeInstanceAttributeResponseUnmarshaller.Instance;return Invoke<DescribeInstanceAttributeResponse>(request, options);}
// Original:
public void cloneStyleFrom(CellStyle source) {if(source instanceof HSSFCellStyle) {this.cloneStyleFrom((HSSFCellStyle)source);} else {throw new IllegalArgumentException("Can only clone from one HSSFCellStyle to another, not between HSSFCellStyle and XSSFCellStyle");}}

// Translation:
public void CloneStyleFrom(ICellStyle source){if (source is HSSFCellStyle){this.CloneStyleFrom((HSSFCellStyle)source);}else{throw new ArgumentException("Can only clone from one HSSFCellStyle to another, not between HSSFCellStyle and XSSFCellStyle");}}
// Original:
public final String readUTF() throws IOException {return decodeUTF(readUnsignedShort());}

// Translation:
public virtual string readUTF(){throw new System.NotImplementedException();}
// Original:
public GetDataEndpointResult getDataEndpoint(GetDataEndpointRequest request) {request = beforeClientExecution(request);return executeGetDataEndpoint(request);}

// Translation:
public virtual GetDataEndpointResponse GetDataEndpoint(GetDataEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDataEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDataEndpointResponseUnmarshaller.Instance;return Invoke<GetDataEndpointResponse>(request, options);}
// Original:
public AddApplicationOutputResult addApplicationOutput(AddApplicationOutputRequest request) {request = beforeClientExecution(request);return executeAddApplicationOutput(request);}

// Translation:
public virtual AddApplicationOutputResponse AddApplicationOutput(AddApplicationOutputRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddApplicationOutputRequestMarshaller.Instance;options.ResponseUnmarshaller = AddApplicationOutputResponseUnmarshaller.Instance;return Invoke<AddApplicationOutputResponse>(request, options);}
// Original:
public LargeObjectException(AnyObjectId id) {setObjectId(id);}

// Translation:
public LargeObjectException(AnyObjectId id){SetObjectId(id);}
// Original:
public void trimToSize() {if (n < array.length) {char[] aux = new char[n];System.arraycopy(array, 0, aux, 0, n);array = aux;}}

// Translation:
public virtual void TrimToSize(){if (n < array.Length){char[] aux = new char[n];System.Array.Copy(array, 0, aux, 0, n);array = aux;}}
// Original:
public UpdateFacetResult updateFacet(UpdateFacetRequest request) {request = beforeClientExecution(request);return executeUpdateFacet(request);}

// Translation:
public virtual UpdateFacetResponse UpdateFacet(UpdateFacetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateFacetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateFacetResponseUnmarshaller.Instance;return Invoke<UpdateFacetResponse>(request, options);}
// Original:
public DeleteDomainRequest(String domainName) {setDomainName(domainName);}

// Translation:
public DeleteDomainRequest(string domainName){_domainName = domainName;}
// Original:
public String getReading() {return dictionary.getReading(wordId, surfaceForm, offset, length);}

// Translation:
public virtual string GetReading(){return dictionary.GetReading(wordId, surfaceForm, offset, length);}
// Original:
public FloatBuffer compact() {System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());position = limit - position;limit = capacity;mark = UNSET_MARK;return this;}

// Translation:
public override java.nio.FloatBuffer compact(){System.Array.Copy(backingArray, _position + offset, backingArray, offset, remaining());_position = _limit - _position;_limit = _capacity;_mark = UNSET_MARK;return this;}
// Original:
public String toString() {return super.toString();}

// Translation:
public override string ToString(){return base.ToString();}
// Original:
public void set(int index, long value) {ensureCapacity(value);current.set(index, value);}

// Translation:
public override void Set(int index, long value){EnsureCapacity(value);current.Set(index, value);}
// Original:
public void serialize(LittleEndianOutput out) {String username = getUsername();boolean is16bit = StringUtil.hasMultibyte(username);out.writeShort(username.length());out.writeByte(is16bit ? 0x01 : 0x00);if (is16bit) {StringUtil.putUnicodeLE(username, out);} else {StringUtil.putCompressedUnicode(username, out);}int encodedByteCount = 3 + username.length() * (is16bit ? 2 : 1);int paddingSize = DATA_SIZE - encodedByteCount;out.write(PADDING, 0, paddingSize);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){String username = Username;bool is16bit = StringUtil.HasMultibyte(username);out1.WriteShort(username.Length);out1.WriteByte(is16bit ? 0x01 : 0x00);if (is16bit){StringUtil.PutUnicodeLE(username, out1);}else{StringUtil.PutCompressedUnicode(username, out1);}int encodedByteCount = 3 + username.Length * (is16bit ? 2 : 1);int paddingSize = DATA_SIZE - encodedByteCount;out1.Write(PADDING, 0, paddingSize);}
// Original:
public boolean isExpired() {return false;}

// Translation:
public new bool IsExpired(){return false;}
// Original:
public ListJobsRequest(String accountId, String vaultName) {setAccountId(accountId);setVaultName(vaultName);}

// Translation:
public ListJobsRequest(string accountId, string vaultName){_accountId = accountId;_vaultName = vaultName;}
// Original:
public SheetRefEvaluator getSheetEvaluator(int sheetIndex) {if (sheetIndex < _firstSheetIndex || sheetIndex > _lastSheetIndex) {throw new IllegalArgumentException("Invalid SheetIndex: " + sheetIndex +" - Outside range " + _firstSheetIndex + " : " + _lastSheetIndex);}return _sheetEvaluators[sheetIndex-_firstSheetIndex];}

// Translation:
public SheetRefEvaluator GetSheetEvaluator(int sheetIndex){if (sheetIndex < _firstSheetIndex || sheetIndex > _lastSheetIndex){throw new ArgumentException("Invalid SheetIndex: " + sheetIndex +" - Outside range " + _firstSheetIndex + " : " + _lastSheetIndex);}return _sheetEvaluators[sheetIndex - _firstSheetIndex];}
// Original:
public static String[] stringToPath(String s) {List<String> parts = new ArrayList<>();int length = s.length();if (length == 0) {return new String[0];}char[] buffer = new char[length];int upto = 0;boolean lastEscape = false;for(int i=0;i<length;i++) {char ch = s.charAt(i);if (lastEscape) {buffer[upto++] = ch;lastEscape = false;} else if (ch == ESCAPE_CHAR) {lastEscape = true;} else if (ch == DELIM_CHAR) {parts.add(new String(buffer, 0, upto));upto = 0;} else {buffer[upto++] = ch;}}parts.add(new String(buffer, 0, upto));assert !lastEscape;return parts.toArray(new String[parts.size()]);}

// Translation:
public static string[] StringToPath(string s){IList<string> parts = new List<string>();int length = s.Length;if (length == 0){return new string[0];}char[] buffer = new char[length];int upto = 0;bool lastEscape = false;for (int i = 0; i < length; i++){char ch = s[i];if (lastEscape){buffer[upto++] = ch;lastEscape = false;}else if (ch == ESCAPE_CHAR){lastEscape = true;}else if (ch == DELIM_CHAR){parts.Add(new string(buffer, 0, upto));upto = 0;}else{buffer[upto++] = ch;}}parts.Add(new string(buffer, 0, upto));Debug.Assert(!lastEscape);return parts.ToArray();}
// Original:
public CreateDirectConnectGatewayResult createDirectConnectGateway(CreateDirectConnectGatewayRequest request) {request = beforeClientExecution(request);return executeCreateDirectConnectGateway(request);}

// Translation:
public virtual CreateDirectConnectGatewayResponse CreateDirectConnectGateway(CreateDirectConnectGatewayRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDirectConnectGatewayRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDirectConnectGatewayResponseUnmarshaller.Instance;return Invoke<CreateDirectConnectGatewayResponse>(request, options);}
// Original:
public GetMLModelResult getMLModel(GetMLModelRequest request) {request = beforeClientExecution(request);return executeGetMLModel(request);}

// Translation:
public virtual GetMLModelResponse GetMLModel(GetMLModelRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetMLModelRequestMarshaller.Instance;options.ResponseUnmarshaller = GetMLModelResponseUnmarshaller.Instance;return Invoke<GetMLModelResponse>(request, options);}
// Original:
public boolean isValid() {if (bytes == null) {throw new IllegalStateException("bytes is null");}if (length < 0) {throw new IllegalStateException("length is negative: " + length);}if (length > bytes.length) {throw new IllegalStateException("length is out of bounds: " + length + ",bytes.length=" + bytes.length);}if (offset < 0) {throw new IllegalStateException("offset is negative: " + offset);}if (offset > bytes.length) {throw new IllegalStateException("offset out of bounds: " + offset + ",bytes.length=" + bytes.length);}if (offset + length < 0) {throw new IllegalStateException("offset+length is negative: offset=" + offset + ",length=" + length);}if (offset + length > bytes.length) {throw new IllegalStateException("offset+length out of bounds: offset=" + offset + ",length=" + length + ",bytes.length=" + bytes.length);}return true;}

// Translation:
public bool IsValid(){if (Bytes == null){throw new InvalidOperationException("bytes is null");}if (Length < 0){throw new InvalidOperationException("length is negative: " + Length);}if (Length > Bytes.Length){throw new InvalidOperationException("length is out of bounds: " + Length + ",bytes.length=" + Bytes.Length);}if (Offset < 0){throw new InvalidOperationException("offset is negative: " + Offset);}if (Offset > Bytes.Length){throw new InvalidOperationException("offset out of bounds: " + Offset + ",bytes.length=" + Bytes.Length);}if (Offset + Length < 0){throw new InvalidOperationException("offset+length is negative: offset=" + Offset + ",length=" + Length);}if (Offset + Length > Bytes.Length){throw new InvalidOperationException("offset+length out of bounds: offset=" + Offset + ",length=" + Length + ",bytes.length=" + Bytes.Length);}return true;}
// Original:
public String toString() {return getName();}

// Translation:
public override string ToString(){return Name;}
// Original:
public DescribeIAMPolicyAssignmentResult describeIAMPolicyAssignment(DescribeIAMPolicyAssignmentRequest request) {request = beforeClientExecution(request);return executeDescribeIAMPolicyAssignment(request);}

// Translation:
public virtual DescribeIAMPolicyAssignmentResponse DescribeIAMPolicyAssignment(DescribeIAMPolicyAssignmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIAMPolicyAssignmentRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIAMPolicyAssignmentResponseUnmarshaller.Instance;return Invoke<DescribeIAMPolicyAssignmentResponse>(request, options);}
// Original:
public boolean isRefLogIncludingResult() {return refLogIncludeResult;}

// Translation:
protected internal virtual bool IsRefLogIncludingResult(){return refLogIncludeResult;}
// Original:
public DeleteStreamingDistributionResult deleteStreamingDistribution(DeleteStreamingDistributionRequest request) {request = beforeClientExecution(request);return executeDeleteStreamingDistribution(request);}

// Translation:
public virtual DeleteStreamingDistributionResponse DeleteStreamingDistribution(DeleteStreamingDistributionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteStreamingDistributionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteStreamingDistributionResponseUnmarshaller.Instance;return Invoke<DeleteStreamingDistributionResponse>(request, options);}
// Original:
public RawSubStringPattern(String patternText) {if (patternText.length() == 0)throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString);needleString = patternText;final byte[] b = Constants.encode(patternText);needle = new byte[b.length];for (int i = 0; i < b.length; i++)needle[i] = lc(b[i]);}

// Translation:
public RawSubStringPattern(string patternText){if (patternText.Length == 0){throw new ArgumentException(JGitText.Get().cannotMatchOnEmptyString);}needleString = patternText;byte[] b = Constants.Encode(patternText);needle = new byte[b.Length];for (int i = 0; i < b.Length; i++){needle[i] = Lc(b[i]);}}
// Original:
public ListRulesResult listRules(ListRulesRequest request) {request = beforeClientExecution(request);return executeListRules(request);}

// Translation:
public virtual ListRulesResponse ListRules(ListRulesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListRulesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListRulesResponseUnmarshaller.Instance;return Invoke<ListRulesResponse>(request, options);}
// Original:
@Override public Iterator<Entry<K, V>> iterator() {final Iterator<Entry<K, V>> iterator = esDelegate.iterator();return new Iterator<Entry<K, V>>() {Entry<K, V> entry;

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