Esempio n. 1
0
        /// <summary>Gathers persitent fields for a type.</summary>
        /// <param name="type">A type of to gather persistent fields for.</param>
        /// <param name="needStatic">Specifies if static fields need to be returned.</param>
        /// <param name="needInstance">Specifies if non-static fields need to be returned.</param>
        /// <param name="group">A filter group for the persitent fields. Note that group is ignored for
        /// the inner fields of a compound type.</param>
        /// <returns>List of persitent fields.</returns>
        public static List <PersistentField> GetPersistentFields(
            Type type, bool needStatic, bool needInstance, string group)
        {
            var result     = new List <PersistentField>();
            var fieldsInfo = FindAnnotatedFields(type, needStatic, needInstance, group);

            foreach (var fieldInfo in fieldsInfo)
            {
                var fieldAttr =
                    fieldInfo.GetCustomAttributes(typeof(BasePersistentFieldAttribute), true).First()
                    as PersistentFieldAttribute;
                try {
                    var persistentField = new PersistentField(fieldInfo, fieldAttr);
                    result.Add(persistentField);
                } catch (Exception ex) {
                    DebugEx.Error(
                        "Ignoring field {0}.{1}: {2}\n{3}",
                        type.FullName, fieldInfo.Name, ex.Message, ex.StackTrace);
                }
            }

            // Sort by config path to ensure the most top level nodes are handled before the children.
            result = result.OrderBy(x => string.Join("/", x.cfgPath)).ToList();

            return(result);
        }
Esempio n. 2
0
 /// <param name="persistentField">A persitent field descriptor.</param>
 /// <param name="valueType">A type to handle. If field is a collection then this type is a type of
 /// the collection's item.</param>
 /// <param name="simpleTypeProtoType">A proto that handles (de)serializing (in)to a simple string.
 /// if this proto cannot handle <paramref name="valueType"/> then the type will be attempted to be
 /// handled as a complex type.</param>
 internal OrdinaryFieldHandler(
     PersistentField persistentField, Type valueType, Type simpleTypeProtoType)
 {
     this.persistentField = persistentField;
     this.valueType       = valueType;
     this.simpleTypeProto = Activator.CreateInstance(simpleTypeProtoType)
                            as AbstractOrdinaryValueTypeProto;
 }
Esempio n. 3
0
        /// <param name="persistentField">A descriptor of persistent field which holds the value.</param>
        /// <param name="collectionType">A type of the collection this handler will be handling.</param>
        /// <param name="collectionProtoType">A proto type that can work with the collection.</param>
        internal CollectionFieldHandler(
            PersistentField persistentField, Type collectionType, Type collectionProtoType)
        {
            this.collectionType  = collectionType;
            this.persistentField = persistentField;

            this.collectionProto = Activator.CreateInstance(collectionProtoType, new[] { collectionType })
                                   as AbstractCollectionTypeProto;
            if (this.collectionProto == null)
            {
                throw new ArgumentException(string.Format("Bad collection proto {0}", collectionProtoType));
            }
        }