C# IList.AddItem方法代码示例

		public override void SetUp()
		{
			base.SetUp();
			toLoad = new AList<WindowCacheGetTest.TestObject>();
			BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(
				JGitTestUtil.GetTestResourceFile("all_packed_objects.txt")), Constants.CHARSET));
			try
			{
				string line;
				while ((line = br.ReadLine()) != null)
				{
					string[] parts = line.Split(" {1,}");
					WindowCacheGetTest.TestObject o = new WindowCacheGetTest.TestObject(this);
					o.id = ObjectId.FromString(parts[0]);
					o.SetType(parts[1]);
					// parts[2] is the inflate size
					// parts[3] is the size-in-pack
					// parts[4] is the offset in the pack
					toLoad.AddItem(o);
				}
			}
			finally
			{
				br.Close();
			}
			NUnit.Framework.Assert.AreEqual(96, toLoad.Count);
		}

        /// <summary>Returns the rev ID of the 'winning' revision of this document, and whether it's deleted.</summary>
        /// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception>
        internal String WinningRevIDOfDoc(Int64 docNumericId, IList<Boolean> outIsDeleted, IList<Boolean> outIsConflict)
        {
            Cursor cursor = null;
            var args = new [] { Convert.ToString(docNumericId) };
            String revId = null;
            var sql = "SELECT revid, deleted FROM revs WHERE doc_id=? and current=1" 
                      + " ORDER BY deleted asc, revid desc LIMIT 2";

            try
            {
                cursor = StorageEngine.RawQuery(sql, args);
                cursor.MoveToNext();

                if (!cursor.IsAfterLast())
                {
                    revId = cursor.GetString(0);
                    var deleted = cursor.GetInt(1) > 0;
                    if (deleted)
                    {
                        outIsDeleted.AddItem(true);
                    }

                    // The document is in conflict if there are two+ result rows that are not deletions.
                    var hasNextResult = cursor.MoveToNext();
                    if (hasNextResult)
                    {
                        var isNextDeleted = cursor.GetInt(1) > 0;
                        var isInConflict = !deleted && hasNextResult && !isNextDeleted;
                        if (isInConflict)
                        {
                            outIsConflict.AddItem(true);
                        }
                    }
                }
            }
            catch (SQLException e)
            {
                Log.E(Tag, "Error", e);
                throw new CouchbaseLiteException("Error", e, new Status(StatusCode.InternalServerError));
            }
            finally
            {
                if (cursor != null)
                {
                    cursor.Close();
                }
            }
            return revId;
        }

        /// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception>
        internal IEnumerable<QueryRow> QueryViewNamed(String viewName, QueryOptions options, IList<Int64> outLastSequence)
        {
            var before = Runtime.CurrentTimeMillis();
            var lastSequence = 0L;
            IEnumerable<QueryRow> rows;

            if (!String.IsNullOrEmpty (viewName)) {
                var view = GetView (viewName);
                if (view == null)
                {
                    throw new CouchbaseLiteException (StatusCode.NotFound);
                }
                    
                lastSequence = view.LastSequenceIndexed;
                if (options.GetStale () == IndexUpdateMode.Before || lastSequence <= 0) {
                    view.UpdateIndex ();
                    lastSequence = view.LastSequenceIndexed;
                } else {
                    if (options.GetStale () == IndexUpdateMode.After 
                        && lastSequence < GetLastSequenceNumber())
                        // NOTE: The exception is handled inside the thread.
                        // TODO: Consider using the async keyword instead.
                        try
                        {
                            view.UpdateIndex();
                        }
                        catch (CouchbaseLiteException e)
                        {
                            Log.E(Tag, "Error updating view index on background thread", e);
                        }
                }
                rows = view.QueryWithOptions (options);
            } else {
                // nil view means query _all_docs
                // note: this is a little kludgy, but we have to pull out the "rows" field from the
                // result dictionary because that's what we want.  should be refactored, but
                // it's a little tricky, so postponing.
                var allDocsResult = GetAllDocs (options);
                rows = (IList<QueryRow>)allDocsResult.Get ("rows");
                lastSequence = GetLastSequenceNumber ();
            }
            outLastSequence.AddItem(lastSequence);

            var delta = Runtime.CurrentTimeMillis() - before;
            Log.D(Tag, String.Format("Query view {0} completed in {1} milliseconds", viewName, delta));

            return rows;
        }

		internal WalkFetchConnection(WalkTransport t, WalkRemoteObjectDatabase w)
		{
			NGit.Transport.Transport wt = (NGit.Transport.Transport)t;
			local = wt.local;
			objCheck = wt.IsCheckFetchedObjects() ? new ObjectChecker() : null;
			inserter = local.NewObjectInserter();
			reader = local.NewObjectReader();
			remotes = new AList<WalkRemoteObjectDatabase>();
			remotes.AddItem(w);
			unfetchedPacks = new List<WalkFetchConnection.RemotePack>();
			packsConsidered = new HashSet<string>();
			noPacksYet = new List<WalkRemoteObjectDatabase>();
			noPacksYet.AddItem(w);
			noAlternatesYet = new List<WalkRemoteObjectDatabase>();
			noAlternatesYet.AddItem(w);
			fetchErrors = new Dictionary<ObjectId, IList<Exception>>();
			packLocks = new AList<PackLock>(4);
			revWalk = new RevWalk(reader);
			revWalk.SetRetainBody(false);
			treeWalk = new TreeWalk(reader);
			COMPLETE = revWalk.NewFlag("COMPLETE");
			IN_WORK_QUEUE = revWalk.NewFlag("IN_WORK_QUEUE");
			LOCALLY_SEEN = revWalk.NewFlag("LOCALLY_SEEN");
			localCommitQueue = new DateRevQueue();
			workQueue = new List<ObjectId>();
		}

		internal string WinningRevIDOfDoc(long docNumericId, IList<bool> outIsDeleted, IList
			<bool> outIsConflict)
		{
			Cursor cursor = null;
			string sql = "SELECT revid, deleted FROM revs" + " WHERE doc_id=? and current=1" 
				+ " ORDER BY deleted asc, revid desc LIMIT 2";
			string[] args = new string[] { System.Convert.ToString(docNumericId) };
			string revId = null;
			try
			{
				cursor = database.RawQuery(sql, args);
				cursor.MoveToNext();
				if (!cursor.IsAfterLast())
				{
					revId = cursor.GetString(0);
					bool deleted = cursor.GetInt(1) > 0;
					if (deleted)
					{
						outIsDeleted.AddItem(true);
					}
					// The document is in conflict if there are two+ result rows that are not deletions.
					bool hasNextResult = cursor.MoveToNext();
					if (hasNextResult)
					{
						bool isNextDeleted = cursor.GetInt(1) > 0;
						bool isInConflict = !deleted && hasNextResult && isNextDeleted;
						if (isInConflict)
						{
							outIsConflict.AddItem(true);
						}
					}
				}
			}
			catch (SQLException e)
			{
				Log.E(Database.Tag, "Error", e);
				throw new CouchbaseLiteException("Error", e, new Status(Status.InternalServerError
					));
			}
			finally
			{
				if (cursor != null)
				{
					cursor.Close();
				}
			}
			return revId;
		}

		public IList<QueryRow> QueryViewNamed(string viewName, QueryOptions options, IList
			<long> outLastSequence)
		{
			long before = Runtime.CurrentTimeMillis();
			long lastSequence = 0;
			IList<QueryRow> rows = null;
			if (viewName != null && viewName.Length > 0)
			{
				View view = GetView(viewName);
				if (view == null)
				{
					throw new CouchbaseLiteException(new Status(Status.NotFound));
				}
				lastSequence = view.GetLastSequenceIndexed();
				if (options.GetStale() == Query.IndexUpdateMode.Before || lastSequence <= 0)
				{
					view.UpdateIndex();
					lastSequence = view.GetLastSequenceIndexed();
				}
				else
				{
					if (options.GetStale() == Query.IndexUpdateMode.After && lastSequence < GetLastSequenceNumber
						())
					{
						new Sharpen.Thread(new _Runnable_1847(view)).Start();
					}
				}
				rows = view.QueryWithOptions(options);
			}
			else
			{
				// nil view means query _all_docs
				// note: this is a little kludgy, but we have to pull out the "rows" field from the
				// result dictionary because that's what we want.  should be refactored, but
				// it's a little tricky, so postponing.
				IDictionary<string, object> allDocsResult = GetAllDocs(options);
				rows = (IList<QueryRow>)allDocsResult.Get("rows");
				lastSequence = GetLastSequenceNumber();
			}
			outLastSequence.AddItem(lastSequence);
			long delta = Runtime.CurrentTimeMillis() - before;
			Log.D(Database.Tag, string.Format("Query view %s completed in %d milliseconds", viewName
				, delta));
			return rows;
		}

		public string GetDesignDocFunction(string fnName, string key, IList<string> outLanguageList
			)
		{
			string[] path = fnName.Split("/");
			if (path.Length != 2)
			{
				return null;
			}
			string docId = string.Format("_design/%s", path[0]);
			RevisionInternal rev = GetDocumentWithIDAndRev(docId, null, EnumSet.NoneOf<Database.TDContentOptions
				>());
			if (rev == null)
			{
				return null;
			}
			string outLanguage = (string)rev.GetPropertyForKey("language");
			if (outLanguage != null)
			{
				outLanguageList.AddItem(outLanguage);
			}
			else
			{
				outLanguageList.AddItem("javascript");
			}
			IDictionary<string, object> container = (IDictionary<string, object>)rev.GetPropertyForKey
				(key);
			return (string)container.Get(path[1]);
		}

		/// <exception cref="System.IO.IOException"></exception>
		internal virtual void Compute(ProgressMonitor pm)
		{
			if (pm == null)
			{
				pm = NullProgressMonitor.INSTANCE;
			}
			pm.BeginTask(JGitText.Get().renamesFindingByContent, 2 * srcs.Count * dsts.Count);
			//
			int mNext = BuildMatrix(pm);
			@out = new AList<DiffEntry>(Math.Min(mNext, dsts.Count));
			// Match rename pairs on a first come, first serve basis until
			// we have looked at everything that is above our minimum score.
			//
			for (--mNext; mNext >= 0; mNext--)
			{
				long ent = matrix[mNext];
				int sIdx = SrcFile(ent);
				int dIdx = DstFile(ent);
				DiffEntry s = srcs[sIdx];
				DiffEntry d = dsts[dIdx];
				if (d == null)
				{
					pm.Update(1);
					continue;
				}
				// was already matched earlier
				DiffEntry.ChangeType type;
				if (s.changeType == DiffEntry.ChangeType.DELETE)
				{
					// First use of this source file. Tag it as a rename so we
					// later know it is already been used as a rename, other
					// matches (if any) will claim themselves as copies instead.
					//
					s.changeType = DiffEntry.ChangeType.RENAME;
					type = DiffEntry.ChangeType.RENAME;
				}
				else
				{
					type = DiffEntry.ChangeType.COPY;
				}
				@out.AddItem(DiffEntry.Pair(type, s, d, Score(ent)));
				dsts.Set(dIdx, null);
				// Claim the destination was matched.
				pm.Update(1);
			}
			srcs = CompactSrcList(srcs);
			dsts = CompactDstList(dsts);
			pm.EndTask();
		}

		/// <exception cref="NGit.Errors.InvalidPatternException"></exception>
		internal GroupHead(string pattern, string wholePattern) : base(false)
		{
			this.characterClasses = new AList<GroupHead.CharacterPattern>();
			this.inverse = pattern.StartsWith("!");
			if (inverse)
			{
				pattern = Sharpen.Runtime.Substring(pattern, 1);
			}
			Matcher matcher = REGEX_PATTERN.Matcher(pattern);
			while (matcher.Find())
			{
				string characterClass = matcher.Group(0);
				if (characterClass.Length == 3 && characterClass[1] == '-')
				{
					char start = characterClass[0];
					char end = characterClass[2];
					characterClasses.AddItem(new GroupHead.CharacterRange(start, end));
				}
				else
				{
					if (characterClass.Equals("[:alnum:]"))
					{
						characterClasses.AddItem(GroupHead.LetterPattern.INSTANCE);
						characterClasses.AddItem(GroupHead.DigitPattern.INSTANCE);
					}
					else
					{
						if (characterClass.Equals("[:alpha:]"))
						{
							characterClasses.AddItem(GroupHead.LetterPattern.INSTANCE);
						}
						else
						{
							if (characterClass.Equals("[:blank:]"))
							{
								characterClasses.AddItem(new GroupHead.OneCharacterPattern(' '));
								characterClasses.AddItem(new GroupHead.OneCharacterPattern('\t'));
							}
							else
							{
								if (characterClass.Equals("[:cntrl:]"))
								{
									characterClasses.AddItem(new GroupHead.CharacterRange('\u0000', '\u001F'));
									characterClasses.AddItem(new GroupHead.OneCharacterPattern('\u007F'));
								}
								else
								{
									if (characterClass.Equals("[:digit:]"))
									{
										characterClasses.AddItem(GroupHead.DigitPattern.INSTANCE);
									}
									else
									{
										if (characterClass.Equals("[:graph:]"))
										{
											characterClasses.AddItem(new GroupHead.CharacterRange('\u0021', '\u007E'));
											characterClasses.AddItem(GroupHead.LetterPattern.INSTANCE);
											characterClasses.AddItem(GroupHead.DigitPattern.INSTANCE);
										}
										else
										{
											if (characterClass.Equals("[:lower:]"))
											{
												characterClasses.AddItem(GroupHead.LowerPattern.INSTANCE);
											}
											else
											{
												if (characterClass.Equals("[:print:]"))
												{
													characterClasses.AddItem(new GroupHead.CharacterRange('\u0020', '\u007E'));
													characterClasses.AddItem(GroupHead.LetterPattern.INSTANCE);
													characterClasses.AddItem(GroupHead.DigitPattern.INSTANCE);
												}
												else
												{
													if (characterClass.Equals("[:punct:]"))
													{
														characterClasses.AddItem(GroupHead.PunctPattern.INSTANCE);
													}
													else
													{
														if (characterClass.Equals("[:space:]"))
														{
															characterClasses.AddItem(GroupHead.WhitespacePattern.INSTANCE);
														}
														else
														{
															if (characterClass.Equals("[:upper:]"))
															{
																characterClasses.AddItem(GroupHead.UpperPattern.INSTANCE);
															}
															else
															{
																if (characterClass.Equals("[:xdigit:]"))
																{
																	characterClasses.AddItem(new GroupHead.CharacterRange('0', '9'));
																	characterClasses.AddItem(new GroupHead.CharacterRange('a', 'f'));
																	characterClasses.AddItem(new GroupHead.CharacterRange('A', 'F'));
																}
//.........这里部分代码省略.........

		/// <summary>Parse a remote block from an existing configuration file.</summary>
		/// <remarks>
		/// Parse a remote block from an existing configuration file.
		/// <p>
		/// This constructor succeeds even if the requested remote is not defined
		/// within the supplied configuration file. If that occurs then there will be
		/// no URIs and no ref specifications known to the new instance.
		/// </remarks>
		/// <param name="rc">
		/// the existing configuration to get the remote settings from.
		/// The configuration must already be loaded into memory.
		/// </param>
		/// <param name="remoteName">subsection key indicating the name of this remote.</param>
		/// <exception cref="Sharpen.URISyntaxException">one of the URIs within the remote's configuration is invalid.
		/// 	</exception>
		public RemoteConfig(Config rc, string remoteName)
		{
			name = remoteName;
			oldName = remoteName;
			string[] vlst;
			string val;
			vlst = rc.GetStringList(SECTION, name, KEY_URL);
			IDictionary<string, string> insteadOf = GetReplacements(rc, KEY_INSTEADOF);
			uris = new AList<URIish>(vlst.Length);
			foreach (string s in vlst)
			{
				uris.AddItem(new URIish(ReplaceUri(s, insteadOf)));
			}
			IDictionary<string, string> pushInsteadOf = GetReplacements(rc, KEY_PUSHINSTEADOF
				);
			vlst = rc.GetStringList(SECTION, name, KEY_PUSHURL);
			pushURIs = new AList<URIish>(vlst.Length);
			foreach (string s_1 in vlst)
			{
				pushURIs.AddItem(new URIish(ReplaceUri(s_1, pushInsteadOf)));
			}
			vlst = rc.GetStringList(SECTION, name, KEY_FETCH);
			fetch = new AList<RefSpec>(vlst.Length);
			foreach (string s_2 in vlst)
			{
				fetch.AddItem(new RefSpec(s_2));
			}
			vlst = rc.GetStringList(SECTION, name, KEY_PUSH);
			push = new AList<RefSpec>(vlst.Length);
			foreach (string s_3 in vlst)
			{
				push.AddItem(new RefSpec(s_3));
			}
			val = rc.GetString(SECTION, name, KEY_UPLOADPACK);
			if (val == null)
			{
				val = DEFAULT_UPLOAD_PACK;
			}
			uploadpack = val;
			val = rc.GetString(SECTION, name, KEY_RECEIVEPACK);
			if (val == null)
			{
				val = DEFAULT_RECEIVE_PACK;
			}
			receivepack = val;
			val = rc.GetString(SECTION, name, KEY_TAGOPT);
			tagopt = NGit.Transport.TagOpt.FromOption(val);
			mirror = rc.GetBoolean(SECTION, name, KEY_MIRROR, DEFAULT_MIRROR);
			timeout = rc.GetInt(SECTION, name, KEY_TIMEOUT, 0);
		}

		public virtual IList<string> GetChangedKeys()
		{
			if (changedKeys == null)
			{
				changedKeys = new AList<string>();
				IDictionary<string, object> cur = GetCurrentRevision().GetProperties();
				IDictionary<string, object> nuu = newRev.GetProperties();
				foreach (string key in cur.Keys)
				{
					if (!cur.Get(key).Equals(nuu.Get(key)) && !key.Equals("_rev"))
					{
						changedKeys.AddItem(key);
					}
				}
				foreach (string key_1 in nuu.Keys)
				{
					if (cur.Get(key_1) == null && !key_1.Equals("_rev") && !key_1.Equals("_id"))
					{
						changedKeys.AddItem(key_1);
					}
				}
			}
			return changedKeys;
		}