yijunyu/c-to-rust huggingface dataset:
// Original:
public int getRate() {return (perMin ? rate : 60*rate);}

// Translation:
public virtual int GetRate(){return (perMin ? rate : 60 * rate);}
// Original:
public DescribeDBParametersRequest(String dBParameterGroupName) {setDBParameterGroupName(dBParameterGroupName);}

// Translation:
public DescribeDBParametersRequest(string dbParameterGroupName){_dbParameterGroupName = dbParameterGroupName;}
// Original:
public DeleteNodeResult deleteNode(DeleteNodeRequest request) {request = beforeClientExecution(request);return executeDeleteNode(request);}

// Translation:
public virtual DeleteNodeResponse DeleteNode(DeleteNodeRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteNodeRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteNodeResponseUnmarshaller.Instance;return Invoke<DeleteNodeResponse>(request, options);}
// Original:
@Override public List<E> subList(int from, int to) {Slice slice = this.slice;if (from < 0 || from > to || to > size()) {throw new IndexOutOfBoundsException("from=" + from + ", to=" + to +", list size=" + size());}return new CowSubList(slice.expectedElements, slice.from + from, slice.from + to);}

// Translation:
public virtual java.util.List<E> subList(int from, int to){object[] snapshot = elements;if (from < 0 || from > to || to > snapshot.Length){throw new System.IndexOutOfRangeException("from=" + from + ", to=" + to + ", list size="+ snapshot.Length);}return new java.util.concurrent.CopyOnWriteArrayList<E>.CowSubList(this, snapshot, from, to);}
// Original:
public CompositeReaderContext build() {return (CompositeReaderContext) build(null, reader, 0, 0);}

// Translation:
public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}
// Original:
public Cluster rebootCluster(RebootClusterRequest request) {request = beforeClientExecution(request);return executeRebootCluster(request);}

// Translation:
public virtual RebootClusterResponse RebootCluster(RebootClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = RebootClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = RebootClusterResponseUnmarshaller.Instance;return Invoke<RebootClusterResponse>(request, options);}
// Original:
public void setBorder(boolean value){field_1_options = border.setShortBoolean(field_1_options, value);}

// Translation:
public void SetBorder(bool value){field_1_options = border.SetShortBoolean(field_1_options, value);}
// Original:
public DescribeExportTasksResult describeExportTasks(DescribeExportTasksRequest request) {request = beforeClientExecution(request);return executeDescribeExportTasks(request);}

// Translation:
public virtual DescribeExportTasksResponse DescribeExportTasks(DescribeExportTasksRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeExportTasksRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeExportTasksResponseUnmarshaller.Instance;return Invoke<DescribeExportTasksResponse>(request, options);}
// Original:
public SeriesLabelsRecord clone() {return copy();}

// Translation:
public override Object Clone(){SeriesLabelsRecord rec = new SeriesLabelsRecord();rec.field_1_formatFlags = field_1_formatFlags;return rec;}
// Original:
public final String getShortMessage() {byte[] raw = buffer;int msgB = RawParseUtils.tagMessage(raw, 0);if (msgB < 0) {return ""; }int msgE = RawParseUtils.endOfParagraph(raw, msgB);String str = RawParseUtils.decode(guessEncoding(), raw, msgB, msgE);if (RevCommit.hasLF(raw, msgB, msgE)) {str = StringUtils.replaceLineBreaksWithSpace(str);}return str;}

// Translation:
public string GetShortMessage(){byte[] raw = buffer;int msgB = RawParseUtils.TagMessage(raw, 0);if (msgB < 0){return string.Empty;}Encoding enc = RawParseUtils.ParseEncoding(raw);int msgE = RawParseUtils.EndOfParagraph(raw, msgB);string str = RawParseUtils.Decode(enc, raw, msgB, msgE);if (RevCommit.HasLF(raw, msgB, msgE)){str = str.Replace('\n', ' ');}return str;}
// Original:
public String toString() {StringBuilder r = new StringBuilder();if (isOperatorInfix()) {infixToString(r);} else {prefixToString(r);}weightToString(r);return r.toString();}

// Translation:
public override string ToString(){StringBuilder r = new StringBuilder();if (IsOperatorInfix){InfixToString(r);}else{PrefixToString(r);}WeightToString(r);return r.ToString();}
// Original:
public String getPreferredAuthentications() {return preferredAuthentications;}

// Translation:
public virtual string GetPreferredAuthentications(){return preferredAuthentications;}
// Original:
public int size() {return elements.length;}

// Translation:
public virtual int size(){return elements.Length;}
// Original:
public ListPartnerEventSourcesResult listPartnerEventSources(ListPartnerEventSourcesRequest request) {request = beforeClientExecution(request);return executeListPartnerEventSources(request);}

// Translation:
public virtual ListPartnerEventSourcesResponse ListPartnerEventSources(ListPartnerEventSourcesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListPartnerEventSourcesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListPartnerEventSourcesResponseUnmarshaller.Instance;return Invoke<ListPartnerEventSourcesResponse>(request, options);}
// Original:
public void write(byte[] buffer, int offset, int length) {Arrays.checkOffsetAndCount(buffer.length, offset, length);synchronized (this) {if (out == null) {setError();return;}try {out.write(buffer, offset, length);if (autoFlush) {flush();}} catch (IOException e) {setError();}}}

// Translation:
public override void write(byte[] buffer, int offset, int length){java.util.Arrays.checkOffsetAndCount(buffer.Length, offset, length);lock (this){if (@out == null){setError();return;}try{@out.write(buffer, offset, length);if (autoFlush){flush();}}catch (System.IO.IOException){setError();}}}
// Original:
public ListRegisteredTagsRequest() {super("CloudPhoto", "2017-07-11", "ListRegisteredTags", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public ListRegisteredTagsRequest(): base("CloudPhoto", "2017-07-11", "ListRegisteredTags", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public DeleteDBSubnetGroupResult deleteDBSubnetGroup(DeleteDBSubnetGroupRequest request) {request = beforeClientExecution(request);return executeDeleteDBSubnetGroup(request);}

// Translation:
public virtual DeleteDBSubnetGroupResponse DeleteDBSubnetGroup(DeleteDBSubnetGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDBSubnetGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDBSubnetGroupResponseUnmarshaller.Instance;return Invoke<DeleteDBSubnetGroupResponse>(request, options);}
// Original:
public PacketLineOut(OutputStream outputStream) {out = outputStream;lenbuffer = new byte[5];flushOnEnd = true;}

// Translation:
public PacketLineOut(OutputStream outputStream){@out = outputStream;lenbuffer = new byte[5];flushOnEnd = true;}
// Original:
public void appendDebugInfo(StringBuilder sb) {sb.append('(');sb.append( "isxvi=").append(HexDump.shortToHex(_isxvi));sb.append(" isxvd=").append(HexDump.shortToHex(_isxvd));sb.append(" idObj=").append(HexDump.shortToHex(_idObj));sb.append(')');}

// Translation:
public void AppendDebugInfo(StringBuilder sb){sb.Append('(');sb.Append("isxvi=").Append(HexDump.ShortToHex(_isxvi));sb.Append(" isxvd=").Append(HexDump.ShortToHex(_isxvd));sb.Append(" idObj=").Append(HexDump.ShortToHex(_idObj));sb.Append(')');}
// Original:
public InterfaceHdrRecord(RecordInputStream in) {_codepage = in.readShort();}

// Translation:
public InterfaceHdrRecord(RecordInputStream in1){_codepage = in1.ReadShort();}
// Original:
public DescribeVaultRequest(String accountId, String vaultName) {setAccountId(accountId);setVaultName(vaultName);}

// Translation:
public DescribeVaultRequest(string accountId, string vaultName){_accountId = accountId;_vaultName = vaultName;}
// Original:
public void add(String match, String replacement) {if (match.length() == 0 ){throw new IllegalArgumentException("cannot match the empty string");}if (pendingPairs.containsKey(match)) {throw new IllegalArgumentException("match \"" + match + "\" was already added");}pendingPairs.put(match, replacement);}

// Translation:
public virtual void Add(string match, string replacement){if (match.Length == 0){throw new System.ArgumentException("cannot match the empty string");}if (pendingPairs.ContainsKey(match)){throw new System.ArgumentException("match \"" + match + "\" was already added");}pendingPairs[match] = replacement;}
// Original:
public boolean equals(Object o) {if (this == o) {return true;}else if ( !(o instanceof ArrayPredictionContext) ) {return false;}if ( this.hashCode() != o.hashCode() ) {return false; }ArrayPredictionContext a = (ArrayPredictionContext)o;return Arrays.equals(returnStates, a.returnStates) &&Arrays.equals(parents, a.parents);}

// Translation:
public override bool Equals(Object o){if (this == o){return true;}else if (!(o is ArrayPredictionContext)){return false;}if (this.GetHashCode() != o.GetHashCode()){return false; }ArrayPredictionContext a = (ArrayPredictionContext)o;return Arrays.Equals(returnStates, a.returnStates) &&Arrays.Equals(parents, a.parents);}
// Original:
public byte[] toArray() {if (arrays.isEmpty()) {return null;} else if (arrays.size() > 1) {int totalLength = 0;for (byte[] array : arrays) {totalLength += array.length;}byte[] concatenated = new byte[totalLength];int destPos = 0;for (byte[] array : arrays) {System.arraycopy(array, 0, concatenated, destPos, array.length);destPos += array.length;}arrays.clear();arrays.add(concatenated);}return arrays.get(0);}

// Translation:
public byte[] ToArray(){if (arrays.Count==0){return null;}else if (arrays.Count > 1){int totalLength = 0;foreach (byte[] array in arrays){totalLength += array.Length;}byte[] concatenated = new byte[totalLength];int destPos = 0;foreach (byte[] array in arrays){Array.Copy(array, 0, concatenated, destPos, array.Length);destPos += array.Length;}arrays.Clear();arrays.Add(concatenated);}return arrays[(0)];}
// Original:
public void serialize(LittleEndianOutput out) {int nItems = field_1_seriesNumbers.length;out.writeShort(nItems);for (int i = 0; i < nItems; i++) {out.writeShort(field_1_seriesNumbers[i]);}}

// Translation:
public override void Serialize(ILittleEndianOutput out1){int nItems = field_1_seriesNumbers.Length;out1.WriteShort(nItems);for (int i = 0; i < nItems; i++){out1.WriteShort(field_1_seriesNumbers[i]);}}
// Original:
public boolean removePushURI(URIish toRemove) {return pushURIs.remove(toRemove);}

// Translation:
public virtual bool RemovePushURI(URIish toRemove){return pushURIs.Remove(toRemove);}
// Original:
public StringBuilder append(String str) {append0(str);return this;}

// Translation:
public java.lang.StringBuilder append(string str){append0(str);return this;}
// Original:
public synchronized void close() {flush();if (out != null) {try {out.close();out = null;} catch (IOException e) {setError();}}}

// Translation:
public override void close(){lock (this){flush();if (@out != null){try{@out.close();@out = null;}catch (System.IO.IOException){setError();}}}}
// Original:
public final BytesRef[] getBinaryValues(String name) {final List<BytesRef> result = new ArrayList<>();for (IndexableField field : fields) {if (field.name().equals(name)) {final BytesRef bytes = field.binaryValue();if (bytes != null) {result.add(bytes);}}}return result.toArray(new BytesRef[result.size()]);}

// Translation:
public BytesRef[] GetBinaryValues(string name){var result = new List<BytesRef>();foreach (IIndexableField field in fields){if (field.Name.Equals(name, StringComparison.Ordinal)){BytesRef bytes = field.GetBinaryValue();if (bytes != null){result.Add(bytes);}}}return result.ToArray();}
// Original:
public final void backup(int amount) {bufferPosition -= amount;}

// Translation:
public void  BackUp(int amount){bufferPosition -= amount;}
// Original:
public void addChildRecord(EscherRecord childRecord) {getChildRecords().add( childRecord );}

// Translation:
public void AddChildRecord(EscherRecord childRecord){ChildRecords.Add(childRecord);}
// Original:
public DeleteExpressionResult deleteExpression(DeleteExpressionRequest request) {request = beforeClientExecution(request);return executeDeleteExpression(request);}

// Translation:
public virtual DeleteExpressionResponse DeleteExpression(DeleteExpressionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteExpressionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteExpressionResponseUnmarshaller.Instance;return Invoke<DeleteExpressionResponse>(request, options);}
// Original:
public ReorderReceiptRuleSetResult reorderReceiptRuleSet(ReorderReceiptRuleSetRequest request) {request = beforeClientExecution(request);return executeReorderReceiptRuleSet(request);}

// Translation:
public virtual ReorderReceiptRuleSetResponse ReorderReceiptRuleSet(ReorderReceiptRuleSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReorderReceiptRuleSetRequestMarshaller.Instance;options.ResponseUnmarshaller = ReorderReceiptRuleSetResponseUnmarshaller.Instance;return Invoke<ReorderReceiptRuleSetResponse>(request, options);}
// Original:
public FtrHeader(RecordInputStream in) {recordType = in.readShort();grbitFrt   = in.readShort();associatedRange = new CellRangeAddress(in);}

// Translation:
public FtrHeader(RecordInputStream in1){recordType = in1.ReadShort();grbitFrt = in1.ReadShort();reserved = new byte[8];in1.Read(reserved, 0, 8);}
// Original:
public PutVoiceConnectorProxyResult putVoiceConnectorProxy(PutVoiceConnectorProxyRequest request) {request = beforeClientExecution(request);return executePutVoiceConnectorProxy(request);}

// Translation:
public virtual PutVoiceConnectorProxyResponse PutVoiceConnectorProxy(PutVoiceConnectorProxyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutVoiceConnectorProxyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutVoiceConnectorProxyResponseUnmarshaller.Instance;return Invoke<PutVoiceConnectorProxyResponse>(request, options);}
// Original:
public DescribeDataSourcePermissionsResult describeDataSourcePermissions(DescribeDataSourcePermissionsRequest request) {request = beforeClientExecution(request);return executeDescribeDataSourcePermissions(request);}

// Translation:
public virtual DescribeDataSourcePermissionsResponse DescribeDataSourcePermissions(DescribeDataSourcePermissionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDataSourcePermissionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDataSourcePermissionsResponseUnmarshaller.Instance;return Invoke<DescribeDataSourcePermissionsResponse>(request, options);}
// Original:
public final char get(int index) {checkIndex(index);return backingArray[offset + index];}

// Translation:
public sealed override char get(int index){checkIndex(index);return backingArray[offset + index];}
// Original:
public final void writeByte(int val) throws IOException {out.write(val);written++;}

// Translation:
public virtual void writeByte(int val){throw new System.NotImplementedException();}
// Original:
public ListTablesResult listTables(String exclusiveStartTableName) {return listTables(new ListTablesRequest().withExclusiveStartTableName(exclusiveStartTableName));}

// Translation:
public virtual ListTablesResponse ListTables(string exclusiveStartTableName){var request = new ListTablesRequest();request.ExclusiveStartTableName = exclusiveStartTableName;return ListTables(request);}
// Original:
public String toString() {return "Cell(readerIndex=" + readerIndex + " nodeID=" + index.getNodeID()+ " isLeaf=" + index.isLeafNode() + " distanceSquared=" + distanceSquared + ")";}

// Translation:
public override string ToString(){return TokenString + (IsLeaf ? ((char)LEAF_BYTE).ToString() : string.Empty);}
// Original:
public Result getResult() {return status;}

// Translation:
public virtual RefUpdate.Result GetResult(){return result;}
// Original:
public int addConditionalFormatting(CellRangeAddress[] regions,HSSFConditionalFormattingRule rule1,HSSFConditionalFormattingRule rule2) {return addConditionalFormatting(regions,new HSSFConditionalFormattingRule[] { rule1, rule2 });}

// Translation:
public int AddConditionalFormatting(CellRangeAddress[] regions,IConditionalFormattingRule rule1,IConditionalFormattingRule rule2){return AddConditionalFormatting(regions,new HSSFConditionalFormattingRule[]{(HSSFConditionalFormattingRule)rule1, (HSSFConditionalFormattingRule)rule2});}
// Original:
public DescribeImageBuildersResult describeImageBuilders(DescribeImageBuildersRequest request) {request = beforeClientExecution(request);return executeDescribeImageBuilders(request);}

// Translation:
public virtual DescribeImageBuildersResponse DescribeImageBuilders(DescribeImageBuildersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeImageBuildersRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeImageBuildersResponseUnmarshaller.Instance;return Invoke<DescribeImageBuildersResponse>(request, options);}
// Original:
public DescribeMountTargetsResult describeMountTargets(DescribeMountTargetsRequest request) {request = beforeClientExecution(request);return executeDescribeMountTargets(request);}

// Translation:
public virtual DescribeMountTargetsResponse DescribeMountTargets(DescribeMountTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeMountTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeMountTargetsResponseUnmarshaller.Instance;return Invoke<DescribeMountTargetsResponse>(request, options);}
// Original:
public UpdateClientCertificateResult updateClientCertificate(UpdateClientCertificateRequest request) {request = beforeClientExecution(request);return executeUpdateClientCertificate(request);}

// Translation:
public virtual UpdateClientCertificateResponse UpdateClientCertificate(UpdateClientCertificateRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateClientCertificateRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateClientCertificateResponseUnmarshaller.Instance;return Invoke<UpdateClientCertificateResponse>(request, options);}
// Original:
public String getFormatString(CellValueRecordInterface cell) {int formatIndex = getFormatIndex(cell);if (formatIndex == -1) {return null;}return getFormatString(formatIndex);}

// Translation:
public String GetFormatString(CellValueRecordInterface cell){int formatIndex = GetFormatIndex(cell);if (formatIndex == -1){return null;}return GetFormatString(formatIndex);}
// Original:
public void clear() {w1 = 0;w2 = 0;w3 = 0;w4 = 0;w5 = 0;}

// Translation:
public virtual void Clear(){w1 = 0;w2 = 0;w3 = 0;w4 = 0;w5 = 0;}
// Original:
public boolean equals( Object o ) {return o instanceof TurkishStemmer;}

// Translation:
public override bool Equals(object o){return o is TurkishStemmer;}
// Original:
public void disableRefLog() {customRefLog = true;refLogMessage = null;refLogIncludeResult = false;}

// Translation:
public virtual void DisableRefLog(){refLogMessage = null;refLogIncludeResult = false;}
// Original:
public ListPublicKeysResult listPublicKeys(ListPublicKeysRequest request) {request = beforeClientExecution(request);return executeListPublicKeys(request);}

// Translation:
public virtual ListPublicKeysResponse ListPublicKeys(ListPublicKeysRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListPublicKeysRequestMarshaller.Instance;options.ResponseUnmarshaller = ListPublicKeysResponseUnmarshaller.Instance;return Invoke<ListPublicKeysResponse>(request, options);}
// Original:
public CreateDhcpOptionsResult createDhcpOptions(CreateDhcpOptionsRequest request) {request = beforeClientExecution(request);return executeCreateDhcpOptions(request);}

// Translation:
public virtual CreateDhcpOptionsResponse CreateDhcpOptions(CreateDhcpOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDhcpOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDhcpOptionsResponseUnmarshaller.Instance;return Invoke<CreateDhcpOptionsResponse>(request, options);}
// Original:
public TokenStream create(TokenStream input) {return new ASCIIFoldingFilter(input, preserveOriginal);}

// Translation:
public override TokenStream Create(TokenStream input){return new ASCIIFoldingFilter(input, preserveOriginal);}
// Original:
public BlockList(int capacity) {int dirSize = toDirectoryIndex(capacity);if ((capacity & BLOCK_MASK) != 0 || dirSize == 0)dirSize++;directory = BlockList.<T> newDirectory(dirSize);directory[0] = BlockList.<T> newBlock();tailBlock = directory[0];}

// Translation:
public BlockList(int capacity){int dirSize = ToDirectoryIndex(capacity);if ((capacity & BLOCK_MASK) != 0 || dirSize == 0){dirSize++;}directory = NGit.Util.BlockList<T>.NewDirectory(dirSize);directory[0] = NGit.Util.BlockList<T>.NewBlock();tailBlock = directory[0];}
// Original:
@Override public int size() {return Impl.this.size();}

// Translation:
public override int size(){return this._enclosing._size;}
// Original:
public void addCellRangeAddress(int firstRow, int firstCol, int lastRow, int lastCol) {CellRangeAddress region = new CellRangeAddress(firstRow, lastRow, firstCol, lastCol);addCellRangeAddress(region);}

// Translation:
public void AddCellRangeAddress(int firstRow, int firstCol, int lastRow, int lastCol){CellRangeAddress region = new CellRangeAddress(firstRow, lastRow, firstCol, lastCol);AddCellRangeAddress(region);}
// Original:
public DescribeCacheEngineVersionsResult describeCacheEngineVersions() {return describeCacheEngineVersions(new DescribeCacheEngineVersionsRequest());}

// Translation:
public virtual DescribeCacheEngineVersionsResponse DescribeCacheEngineVersions(){return DescribeCacheEngineVersions(new DescribeCacheEngineVersionsRequest());}
// Original:
public DeleteEndpointConfigResult deleteEndpointConfig(DeleteEndpointConfigRequest request) {request = beforeClientExecution(request);return executeDeleteEndpointConfig(request);}

// Translation:
public virtual DeleteEndpointConfigResponse DeleteEndpointConfig(DeleteEndpointConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteEndpointConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteEndpointConfigResponseUnmarshaller.Instance;return Invoke<DeleteEndpointConfigResponse>(request, options);}
// Original:
public String findSheetFirstNameFromExternSheet(int externSheetIndex){int indexToSheet = linkTable.getFirstInternalSheetIndexForExtIndex(externSheetIndex);return findSheetNameFromIndex(indexToSheet);}

// Translation:
public String FindSheetFirstNameFromExternSheet(int externSheetIndex){int indexToSheet = linkTable.GetFirstInternalSheetIndexForExtIndex(externSheetIndex);return FindSheetNameFromIndex(indexToSheet);}
// Original:
public void copy(MutableValue source) {MutableValueBool s = (MutableValueBool) source;value = s.value;exists = s.exists;}

// Translation:
public override void Copy(MutableValue source){MutableValueBool s = (MutableValueBool)source;Value = s.Value;Exists = s.Exists;}
// Original:
public void setChild(QueryNode child) {List<QueryNode> list = new ArrayList<>();list.add(child);this.set(list);}

// Translation:
public virtual void SetChild(IQueryNode child){List<IQueryNode> list = new List<IQueryNode>();list.Add(child);this.Set(list);}
// Original:
public void setDateResolution(DateTools.Resolution dateResolution) {getQueryConfigHandler().set(ConfigurationKeys.DATE_RESOLUTION, dateResolution);}

// Translation:
public virtual void SetDateResolution(DateTools.Resolution dateResolution){QueryConfigHandler.Set(ConfigurationKeys.DATE_RESOLUTION, dateResolution);}
// Original:
public static <T> boolean contains(T[] array, T value) {for (T element : array) {if (element == null) {if (value == null) return true;} else {if (value != null && element.equals(value)) return true;}}return false;}

// Translation:
public static bool contains(int[] array, int value){foreach (int element in array){if (element == value){return true;}}return false;}