yijunyu/c-to-rust huggingface dataset:
// Original:
public DoubleBuffer slice() {return new ReadWriteDoubleArrayBuffer(remaining(), backingArray, offset + position);}

// Translation:
public override java.nio.DoubleBuffer slice(){return new java.nio.ReadWriteDoubleArrayBuffer(remaining(), backingArray, offset+ _position);}
// Original:
public DescribeEvaluationsResult describeEvaluations(DescribeEvaluationsRequest request) {request = beforeClientExecution(request);return executeDescribeEvaluations(request);}

// Translation:
public virtual DescribeEvaluationsResponse DescribeEvaluations(DescribeEvaluationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEvaluationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEvaluationsResponseUnmarshaller.Instance;return Invoke<DescribeEvaluationsResponse>(request, options);}
// Original:
public int getBigBlockSize() {return bigBlockSize;}

// Translation:
public int GetBigBlockSize(){return bigBlockSize;}
// Original:
public static ValueVector createRowVector(TwoDEval tableArray, int relativeRowIndex) {return new RowVector(tableArray, relativeRowIndex);}

// Translation:
public static ValueVector CreateRowVector(TwoDEval tableArray, int relativeRowIndex){return new RowVector((AreaEval)tableArray, relativeRowIndex);}
// Original:
public void setDbcell(int cell, int value){field_5_dbcells.set(cell, value);}

// Translation:
public void SetDbcell(int cell, int value){field_5_dbcells.Set(cell, value);}
// Original:
public int compareTo(MutableValue other) {Class<? extends MutableValue> c1 = this.getClass();Class<? extends MutableValue> c2 = other.getClass();if (c1 != c2) {int c = c1.hashCode() - c2.hashCode();if (c == 0) {c = c1.getCanonicalName().compareTo(c2.getCanonicalName());}return c;}return compareSameType(other);}

// Translation:
public virtual int CompareTo(MutableValue other){Type c1 = this.GetType();Type c2 = other.GetType();if (c1 != c2){int c = c1.GetHashCode() - c2.GetHashCode();if (c == 0){c = c1.FullName.CompareToOrdinal(c2.FullName);}return c;}return CompareSameType(other);}
// Original:
public StartSpeechSynthesisTaskResult startSpeechSynthesisTask(StartSpeechSynthesisTaskRequest request) {request = beforeClientExecution(request);return executeStartSpeechSynthesisTask(request);}

// Translation:
public virtual StartSpeechSynthesisTaskResponse StartSpeechSynthesisTask(StartSpeechSynthesisTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartSpeechSynthesisTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = StartSpeechSynthesisTaskResponseUnmarshaller.Instance;return Invoke<StartSpeechSynthesisTaskResponse>(request, options);}
// Original:
public void removeParseListeners() {_parseListeners = null;}

// Translation:
public virtual void RemoveParseListeners(){_parseListeners = null;}
// Original:
public ListIdentityPoolsResult listIdentityPools(ListIdentityPoolsRequest request) {request = beforeClientExecution(request);return executeListIdentityPools(request);}

// Translation:
public virtual ListIdentityPoolsResponse ListIdentityPools(ListIdentityPoolsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListIdentityPoolsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListIdentityPoolsResponseUnmarshaller.Instance;return Invoke<ListIdentityPoolsResponse>(request, options);}
// Original:
public String toString(){return text + '(' + startOffset + ',' + endOffset + ',' + position + ')';}

// Translation:
public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append(text).Append('(').Append(startOffset).Append(',').Append(endOffset).Append(',').Append(position).Append(')');return sb.ToString();}
// Original:
public void setWrapIfNotCachingTokenFilter(boolean wrap) {this.wrapToCaching = wrap;}

// Translation:
public virtual void SetWrapIfNotCachingTokenFilter(bool wrap){this.wrapToCaching = wrap;}
// Original:
public void onChange(boolean selfChange) {mCursor.requery();}

// Translation:
public override void onChange(bool selfChange){this._enclosing.onContentChanged();}
// Original:
public DeleteRuleResult deleteRule(DeleteRuleRequest request) {request = beforeClientExecution(request);return executeDeleteRule(request);}

// Translation:
public virtual DeleteRuleResponse DeleteRule(DeleteRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance;return Invoke<DeleteRuleResponse>(request, options);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeByte(getAddMenuCount());out.writeByte(getDelMenuCount());}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteByte(AddMenuCount);out1.WriteByte(DelMenuCount);}
// Original:
public String getPattern() {return pattern;}

// Translation:
public virtual string getPattern(){return pattern;}
// Original:
public String toString(){StringBuilder buffer = new StringBuilder();buffer.append( "[BottomMargin]\n" );buffer.append( "    .margin               = " ).append( " (" ).append( getMargin() ).append( " )\n" );buffer.append( "[/BottomMargin]\n" );return buffer.toString();}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[BottomMargin]\n");buffer.Append("    .margin               = ").Append(" (").Append(Margin).Append(" )\n");buffer.Append("[/BottomMargin]\n");return buffer.ToString();}
// Original:
public final void getText(CharTermAttribute t) {t.copyBuffer(zzBuffer, zzStartRead, zzMarkedPos-zzStartRead);}

// Translation:
public void GetText(ICharTermAttribute t){t.CopyBuffer(zzBuffer, zzStartRead, zzMarkedPos - zzStartRead);}
// Original:
public LinkedList() {voidLink = new Link<E>(null, null, null);voidLink.previous = voidLink;voidLink.next = voidLink;}

// Translation:
public LinkedList(){voidLink = new java.util.LinkedList.Link<E>(default(E), null, null);voidLink.previous = voidLink;voidLink.next = voidLink;}
// Original:
public SnapshotCopyGrant createSnapshotCopyGrant(CreateSnapshotCopyGrantRequest request) {request = beforeClientExecution(request);return executeCreateSnapshotCopyGrant(request);}

// Translation:
public virtual CreateSnapshotCopyGrantResponse CreateSnapshotCopyGrant(CreateSnapshotCopyGrantRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateSnapshotCopyGrantRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateSnapshotCopyGrantResponseUnmarshaller.Instance;return Invoke<CreateSnapshotCopyGrantResponse>(request, options);}
// Original:
public static int getSingleViableAlt(Collection<BitSet> altsets) {BitSet viableAlts = new BitSet();for (BitSet alts : altsets) {int minAlt = alts.nextSetBit(0);viableAlts.set(minAlt);if ( viableAlts.cardinality()>1 ) { return ATN.INVALID_ALT_NUMBER;}}return viableAlts.nextSetBit(0);}

// Translation:
public static int GetSingleViableAlt(IEnumerable<BitSet> altsets){BitSet viableAlts = new BitSet();foreach (BitSet alts in altsets){int minAlt = alts.NextSetBit(0);viableAlts.Set(minAlt);if (viableAlts.Cardinality() > 1){return ATN.INVALID_ALT_NUMBER;}}return viableAlts.NextSetBit(0);}
// Original:
public Builder() {this.similarity = new BM25Similarity();}

// Translation:
public Builder(){InitializeInstanceFields();}
// Original:
public List<Ref> getRevertedRefs() {return revertedRefs;}

// Translation:
public virtual IList<Ref> GetRevertedRefs(){return revertedRefs;}
// Original:
public DetachPolicyResult detachPolicy(DetachPolicyRequest request) {request = beforeClientExecution(request);return executeDetachPolicy(request);}

// Translation:
public virtual DetachPolicyResponse DetachPolicy(DetachPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = DetachPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = DetachPolicyResponseUnmarshaller.Instance;return Invoke<DetachPolicyResponse>(request, options);}
// Original:
public final void writeUTF(String str) throws IOException {write(ModifiedUtf8.encode(str));}

// Translation:
public virtual void writeUTF(string str){throw new System.NotImplementedException();}
// Original:
public DeleteBusinessReportScheduleResult deleteBusinessReportSchedule(DeleteBusinessReportScheduleRequest request) {request = beforeClientExecution(request);return executeDeleteBusinessReportSchedule(request);}

// Translation:
public virtual DeleteBusinessReportScheduleResponse DeleteBusinessReportSchedule(DeleteBusinessReportScheduleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteBusinessReportScheduleRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteBusinessReportScheduleResponseUnmarshaller.Instance;return Invoke<DeleteBusinessReportScheduleResponse>(request, options);}
// Original:
public JapanesePartOfSpeechStopFilterFactory(Map<String,String> args) {super(args);stopTagFiles = get(args, "tags");if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public JapanesePartOfSpeechStopFilterFactory(IDictionary<string, string> args): base(args){stopTagFiles = Get(args, "tags");enablePositionIncrements = GetBoolean(args, "enablePositionIncrements", true);if (args.Count > 0){throw new ArgumentException("Unknown parameters: " + args);}}
// Original:
public SetVaultNotificationsResult setVaultNotifications(SetVaultNotificationsRequest request) {request = beforeClientExecution(request);return executeSetVaultNotifications(request);}

// Translation:
public virtual SetVaultNotificationsResponse SetVaultNotifications(SetVaultNotificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetVaultNotificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = SetVaultNotificationsResponseUnmarshaller.Instance;return Invoke<SetVaultNotificationsResponse>(request, options);}
// Original:
public void writeBytes(byte[] b, int offset, int length) {assert pos + length <= limit;System.arraycopy(b, offset, bytes, pos, length);pos += length;}

// Translation:
public override void WriteBytes(byte[] b, int offset, int length){Debug.Assert(pos + length <= limit);System.Buffer.BlockCopy(b, offset, bytes, pos, length);pos += length;}
// Original:
public UpdateLedgerResult updateLedger(UpdateLedgerRequest request) {request = beforeClientExecution(request);return executeUpdateLedger(request);}

// Translation:
public virtual UpdateLedgerResponse UpdateLedger(UpdateLedgerRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateLedgerRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateLedgerResponseUnmarshaller.Instance;return Invoke<UpdateLedgerResponse>(request, options);}
// Original:
public BatchDetectDominantLanguageResult batchDetectDominantLanguage(BatchDetectDominantLanguageRequest request) {request = beforeClientExecution(request);return executeBatchDetectDominantLanguage(request);}

// Translation:
public virtual BatchDetectDominantLanguageResponse BatchDetectDominantLanguage(BatchDetectDominantLanguageRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchDetectDominantLanguageRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchDetectDominantLanguageResponseUnmarshaller.Instance;return Invoke<BatchDetectDominantLanguageResponse>(request, options);}
// Original:
public void pollForUpdates() {assert isMainThread();doUpdates();}

// Translation:
public virtual void PollForUpdates(){DoUpdates();}
// Original:
public int getAltNumber() { return ATN.INVALID_ALT_NUMBER; }

// Translation:
public virtual int getAltNumber() { return Atn.ATN.INVALID_ALT_NUMBER; }
// Original:
public String toString() {StringBuilder sb = new StringBuilder(64);sb.append(getClass().getName()).append(" [");sb.append("]");return sb.toString();}

// Translation:
public override String ToString(){StringBuilder sb = new StringBuilder(64);sb.Append(GetType().Name).Append(" [");sb.Append(FormatAsString());sb.Append("]");return sb.ToString();}
// Original:
public int getTimeout() {return timeout;}

// Translation:
public virtual int GetTimeout(){return timeout;}
// Original:
public boolean canReuse(IndexInput in) {return in == inStart;}

// Translation:
public virtual bool CanReuse(IndexInput @in){return @in == _inStart;}
// Original:
public DescribeMetricFiltersRequest(String logGroupName) {setLogGroupName(logGroupName);}

// Translation:
public DescribeMetricFiltersRequest(string logGroupName){_logGroupName = logGroupName;}
// Original:
public final void write(char[] b) {write(b,0,b.length);}

// Translation:
public virtual void Write(char b){if (m_len >= m_buf.Length){Resize(m_len + 1);}UnsafeWrite(b);}
// Original:
public void trimToSize() {if (count < value.length) {char[] newValue = new char[count];System.arraycopy(value, 0, newValue, 0, count);value = newValue;shared = false;}}

// Translation:
public virtual void trimToSize(){if (count < value.Length){char[] newValue = new char[count];System.Array.Copy(value, 0, newValue, 0, count);value = newValue;shared = false;}}
// Original:
public ListTransformJobsResult listTransformJobs(ListTransformJobsRequest request) {request = beforeClientExecution(request);return executeListTransformJobs(request);}

// Translation:
public virtual ListTransformJobsResponse ListTransformJobs(ListTransformJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTransformJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTransformJobsResponseUnmarshaller.Instance;return Invoke<ListTransformJobsResponse>(request, options);}
// Original:
public EvaluationName getName(NamePtg namePtg) {int ix = namePtg.getIndex();return new Name(_iBook.getNameRecord(ix), ix);}

// Translation:
public IEvaluationName GetName(NamePtg namePtg){int ix = namePtg.Index;return new Name(_iBook.GetNameRecord(ix), ix);}
// Original:
public StashCreateCommand setIndexMessage(String message) {indexMessage = message;return this;}

// Translation:
public virtual NGit.Api.StashCreateCommand SetIndexMessage(string message){indexMessage = message;return this;}
// Original:
public HSSFPalette getCustomPalette(){return new HSSFPalette(workbook.getCustomPalette());}

// Translation:
public HSSFPalette GetCustomPalette(){return new HSSFPalette(workbook.CustomPalette);}
// Original:
public DeregisterTaskDefinitionResult deregisterTaskDefinition(DeregisterTaskDefinitionRequest request) {request = beforeClientExecution(request);return executeDeregisterTaskDefinition(request);}

// Translation:
public virtual DeregisterTaskDefinitionResponse DeregisterTaskDefinition(DeregisterTaskDefinitionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterTaskDefinitionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterTaskDefinitionResponseUnmarshaller.Instance;return Invoke<DeregisterTaskDefinitionResponse>(request, options);}
// Original:
public String pattern() {return pattern;}

// Translation:
public string pattern(){return _pattern;}
// Original:
public void setThreads(int threads) {this.threads = threads;}

// Translation:
public virtual void SetThreads(int threads){this.threads = threads;}
// Original:
public void execute(ReceivePack rp) {try {String expTarget = getOldSymref();boolean detach = getNewSymref() != null|| (type == Type.DELETE && expTarget != null);RefUpdate ru = rp.getRepository().updateRef(getRefName(), detach);if (expTarget != null) {if (!ru.getRef().isSymbolic() || !ru.getRef().getTarget().getName().equals(expTarget)) {setResult(Result.LOCK_FAILURE);return;}}ru.setRefLogIdent(rp.getRefLogIdent());ru.setRefLogMessage(refLogMessage, refLogIncludeResult);switch (getType()) {case DELETE:if (!ObjectId.zeroId().equals(getOldId())) {ru.setExpectedOldObjectId(getOldId());}ru.setForceUpdate(true);setResult(ru.delete(rp.getRevWalk()));break;case CREATE:case UPDATE:case UPDATE_NONFASTFORWARD:ru.setForceUpdate(rp.isAllowNonFastForwards());ru.setExpectedOldObjectId(getOldId());ru.setRefLogMessage("push", true); if (getNewSymref() != null) {setResult(ru.link(getNewSymref()));} else {ru.setNewObjectId(getNewId());setResult(ru.update(rp.getRevWalk()));}break;}} catch (IOException err) {reject(err);}}

// Translation:
public virtual void Execute(BaseReceivePack rp){try{RefUpdate ru = rp.GetRepository().UpdateRef(GetRefName());ru.SetRefLogIdent(rp.GetRefLogIdent());switch (GetType()){case ReceiveCommand.Type.DELETE:{if (!ObjectId.ZeroId.Equals(GetOldId())){ru.SetExpectedOldObjectId(GetOldId());}ru.SetForceUpdate(true);SetResult(ru.Delete(rp.GetRevWalk()));break;}case ReceiveCommand.Type.CREATE:case ReceiveCommand.Type.UPDATE:case ReceiveCommand.Type.UPDATE_NONFASTFORWARD:{ru.SetForceUpdate(rp.IsAllowNonFastForwards());ru.SetExpectedOldObjectId(GetOldId());ru.SetNewObjectId(GetNewId());ru.SetRefLogMessage("push", true);SetResult(ru.Update(rp.GetRevWalk()));break;}}}catch (IOException err){Reject(err);}}
// Original:
public GetEbsDefaultKmsKeyIdResult getEbsDefaultKmsKeyId(GetEbsDefaultKmsKeyIdRequest request) {request = beforeClientExecution(request);return executeGetEbsDefaultKmsKeyId(request);}

// Translation:
public virtual GetEbsDefaultKmsKeyIdResponse GetEbsDefaultKmsKeyId(GetEbsDefaultKmsKeyIdRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetEbsDefaultKmsKeyIdRequestMarshaller.Instance;options.ResponseUnmarshaller = GetEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;return Invoke<GetEbsDefaultKmsKeyIdResponse>(request, options);}
// Original:
public String toString() {return "MultiDocsAndPositionsEnum(" + Arrays.toString(getSubs()) + ")";}

// Translation:
public override string ToString(){return Slice.ToString() + ":" + DocsAndPositionsEnum;}
// Original:
public DeleteCacheParameterGroupRequest(String cacheParameterGroupName) {setCacheParameterGroupName(cacheParameterGroupName);}

// Translation:
public DeleteCacheParameterGroupRequest(string cacheParameterGroupName){_cacheParameterGroupName = cacheParameterGroupName;}
// Original:
public NavigableMap<K, V> headMap(K to, boolean inclusive) {Bound toBound = inclusive ? INCLUSIVE : EXCLUSIVE;return subMap(null, NO_BOUND, to, toBound);}

// Translation:
public java.util.NavigableMap<K, V> headMap(K to, bool inclusive){java.util.TreeMap.Bound toBound = inclusive ? java.util.TreeMap.Bound.INCLUSIVE :java.util.TreeMap.Bound.EXCLUSIVE;return this.subMap(default(K), java.util.TreeMap.Bound.NO_BOUND, to, toBound);}
// Original:
public OutputStream getOutputStream() {return rawOut;}

// Translation:
public virtual OutputStream GetOutputStream(){return rawOut;}
// Original:
public Boolean booleanValue(String key) {String value = responseMap.get(key);if (null == value || 0 == value.length()) {return null;}return Boolean.valueOf(responseMap.get(key));}

// Translation:
public bool? BooleanValue(string key){if (null != DictionaryUtil.Get(ResponseDictionary, key)){return bool.Parse(DictionaryUtil.Get(ResponseDictionary, key));}return null;}
// Original:
public ATN getATNWithBypassAlts() {String serializedAtn = getSerializedATN();if (serializedAtn == null) {throw new UnsupportedOperationException("The current parser does not support an ATN with bypass alternatives.");}synchronized (bypassAltsAtnCache) {ATN result = bypassAltsAtnCache.get(serializedAtn);if (result == null) {ATNDeserializationOptions deserializationOptions = new ATNDeserializationOptions();deserializationOptions.setGenerateRuleBypassTransitions(true);result = new ATNDeserializer(deserializationOptions).deserialize(serializedAtn.toCharArray());bypassAltsAtnCache.put(serializedAtn, result);}return result;}}

// Translation:
public virtual ATN GetATNWithBypassAlts(){string serializedAtn = SerializedAtn;if (serializedAtn == null){throw new NotSupportedException("The current parser does not support an ATN with bypass alternatives.");}lock (bypassAltsAtnCache){ATN result = bypassAltsAtnCache.Get(serializedAtn);if (result == null){ATNDeserializationOptions deserializationOptions = new ATNDeserializationOptions();deserializationOptions.GenerateRuleBypassTransitions = true;result = new ATNDeserializer(deserializationOptions).Deserialize(serializedAtn.ToCharArray());bypassAltsAtnCache.Put(serializedAtn, result);}return result;}}
// Original:
public GetDownloadUrlRequest() {super("CloudPhoto", "2017-07-11", "GetDownloadUrl", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public GetDownloadUrlRequest(): base("CloudPhoto", "2017-07-11", "GetDownloadUrl", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public int getCRC() {return crc;}

// Translation:
public virtual int GetCRC(){return crc;}
// Original:
public boolean addEscherRecord(EscherRecord element){return escherRecords.add( element );}

// Translation:
public bool AddEscherRecord(EscherRecord element){escherRecords.Add(element);return true;}
// Original:
public CharBuffer put(String src, int start, int end) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.CharBuffer put(string src, int start, int end){throw new java.nio.ReadOnlyBufferException();}
// Original:
public ModifyWorkspaceStateResult modifyWorkspaceState(ModifyWorkspaceStateRequest request) {request = beforeClientExecution(request);return executeModifyWorkspaceState(request);}

// Translation:
public virtual ModifyWorkspaceStateResponse ModifyWorkspaceState(ModifyWorkspaceStateRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyWorkspaceStateRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyWorkspaceStateResponseUnmarshaller.Instance;return Invoke<ModifyWorkspaceStateResponse>(request, options);}
// Original:
public ICUTransformFilter(TokenStream input, Transliterator transform) {super(input);this.transform = transform;if (transform.getFilter() == null && transform instanceof com.ibm.icu.text.RuleBasedTransliterator) {final UnicodeSet sourceSet = transform.getSourceSet();if (sourceSet != null && !sourceSet.isEmpty())transform.setFilter(sourceSet);}}

// Translation:
public ICUTransformFilter(TokenStream input, Transliterator transform): base(input){this.transform = transform;this.termAtt = AddAttribute<ICharTermAttribute>();#pragma warning disable 612, 618if (transform.Filter == null && transform is RuleBasedTransliterator)#pragma warning restore 612, 618{UnicodeSet sourceSet = transform.GetSourceSet();if (sourceSet != null && sourceSet.Any())transform.Filter=sourceSet;}}
// Original:
public StopGameSessionPlacementResult stopGameSessionPlacement(StopGameSessionPlacementRequest request) {request = beforeClientExecution(request);return executeStopGameSessionPlacement(request);}

// Translation:
public virtual StopGameSessionPlacementResponse StopGameSessionPlacement(StopGameSessionPlacementRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopGameSessionPlacementRequestMarshaller.Instance;options.ResponseUnmarshaller = StopGameSessionPlacementResponseUnmarshaller.Instance;return Invoke<StopGameSessionPlacementResponse>(request, options);}
// Original:
public ObjectId getDeltaBase() {return null;}

// Translation:
public virtual ObjectId GetDeltaBase(){return null;}
// Original:
public RefModeRecord clone() {return copy();}

// Translation:
public override Object Clone(){RefModeRecord rec = new RefModeRecord();rec.field_1_mode = field_1_mode;return rec;}
// Original:
public boolean addURI(URIish toAdd) {if (uris.contains(toAdd))return false;return uris.add(toAdd);}

// Translation:
public virtual bool AddURI(URIish toAdd){if (uris.Contains(toAdd)){return false;}return uris.AddItem(toAdd);}
// Original:
public FileMode getOldMode() {return getOldMode(0);}

// Translation:
public override FileMode GetOldMode(){return GetOldMode(0);}
// Original:
public Collection<RemoteRefUpdate> getRemoteUpdates() {return Collections.unmodifiableCollection(remoteUpdates.values());}

// Translation:
public virtual ICollection<RemoteRefUpdate> GetRemoteUpdates(){return Sharpen.Collections.UnmodifiableCollection(remoteUpdates.Values);}