C# RevCommit类代码示例

		private static string TextFor(RevCommit cmit)
		{
			byte[] raw = cmit.RawBuffer;
			int b = RawParseUtils.author(raw, 0);
			if (b < 0) return string.Empty;
			int e = RawParseUtils.nextLF(raw, b, (byte)'>');
			return Constants.CHARSET.GetString(raw, b, e);
		}

 public static RawCharSequence textFor(RevCommit cmit)
 {
     byte[] raw = cmit.getRawBuffer();
     int b = RawParseUtils.committer(raw, 0);
     if (b < 0)
         return RawCharSequence.EMPTY;
     int e = RawParseUtils.nextLF(raw, b, (byte)'>');
     return new RawCharSequence(raw, b, e);
 }

		private static string TextFor(RevCommit cmit)
		{
			byte[] raw = cmit.RawBuffer;
			int b = RawParseUtils.commitMessage(raw, 0);
			if (b < 0)
			{
				return string.Empty;
			}

			return Constants.CHARSET.GetString(raw, b, raw.Length);
		}

 /**
  * Obtain the raw text to match against.
  *
  * @param cmit
  *            current commit being evaluated.
  * @return sequence for the commit's content that we need to match on.
  */
 internal abstract string text(RevCommit cmit);

        private RevCommit rewrite(RevCommit p)
        {
            for (; ; )
            {
                RevCommit[] pList = p.parents;
                if (pList.Length > 1)
                {
                    // This parent is a merge, so keep it.
                    //
                    return p;
                }

                if ((p.flags & RevWalk.UNINTERESTING) != 0)
                {
                    // Retain uninteresting parents. They show where the
                    // DAG was cut off because it wasn't interesting.
                    //
                    return p;
                }

                if ((p.flags & REWRITE) == 0)
                {
                    // This parent was not eligible for rewriting. We
                    // need to keep it in the DAG.
                    //
                    return p;
                }

                if (pList.Length == 0)
                {
                    // We can't go back any further, other than to
                    // just delete the parent entirely.
                    //
                    return null;
                }

                p = pList[0];
            }
        }

            public override bool include(RevWalk walker, RevCommit cmit)
            {
                // Since the walker sorts commits by commit time we can be
                // reasonably certain there is nothing remaining worth our
                // scanning if this commit is before the point in question.
                //
                if (cmit.CommitTime < _when)
                {
                    throw StopWalkException.INSTANCE;
                }

                return true;
            }

 public void add(RevCommit c)
 {
     commits[tailIndex++] = c;
 }

 public override bool include(RevWalk walker, RevCommit cmit)
 {
     return _compiledPattern.IsMatch(text(cmit));
 }

 public override bool include(RevWalk walker, RevCommit c)
 {
     return true;
 }

			public override bool include(RevWalk walker, RevCommit cmit)
			{
				return false;
			}

 internal override string text(RevCommit cmit)
 {
     return textFor(cmit).ToString();
 }

 		public void unpop(RevCommit c)
 		{
 			_commits[--HeadIndex] = c;
 		}

 		public void add(RevCommit c)
 		{
 			_commits[TailIndex++] = c;
 		}

			public override bool include(RevWalk walker, RevCommit cmit)
			{
				return cmit.hasAll(_flags);
			}

 public override bool include(RevWalk walker, RevCommit c)
 {
     return c.hasAny(flags);
 }