Beispiel #1
0
        public LiteCrawlerStorage(string fileName)
        {
            BsonDocument BsonFromImage(ICrawlerImage image)
            {
                return(new BsonDocument
                {
                    ["_id"] = image.ImageId,
                    ["url"] = image.ImageUrl,
                    ["tags"] = new BsonArray(image.HumanoidTags.Select(t => new BsonValue(t)))
                });
            }

            ICrawlerImage ImageFromBson(BsonValue value)
            {
                var doc = value.AsDocument;

                return(new AutoTaggerImage
                {
                    ImageId = doc["_id"],
                    ImageUrl = doc["url"],
                    HumanoidTags = doc["tags"].AsArray.Select(t => t.AsString)
                });
            }

            var mapper = new BsonMapper();

            mapper.RegisterType(BsonFromImage, ImageFromBson);

            var database = new LiteDatabase(fileName, mapper);

            this.images = database.GetCollection <ICrawlerImage>("images");
        }
Beispiel #2
0
        /// <summary>
        /// Registers mappings for a specific ExtendableEnum type with a Value property type of string.
        /// </summary>
        /// <param name="mapper">The <see cref="BsonMapper"/> for which the mapping will be registered.</param>
        /// <param name="type">An ExtendableEnum <see cref="Type"/> which is to be registered.</param>
        public static void RegisterExtendableEnumAsString(this BsonMapper mapper, Type type)
        {
            if (mapper == null)
            {
                throw new ArgumentNullException(nameof(mapper));
            }

            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            if (!type.IsExtendableEnum())
            {
                throw new ArgumentException("The type must be an ExtendableEnum.", nameof(type));
            }

            var valueProperty = type.GetProperty("Value");

            if (valueProperty.PropertyType != typeof(string))
            {
                throw new ArgumentException("The ExtendableEnum type must have a value type of string.", nameof(type));
            }

            var parseMethod = type.GetMethod("ParseValue", BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Public);

            mapper.RegisterType(type, s => ((IExtendableEnum <string>)s).Value, b => parseMethod.Invoke(null, new object[] { b.AsString }));
        }
        public virtual void Register(BsonMapper bsonMapper)
        {
            BsonMapper = bsonMapper ?? throw new ArgumentNullException(nameof(bsonMapper));

            BsonMapper.RegisterType(
                serialize: Serialize,
                deserialize: Deserialize);
        }
Beispiel #4
0
 protected void RegisterType <TIdentity>()
     where TIdentity : Identity <TIdentity>
 {
     _mapper.RegisterType <TIdentity>(
         (id) => id.Value,
         (bson) => (TIdentity)Activator.CreateInstance(typeof(TIdentity), (object)bson.AsGuid)
         );
 }
Beispiel #5
0
        public static void RegisterIdBsonMappers(this BsonMapper mapper, Assembly assemblyToScanForTypes = null)
        {
            var types = GetIHasIdTypes(assemblyToScanForTypes);

            foreach (var type in types)
            {
                mapper.RegisterType(type, obj => ((IGuidValue)obj).Value.ToString("N"),
                                    value => Activator.CreateInstance(type, new Guid(value.AsString)));
            }
        }
Beispiel #6
0
        public void RegisterCustomSerializers(BsonMapper mapper)
        {
            //this implementation is only for testing as the simulator doesn't save it's state
            BsonMapper defaultMapper = new BsonMapper();

            BsonValue OrderToBson(Order order)
            {
                return(defaultMapper.Serialize(typeof(IOrder), order));
            }

            Order BsonToOrder(BsonValue value)
            {
                var order = DeserializedOrders.FirstOrDefault(o => o.Id == value["_id"].AsString);

                if (order == null)
                {
                    DeserializedOrders.Add(order = defaultMapper.Deserialize <Order>(value));
                }
                return(order);
            }

            BsonValue SerializeTrade(Trade trade)
            {
                return(defaultMapper.Serialize(typeof(ITrade), trade));
            }

            Trade DeserializeTrade(BsonValue value)
            {
                var trade = DeserializedTrades.FirstOrDefault(o => o.Id == value["_id"].AsString);

                if (trade == null)
                {
                    DeserializedTrades.Add(trade = defaultMapper.Deserialize <Trade>(value));
                }
                return(trade);
            }

            mapper.RegisterType <Order>(OrderToBson, BsonToOrder);
            mapper.RegisterType <Trade>(SerializeTrade, DeserializeTrade);
        }
        public static void MapSimpleValueObjects(this BsonMapper mapper)
        {
            var simpleValueObjectTypes = from type in PizzaMaster.PizzaMasterAssembly.ExportedTypes
                                         where type.IsClass && !type.IsAbstract
                                         where type.IsAssignableTo <ISingleValueObject>()
                                         select type;

            foreach (var type in simpleValueObjectTypes)
            {
                mapper.RegisterType(type,
                                    o => new BsonValue(((ISingleValueObject)o).GetValue()),
                                    v => Activator.CreateInstance(type, v.RawValue));
            }
        }
Beispiel #8
0
        /// <summary>
        /// Create a new instance of the BmpCoffer manager based on the given LiteDB database.
        /// </summary>
        /// <param name="dbPath"></param>
        /// <returns></returns>
        internal static BmpCoffer CreateInstance(string dbPath)
        {
            var mapper = new BsonMapper();

            mapper.RegisterType
            (
                group => group.Index,
                bson => Instrument.Parse(bson.AsInt32)
            );
            mapper.RegisterType
            (
                group => group.Index,
                bson => InstrumentTone.Parse(bson.AsInt32)
            );
            mapper.RegisterType
            (
                group => group.Index,
                bson => OctaveRange.Parse(bson.AsInt32)
            );
            mapper.RegisterType
            (
                tempoMap => SerializeTempoMap(tempoMap),
                bson => DeserializeTempoMap(bson.AsBinary)
            );
            mapper.RegisterType
            (
                trackChunk => SerializeTrackChunk(trackChunk),
                bson => DeserializeTrackChunk(bson.AsBinary)
            );

            var dbi = new LiteDatabase(dbPath, mapper);

            MigrateDatabase(dbi);

            return(new BmpCoffer(dbi));
        }
        public LiteConfigStore(
            ConnectionString connectionString,
            CommandService commands,
            BsonMapper mapper = null,
            Func <LogMessage, Task> logger = null)
        {
            _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
            _commands         = commands ?? throw new ArgumentNullException(nameof(commands));
            _mapper           = mapper ?? BsonMapper.Global;
            _logger           = logger ?? Extensions.NoOpLogger;

            _mapper.RegisterType <ulong>(
                serialize: (ul => new BsonValue((long)ul)),
                deserialize: (val => (ulong)val.AsInt64));
        }
Beispiel #10
0
        public static void RegisterIdBsonMappers(this BsonMapper mapper, Assembly assemblyToScanForTypes = null)
        {
            if (assemblyToScanForTypes == null)
            {
                assemblyToScanForTypes = Assembly.GetExecutingAssembly();
            }
            var iHasTraits = typeof(IHasTraits);
            var types      = assemblyToScanForTypes.GetTypes()
                             .Select(x => (type: x, interfaces: x.GetInterfaces()))
                             .Where(x => x.interfaces.Contains(iHasTraits))
                             .Where(HasId);
            var idType = typeof(Id <>);

            foreach (var type in types)
            {
                var idClosed = idType.MakeGenericType(type.type);
                mapper.RegisterType(idClosed, obj => ((IGuidValue)obj).Value.ToString("N"), value => Activator.CreateInstance(idClosed, new Guid(value.AsString)));
            }
        }
Beispiel #11
0
        private BsonMapper Create()
        {
            var mapper = new BsonMapper();

            mapper.RegisterType <HashHeightPair>
            (
                serialize: (hash) => hash.ToString(),
                deserialize: (bson) => HashHeightPair.Parse(bson.AsString)
            );

            mapper.RegisterType <OutPoint>
            (
                serialize: (outPoint) => outPoint.ToString(),
                deserialize: (bson) => OutPoint.Parse(bson.AsString)
            );

            mapper.RegisterType <uint256>
            (
                serialize: (hash) => hash.ToString(),
                deserialize: (bson) => uint256.Parse(bson.AsString)
            );

            mapper.RegisterType <Money>
            (
                serialize: (money) => money.Satoshi,
                deserialize: (bson) => Money.Satoshis(bson.AsInt64)
            );

            mapper.RegisterType <Script>
            (
                serialize: (script) => Encoders.Hex.EncodeData(script.ToBytes(false)),
                deserialize: (bson) => Script.FromBytesUnsafe(Encoders.Hex.DecodeData(bson.AsString))
            );

            mapper.RegisterType <PartialMerkleTree>
            (
                serialize: (pmt) => Encoders.Hex.EncodeData(pmt.ToBytes()),
                deserialize: (bson) =>
            {
                var ret   = new PartialMerkleTree();
                var bytes = Encoders.Hex.DecodeData(bson.AsString);
                ret.ReadWrite(bytes);
                return(ret);
            }
            );

            return(mapper);
        }
Beispiel #12
0
        public BsonMapper CreateMapper()
        {
            var mapper = new BsonMapper();

            mapper.UseLowerCaseDelimiter('_');

#if NAMEVALUECOLLECTION
            mapper.RegisterType(
                nv =>
            {
                var doc = new BsonDocument();

                foreach (var key in nv.AllKeys)
                {
                    doc[key] = nv[key];
                }

                return(doc);
            },

                bson =>
            {
                var nv  = new NameValueCollection();
                var doc = bson.AsDocument;

                foreach (var key in doc.Keys)
                {
                    nv[key] = doc[key].AsString;
                }

                return(nv);
            }
                );
#endif

            return(mapper);
        }
        public static void Register(BsonMapper mapper)
        {
            IEntity GetValue(Type type, int id)
            {
                if (type == typeof(Exercise))
                {
                    return(new Exercise
                    {
                        Id = id
                    });
                }

                if (type == typeof(Muscle))
                {
                    return(new Muscle
                    {
                        Id = id
                    });
                }

                if (type == typeof(Category))
                {
                    return(new Category
                    {
                        Id = id
                    });
                }

                throw new ArgumentException("Invalid value type");
            }

            Type GetType(string typeName) => Type.GetType(typeName);

            mapper.RegisterType(
                filter =>
            {
                var doc = new Dictionary <string, BsonValue>
                {
                    { "_id", filter.Id },
                    { "name", filter.Name },
                };

                if (filter.Metric.HasValue)
                {
                    doc.Add("metric", (int)filter.Metric.Value);
                }

                if (filter.GroupBy.HasValue)
                {
                    doc.Add("groupBy", (int)filter.GroupBy.Value);
                }

                if (filter.FilterBy.HasValue)
                {
                    doc.Add("filterBy", (int)filter.FilterBy.Value);
                    doc.Add("valueType", filter.FilteringValue.GetType().AssemblyQualifiedName);
                    doc.Add("valueId", filter.FilteringValue.Id);
                }

                return(doc);
            },
                bsonValue =>
            {
                var doc = bsonValue.AsDocument;

                var filterBy = doc["filterBy"].RawValue;
                var groupBy  = doc["groupBy"].RawValue;
                var metric   = doc["metric"].RawValue;

                var filter = new ProgressFilter
                {
                    Id   = doc["_id"],
                    Name = doc["name"],
                };

                if (filterBy != null)
                {
                    filter.FilterBy       = (FilterBy)filterBy;
                    filter.FilteringValue = GetValue(GetType(doc["valueType"].AsString), doc["valueId"].AsInt32);
                }

                if (groupBy != null)
                {
                    filter.GroupBy = (GroupBy)groupBy;
                }

                if (metric != null)
                {
                    filter.Metric = (FilterMetric)metric;
                }

                return(filter);
            }
                );
        }