private IEnumerator ClearBucket(Bucket bucket)
    {
        // Get all keys in the given bucket.
        var getKeysRequest = bucket.GetKeys();
        yield return getKeysRequest.WaitUntilDone();
        if (getKeysRequest.hasFailed)
        {
            Debug.LogError("Unable to clear " + bucket + ". " + getKeysRequest.GetErrorString());
            yield break;
        }

        // Remove each one of the keys. Issue the requests all at once.
        var removeRequests = new List<RemoveRequest>();
        foreach (var key in getKeysRequest.GetKeyEnumerable())
        {
            removeRequests.Add(bucket.Remove(key));
        }

        // Then wait for each request to finish.
        foreach (var removeRequest in removeRequests)
        {
            yield return removeRequest.WaitUntilDone();
            if (removeRequest.hasFailed)
                Debug.LogError("Unable to remove '" + removeRequest.key + "' from " + removeRequest.bucket + ". " +
                               removeRequest.GetErrorString());
        }

        // Finally refresh the list.
        StartCoroutine(RefreshList());
    }

        /**
         * Add an object to the tail of the queue.
         * 
         * @param o
         *                Object to insert in the queue
         */
        public void put(Object o)
        {
            Monitor.Enter(this);
            try
            {
                Bucket b = new Bucket(o);

                if (tail != null)
                {
                    tail.setNext(b);
                    tail = b;
                }
                else
                {
                    // queue was empty but has one element now
                    head = tail = b;
                }
                count++;

                // notify any waiting tasks
                Monitor.Pulse(this);
            }
            finally
            {
                Monitor.Exit(this);
            }
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="buffer">A <see cref="Bucket"/> object.</param>
        public BucketStream(Bucket buffer)
        {
            if (buffer == null)
                throw new ArgumentNullException("buffer");

            _targetBuffer = buffer;
        }

			public override void  Collect(int doc)
			{
				BucketTable table = bucketTable;
				int i = doc & Mono.Lucene.Net.Search.BooleanScorer.BucketTable.MASK;
				Bucket bucket = table.buckets[i];
				if (bucket == null)
					table.buckets[i] = bucket = new Bucket();
				
				if (bucket.doc != doc)
				{
					// invalid bucket
					bucket.doc = doc; // set doc
					bucket.score = scorer.Score(); // initialize score
					bucket.bits = mask; // initialize mask
					bucket.coord = 1; // initialize coord
					
					bucket.next = table.first; // push onto valid list
					table.first = bucket;
				}
				else
				{
					// valid bucket
					bucket.score += scorer.Score(); // increment score
					bucket.bits |= mask; // add bits in mask
					bucket.coord++; // increment coord
				}
			}

 public static void DifferentPathsNoRevisions(Bucket bucket)
 {
     bucket.Upload("/monkey.mp4", TestBytes.NoChunks);
     bucket.Upload("/animals/dog.mp4", TestBytes.NoChunks);
     bucket.Upload("/animals/cat.mp4", TestBytes.NoChunks);
     bucket.Upload("/animals/fish.mp4", TestBytes.NoChunks);
     bucket.Upload("/people/father.mp4", TestBytes.NoChunks);
     bucket.Upload("/people/mother.mp4", TestBytes.NoChunks);
 }

        public void Init()
        {
            bucket = Bucket.Instance;

            bucket.Register<XmlModelBinder>(() => new XmlModelBinder());
            bucket.Register<XmlSerializer>(() => new XmlSerializer());
            bucket.Register<JsonModelBinder>(() => new JsonModelBinder());
            bucket.Register<JsonSerializer>(() => new JsonSerializer());
            bucket.Register<StringSerializer>(() => new StringSerializer());
        }

    // Use this for initialization
    void Start()
    {
        transform = GetComponent<Transform>();
        bucketScript = GetComponentInChildren<Bucket>();
        prenableScript = GetComponent<PrenableObject>();
        size = transform.localScale.y;
        gravityEmpty = new Vector3(0, -3.0F * size, 0);
        gravityFull  = new Vector3(0, -6.2F * size, 0);

        Debug.Log(name + "--> " + prenableScript.m_Gravity);
    }

 private void UpdateGamingConsoleHashWithBucketValues(Bucket<Game> gameBucket, int dataIndex)
 {
     gameBucket
         .Values
         .ToList()
         .ForEach(game =>
         {
             var gamingConsoleData = gamingConsoleHash[game.ConsoleName];
             gamingConsoleData[dataIndex]++;
         });
 }

		public void TestZeroDueTime ()
		{
			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), bucket, 0, Timeout.Infinite);
			Thread.Sleep (100);
			Assert.AreEqual (1, bucket.count, "#1");
			t.Change (0, Timeout.Infinite);
			Thread.Sleep (100);
			Assert.AreEqual (2, bucket.count, "#2");
			t.Dispose ();
		}

		public void TestChange ()
		{
			Bucket bucket = new Bucket();
			Timer t = new Timer (new TimerCallback (Callback), bucket, 1, 1);
			Thread.Sleep (500);
			int c = bucket.count;
			Assert.IsTrue(c > 20, "#1");
			t.Change (100, 100);
			Thread.Sleep (500);
			Assert.IsTrue(bucket.count <= c + 20, "#2");
			t.Dispose ();
		}

		public void TestZeroDueTime ()
		{
			Bucket bucket = new Bucket();

			using (Timer t = new Timer (o => Callback (o), bucket, 0, Timeout.Infinite)) {
				Thread.Sleep (100);
				Assert.AreEqual (1, bucket.count, "#1");
				t.Change (0, Timeout.Infinite);
				Thread.Sleep (100);
				Assert.AreEqual (2, bucket.count, "#2");
			}
		}

        static CollisionHashMap()
        {
            int divisionSizeX = MomolikeGame.SCREEN_WIDTH / BUCKETS_PER_ROW;
            int divisionSizeY = MomolikeGame.SCREEN_HEIGHT / BUCKETS_PER_COLUMN;

            // Initialize partition coordinates
            for (int x = 0; x < BUCKETS_PER_ROW; x++)
                for (int y = 0; y < BUCKETS_PER_COLUMN; y++)
                {
                    BUCKETS[x, y] = new Bucket();
                    BUCKETS[x, y].BucketArea = new Rectangle(x * divisionSizeX, y * divisionSizeY, divisionSizeX, divisionSizeY);
                }
        }

        /// <param name="min">minimum delta presence threshold</param>
        /// <param name="max">maximum delta presence threshold</param>
        /// <param name="bucket">the bucket that to be examined</param>
        /// <param name="qid">QI indecies</param>
        /// <returns>Returns true, if the bucket is delta present, false otherwise.</returns>
        public bool IsDeltaPresent(double min, double max, Bucket bucket, int[] qid)
        {
            CreateAB(bucket, qid);
            double[] probabilities = Probability(A, B);

            for (int k = 0; k < probabilities.Count(); k++)
            {
                double curValue = probabilities[k];
                if (curValue < min || curValue > max)
                    return false;
            }
            return true;
        }

        private static Bucket[] CreateWheel(int ticksPerWheel, ILoggingAdapter log)
        {
            if (ticksPerWheel <= 0)
                throw new ArgumentOutOfRangeException(nameof(ticksPerWheel), ticksPerWheel, "Must be greater than 0.");
            if (ticksPerWheel > 1073741824)
                throw new ArgumentOutOfRangeException(nameof(ticksPerWheel), ticksPerWheel, "Cannot be greater than 2^30.");

            ticksPerWheel = NormalizeTicksPerWheel(ticksPerWheel);
            var wheel = new Bucket[ticksPerWheel];
            for (var i = 0; i < wheel.Length; i++)
                wheel[i] = new Bucket(log);
            return wheel;
        }

 public void SetUp()
 {
     consoleNames = new[] { "Console1", "Console2", "Console3", "Console4" };
     games = consoleNames.Take(3).Select(consoleName => new Game { ConsoleName = consoleName });
     gameBuckets = new[]
                       {
                           new Bucket<Game> {Label = "9-11", Values = games},
                           new Bucket<Game> {Label = "11-13", Values = games},
                           new Bucket<Game> {Label = "13-15", Values = games.Take(2)},
                           new Bucket<Game> {Label = "15-17", Values = new[] { new Game{ConsoleName = consoleNames.Last()}}}
                       };
     trendChartEngine = new TrendChartEngine();
 }

        public void issue_28_should_be_able_to_download_on_windows_preview()
        {
            Bucket bucket = new Bucket(conn, "query", "file");
            bucket.Purge();
            bucket.Mount();

            var uploadId = bucket.Upload("MyNameIsBob.jpg", TestBytes.TwoMB);
            uploadId.Dump();

            byte[] bytes = bucket.DownloadAsBytes(uploadId, new DownloadOptions());

            bytes.Should().Equal(TestBytes.TwoMB);
        }

		public void TestChange ()
		{
			Bucket bucket = new Bucket();

			using (Timer t = new Timer (o => Callback (o), bucket, 10, 10)) {
				Thread.Sleep (500);
				int c = bucket.count;
				Assert.IsTrue (c > 20, "#1 " + c.ToString ());
				t.Change (100, 100);
				c = bucket.count;
				Thread.Sleep (500);
				Assert.IsTrue (bucket.count <= c + 20, "#2 " + c.ToString ());
			}
		}

		public void TestDueTime ()
		{
			Bucket bucket = new Bucket();
			Timer t = new Timer (new TimerCallback (Callback), bucket, 200, Timeout.Infinite);
			Thread.Sleep (50);
			Assert.AreEqual (0, bucket.count, "#1");
			Thread.Sleep (200);
			Assert.AreEqual (1, bucket.count, "#2");
			Thread.Sleep (500);
			Assert.AreEqual (1, bucket.count, "#3");
			t.Change (10, 10);
			Thread.Sleep (1000);
			Assert.IsTrue(bucket.count > 20, "#4");
			t.Dispose ();
		}

        public static Node GetNode(Bucket bucket, string key, HashingAlgortihm hashAlgorithm)
        {
            int hash;
            switch (hashAlgorithm) {
                case HashingAlgortihm.Ketama:
                    hash = KetamaHash(key);
                    break;
                default:
                    hash = DefaultHash(key);
                    break;
            }

            var nodes = config.GetNodes(bucket);
            var idx = Math.Abs(hash % nodes.Count);
            return nodes[idx];
        }

    public void HandleFullBucket(Bucket bucket)
    {
        string layer = colorToLayer[bucket.Color];
        colorToLayer.Remove(bucket.Color);

        buckets.Remove(bucket.Direction);

        Destroy(bucket.gameObject);

        HashSet<Color> usedColors = new HashSet<Color>(colorToLayer.Keys);

        Color[] colors = colorManager.UniqueColors(1, usedColors);
        BuildBucket(colors[0], layer, bucket.Direction);

        tileGroupManager.UpdateTileGroupLayers();
    }