public PagesModule(DataStore store)
 {
     _Store = store;
     Get["/"] = Home;
     Get["/Apps"] = Apps;
     Get["/About"] = About;
 }

 protected DataStorageManager(DataStore dataStore)
 {
     this.dataStore = dataStore;
     this.typeMappings = new TypeMappingCollection();
     this.registeredMemberTypeMappings = new RegisteredMemberMappingCollection();
     this.relationshipMappings = new RelationshipMappingCollection();
 }

        public MainForm()
        {
            InitializeComponent();
            data = new DataStore();

            //Set AutoGenerateColumns False
            dataGridView1.AutoGenerateColumns = false;

            //Set Columns Count
            dataGridView1.ColumnCount = 3;

            //Add Columns
            dataGridView1.Columns[0].Name = "Post";
            dataGridView1.Columns[0].HeaderText = "Post";
            dataGridView1.Columns[0].DataPropertyName = "Rentedatum";

            dataGridView1.Columns[1].HeaderText = "Bedrag";
            dataGridView1.Columns[1].Name = "Bedrag";
            dataGridView1.Columns[1].DataPropertyName = "Bedrag";

            dataGridView1.Columns[2].Name = "NaarNaam";
            dataGridView1.Columns[2].HeaderText = "NaarNaam";
            dataGridView1.Columns[2].DataPropertyName = "NaarNaam";

            //this.dataGridView1.DataSource = data.Transactions;
        }

        internal static ReadHoldingInputRegistersResponse ReadRegisters(ReadHoldingInputRegistersRequest request, DataStore dataStore, ModbusDataCollection<ushort> dataSource)
        {
            RegisterCollection data = DataStore.ReadData<RegisterCollection, ushort>(dataStore, dataSource, request.StartAddress, request.NumberOfPoints, dataStore.SyncRoot);
            ReadHoldingInputRegistersResponse response = new ReadHoldingInputRegistersResponse(request.FunctionCode, request.SlaveAddress, data);

            return response;
        }

        public List<HistoryModel> GetHistory(string symbol, DateTime? startDate, DateTime? endDate)
        {
            using (var db = new DataStore<HistoryModel>("history"))
            {
                if (startDate == null || endDate == null)
                {
                    startDate = DateTime.Now.AddYears(-3);
                    endDate = DateTime.Now;
                }

                var history = db.GetCollection().Where(x => x.Symbol == symbol && x.Date >= startDate.Value && x.Date <= endDate.Value);
                if (!history.Any())
                {
                    var json = _yqlService.FetchHistory(symbol, startDate.Value, endDate.Value);
                    var jobj = JObject.Parse(json);
                    if (Convert.ToInt32(((JValue)(jobj["query"]["count"])).Value) > 0)
                    {
                        history = Helper.DeserializeJson<List<HistoryModel>>(JArray.Parse(jobj["query"]["results"]["quote"].ToString()));
                        history.ToList().ForEach(x => x.Symbol = symbol);
                        SaveHistory(history.ToList());
                    }
                }
                return history.ToList();
            }
        }

        public MasterMateria(MateriaType type, DataStore data)
            : base()
        {
            Name = "Master" + type.ToString();
            Type = type;

            switch (type)
            {
                case MateriaType.Magic:
                    Description = "Equips all magical spells";
                    _abilities = data.GetMagicSpells().Select(x => x.Name).ToList();
                    break;
                case MateriaType.Command:
                    Description = "Equips all commands";
                    // TODO : define command abilities
                    _abilities = new List<string> { "Sense", "Steal" };
                    break;
                case MateriaType.Summon:
                    Description = "Equips all summon spells";
                    _abilities = data.GetSummonSpells().Select(x => x.Name).ToList();
                    break;

                case MateriaType.Support:
                case MateriaType.Independent:
                    throw new ImplementationException("No master materia definition for type " + type);
            }

            Tiers = new int[1];
        }

 public void SaveSubSectors(List<SectorModel> list)
 {
     using (var db = new DataStore<SectorModel>("subsectors"))
     {
         db.SaveMany(list);
     }
 }

 public void SaveSectors(List<SectorModel> sectors)
 {
     using (var db = new DataStore<SectorModel>("sectors"))
     {
         db.SaveMany(sectors);
     }
 }

 internal CachedList(IList list, DataStore dataStore, IMemberMapping childPropertyMapping, object key)
     : base(list)
 {
     this.key = key;
     this.dataStore = dataStore;
     this.childPropertyMapping = childPropertyMapping;
 }

 public Customer(string name, Statement statementGenerator)
 {
     Name = name;
     Rentals = new List<Rental>();
     StatementGenerator = statementGenerator;
     CurrentDataStore = new DataStore();
 }

 public List<SectorModel> GetCachedSectors()
 {
     using (var db = new DataStore<SectorModel>("sectors"))
     {
         return db.GetCollection();
     }
 }

        internal static ReadCoilsInputsResponse ReadDiscretes(ReadCoilsInputsRequest request, DataStore dataStore, ModbusDataCollection<bool> dataSource)
        {
            DiscreteCollection data = DataStore.ReadData<DiscreteCollection, bool>(dataStore, dataSource, request.StartAddress, request.NumberOfPoints, dataStore.SyncRoot);
            ReadCoilsInputsResponse response = new ReadCoilsInputsResponse(request.FunctionCode, request.SlaveAddress, data.ByteCount, data);

            return response;
        }

 public override void Serialize(string path, DataStore currentData)
 {
     foreach (var item in statements)
     {
         item.Serialize(path,currentData);
     }
 }

        public async Task Process()
        {
            var bytes = File.ReadAllBytes(Environment.CurrentDirectory + @"\icon.png");

            var versions = this.Versions();
            var version = versions.Values.First();

            var queued = new ImageQueued
            {
                Identifier = Guid.NewGuid(),
                OriginalExtension = Naming.DefaultExtension,
                
            };
            queued.FileNameFormat = queued.Identifier.ToString() + "_{0}.{1}";

            await this.container.Save(string.Format("{0}_original.jpeg", queued.Identifier), bytes);

            var store = new DataStore(connectionString);

            var processor = new Processor(new DataStore(connectionString), versions);
            await processor.Process(queued);

            var data = await this.container.Get(string.Format("{0}_test.gif", queued.Identifier));
            Assert.IsNotNull(data);

            var entities = await this.table.QueryByRow<ImageEntity>("test");
            var entity = entities.FirstOrDefault();

            Assert.IsNotNull(entity);
            Assert.AreEqual(version.Format.MimeType, entity.MimeType);
            Assert.AreEqual(string.Format(Naming.PathFormat, this.container.Name, entity.FileName), entity.RelativePath);
        }

 public void It_should_fetch_a_valid_addon()
 {
     var data = new DataStore();
     var addon = data.GetAddonByKey("sqlserver");
     Assert.NotNull(addon);
     Assert.Equal("sqlserver", addon.Key);
 }

 /// <summary>
 /// Creates a new SqlObjectReader.
 /// </summary>
 internal SqlObjectReader(SqlDataStore dataStore, SqlDataReader reader, Type mappedType, bool polymorphic)
 {
     this.dataStore = dataStore;
     this.reader = reader;
     this.polymorphic = polymorphic;
     this.MappedType = mappedType;
 }

        internal static WriteSingleCoilRequestResponse WriteSingleCoil(WriteSingleCoilRequestResponse request,
            DataStore dataStore, ModbusDataCollection<bool> dataSource)
        {
            DataStore.WriteData(dataStore, new DiscreteCollection(request.Data[0] == Modbus.CoilOn), dataSource,
                request.StartAddress, dataStore.SyncRoot);

            return request;
        }

 internal DataStoreShard(DataStore owner, System.Net.HostEndPoint endPoint)
 {
     _owner = owner;
     _endPoint = endPoint;
     _subscribeListenerClient = Allocate();
     _subscribeListenerThread = new Thread(ListenerLoop);
     _subscribeListenerThread.Start();
 }

 // The user must not create a configuration directly.
 internal Configuration(Type configType, DataStore dataStore, IReadOnlyDictionary<string, object> attributes,
     TypeConverter converter)
 {
     Type = configType;
     DataStore = dataStore;
     Attributes = attributes;
     Converter = converter;
 }

 public static TodoListRepository CreateTodoListRepository()
 {
     var configProvider = new ConfigProvider();
     var connectionProvider = new ConnectionProvider(configProvider);
     var databaseProvider = new DatabaseProvider(connectionProvider);
     var dataStore = new DataStore(databaseProvider);
     return new TodoListRepository(dataStore);
 }