/// <summary> /// Creates a new instance of LightningEnvironment. /// </summary> /// <param name="directory">Directory for storing database files.</param> /// <param name="openFlags">Database open options.</param> /// <param name="accessMode">Unix file access privelegies (optional). Only makes sense on unix operationg systems.</param> public LightningEnvironment(string directory, EnvironmentOpenFlags openFlags = EnvironmentOpenFlags.None, UnixAccessMode accessMode = UnixAccessMode.Default) { if (String.IsNullOrWhiteSpace(directory)) throw new ArgumentException("Invalid directory name"); IntPtr handle = default(IntPtr); NativeMethods.Execute(lib => lib.mdb_env_create(out handle)); _shouldDispose = true; _handle = handle; _accessMode = accessMode; this.Directory = directory; _openFlags = openFlags; if (LightningConfig.Environment.DefaultMapSize != LightningConfig.Environment.LibDefaultMapSize) this.MapSize = LightningConfig.Environment.DefaultMapSize; else _mapSize = LightningConfig.Environment.LibDefaultMapSize; if (LightningConfig.Environment.DefaultMaxDatabases != LightningConfig.Environment.LibDefaultMaxDatabases) this.MaxDatabases = LightningConfig.Environment.DefaultMaxDatabases; else _maxDbs = LightningConfig.Environment.LibDefaultMaxDatabases; _openedDatabases = new ConcurrentDictionary<string, LightningDatabase>(); _databasesForReuse = new HashSet<uint>(); ConverterStore = new ConverterStore(); var defaultConverters = new DefaultConverters(); defaultConverters.RegisterDefault(this); }
public LightningEnvironment(string directory, EnvironmentOpenFlags openFlags) { if (String.IsNullOrWhiteSpace(directory)) throw new ArgumentException("Invalid directory name"); IntPtr handle = default(IntPtr); Native.Execute(() => Native.mdb_env_create(out handle)); _shouldDispose = true; _handle = handle; this.Directory = directory; _openFlags = openFlags; _mapSize = DefaultMapSize; _maxDbs = DefaultMaxDatabases; _openedDatabases = new ConcurrentDictionary<string, LightningDatabase>(); _databasesForReuse = new HashSet<uint>(); ConverterStore = new ConverterStore(); var defaultConverters = new DefaultConverters(); defaultConverters.RegisterDefault(this); }
public object Deserialize(XElement root, Deserializer deserializer) { object crObject = deserializer.GetCRObject(root); if (crObject != null) { return(crObject); } Body body = (Body)deserializer.DeserializeObject(root.Element("Body")); Shape shape = (Shape)deserializer.DeserializeObject(root.Element("Shape")); Fixture fixture = new Fixture(body, shape); deserializer.DeserializeMetadata(root, fixture); deserializer.AddToCRList(root, fixture); fixture.CollisionCategories = (Category)DefaultConverters.StringToInt(root.Attribute("CategoryBits").Value); fixture.CollidesWith = (Category)DefaultConverters.StringToInt(root.Attribute("MaskBits").Value); fixture.CollisionGroup = (short)DefaultConverters.StringToShort(root.Attribute("GroupIndex").Value); fixture.Friction = (float)DefaultConverters.StringToFloat(root.Attribute("Friction").Value); fixture.IsSensor = (bool)DefaultConverters.StringToBool(root.Attribute("IsSensor").Value); fixture.Restitution = (float)DefaultConverters.StringToFloat(root.Attribute("Restitution").Value); return(fixture); }
public static TypeConverter GetConverter(Type type) { if (type == null) { throw new ArgumentNullException("type"); } var attributes = type.GetCustomAttributes( typeof(TypeConverterAttribute), true); if (attributes.Length > 0) { return(( TypeConverter )Activator.CreateInstance( Type.GetType( ((TypeConverterAttribute)attributes[0]).ConverterTypeName, true) )); } if (DefaultConverters.ContainsKey(type)) { return(( TypeConverter ) Activator.CreateInstance(DefaultConverters[type])); } return(null); }
public void GetPolicies(JsonSerializerOptions options) { if (ClassType == ClassType.Enumerable) { EnumerableConverter = DefaultConverters.GetEnumerableConverter(Type, propertyInfo: null, Type, options); } }
public LightningEnvironment(string directory, EnvironmentOpenFlags openFlags, UnixAccessMode accessMode = UnixAccessMode.Default) { if (String.IsNullOrWhiteSpace(directory)) throw new ArgumentException("Invalid directory name"); IntPtr handle = default(IntPtr); Native.Execute(lib => lib.mdb_env_create(out handle)); _shouldDispose = true; _handle = handle; _accessMode = accessMode; this.Directory = directory; _openFlags = openFlags; _mapSize = DefaultMapSize; _maxDbs = DefaultMaxDatabases; _openedDatabases = new ConcurrentDictionary<string, LightningDatabase>(); _databasesForReuse = new HashSet<uint>(); ConverterStore = new ConverterStore(); var defaultConverters = new DefaultConverters(); defaultConverters.RegisterDefault(this); }
public ValueBinder <TParams, TField> Compile(bool withDefaults) { IEnumerable <Converter <TField> > converters; if (withDefaults) { Converter <TField>[] defaultConverters = DefaultConverters.To <TField>(); if (Converters.Count > 0) { Converters.AddRange(defaultConverters); converters = Converters; } else { converters = defaultConverters; } } else { converters = Converters; } return(new ValueBinder <TParams, TField>( Member?.Name, CompileGetter(Member), converters)); }
/// <summary> /// Initializes a new instance of the <see cref="XmlSerializerSettings"/> class. /// </summary> /// <remarks> /// The following table shows the initial property values for an instance of <see cref="DefaultXmlConverter"/>. /// <list type="table"> /// <listheader> /// <term>Property</term> /// <description>Initial Value</description> /// </listheader> /// <item> /// <term><see cref="Reader"/></term> /// <description><see cref="XmlReaderUtility.CreateSettings"/></description> /// </item> /// <item> /// <term><see cref="Writer"/></term> /// <description><see cref="XmlWriterUtility.CreateSettings"/></description> /// </item> /// <item> /// <term><see cref="Converters"/></term> /// <description><see cref="List{XmlConverter}"/></description> /// </item> /// <item> /// <term><see cref="RootName"/></term> /// <description><c>null</c></description> /// </item> /// </list> /// </remarks> public XmlSerializerSettings() { Writer = XmlWriterUtility.CreateSettings(); Reader = XmlReaderUtility.CreateSettings(); Converters = new List <XmlConverter>(); DefaultConverters?.Invoke(Converters); }
internal static ClassType GetClassType(Type type) { Debug.Assert(type != null); if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { type = Nullable.GetUnderlyingType(type); } if (DefaultConverters.IsValueConvertable(type)) { return(ClassType.Value); } if (typeof(IDictionary).IsAssignableFrom(type) || (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(IDictionary <,>) || type.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary <,>)))) { return(ClassType.Dictionary); } if (typeof(IEnumerable).IsAssignableFrom(type)) { return(ClassType.Enumerable); } if (type == typeof(object)) { return(ClassType.Unknown); } return(ClassType.Object); }
public XElement Serialize(string name, object rootObject, Serializer serializer) { XElement root = new XElement(name); //Обрабатываем кольцевые ссылки if (serializer.CheckCircularReferences(root, rootObject)) { return(root); } //Сериализуем метаданные Serializer.SerializeMetadata(root, rootObject); //Сериализуем имя типа Serializer.SerializeTypeName(root, typeof(Fixture)); Fixture fixture = (Fixture)rootObject; root.Add(serializer.SerializeObject("Shape", fixture.Shape)); root.Add( new XAttribute("CategoryBits", DefaultConverters.IntToString((int)fixture.CollisionCategories)), new XAttribute("MaskBits", DefaultConverters.IntToString((int)fixture.CollidesWith)), new XAttribute("GroupIndex", DefaultConverters.ShortToString(fixture.CollisionGroup)), new XAttribute("Friction", DefaultConverters.FloatToString(fixture.Friction)), new XAttribute("IsSensor", DefaultConverters.BoolToString(fixture.IsSensor)), new XAttribute("Restitution", DefaultConverters.FloatToString(fixture.Restitution)), serializer.SerializeObject("Body", fixture.Body)); return(root); }
protected JsonValueConverter <TValue> GetPropertyValueConverter(JsonSerializerOptions options) { JsonValueConverterAttribute attr = DefaultConverters.GetPropertyValueConverter(ParentClassType, PropertyInfo, PropertyType, options); if (attr != null) { return(attr.GetConverter <TValue>()); } return(null); }
/// <summary> /// <see cref="CsvConverter"/>を返します。<see cref="CsvConverter"/>が存在しない場合は例外をスローします。 /// </summary> /// <param name="property"><see cref="PropertyInfo"/>。</param> /// <returns><see cref="CsvConverter"/>。</returns> private CsvConverter GetConverter(PropertyInfo property) { if (this.converter != null) { return(this.converter); } var converter = DefaultConverters.GetOrNull(property.PropertyType); if (converter != null) { return(converter); } throw new InvalidOperationException("I couldn't find a converter for the property type."); }
/// <summary> /// <see cref="CsvConverter"/>を返します。<see cref="CsvConverter"/>が存在しない場合は例外をスローします。 /// </summary> /// <param name="property"><see cref="PropertyInfo"/>。</param> /// <returns><see cref="CsvConverter"/>。</returns> private static CsvConverter GetConverter(PropertyInfo property) { var a = property.GetCustomAttribute <CsvConverterAttribute>(); if (a != null) { return(a.CreateConverter()); } var converter = DefaultConverters.GetOrNull(property.PropertyType); if (converter != null) { return(converter); } throw new InvalidOperationException("I couldn't find a converter for the property type."); }
public static ClassType GetClassType(Type type) { Debug.Assert(type != null); if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { type = Nullable.GetUnderlyingType(type); } if (DefaultConverters.IsValueConvertable(type)) { return(ClassType.Value); } if (DefaultImmutableDictionaryConverter.IsImmutableDictionary(type) || IsDeserializedByConstructingWithIDictionary(type)) { return(ClassType.IDictionaryConstructible); } if (typeof(IDictionary).IsAssignableFrom(type) || (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(IDictionary <,>) || type.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary <,>)))) { return(ClassType.Dictionary); } if (IsKeyValuePair(type)) { return(ClassType.KeyValuePair); } if (typeof(IEnumerable).IsAssignableFrom(type)) { return(ClassType.Enumerable); } if (type == typeof(object)) { return(ClassType.Unknown); } return(ClassType.Object); }
public XElement Serialize(string name, object rootObject, Serializer serializer) { XElement root = new XElement(name); //Обрабатываем кольцевые ссылки if (serializer.CheckCircularReferences(root, rootObject)) { return(root); } //Сериализуем метаданные Serializer.SerializeMetadata(root, rootObject); //Сериализуем имя типа Serializer.SerializeTypeName(root, typeof(Body)); Body body = (Body)rootObject; root.Add( new XAttribute("BodyType", DefaultConverters.IntToString((int)body.BodyType)), new XAttribute("Active", DefaultConverters.BoolToString(body.Enabled)), new XAttribute("AllowSleep", DefaultConverters.BoolToString(body.SleepingAllowed)), new XAttribute("Angle", DefaultConverters.FloatToString(body.Rotation)), new XAttribute("AngularDamping", DefaultConverters.FloatToString(body.AngularDamping)), new XAttribute("AngularVelocity", DefaultConverters.FloatToString(body.AngularVelocity)), new XAttribute("Awake", DefaultConverters.BoolToString(body.Awake)), new XAttribute("Bullet", DefaultConverters.BoolToString(body.IsBullet)), new XAttribute("FixedRotation", DefaultConverters.BoolToString(body.FixedRotation)), new XAttribute("LinearDamping", DefaultConverters.FloatToString(body.LinearDamping)), new XAttribute("LinearVelocity", DefaultConverters.Vector2ToString(body.LinearVelocity)), new XAttribute("Position", DefaultConverters.Vector2ToString(body.Position)), serializer.SerializeObject("World", SerializerHelpers.GetFieldValue(body, "World"))); XElement fixtures = new XElement("Fixtures"); for (int i = 0; i < body.FixtureList.Count; i++) { fixtures.Add(serializer.SerializeObject("Fixture", body.FixtureList[i])); } root.Add(fixtures); return(root); }
public XElement Serialize(string name, object rootObject, Serializer serializer) { XElement root = new XElement(name); //Обрабатываем кольцевые ссылки if (serializer.CheckCircularReferences(root, rootObject)) { return(root); } //Сериализуем метаданные Serializer.SerializeMetadata(root, rootObject); //Сериализуем имя типа Serializer.SerializeTypeName(root, typeof(World)); //Сериализуем гравитацию World world = (World)rootObject; root.Add( new XAttribute("Gravity", DefaultConverters.Vector2ToString(world.Gravity))); //Сериализуем bodies XElement bodies = new XElement("Bodies"); for (int i = 0; i < world.BodyList.Count; i++) { bodies.Add(serializer.SerializeObject("Body", world.BodyList[i])); } //Сериализуем joint'ы XElement joints = new XElement("Joints"); foreach (Joint joint in world.JointList) { joints.Add(serializer.SerializeObject("Joint", joint)); } root.Add(bodies); root.Add(joints); return(root); }
public virtual void GetPolicies(JsonSerializerOptions options) { { PropertyNamePolicyAttribute attr = DefaultConverters.GetPolicy <PropertyNamePolicyAttribute>(ParentClassType, PropertyInfo, options); if (attr != null) { NameConverter = attr; } } { _skipNullValuesOnRead = DefaultConverters.GetPropertyClassAssemblyPolicy(ParentClassType, PropertyInfo, options, attr => attr.SkipNullValuesOnRead); _skipNullValuesOnWrite = DefaultConverters.GetPropertyClassAssemblyPolicy(ParentClassType, PropertyInfo, options, attr => attr.SkipNullValuesOnWrite); } if (ElementClassInfo != null) { EnumerableConverter = DefaultConverters.GetEnumerableConverter(ParentClassType, PropertyInfo, PropertyType, options); } }
public object Deserialize(XElement root, Deserializer deserializer) { //Проверяем, был ли уже сериализован данный объект object crObject = deserializer.GetCRObject(root); if (crObject != null) { return(crObject); } //Десериализуем гравитацию и создаём новый world Vector2 gravity = (Vector2)DefaultConverters.StringToVector2(root.Attribute("Gravity").Value); World world = new World(gravity); deserializer.DeserializeMetadata(root, world); //Добавляем world в список уже десериализованных объектов deserializer.AddToCRList(root, world); //Десериализуем bodies var bodiesElement = root.Element("Bodies"); var bodyElements = bodiesElement.Elements("Body"); foreach (XElement bodyElement in bodyElements) { Body body = (Body)deserializer.DeserializeObject(bodyElement); world.BodyList.Add(body); } //Десериализуем joint'ы var jointsElement = root.Element("Joints"); var jointElements = jointsElement.Elements("Joint"); foreach (XElement jointElement in jointElements) { Joint joint = (Joint)deserializer.DeserializeObject(jointElement); world.AddJoint(joint); } return(world); }
public object Deserialize(XElement root, Deserializer deserializer) { object crObject = deserializer.GetCRObject(root); if (crObject != null) { return(crObject); } World world = (World)deserializer.DeserializeObject(root.Element("World")); Body body = new Body(world); deserializer.DeserializeMetadata(root, body); deserializer.AddToCRList(root, body); body.BodyType = (BodyType)DefaultConverters.StringToInt(root.Attribute("BodyType").Value); body.Enabled = (bool)DefaultConverters.StringToBool(root.Attribute("Active").Value); body.SleepingAllowed = (bool)DefaultConverters.StringToBool(root.Attribute("AllowSleep").Value); body.Rotation = (float)DefaultConverters.StringToFloat(root.Attribute("Angle").Value); body.AngularDamping = (float)DefaultConverters.StringToFloat(root.Attribute("AngularDamping").Value); body.AngularVelocity = (float)DefaultConverters.StringToFloat(root.Attribute("AngularVelocity").Value); body.Awake = (bool)DefaultConverters.StringToBool(root.Attribute("Awake").Value); body.IsBullet = (bool)DefaultConverters.StringToBool(root.Attribute("Bullet").Value); body.FixedRotation = (bool)DefaultConverters.StringToBool(root.Attribute("FixedRotation").Value); body.LinearDamping = (float)DefaultConverters.StringToFloat(root.Attribute("LinearDamping").Value); body.LinearVelocity = (Vector2)DefaultConverters.StringToVector2(root.Attribute("LinearVelocity").Value); body.Position = (Vector2)DefaultConverters.StringToVector2(root.Attribute("Position").Value); var fixturesElement = root.Element("Fixtures"); var fixtureElements = fixturesElement.Elements("Fixture"); foreach (XElement fixtureElement in fixtureElements) { Fixture fixture = (Fixture)deserializer.DeserializeObject(fixtureElement); body.FixtureList.Add(fixture); } return(body); }
internal override void GetPolicies(JsonSerializerOptions options) { Type propertyType = PropertyType; bool isNullable = propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(Nullable <>); if (isNullable) { propertyType = Nullable.GetUnderlyingType(propertyType); } // For Enums, support both the type Enum plus strongly-typed Enums. if (propertyType.IsEnum || propertyType == typeof(Enum)) { ValueConverter = s_enumConverter; } else { ValueConverter = (JsonValueConverter <TProperty>)DefaultConverters.GetDefaultPropertyValueConverter(propertyType, isNullable); } base.GetPolicies(options); }
private static void RegisterDefaultConverter <T>(Func <string, T> converter) { DefaultConverters.Add(typeof(T), converter); }
protected PropertyValueConverterAttribute GetPropertyValueConverter(JsonSerializerOptions options) { PropertyValueConverterAttribute attr = DefaultConverters.GetPropertyValueConverter(ParentClassType, PropertyInfo, PropertyType, options); return(attr); }
public static Func <string, T> GetDefaultConverter <T>() //TODO: nasty. Way that doesn't compromise compile-time type safety? { object converter; return(DefaultConverters.TryGetValue(typeof(T), out converter) ? (Func <string, T>)converter : DefaultDotNet <T>()); }