yijunyu/c-to-rust huggingface dataset:
// Original:
public PathFilter clone() {return this;}

// Translation:
public override TreeFilter Clone(){return this;}
// Original:
public String toString() {if (isEmpty()) {return "[]";}StringBuilder buffer = new StringBuilder(size() * 16);buffer.append('[');Iterator<?> it = iterator();while (it.hasNext()) {Object next = it.next();if (next != this) {buffer.append(next);} else {buffer.append("(this Collection)");}if (it.hasNext()) {buffer.append(", ");}}buffer.append(']');return buffer.toString();}

// Translation:
public override string ToString(){if (isEmpty()){return "[]";}java.lang.StringBuilder buffer = new java.lang.StringBuilder(size() * 16);buffer.append('[');java.util.Iterator<E> it = iterator();while (it.hasNext()){object next = it.next();if (next != this){buffer.append(next);}else{buffer.append("(this Collection)");}if (it.hasNext()){buffer.append(", ");}}buffer.append(']');return buffer.ToString();}
// Original:
public synchronized void close() throws IOException {buffer = null;notifyAll();}

// Translation:
public override void close(){throw new System.NotImplementedException();}
// Original:
public String toString() {return "ShardIter(shard=" + shardIndex + ")";}

// Translation:
public override string ToString(){return "ShardIter(shard=" + shardIndex + ")";}
// Original:
public JobParameters(String format, String type, String archiveId, String description) {setFormat(format);setType(type);setArchiveId(archiveId);setDescription(description);}

// Translation:
public JobParameters(string format, string type, string archiveId, string description){_format = format;_type = type;_archiveId = archiveId;_description = description;}
// Original:
public IntBuffer get(int[] dst) {return get(dst, 0, dst.length);}

// Translation:
public virtual java.nio.IntBuffer get(int[] dst){return get(dst, 0, dst.Length);}
// Original:
public SupBookRecord(String url, String[] sheetNames) {field_1_number_of_sheets = (short) sheetNames.length;field_2_encoded_url = url;field_3_sheet_names = sheetNames;_isAddInFunctions = false;}

// Translation:
public SupBookRecord(String url, String[] sheetNames){field_1_number_of_sheets = (short)sheetNames.Length;field_2_encoded_url = url;field_3_sheet_names = sheetNames;_isAddInFunctions = false;}
// Original:
public SeriesLabelsRecord(RecordInputStream in) {field_1_formatFlags = in.readShort();}

// Translation:
public SeriesLabelsRecord(RecordInputStream in1){field_1_formatFlags = in1.ReadShort();}
// Original:
public DescribeAssessmentRunsResult describeAssessmentRuns(DescribeAssessmentRunsRequest request) {request = beforeClientExecution(request);return executeDescribeAssessmentRuns(request);}

// Translation:
public virtual DescribeAssessmentRunsResponse DescribeAssessmentRuns(DescribeAssessmentRunsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAssessmentRunsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAssessmentRunsResponseUnmarshaller.Instance;return Invoke<DescribeAssessmentRunsResponse>(request, options);}
// Original:
public DescribeClassicLinkInstancesResult describeClassicLinkInstances(DescribeClassicLinkInstancesRequest request) {request = beforeClientExecution(request);return executeDescribeClassicLinkInstances(request);}

// Translation:
public virtual DescribeClassicLinkInstancesResponse DescribeClassicLinkInstances(DescribeClassicLinkInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClassicLinkInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClassicLinkInstancesResponseUnmarshaller.Instance;return Invoke<DescribeClassicLinkInstancesResponse>(request, options);}
// Original:
public byte[] getByteBlock() {return new byte[blockSize];}

// Translation:
public virtual byte[] GetByteBlock(){return new byte[m_blockSize];}
// Original:
public SeriesIndexRecord clone() {return copy();}

// Translation:
public override Object Clone(){SeriesIndexRecord rec = new SeriesIndexRecord();rec.field_1_index = field_1_index;return rec;}
// Original:
public RegisterToWorkMailResult registerToWorkMail(RegisterToWorkMailRequest request) {request = beforeClientExecution(request);return executeRegisterToWorkMail(request);}

// Translation:
public virtual RegisterToWorkMailResponse RegisterToWorkMail(RegisterToWorkMailRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterToWorkMailRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterToWorkMailResponseUnmarshaller.Instance;return Invoke<RegisterToWorkMailResponse>(request, options);}
// Original:
public DeleteCollectionRequest() {super("cr", "2016-06-07", "DeleteCollection", "cr");setUriPattern("/collections/[CollectionId]");setMethod(MethodType.DELETE);}

// Translation:
public DeleteCollectionRequest(): base("cr", "2016-06-07", "DeleteCollection", "cr", "openAPI"){UriPattern = "/collections/[CollectionId]";Method = MethodType.DELETE;}
// Original:
public Cluster deleteCluster(DeleteClusterRequest request) {request = beforeClientExecution(request);return executeDeleteCluster(request);}

// Translation:
public virtual DeleteClusterResponse DeleteCluster(DeleteClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance;return Invoke<DeleteClusterResponse>(request, options);}
// Original:
public static double tanh(double d) {double ePowX = Math.pow(Math.E, d);double ePowNegX = Math.pow(Math.E, -d);return (ePowX - ePowNegX) / (ePowX + ePowNegX);}

// Translation:
public static double Tanh(double d){double ePowX = Math.Pow(Math.E, d);double ePowNegX = Math.Pow(Math.E, -d);d = (ePowX - ePowNegX) / (ePowX + ePowNegX);return d;}
// Original:
public CharsRef common(CharsRef output1, CharsRef output2) {assert output1 != null;assert output2 != null;int pos1 = output1.offset;int pos2 = output2.offset;int stopAt1 = pos1 + Math.min(output1.length, output2.length);while(pos1 < stopAt1) {if (output1.chars[pos1] != output2.chars[pos2]) {break;}pos1++;pos2++;}if (pos1 == output1.offset) {return NO_OUTPUT;} else if (pos1 == output1.offset + output1.length) {return output1;} else if (pos2 == output2.offset + output2.length) {return output2;} else {return new CharsRef(output1.chars, output1.offset, pos1-output1.offset);}}

// Translation:
public override CharsRef Common(CharsRef output1, CharsRef output2){Debug.Assert(output1 != null);Debug.Assert(output2 != null);int pos1 = output1.Offset;int pos2 = output2.Offset;int stopAt1 = pos1 + Math.Min(output1.Length, output2.Length);while (pos1 < stopAt1){if (output1.Chars[pos1] != output2.Chars[pos2]){break;}pos1++;pos2++;}if (pos1 == output1.Offset){return NO_OUTPUT;}else if (pos1 == output1.Offset + output1.Length){return output1;}else if (pos2 == output2.Offset + output2.Length){return output2;}else{return new CharsRef(output1.Chars, output1.Offset, pos1 - output1.Offset);}}
// Original:
public GetExclusionsPreviewResult getExclusionsPreview(GetExclusionsPreviewRequest request) {request = beforeClientExecution(request);return executeGetExclusionsPreview(request);}

// Translation:
public virtual GetExclusionsPreviewResponse GetExclusionsPreview(GetExclusionsPreviewRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetExclusionsPreviewRequestMarshaller.Instance;options.ResponseUnmarshaller = GetExclusionsPreviewResponseUnmarshaller.Instance;return Invoke<GetExclusionsPreviewResponse>(request, options);}
// Original:
public KeepWordFilterFactory(Map<String,String> args) {super(args);wordFiles = get(args, "words");ignoreCase = getBoolean(args, "ignoreCase", false);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public KeepWordFilterFactory(IDictionary<string, string> args): base(args){AssureMatchVersion();wordFiles = Get(args, "words");ignoreCase = GetBoolean(args, "ignoreCase", false);enablePositionIncrements = GetBoolean(args, "enablePositionIncrements", true);if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public int uniformCmd(boolean eqSkip) {Iterator<Cell> i = cells.values().iterator();int ret = -1;uniformCnt = 1;uniformSkip = 0;for (; i.hasNext();) {Cell c = i.next();if (c.ref >= 0) {return -1;}if (c.cmd >= 0) {if (ret < 0) {ret = c.cmd;uniformSkip = c.skip;} else if (ret == c.cmd) {if (eqSkip) {if (uniformSkip == c.skip) {uniformCnt++;} else {return -1;}} else {uniformCnt++;}} else {return -1;}}}return ret;}

// Translation:
public int UniformCmd(bool eqSkip){int ret = -1;uniformCnt = 1;uniformSkip = 0;foreach (Cell c in cells.Values){if (c.@ref >= 0){return -1;}if (c.cmd >= 0){if (ret < 0){ret = c.cmd;uniformSkip = c.skip;}else if (ret == c.cmd){if (eqSkip){if (uniformSkip == c.skip){uniformCnt++;}else{return -1;}}else{uniformCnt++;}}else{return -1;}}}return ret;}
// Original:
public ListTypedLinkFacetNamesResult listTypedLinkFacetNames(ListTypedLinkFacetNamesRequest request) {request = beforeClientExecution(request);return executeListTypedLinkFacetNames(request);}

// Translation:
public virtual ListTypedLinkFacetNamesResponse ListTypedLinkFacetNames(ListTypedLinkFacetNamesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTypedLinkFacetNamesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTypedLinkFacetNamesResponseUnmarshaller.Instance;return Invoke<ListTypedLinkFacetNamesResponse>(request, options);}
// Original:
public T remove(int index) {if (index == size - 1) {T[] blockRef = directory[toDirectoryIndex(index)];int blockIdx = toBlockIndex(index);T old = blockRef[blockIdx];blockRef[blockIdx] = null;size--;if (0 < tailBlkIdx)tailBlkIdx--;elseresetTailBlock();return old;} else if (index < 0 || size <= index) {throw new IndexOutOfBoundsException(String.valueOf(index));} else {T old = get(index);for (; index < size - 1; index++)set(index, get(index + 1));set(size - 1, null);size--;resetTailBlock();return old;}}

// Translation:
public override T Remove(int index){if (index == size - 1){T[] blockRef = directory[ToDirectoryIndex(index)];int blockIdx = ToBlockIndex(index);T old = blockRef[blockIdx];blockRef[blockIdx] = default(T);size--;if (0 < tailBlkIdx){tailBlkIdx--;}else{ResetTailBlock();}return old;}else{if (index < 0 || size <= index){throw new IndexOutOfRangeException(index.ToString());}else{T old = this[index];for (; index < size - 1; index++){Set(index, this[index + 1]);}Set(size - 1, default(T));size--;ResetTailBlock();return old;}}}
// Original:
public boolean willSoonExpire() {long now = System.currentTimeMillis();return this.roleSessionDurationSeconds * (1 - expireFact) > (expiration - now) / 1000;}

// Translation:
public override bool WillSoonExpire(){return roleSessionDurationSeconds * (1 - expireFact) * 1000 * 1000 * 10 > RemainTicks();}
// Original:
public GroupingSearch setSortWithinGroup(Sort sortWithinGroup) {this.sortWithinGroup = sortWithinGroup;return this;}

// Translation:
public virtual GroupingSearch SetSortWithinGroup(Sort sortWithinGroup){this.sortWithinGroup = sortWithinGroup;return this;}
// Original:
public long ramBytesUsed() {return BASE_RAM_BYTES_USED +((postings!=null) ? RamUsageEstimator.sizeOf(postings) : 0) +((payloads!=null) ? RamUsageEstimator.sizeOf(payloads) : 0);}

// Translation:
public override long RamBytesUsed(){return ((postings != null) ? RamUsageEstimator.SizeOf(postings) : 0) +((payloads != null) ? RamUsageEstimator.SizeOf(payloads) : 0);}
// Original:
public void seek(long pos) throws IOException {final long curFP = getFilePointer();final long skip = pos - curFP;if (skip < 0) {throw new IllegalStateException(getClass() + " cannot seek backwards (pos=" + pos + " getFilePointer()=" + curFP + ")");}skipBytes(skip);}

// Translation:
public override void Seek(long pos){long skip = pos - GetFilePointer();if (skip < 0){throw new InvalidOperationException(this.GetType() + " cannot seek backwards");}SkipBytes(skip);}
// Original:
public ExternalName getExternalName(int externSheetIndex, int externNameIndex) {return _iBook.getExternalName(externSheetIndex, externNameIndex);}

// Translation:
public ExternalName GetExternalName(int externSheetIndex, int externNameIndex){return _iBook.GetExternalName(externSheetIndex, externNameIndex);}
// Original:
public StrDocValues(ValueSource vs) {this.vs = vs;}

// Translation:
public StrDocValues(ValueSource vs){this.m_vs = vs;}
// Original:
public int getFunctionIndex(String name) {return name.hashCode();}

// Translation:
public int GetFunctionIndex(String name){return name.GetHashCode();}
// Original:
public int hash2(char c) {int hash = 5381;hash = ((hash << 5) + hash) + c & 0x00FF;hash = ((hash << 5) + hash) + c >> 8;return hash;}

// Translation:
public virtual int Hash2(char c){int hash = 5381;hash = ((hash << 5) + hash) + c & 0x00FF;hash = ((hash << 5) + hash) + c >> 8;return hash;}
// Original:
public void create(String id, String title, String time, String body) throws IOException {Path d = directory(count++, null);Files.createDirectories(d);Path f = d.resolve(id + ".txt");StringBuilder contents = new StringBuilder();contents.append(time);contents.append("\n\n");contents.append(title);contents.append("\n\n");contents.append(body);contents.append("\n");try (Writer writer = Files.newBufferedWriter(f, StandardCharsets.UTF_8)) {writer.write(contents.toString());}}

// Translation:
public virtual void Create(string id, string title, string time, string body){DirectoryInfo d = Directory(count++, null);d.Create();FileInfo f = new FileInfo(System.IO.Path.Combine(d.FullName, id + ".txt"));StringBuilder contents = new StringBuilder();contents.Append(time);contents.Append("\n\n");contents.Append(title);contents.Append("\n\n");contents.Append(body);contents.Append("\n");try{using (TextWriter writer = new StreamWriter(new FileStream(f.FullName, FileMode.Create, FileAccess.Write), Encoding.UTF8))writer.Write(contents.ToString());}catch (IOException ioe){throw new Exception(ioe.ToString(), ioe);}}
// Original:
public CharArrayWriter append(CharSequence csq) {if (csq == null) {csq = "null";}append(csq, 0, csq.length());return this;}

// Translation:
public override java.io.Writer append(java.lang.CharSequence csq){if (csq == null){csq = java.lang.CharSequenceProxy.Wrap("null");}append(csq, 0, csq.Length);return this;}
// Original:
public PutAccountDedicatedIpWarmupAttributesResult putAccountDedicatedIpWarmupAttributes(PutAccountDedicatedIpWarmupAttributesRequest request) {request = beforeClientExecution(request);return executePutAccountDedicatedIpWarmupAttributes(request);}

// Translation:
public virtual PutAccountDedicatedIpWarmupAttributesResponse PutAccountDedicatedIpWarmupAttributes(PutAccountDedicatedIpWarmupAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutAccountDedicatedIpWarmupAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = PutAccountDedicatedIpWarmupAttributesResponseUnmarshaller.Instance;return Invoke<PutAccountDedicatedIpWarmupAttributesResponse>(request, options);}
// Original:
public static boolean equal(Object a, Object b) {return a == b || (a != null && a.equals(b));}

// Translation:
public static bool equal(object a, object b){return a == b || (a != null && a.Equals(b));}
// Original:
public RevFlag getUnshallowFlag() {return UNSHALLOW;}

// Translation:
public RevFlag GetUnshallowFlag(){return UNSHALLOW;}
// Original:
public DescribeSolutionVersionResult describeSolutionVersion(DescribeSolutionVersionRequest request) {request = beforeClientExecution(request);return executeDescribeSolutionVersion(request);}

// Translation:
public virtual DescribeSolutionVersionResponse DescribeSolutionVersion(DescribeSolutionVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeSolutionVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeSolutionVersionResponseUnmarshaller.Instance;return Invoke<DescribeSolutionVersionResponse>(request, options);}
// Original:
public byte[] getBuffer() {return file.buf;}

// Translation:
public virtual byte[] GetBuffer(){return file.buf;}
// Original:
public String toString() {StringBuilder buffer = new StringBuilder();buffer.append("[WRITEACCESS]\n");buffer.append("    .name = ").append(field_1_username).append("\n");buffer.append("[/WRITEACCESS]\n");return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[WriteACCESS]\n");buffer.Append("    .name            = ").Append(field_1_username).Append("\n");buffer.Append("[/WriteACCESS]\n");return buffer.ToString();}
// Original:
public ModifyFpgaImageAttributeResult modifyFpgaImageAttribute(ModifyFpgaImageAttributeRequest request) {request = beforeClientExecution(request);return executeModifyFpgaImageAttribute(request);}

// Translation:
public virtual ModifyFpgaImageAttributeResponse ModifyFpgaImageAttribute(ModifyFpgaImageAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyFpgaImageAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyFpgaImageAttributeResponseUnmarshaller.Instance;return Invoke<ModifyFpgaImageAttributeResponse>(request, options);}
// Original:
public SubmoduleUpdateCommand(Repository repo) {super(repo);paths = new ArrayList<>();}

// Translation:
protected internal SubmoduleUpdateCommand(Repository repo) : base(repo){paths = new AList<string>();}
// Original:
public boolean isKnown() {return type == Type.KNOWN;}

// Translation:
public virtual bool IsKnown(){return type == JapaneseTokenizerType.KNOWN;}
// Original:
public long get(int index) {final int o = index / 10;final int b = index % 10;final int shift = b * 6;return (blocks[o] >>> shift) & 63L;}

// Translation:
public override long Get(int index){int o = index / 10;int b = index % 10;int shift = b * 6;return ((long)((ulong)blocks[o] >> shift)) & 63L;}
// Original:
public void setValue(byte value) {setValue(FormulaError.forInt(value));}

// Translation:
public void SetValue(bool value){_value = value ? 1 : 0;_isError = false;}
// Original:
public int getCodePoint() {return c;}

// Translation:
public virtual int getCodePoint(){return c;}
// Original:
public GetDocumentationVersionsResult getDocumentationVersions(GetDocumentationVersionsRequest request) {request = beforeClientExecution(request);return executeGetDocumentationVersions(request);}

// Translation:
public virtual GetDocumentationVersionsResponse GetDocumentationVersions(GetDocumentationVersionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDocumentationVersionsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDocumentationVersionsResponseUnmarshaller.Instance;return Invoke<GetDocumentationVersionsResponse>(request, options);}
// Original:
public int indexOfKey(int key) {if (mGarbage) {gc();}return binarySearch(mKeys, 0, mSize, key);}

// Translation:
public virtual int indexOfKey(int key){if (mGarbage){gc();}return binarySearch(mKeys, 0, mSize, key);}
// Original:
public void reportError(Parser recognizer,RecognitionException e){if (inErrorRecoveryMode(recognizer)) {return; }beginErrorCondition(recognizer);if ( e instanceof NoViableAltException ) {reportNoViableAlternative(recognizer, (NoViableAltException) e);}else if ( e instanceof InputMismatchException ) {reportInputMismatch(recognizer, (InputMismatchException)e);}else if ( e instanceof FailedPredicateException ) {reportFailedPredicate(recognizer, (FailedPredicateException)e);}else {System.err.println("unknown recognition error type: "+e.getClass().getName());recognizer.notifyErrorListeners(e.getOffendingToken(), e.getMessage(), e);}}

// Translation:
public virtual void ReportError(Parser recognizer, RecognitionException e){if (InErrorRecoveryMode(recognizer)){return;}BeginErrorCondition(recognizer);if (e is NoViableAltException){ReportNoViableAlternative(recognizer, (NoViableAltException)e);}else{if (e is InputMismatchException){ReportInputMismatch(recognizer, (InputMismatchException)e);}else{if (e is FailedPredicateException){ReportFailedPredicate(recognizer, (FailedPredicateException)e);}else{#if !PORTABLESystem.Console.Error.WriteLine("unknown recognition error type: " + e.GetType().FullName);#endifNotifyErrorListeners(recognizer, e.Message, e);}}}}
// Original:
public ConstantStringFormat(String s) {str = s;}

// Translation:
public ConstantStringFormat(String s){str = s;}
// Original:
public DoubleBuffer asReadOnlyBuffer() {return ReadOnlyDoubleArrayBuffer.copy(this, mark);}

// Translation:
public override java.nio.DoubleBuffer asReadOnlyBuffer(){return java.nio.ReadOnlyDoubleArrayBuffer.copy(this, _mark);}
// Original:
public CacheCluster deleteCacheCluster(DeleteCacheClusterRequest request) {request = beforeClientExecution(request);return executeDeleteCacheCluster(request);}

// Translation:
public virtual DeleteCacheClusterResponse DeleteCacheCluster(DeleteCacheClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteCacheClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteCacheClusterResponseUnmarshaller.Instance;return Invoke<DeleteCacheClusterResponse>(request, options);}
// Original:
public ModifyClusterSnapshotScheduleResult modifyClusterSnapshotSchedule(ModifyClusterSnapshotScheduleRequest request) {request = beforeClientExecution(request);return executeModifyClusterSnapshotSchedule(request);}

// Translation:
public virtual ModifyClusterSnapshotScheduleResponse ModifyClusterSnapshotSchedule(ModifyClusterSnapshotScheduleRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyClusterSnapshotScheduleRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyClusterSnapshotScheduleResponseUnmarshaller.Instance;return Invoke<ModifyClusterSnapshotScheduleResponse>(request, options);}
// Original:
public InitCommand setBare(boolean bare) {validateDirs(directory, gitDir, bare);this.bare = bare;return this;}

// Translation:
public virtual InitCommand SetBare(bool bare){this.bare = bare;return this;}
// Original:
public TermsEnumWithSlice(int index, ReaderSlice subSlice) {this.subSlice = subSlice;this.index = index;assert subSlice.length >= 0: "length=" + subSlice.length;}

// Translation:
public TermsEnumWithSlice(int index, ReaderSlice subSlice){this.SubSlice = subSlice;this.Index = index;Debug.Assert(subSlice.Length >= 0, "length=" + subSlice.Length);}
// Original:
public UserSViewEnd(byte[] data) {_rawData = data;}

// Translation:
public UserSViewEnd(byte[] data){_rawData = data;}
// Original:
public SetIdentityPoolRolesResult setIdentityPoolRoles(SetIdentityPoolRolesRequest request) {request = beforeClientExecution(request);return executeSetIdentityPoolRoles(request);}

// Translation:
public virtual SetIdentityPoolRolesResponse SetIdentityPoolRoles(SetIdentityPoolRolesRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetIdentityPoolRolesRequestMarshaller.Instance;options.ResponseUnmarshaller = SetIdentityPoolRolesResponseUnmarshaller.Instance;return Invoke<SetIdentityPoolRolesResponse>(request, options);}
// Original:
public Vector( short type ) {this._type = type;}

// Translation:
public Vector(short type){this._type = type;}
// Original:
public GetEndpointResult getEndpoint(GetEndpointRequest request) {request = beforeClientExecution(request);return executeGetEndpoint(request);}

// Translation:
public virtual GetEndpointResponse GetEndpoint(GetEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEndpointResponseUnmarshaller.Instance;return Invoke<GetEndpointResponse>(request, options);}