public RevisionInternal(Body body, Database database) : this((string)body.GetPropertyForKey
     ("_id"), (string)body.GetPropertyForKey("_rev"), (((bool)body.GetPropertyForKey(
     "_deleted") != null) && ((bool)body.GetPropertyForKey("_deleted") == true)), database
     )
 {
     this.body = body;
 }

 public static Query GetQuery(Database database, string listDocId)
 {
     View view = database.GetView(ViewName);
     if (view.Map == null)
     {
         view.Map += (IDictionary<string, object> document, EmitDelegate emitter)=> 
         {
             if (Task.DocType.Equals(document.Get("type")))
             {
                 var keys = new AList<object>();
                 keys.AddItem(document.Get("list_id"));
                 keys.AddItem(document.Get("created_at"));
                 emitter(keys, document);
             }
         };
     }
     Query query = view.CreateQuery();
     query.Descending = true;
     IList<object> startKeys = new AList<object>();
     startKeys.AddItem(listDocId);
     startKeys.AddItem(new Dictionary<string, object>());
     IList<object> endKeys = new AList<object>();
     endKeys.AddItem(listDocId);
     query.StartKey = startKeys;
     query.EndKey = endKeys;
     return query;
 }

		internal ValidationContextImpl(Database database, RevisionInternal currentRevision
			, RevisionInternal newRev)
		{
			this.database = database;
			this.currentRevision = currentRevision;
			this.newRev = newRev;
		}

 /// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception>
 public static Couchbase.Lite.Document CreateTask(Database database, string title, 
     Bitmap image, string listId)
 {
     SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
         );
     Calendar calendar = GregorianCalendar.GetInstance();
     string currentTimeString = dateFormatter.Format(calendar.GetTime());
     IDictionary<string, object> properties = new Dictionary<string, object>();
     properties.Put("type", DocType);
     properties.Put("title", title);
     properties.Put("checked", false);
     properties.Put("created_at", currentTimeString);
     properties.Put("list_id", listId);
     Couchbase.Lite.Document document = database.CreateDocument();
     UnsavedRevision revision = document.CreateRevision();
     revision.SetUserProperties(properties);
     if (image != null)
     {
         ByteArrayOutputStream @out = new ByteArrayOutputStream();
         image.Compress(Bitmap.CompressFormat.Jpeg, 50, @out);
         ByteArrayInputStream @in = new ByteArrayInputStream(@out.ToByteArray());
         revision.SetAttachment("image", "image/jpg", @in);
     }
     revision.Save();
     return document;
 }

		/// <summary>Constructor</summary>
        public Pusher(Database db, Uri remote, bool continuous, IHttpClientFactory clientFactory
            , TaskFactory workExecutor) : base(db, remote, continuous, clientFactory
			, workExecutor)
		{
			CreateTarget = false;
			observing = false;
		}

        public static Document CreateDocumentWithProperties(Database db, IDictionary<String, Object> properties)
		{
            var doc = db.CreateDocument();

			Assert.IsNotNull(doc);
			Assert.IsNull(doc.CurrentRevisionId);
			Assert.IsNull(doc.CurrentRevision);
			Assert.IsNotNull("Document has no ID", doc.Id);

			// 'untitled' docs are no longer untitled (8/10/12)
			try
			{
				doc.PutProperties(properties);
			}
			catch (Exception e)
			{
				Log.E(Tag, "Error creating document", e);
                Assert.IsTrue( false, "can't create new document in db:" + db.Name +
                    " with properties:" + properties.Aggregate(new StringBuilder(" >>> "), (str, kvp)=> { str.AppendFormat("'{0}:{1}' ", kvp.Key, kvp.Value); return str; }, str=>str.ToString()));
			}

			Assert.IsNotNull(doc.Id);
			Assert.IsNotNull(doc.CurrentRevisionId);
			Assert.IsNotNull(doc.UserProperties);
			Assert.AreEqual(db.GetDocument(doc.Id), doc);

			return doc;
		}

		/// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception>
		private RevisionInternal PutDoc(Database db, IDictionary<string, object> props)
		{
			RevisionInternal rev = new RevisionInternal(props, db);
			Status status = new Status();
			rev = db.PutRevision(rev, null, false, status);
			NUnit.Framework.Assert.IsTrue(status.IsSuccessful());
			return rev;
		}

        /// <summary>
        /// Deserializes a <c>Document</c>
        /// </summary>
        /// <returns>A new object deserialized.</returns>
        /// <param name="db">The <c>Database</c> where the Document is stored.</param>
        /// <param name="doc">The document to deserialize.</param>
        /// <param name = "serializer">The serializer to use when deserializing the object</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        internal static object DeserializeObject(Type type, Document doc, Database db,
		                                          IDReferenceResolver resolver = null)
        {
            JObject jo = JObject.FromObject (doc.Properties);
            JsonSerializer serializer = GetSerializer (type, doc.CurrentRevision, db,
                                            resolver, GetLocalTypes (type));
            return jo.ToObject (type, serializer);
        }

 internal View(Database database, String name)
 {
     Database = database;
     Name = name;
     _id = -1;
     // means 'unknown'
     Collation = ViewCollation.Unicode;
 }

        static ConversationDatabase()
        {
            conversations = new List<Conversation> ();

            database = Manager.SharedInstance.GetDatabase ("conversations");

            LoadConversations ();
        }

 public RevisionInternal(String docId, String revId, Boolean deleted, Database database)
 {
     // TODO: get rid of this field!
     this.docId = docId;
     this.revId = revId;
     this.deleted = deleted;
     this.database = database;
 }

 public RemoteMultipartRequest(ScheduledExecutorService workExecutor, HttpClientFactory
      clientFactory, string method, Uri url, MultipartEntity multiPart, Database db, 
     IDictionary<string, object> requestHeaders, RemoteRequestCompletionBlock onCompletion
     ) : base(workExecutor, clientFactory, method, url, null, db, requestHeaders, onCompletion
     )
 {
     this.multiPart = multiPart;
 }

 static Conversation()
 {
     database = Manager.SharedInstance.GetDatabase ("conversations");
     defaultView = database.GetView ("conversation-messages");
     defaultView.SetMap ((document, emit) => {
         //
     }, "1");
 }

        public static Task CreateDocumentsAsync(Database db, int n)
		{
            return db.RunAsync((database)=>
                {
                    database.BeginTransaction();
                    ApiTest.CreateDocuments(database, n);
                    database.EndTransaction(true);
                });
		}

 internal Query(Database database, View view)
 {
     // null for _all_docs query
     Database = database;
     View = view;
     Limit = Int32.MaxValue;
     MapOnly = (view != null && view.Reduce == null);
     IndexUpdateMode = IndexUpdateMode.Before;
     AllDocsMode = AllDocsMode.AllDocs;
 }

 public static Query GetQuery(Database database, string ignoreUserId)
 {
     View view = database.GetView(ViewName);
     if (view.GetMap() == null)
     {
         Mapper map = new _Mapper_30(ignoreUserId);
         view.SetMap(map, null);
     }
     Query query = view.CreateQuery();
     return query;
 }

  		public static void CreateDocuments(Database db, int numberOfDocsToCreate)
		{
			//TODO should be changed to use db.runInTransaction
			for (int i = 0; i < numberOfDocsToCreate; i++)
			{
                var properties = new Dictionary<String, Object>();
                properties["testName"] = "testDatabase";
                properties["sequence"] = i;
				CreateDocumentWithProperties(db, properties);
			}
		}

 public static Query GetQueryById(Database database, string userId)
 {
     View view = database.GetView(ByIdViewName);
     if (view.GetMap() == null)
     {
         Mapper map = new _Mapper_52();
         view.SetMap(map, null);
     }
     Query query = view.CreateQuery();
     IList<object> keys = new AList<object>();
     keys.AddItem(userId);
     query.SetKeys(keys);
     return query;
 }

 /// <exception cref="Couchbase.Lite.CouchbaseLiteException"></exception>
 public static Couchbase.Lite.Document CreateNewList(Database database, string title, string userId)
 {
     var dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
     var calendar = Calendar.CurrentEra;
     string currentTimeString = dateFormatter.Format(calendar.GetTime());
     IDictionary<string, object> properties = new Dictionary<string, object>();
     properties.Put("type", "list");
     properties.Put("title", title);
     properties.Put("created_at", currentTimeString);
     properties.Put("owner", "profile:" + userId);
     properties.Put("members", new AList<string>());
     Couchbase.Lite.Document document = database.CreateDocument();
     document.PutProperties(properties);
     return document;
 }

        public static IDictionary<string, object> ReadToDatabase(IEnumerable<byte> data, IDictionary<string, string> headers, 
            Database db)
        {
            var realized = data.ToArray();
            if (realized.Length == 0) {
                throw new CouchbaseLiteException(StatusCode.BadJson);
            }

            var reader = new MultipartDocumentReader(db);
            reader.SetHeaders(headers);
            reader.AppendData(data);
            reader.Finish();

            return reader.document;
        }