yijunyu/c-to-rust huggingface dataset:
// Original:
public String toString() {final int n = length();final StringBuilder b = new StringBuilder(n);for (int i = 0; i < n; i++)b.append(charAt(i));return b.toString();}

// Translation:
public override string ToString(){int n = Length;StringBuilder b = new StringBuilder(n);for (int i = 0; i < n; i++){b.Append(CharAt (i));}return b.ToString();}
// Original:
public String toString(String field) {StringBuilder buffer = new StringBuilder();buffer.append("(");for (int i = 0 ; i < disjuncts.length; i++) {Query subquery = disjuncts[i];if (subquery instanceof BooleanQuery) {   buffer.append("(");buffer.append(subquery.toString(field));buffer.append(")");}else buffer.append(subquery.toString(field));if (i != disjuncts.length-1) buffer.append(" | ");}buffer.append(")");if (tieBreakerMultiplier != 0.0f) {buffer.append("~");buffer.append(tieBreakerMultiplier);}return buffer.toString();}

// Translation:
public override string ToString(string field){StringBuilder buffer = new StringBuilder();buffer.Append("(");int numDisjunctions = disjuncts.Count;for (int i = 0; i < numDisjunctions; i++){Query subquery = disjuncts[i];if (subquery is BooleanQuery) {buffer.Append("(");buffer.Append(subquery.ToString(field));buffer.Append(")");}else{buffer.Append(subquery.ToString(field));}if (i != numDisjunctions - 1){buffer.Append(" | ");}}buffer.Append(")");if (tieBreakerMultiplier != 0.0f){buffer.Append("~");buffer.Append(tieBreakerMultiplier);}if (Boost != 1.0){buffer.Append("^");buffer.Append(Boost);}return buffer.ToString();}
// Original:
@Override public boolean isEmpty() {return c.isEmpty();}

// Translation:
public virtual bool isEmpty(){return c.isEmpty();}
// Original:
public String getContentDisposition() {return contentDisposition;}

// Translation:
public string ServiceEndpoint { get; internal set; }
// Original:
public DescribeHsmClientCertificatesResult describeHsmClientCertificates() {return describeHsmClientCertificates(new DescribeHsmClientCertificatesRequest());}

// Translation:
public virtual DescribeHsmClientCertificatesResponse DescribeHsmClientCertificates(){return DescribeHsmClientCertificates(new DescribeHsmClientCertificatesRequest());}
// Original:
public static int[] grow(int[] array, int minSize) {assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";if (array.length < minSize) {return growExact(array, oversize(minSize, Integer.BYTES));} elsereturn array;}

// Translation:
public static short[] Grow(short[] array, int minSize){Debug.Assert(minSize >= 0, "size must be positive (got " + minSize + "): likely integer overflow?");if (array.Length < minSize){short[] newArray = new short[Oversize(minSize, RamUsageEstimator.NUM_BYTES_INT16)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}
// Original:
public String highlightTerm(String originalText, TokenGroup tokenGroup) {if (tokenGroup.getTotalScore() <= 0) {return originalText;}StringBuilder returnBuffer = new StringBuilder(preTag.length() + originalText.length() + postTag.length());returnBuffer.append(preTag);returnBuffer.append(originalText);returnBuffer.append(postTag);return returnBuffer.toString();}

// Translation:
public virtual string HighlightTerm(string originalText, TokenGroup tokenGroup){if (tokenGroup.TotalScore <= 0){return originalText;}StringBuilder returnBuffer = new StringBuilder(preTag.Length + originalText.Length + postTag.Length);returnBuffer.Append(preTag);returnBuffer.Append(originalText);returnBuffer.Append(postTag);return returnBuffer.ToString();}
// Original:
public LimitTokenCountFilter(TokenStream in, int maxTokenCount, boolean consumeAllTokens) {super(in);if (maxTokenCount < 1) {throw new IllegalArgumentException("maxTokenCount must be greater than zero");}this.maxTokenCount = maxTokenCount;this.consumeAllTokens = consumeAllTokens;}

// Translation:
public LimitTokenCountFilter(TokenStream @in, int maxTokenCount, bool consumeAllTokens): base(@in){if (maxTokenCount < 1){throw new System.ArgumentOutOfRangeException("maxTokenCount must be greater than zero");}this.maxTokenCount = maxTokenCount;this.consumeAllTokens = consumeAllTokens;}
// Original:
public void encode(int[] values, int valuesOffset, byte[] blocks,int blocksOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long block = encode(values, valuesOffset);valuesOffset += valueCount;blocksOffset = writeLong(block, blocks, blocksOffset);}}

// Translation:
public override void Encode(int[] values, int valuesOffset, byte[] blocks, int blocksOffset, int iterations){for (int i = 0; i < iterations; ++i){long block = Encode(values, valuesOffset);valuesOffset += valueCount;blocksOffset = WriteInt64(block, blocks, blocksOffset);}}
// Original:
public TokenFilter create(TokenStream input) {return new ClassicFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new ClassicFilter(input);}
// Original:
public boolean isAllowThin() {return allowThin;}

// Translation:
public virtual bool IsAllowThin(){return allowThin;}
// Original:
public boolean contains(Object o) {if (!(o instanceof Entry))return false;Entry<?, ?> e = (Entry<?, ?>) o;return containsMapping(e.getKey(), e.getValue());}

// Translation:
public override bool contains(object o){if (!(o is java.util.MapClass.Entry<K, V>)){return false;}java.util.MapClass.Entry<object, object> e = (java.util.MapClass.Entry<object, object>)o;return this._enclosing.containsMapping(e.getKey(), e.getValue());}
// Original:
public void add(long v) throws IOException {assert PackedInts.unsignedBitsRequired(v) <= bitsPerValue;assert !finished;if (valueCount != -1 && written >= valueCount) {throw new EOFException("Writing past end of stream");}nextValues[off++] = v;if (off == nextValues.length) {flush();}++written;}

// Translation:
public override void Add(long v){Debug.Assert(m_bitsPerValue == 64 || (v >= 0 && v <= PackedInt32s.MaxValue(m_bitsPerValue)), m_bitsPerValue.ToString());Debug.Assert(!finished);if (m_valueCount != -1 && written >= m_valueCount){throw new System.IO.EndOfStreamException("Writing past end of stream");}nextValues[off++] = v;if (off == nextValues.Length){Flush();}++written;}
// Original:
public GetOnlineServiceResultRequest() {super("industry-brain", "2018-07-12", "GetOnlineServiceResult");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

// Translation:
public GetOnlineServiceResultRequest(): base("industry-brain", "2018-07-12", "GetOnlineServiceResult"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}
// Original:
public void setBigFileThreshold(int bigFileThreshold) {this.bigFileThreshold = bigFileThreshold;}

// Translation:
public virtual void SetBigFileThreshold(int bigFileThreshold){this.bigFileThreshold = bigFileThreshold;}
// Original:
public boolean isEmpty() {return size == 0;}

// Translation:
public override bool isEmpty(){return this._enclosing._size == 0;}
// Original:
public int compareTo(ScoreTerm other) {if (term.bytesEquals(other.term))return 0; if (this.boost == other.boost)return other.term.compareTo(this.term);elsereturn Float.compare(this.boost, other.boost);}

// Translation:
public virtual int CompareTo(ScoreTerm other){if (Term.BytesEquals(other.Term)){return 0; }if (this.Boost == other.Boost){return other.Term.CompareTo(this.Term);}else{return this.Boost.CompareTo(other.Boost);}}
// Original:
public int codePointCount(int start, int end) {if (start < 0 || end > count || start > end) {throw startEndAndLength(start, end);}return Character.codePointCount(value, start, end - start);}

// Translation:
public virtual int codePointCount(int start, int end){if (start < 0 || end > count || start > end){throw startEndAndLength(start, end);}return Sharpen.CharHelper.CodePointCount(value, start, end - start);}
// Original:
public String[] getCommitNames() {return commitNames;}

// Translation:
public virtual string[] GetCommitNames(){return commitNames;}
// Original:
public boolean isEmpty() {if (sizeIsValid)return 0 == size;return !iterator().hasNext();}

// Translation:
public override bool IsEmpty(){return EntrySet().IsEmpty();}
// Original:
public boolean isBorder(){return border.isSet(field_1_options);}

// Translation:
public bool IsBorder(){return border.IsSet(field_1_options);}
// Original:
public DeleteLaunchTemplateVersionsResult deleteLaunchTemplateVersions(DeleteLaunchTemplateVersionsRequest request) {request = beforeClientExecution(request);return executeDeleteLaunchTemplateVersions(request);}

// Translation:
public virtual DeleteLaunchTemplateVersionsResponse DeleteLaunchTemplateVersions(DeleteLaunchTemplateVersionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteLaunchTemplateVersionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteLaunchTemplateVersionsResponseUnmarshaller.Instance;return Invoke<DeleteLaunchTemplateVersionsResponse>(request, options);}
// Original:
public DescribeDeviceResult describeDevice(DescribeDeviceRequest request) {request = beforeClientExecution(request);return executeDescribeDevice(request);}

// Translation:
public virtual DescribeDeviceResponse DescribeDevice(DescribeDeviceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDeviceRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDeviceResponseUnmarshaller.Instance;return Invoke<DescribeDeviceResponse>(request, options);}
// Original:
public static Class<? extends TokenizerFactory> lookupClass(String name) {return loader.lookupClass(name);}

// Translation:
public static Type LookupClass(string name){return loader.LookupClass(name);}
// Original:
public CreateParameterGroupResult createParameterGroup(CreateParameterGroupRequest request) {request = beforeClientExecution(request);return executeCreateParameterGroup(request);}

// Translation:
public virtual CreateParameterGroupResponse CreateParameterGroup(CreateParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateParameterGroupResponseUnmarshaller.Instance;return Invoke<CreateParameterGroupResponse>(request, options);}
// Original:
public FieldsQuery(SrndQuery q, String fieldName, char fieldOp) {this.q = q;fieldNames = new ArrayList<>();fieldNames.add(fieldName);this.fieldOp = fieldOp;}

// Translation:
public FieldsQuery(SrndQuery q, string fieldName, char fieldOp){this.q = q;var fieldNameList = new List<string>();fieldNameList.Add(fieldName);this.fieldNames = fieldNameList;this.fieldOp = fieldOp;}
// Original:
public DescribeReservedCacheNodesOfferingsResult describeReservedCacheNodesOfferings(DescribeReservedCacheNodesOfferingsRequest request) {request = beforeClientExecution(request);return executeDescribeReservedCacheNodesOfferings(request);}

// Translation:
public virtual DescribeReservedCacheNodesOfferingsResponse DescribeReservedCacheNodesOfferings(DescribeReservedCacheNodesOfferingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeReservedCacheNodesOfferingsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeReservedCacheNodesOfferingsResponseUnmarshaller.Instance;return Invoke<DescribeReservedCacheNodesOfferingsResponse>(request, options);}
// Original:
public String toString() {final StringBuilder s = new StringBuilder();s.append(Constants.typeString(getType()));s.append(' ');s.append(name());s.append(' ');appendCoreFlags(s);return s.toString();}

// Translation:
public override string ToString(){StringBuilder s = new StringBuilder();s.Append(Constants.TypeString(Type));s.Append(' ');s.Append(Name);s.Append(' ');AppendCoreFlags(s);return s.ToString();}
// Original:
public UpdateTableReplicaAutoScalingResult updateTableReplicaAutoScaling(UpdateTableReplicaAutoScalingRequest request) {request = beforeClientExecution(request);return executeUpdateTableReplicaAutoScaling(request);}

// Translation:
public virtual UpdateTableReplicaAutoScalingResponse UpdateTableReplicaAutoScaling(UpdateTableReplicaAutoScalingRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateTableReplicaAutoScalingRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateTableReplicaAutoScalingResponseUnmarshaller.Instance;return Invoke<UpdateTableReplicaAutoScalingResponse>(request, options);}
// Original:
public ValidateConfigurationResult validateConfiguration(ValidateConfigurationRequest request) {request = beforeClientExecution(request);return executeValidateConfiguration(request);}

// Translation:
public virtual ValidateConfigurationResponse ValidateConfiguration(ValidateConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ValidateConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = ValidateConfigurationResponseUnmarshaller.Instance;return Invoke<ValidateConfigurationResponse>(request, options);}
// Original:
public ModifyReservedInstancesResult modifyReservedInstances(ModifyReservedInstancesRequest request) {request = beforeClientExecution(request);return executeModifyReservedInstances(request);}

// Translation:
public virtual ModifyReservedInstancesResponse ModifyReservedInstances(ModifyReservedInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyReservedInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyReservedInstancesResponseUnmarshaller.Instance;return Invoke<ModifyReservedInstancesResponse>(request, options);}
// Original:
public void ReInit(CharStream stream, int lexState){ReInit(stream);SwitchTo(lexState);}

// Translation:
public virtual void ReInit(ICharStream stream, int lexState){ReInit(stream);SwitchTo(lexState);}
// Original:
public DeleteIdentityResult deleteIdentity(DeleteIdentityRequest request) {request = beforeClientExecution(request);return executeDeleteIdentity(request);}

// Translation:
public virtual DeleteIdentityResponse DeleteIdentity(DeleteIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteIdentityResponseUnmarshaller.Instance;return Invoke<DeleteIdentityResponse>(request, options);}
// Original:
public PackConfig(Config cfg) {fromConfig(cfg);}

// Translation:
public PackConfig(Config cfg){FromConfig(cfg);}
// Original:
public StringBuilder append(float f) {RealToString.getInstance().appendFloat(this, f);return this;}

// Translation:
public java.lang.StringBuilder append(char c){append0(c);return this;}
// Original:
public DeleteBrokerResult deleteBroker(DeleteBrokerRequest request) {request = beforeClientExecution(request);return executeDeleteBroker(request);}

// Translation:
public virtual DeleteBrokerResponse DeleteBroker(DeleteBrokerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteBrokerRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteBrokerResponseUnmarshaller.Instance;return Invoke<DeleteBrokerResponse>(request, options);}
// Original:
public static String stripTags(StringBuilder buf, int start) {return stripTags(buf.substring(start),0);}

// Translation:
public static string StripTags(StringBuilder buf, int start){return StripTags(buf.ToString(start, buf.Length - start), 0);}
// Original:
public Explanation idfExplain(CollectionStatistics collectionStats, TermStatistics termStats[]) {double idf = 0d; List<Explanation> subs = new ArrayList<>();for (final TermStatistics stat : termStats ) {Explanation idfExplain = idfExplain(collectionStats, stat);subs.add(idfExplain);idf += idfExplain.getValue().floatValue();}return Explanation.match((float) idf, "idf(), sum of:", subs);}

// Translation:
public virtual Explanation IdfExplain(CollectionStatistics collectionStats, TermStatistics termStats){long df = termStats.DocFreq;long max = collectionStats.MaxDoc;float idf = Idf(df, max);return new Explanation(idf, "idf(docFreq=" + df + ", maxDocs=" + max + ")");}
// Original:
public CalcCountRecord clone() {return copy();}

// Translation:
public override Object Clone(){CalcCountRecord rec = new CalcCountRecord();rec.field_1_iterations = field_1_iterations;return rec;}
// Original:
public boolean matches(ParseTree tree, String pattern, int patternRuleIndex) {ParseTreePattern p = compile(pattern, patternRuleIndex);return matches(tree, p);}

// Translation:
public virtual bool Matches(IParseTree tree, string pattern, int patternRuleIndex){ParseTreePattern p = Compile(pattern, patternRuleIndex);return Matches(tree, p);}
// Original:
public int addConditionalFormatting(CellRangeAddress[] regions,HSSFConditionalFormattingRule rule1) {return addConditionalFormatting(regions, rule1 == null ?null : new HSSFConditionalFormattingRule[] { rule1 });}

// Translation:
public int AddConditionalFormatting(CellRangeAddress[] regions,HSSFConditionalFormattingRule rule1){return AddConditionalFormatting(regions,rule1 == null ? null : new HSSFConditionalFormattingRule[]{rule1});}
// Original:
public long hash1(char carray[]) {final long p = 1099511628211L;long hash = 0xcbf29ce484222325L;for (int i = 0; i < carray.length; i++) {char d = carray[i];hash = (hash ^ (d & 0x00FF)) * p;hash = (hash ^ (d >> 8)) * p;}return hash;}

// Translation:
public virtual long Hash1(char[] carray){long p = 1099511628211L;long hash = unchecked((long)0xcbf29ce484222325L);for (int i = 0; i < carray.Length; i++){char d = carray[i];hash = (hash ^ (d & 0x00FF)) * p;hash = (hash ^ (d >> 8)) * p;}return hash;}
// Original:
public PutAnomalyDetectorResult putAnomalyDetector(PutAnomalyDetectorRequest request) {request = beforeClientExecution(request);return executePutAnomalyDetector(request);}

// Translation:
public virtual PutAnomalyDetectorResponse PutAnomalyDetector(PutAnomalyDetectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutAnomalyDetectorRequestMarshaller.Instance;options.ResponseUnmarshaller = PutAnomalyDetectorResponseUnmarshaller.Instance;return Invoke<PutAnomalyDetectorResponse>(request, options);}
// Original:
public AssociateTransitGatewayRouteTableResult associateTransitGatewayRouteTable(AssociateTransitGatewayRouteTableRequest request) {request = beforeClientExecution(request);return executeAssociateTransitGatewayRouteTable(request);}

// Translation:
public virtual AssociateTransitGatewayRouteTableResponse AssociateTransitGatewayRouteTable(AssociateTransitGatewayRouteTableRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssociateTransitGatewayRouteTableRequestMarshaller.Instance;options.ResponseUnmarshaller = AssociateTransitGatewayRouteTableResponseUnmarshaller.Instance;return Invoke<AssociateTransitGatewayRouteTableResponse>(request, options);}
// Original:
public List<String> getIPv4Association(String publicIp) {return EC2MetadataUtils.getItems(EC2_METADATA_ROOT + path+ "ipv4-associations/" + publicIp);}

// Translation:
public IEnumerable<string> GetIpV4Association(string publicIp){return EC2Metadata.GetItems(string.Format(CultureInfo.InvariantCulture, "{0}ipv4-associations/{1}", _path, publicIp));}
// Original:
public void reset() {count = 0;assert forwardCount == 0: "pos=" + pos + " forwardCount=" + forwardCount;}

// Translation:
public void Reset(){arriving = null;leaving = null;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_recalc);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_recalc);}
// Original:
public final void addConsumingCell(FormulaCellCacheEntry cellLoc) {_consumingCells.add(cellLoc);}

// Translation:
public void AddConsumingCell(FormulaCellCacheEntry cellLoc){_consumingCells.Add(cellLoc);}
// Original:
public DeleteUserRequest(String userName) {setUserName(userName);}

// Translation:
public DeleteUserRequest(string userName){_userName = userName;}
// Original:
public SingleValueVector(ValueEval value) {_value = value;}

// Translation:
public SingleValueVector(ValueEval value){_value = value;}
// Original:
public DeleteMethodResult deleteMethod(DeleteMethodRequest request) {request = beforeClientExecution(request);return executeDeleteMethod(request);}

// Translation:
public virtual DeleteMethodResponse DeleteMethod(DeleteMethodRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMethodRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMethodResponseUnmarshaller.Instance;return Invoke<DeleteMethodResponse>(request, options);}
// Original:
public static CompareResult valueOf(int simpleCompareResult) {if(simpleCompareResult < 0) {return LESS_THAN;}if(simpleCompareResult > 0) {return GREATER_THAN;}return EQUAL;}

// Translation:
public static CompareResult ValueOf(int simpleCompareResult){if (simpleCompareResult < 0){return LessThan;}if (simpleCompareResult > 0){return GreaterThan;}return Equal;}
// Original:
public CreatePresetResult createPreset(CreatePresetRequest request) {request = beforeClientExecution(request);return executeCreatePreset(request);}

// Translation:
public virtual CreatePresetResponse CreatePreset(CreatePresetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePresetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePresetResponseUnmarshaller.Instance;return Invoke<CreatePresetResponse>(request, options);}
// Original:
public S3Origin(String domainName) {setDomainName(domainName);}

// Translation:
public S3Origin(string domainName){_domainName = domainName;}
// Original:
public HTMLStripCharFilter create(Reader input) {HTMLStripCharFilter charFilter;if (null == escapedTags) {charFilter = new HTMLStripCharFilter(input);} else {charFilter = new HTMLStripCharFilter(input, escapedTags);}return charFilter;}

// Translation:
public override TextReader Create(TextReader input){HTMLStripCharFilter charFilter;if (null == escapedTags){charFilter = new HTMLStripCharFilter(input);}else{charFilter = new HTMLStripCharFilter(input, escapedTags);}return charFilter;}
// Original:
public void setCurrent(char text[], int length) {current = text;cursor = 0;limit = length;limit_backward = 0;bra = cursor;ket = limit;}

// Translation:
public virtual void SetCurrent(char[] text, int length){m_current = text;m_cursor = 0;m_limit = length;m_limit_backward = 0;m_bra = m_cursor;m_ket = m_limit;}
// Original:
public DisableTransitGatewayRouteTablePropagationResult disableTransitGatewayRouteTablePropagation(DisableTransitGatewayRouteTablePropagationRequest request) {request = beforeClientExecution(request);return executeDisableTransitGatewayRouteTablePropagation(request);}

// Translation:
public virtual DisableTransitGatewayRouteTablePropagationResponse DisableTransitGatewayRouteTablePropagation(DisableTransitGatewayRouteTablePropagationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableTransitGatewayRouteTablePropagationRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableTransitGatewayRouteTablePropagationResponseUnmarshaller.Instance;return Invoke<DisableTransitGatewayRouteTablePropagationResponse>(request, options);}
// Original:
public UpdateTagsForDomainResult updateTagsForDomain(UpdateTagsForDomainRequest request) {request = beforeClientExecution(request);return executeUpdateTagsForDomain(request);}

// Translation:
public virtual UpdateTagsForDomainResponse UpdateTagsForDomain(UpdateTagsForDomainRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateTagsForDomainRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateTagsForDomainResponseUnmarshaller.Instance;return Invoke<UpdateTagsForDomainResponse>(request, options);}
// Original:
public ObjectId getPeeledObjectId() {return peeledObjectId;}

// Translation:
public override ObjectId GetPeeledObjectId(){return peeledObjectId;}