static void Main(string[] args)
    {
      var couchbaseConfig = new Couchbase.Configuration.CouchbaseClientConfiguration();
      couchbaseConfig.Bucket = "larm";
      couchbaseConfig.Urls.Add(new Uri("http://10.0.252.63:8091/pools"));
      var cache = new Cache(new Couchbase.CouchbaseClient(couchbaseConfig));
      var portalRepository = new PortalRepository().WithConfiguration("user id=larm-app;password=0n44Fx4f4m2jNtuLuA6ym88mr3h40D;server=mysql01.cpwvkgghf9fg.eu-west-1.rds.amazonaws.com;persist security info=True;database=larm-portal;Allow User Variables=True;CharSet=utf8;");
      var portal = new PortalApplication(cache, new ViewManager(new Dictionary<string, IView>(), cache), portalRepository, new DatabaseLoggerFactory(portalRepository));
      var mcm = new McmModule();
      mcm.Load(portal);

      const uint PageSize = 100;
      var indexedCount = 0;

      for (uint i = 0; ; i++)
      {
        var objects = mcm.McmRepository.ObjectGet(null, i, PageSize, true, true, true, true, true, null);

        portal.ViewManager.GetView("Search").Index(objects);
        portal.ViewManager.GetView("Object").Index(objects);

        Console.SetCursorPosition(0,Console.CursorTop);
        Console.Write("Objects indexed: {0}", ++indexedCount);
        if (objects.Count != PageSize) break;
      }
    }

 private Cache<int, string> CreateCacheContainingFirstThousandCountingNumbers()
 {
     Cache<int, string> c = new Cache<int, string>();
     foreach (KeyValuePair<int, string> entry in Enumerable.Range(1, 1000).Select(i => new KeyValuePair<int, string>(i, i.ToString())))
         c.Add(entry);
     return c;
 }

        public TerrainRenderer(World world, WorldRenderer wr)
        {
            this.world = world;
            this.map = world.Map;

            var tileSize = new Size( Game.CellSize, Game.CellSize );
            var tileMapping = new Cache<TileReference<ushort,byte>, Sprite>(
                x => Game.modData.SheetBuilder.Add(world.TileSet.GetBytes(x), tileSize));

            var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];

            terrainSheet = tileMapping[map.MapTiles.Value[map.Bounds.Left, map.Bounds.Top]].sheet;

            int nv = 0;

            var terrainPalette = wr.Palette("terrain").Index;

            for( int j = map.Bounds.Top; j < map.Bounds.Bottom; j++ )
                for( int i = map.Bounds.Left; i < map.Bounds.Right; i++ )
                {
                    var tile = tileMapping[map.MapTiles.Value[i, j]];
                    // TODO: move GetPaletteIndex out of the inner loop.
                    Util.FastCreateQuad(vertices, Game.CellSize * new float2(i, j), tile, terrainPalette, nv, tile.size);
                    nv += 4;

                    if (tileMapping[map.MapTiles.Value[i, j]].sheet != terrainSheet)
                        throw new InvalidOperationException("Terrain sprites span multiple sheets");
                }

            vertexBuffer = Game.Renderer.Device.CreateVertexBuffer( vertices.Length );
            vertexBuffer.SetData( vertices, nv );
        }

    public static CounterCache GetCounterCache(Cache cache, SessionManager manager)
    {
        try
        {
            if (s_CounterCache.Expired)
            {
                lock (s_CounterCache)
                {
                    if (s_CounterCache.Expired)
                    {
                        s_CounterCache.Flush(manager);
                    }
                }
            }
        }
        catch(Exception ex)
        {
            manager.BlogService.EventLogWriteEntry(string.Format("GetCounterCache failed to flush the cache. {0}",
                ex.Message), EventLogEntryType.Error);

            s_CounterCache = new CounterCache();
        }

        return s_CounterCache;
    }

		public CsdlSemanticsAssertTypeExpression(CsdlAssertTypeExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
		{
			this.operandCache = new Cache<CsdlSemanticsAssertTypeExpression, IEdmExpression>();
			this.typeCache = new Cache<CsdlSemanticsAssertTypeExpression, IEdmTypeReference>();
			this.expression = expression;
			this.bindingContext = bindingContext;
		}

        /*[Test]
        public void RunTest100000()
        {
            MaxIterations = 100000;
            RunTest();
        }*/
        /*[Test]
        public void RunTest10000000()
        {
            MaxIterations = 10000000;
            RunTest();
        }*/
        private void RunTest()
        {
            NumIterations = 0;

            Cache = new Cache<long, CachedObject>(CreateForCache);

            Exception = null;

            CreatedObjects = new HashSet<long>();

            List<Thread> threads = new List<Thread>();

            for (int ctr = 0; ctr < Environment.ProcessorCount; ctr++)
            {
                Thread thread = new Thread(RunTestThread);
                thread.Name = "Cache test thread " + ctr.ToString();
                thread.Start();

                threads.Add(thread);
            }

            foreach (Thread thread in threads)
                thread.Join();

            if (null != Exception)
                throw Exception;
        }

        public async Task should_keep_cache_if_versions_same()
        {
            var cacheConfiguration = new CacheConfiguration(1024, 5, 1024, 5);

            var cacheContainer = InitializeCacheContainer();
            var storage = (TestStorage)cacheContainer.Resolve<IStorage>();

            cacheContainer.Register<IVersionProvider, TestVersionProvider>().WithValue("version", new Version(1, 1));

            using (var cache = new Cache(cacheContainer, cacheConfiguration))
            {
                await cache.Initialize();
                //when at least one value set cache is written
                await cache.Set("some_entry", 42);
            }

            //cache should not be cleanued up if versions in storage and executing assembly differ
            cacheContainer.Register<IVersionProvider, TestVersionProvider>().WithValue("version", new Version(1, 1));
            using (var cache = new Cache(cacheContainer, cacheConfiguration))
            {
                await cache.Initialize();
                storage.KeyToStreams.Should().NotBeEmpty();
                cache.Get<Int32>("some_entry").Result.Value.Should().Be(42);
            }
        }

        public void SetUp()
        {
            testee = new Cache<string, string>(8);

            var field = testee.GetType().GetField("items", BindingFlags.Instance | BindingFlags.NonPublic);
            items = field.GetValue(testee) as List<CacheItem<string, string>>;
        }

        public void ValueAndIsDirtyTest()
        {
            int value = 3;
            int factoryCallCount = 0;
            var cache = new Cache<int>(() =>
            {
                factoryCallCount++;
                return value;
            });

            Assert.IsTrue(cache.IsDirty);
            Assert.AreEqual(0, factoryCallCount);

            Assert.AreEqual(3, cache.Value);
            Assert.IsFalse(cache.IsDirty);
            Assert.AreEqual(1, factoryCallCount);

            // Now the cached value is used.
            Assert.AreEqual(3, cache.Value);
            Assert.IsFalse(cache.IsDirty);
            Assert.AreEqual(1, factoryCallCount);

            value = 4;
            cache.SetDirty();
            Assert.IsTrue(cache.IsDirty);

            Assert.AreEqual(4, cache.Value);
            Assert.IsFalse(cache.IsDirty);
            Assert.AreEqual(2, factoryCallCount);

            AssertHelper.ExpectedException<ArgumentNullException>(() => new Cache<int>(null));
        }

 public EventListenerRequest(IEventContract contract, Cache cache)
     : base(contract.Reference, HttpMethod.Get)
 {
     this.contract = contract;
     this.cache = cache;
     cts = new CancellationTokenSource();
 }

 public LuaScriptContext()
 {
     Log.Write("debug", "Creating Lua script context");
     Lua = new Lua();
     Lua.HookException += OnLuaException;
     functionCache = new Cache<string, LuaFunction>(Lua.GetFunction);
 }

        public SubscriptionCache(ChannelGraph graph, IEnumerable<ITransport> transports)
        {
            if (!transports.Any())
            {
                throw new Exception(
                    "No transports are registered.  FubuTransportation cannot function without at least one ITransport");
            }

            _graph = graph;
            _transports = transports;

            _volatileNodes = new Cache<Uri, ChannelNode>(uri =>
            {
                var transport = _transports.FirstOrDefault(x => x.Protocol == uri.Scheme);
                if (transport == null)
                {
                    throw new UnknownChannelException(uri);
                }

                var node = new ChannelNode { Uri = uri, Key = uri.ToString() };
                node.Channel = transport.BuildDestinationChannel(node.Uri);

                return node;
            });
        }

		public CsdlSemanticsPropertyValueBinding(CsdlSemanticsTypeAnnotation context, CsdlPropertyValue property) : base(property)
		{
			this.valueCache = new Cache<CsdlSemanticsPropertyValueBinding, IEdmExpression>();
			this.boundPropertyCache = new Cache<CsdlSemanticsPropertyValueBinding, IEdmProperty>();
			this.context = context;
			this.property = property;
		}

        public void for_each_attribute()
        {
            var cache = new Cache<string, string>
            {
                OnMissing = key =>
                {
                    Assert.Fail(key + " does not exist");
                    return null;
                }
            };

            var node = new JsonNode("Test");
            node.InnerText = "something";

            node["a"] = "1";
            node["b"] = "2";
            node["c"] = "3";

            node.ForEachAttribute((key, value) => cache[key] = value);

            cache.Count.ShouldEqual(3);
            cache["a"].ShouldEqual("1");
            cache["b"].ShouldEqual("2");
            cache["c"].ShouldEqual("3");
        }

 public TextureFactory(Engine engine)
 {
     _missingTexture = engine.Content.Load<Texture2D>("Textures\\missing-texture");
     _landCache = new Cache<int, Texture2D>(TimeSpan.FromMinutes(5), 0x1000);
     _lastCacheClean = DateTime.MinValue;
     _textures = new Textures(engine);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="BusSubscriptionConnector"/> class.
        /// </summary>
        /// <param name="bus">The bus.</param>
        public BusSubscriptionConnector(IServiceBus bus)
        {
            _dataBusSubscriptionCache = new EndpointSubscriptionConnectorCache(bus);
            _controlBusSubscriptionCache = new EndpointSubscriptionConnectorCache(bus.ControlBus);

            _connectionCache = new ConcurrentCache<Guid, UnsubscribeAction>();
        }

 public PersistentQueues(ILogger logger, IDelayedMessageCache<MessageId> delayedMessages, LightningQueueSettings settings)
 {
     _logger = logger;
     _delayedMessages = delayedMessages;
     _queueManagerConfiguration = settings.ToConfiguration();
     _queueManagers = new Cache<int, QueueManager>(port => new QueueManager(new IPEndPoint(IPAddress.Any, port), EsentPath + "." + port, _queueManagerConfiguration));
 }

        public NugetService(Solution solution)
        {
            //_defaultPackageSource = new PackageSource(NuGetConstants.DefaultFeedUrl);

            var factory = new PackageRepositoryFactory();

            _remoteRepository = factory.CreateRepository(GalleryUrl);
            _localRepository = factory.CreateRepository(solution.PackagesFolder());

            _sourceRepository = new AggregateRepository(new[] { _remoteRepository, _localRepository });

            _fileSystem = new PhysicalFileSystem(solution.PackagesFolder());
            _pathResolver = new DefaultPackagePathResolver(_fileSystem);

            _console = new Console();
            _packageManager = new PackageManager(_sourceRepository, _pathResolver, _fileSystem, _localRepository){
                Logger = _console
            };

            _packages = new Cache<NugetDependency, IPackage>(dep =>
            {
                Install(dep);
                return _sourceRepository.FindPackage(dep.Name, dep.Version);
            });
        }

        static PluginCache()
        {
            _setterRules = new List<Predicate<PropertyInfo>>();
            _plugins = new Cache<Type, Plugin>(t =>
            {
                var plugin = new Plugin(t);
                foreach (var rule in _setterRules)
                {
                    plugin.UseSetterRule(rule);
                }

                return plugin;
            });

            _builders = new Cache<Type, IInstanceBuilder>(t =>
            {
                try
                {
                    Plugin plugin = _plugins[t];
                    return BuilderCompiler.CreateBuilder(plugin);
                }
                catch (Exception e)
                {
                    throw new StructureMapException(245, e, t.AssemblyQualifiedName);
                }
            });
        }

 public void CacheBeforeExpiration()
 {
     var target = new Cache<string>();
     target.GetOrAdd("k", () => "v1", () => DateTime.UtcNow.AddMinutes(1));
     var actual = target.GetOrAdd("k", () => { throw new InvalidOperationException(); }, () => { throw new InvalidOperationException(); });
     Assert.AreEqual("v1", actual);
 }