C# AnyObjectId.ToObjectId方法代码示例

		/// <summary>Include an object (and everything reachable from it) in the bundle.</summary>
		/// <remarks>Include an object (and everything reachable from it) in the bundle.</remarks>
		/// <param name="name">
		/// name the recipient can discover this object as from the
		/// bundle's list of advertised refs . The name must be a valid
		/// ref format and must not have already been included in this
		/// bundle writer.
		/// </param>
		/// <param name="id">object to pack. Multiple refs may point to the same object.</param>
		public virtual void Include(string name, AnyObjectId id)
		{
			if (!Repository.IsValidRefName(name))
			{
				throw new ArgumentException(MessageFormat.Format(JGitText.Get().invalidRefName, name
					));
			}
			if (include.ContainsKey(name))
			{
				throw new InvalidOperationException(JGitText.Get().duplicateRef + name);
			}
			include.Put(name, id.ToObjectId());
		}

		/// <summary>Recursively add an entire tree into this builder.</summary>
		/// <remarks>
		/// Recursively add an entire tree into this builder.
		/// <p>
		/// If pathPrefix is "a/b" and the tree contains file "c" then the resulting
		/// DirCacheEntry will have the path "a/b/c".
		/// <p>
		/// All entries are inserted at stage 0, therefore assuming that the
		/// application will not insert any other paths with the same pathPrefix.
		/// </remarks>
		/// <param name="pathPrefix">
		/// UTF-8 encoded prefix to mount the tree's entries at. If the
		/// path does not end with '/' one will be automatically inserted
		/// as necessary.
		/// </param>
		/// <param name="stage">stage of the entries when adding them.</param>
		/// <param name="reader">
		/// reader the tree(s) will be read from during recursive
		/// traversal. This must be the same repository that the resulting
		/// DirCache would be written out to (or used in) otherwise the
		/// caller is simply asking for deferred MissingObjectExceptions.
		/// Caller is responsible for releasing this reader when done.
		/// </param>
		/// <param name="tree">
		/// the tree to recursively add. This tree's contents will appear
		/// under <code>pathPrefix</code>. The ObjectId must be that of a
		/// tree; the caller is responsible for dereferencing a tag or
		/// commit (if necessary).
		/// </param>
		/// <exception cref="System.IO.IOException">a tree cannot be read to iterate through its entries.
		/// 	</exception>
		public virtual void AddTree(byte[] pathPrefix, int stage, ObjectReader reader, AnyObjectId
			 tree)
		{
			TreeWalk tw = new TreeWalk(reader);
			tw.AddTree(new CanonicalTreeParser(pathPrefix, reader, tree.ToObjectId()));
			tw.Recursive = true;
			if (tw.Next())
			{
				DirCacheEntry newEntry = ToEntry(stage, tw);
				BeforeAdd(newEntry);
				FastAdd(newEntry);
				while (tw.Next())
				{
					FastAdd(ToEntry(stage, tw));
				}
			}
		}

		/// <exception cref="System.IO.IOException"></exception>
		private void AdvertiseAny(AnyObjectId obj, string refName)
		{
			sent.AddItem(obj.ToObjectId());
			AdvertiseId(obj, refName);
		}

		/// <param name="id">
		/// the expected value of the ref after the lock is taken, but
		/// before update occurs. Null to avoid the compare and swap test.
		/// Use
		/// <see cref="ObjectId.ZeroId()">ObjectId.ZeroId()</see>
		/// to indicate expectation of a
		/// non-existant ref.
		/// </param>
		public virtual void SetExpectedOldObjectId(AnyObjectId id)
		{
			expValue = id != null ? id.ToObjectId() : null;
		}

		/// <summary>
		/// Construct a CorruptObjectException for reporting a problem specified
		/// object id
		/// </summary>
		/// <param name="id"></param>
		/// <param name="why"></param>
		public CorruptObjectException(AnyObjectId id, string why) : this(id.ToObjectId(), 
			why)
		{
		}