/// <summary>
        /// Maps the defined <see cref="Type"/> to the supplied <see cref="TypeMap"/> using 
        /// attributes from the <see cref="N:Ikarii.Lib.Data.Alpaca.Attributes"/> namespace.
        /// </summary>
        /// <param name="t"><see cref="Type"/> to map.</param>
        /// <param name="otm"><see cref="TypeMap"/> instance to populate with mappings.</param>
        public override void MapByType( Type t, TypeMap otm )
        {
            this.Context = otm;
                                                this.Context.Table = this.GetTableName( t );
                                                this.Context.SetNamingConvention( this.GetConvention( t ) );

                                                List<PropertyInfo> fields = new List<PropertyInfo>( t.GetProperties() );

                                                fields.FindAll( f => ValidField( f, t ) )
                                                    .ForEach( f => this.HandleField( f, Utility.GetCustomFieldAttribute<IFieldAttribute>( f ), t ) );
        }
Пример #2
0
        /// <summary>
        /// Maps the given <see cref="T:Type"/> <paramref name="t"/> to the specified <see cref="T:TypeMap"/> <paramref name="otm"/>.
        /// </summary>
        /// <param name="t"><see cref="T:Type"/> to map.</param>
        /// <param name="otm"><see cref="T:TypeMap"/> to populate.</param>
        public override void MapByType( Type t, TypeMap otm )
        {
            this.Context = otm;
            this.Context.SetNamingConvention( Configuration.AlpacaConfiguration.Settings.GetNamingConvention() );

            List<PropertyInfo> fields = new List<PropertyInfo>( t.GetProperties() );

            this.Context.SetPrimaryKey( FindPrimaryKey( fields ) );
            this.FindChildren( fields );
            this.FindForeignKeys( fields );
            this.FindReferencedFields( fields );
            fields.FindAll( f => Utility.IsElemental( f.PropertyType ) )
                .ForEach( value => this.HandleField( value ) );
        }
Пример #3
0
 /// <summary>
 /// Instantiates PersistentPackage to be used for persistence operations.
 /// <remarks>This is useful when you have a sub class instantiated and want to deserialize or serialize it's base.</remarks>
 /// </summary>
 /// <param name="o"><see cref="T:Object"/> marked with <see cref="T:Ikarii.Lib.Data.Alpaca.PersistentAttribute"/>.</param>
 /// <param name="t"><see cref="T:Type"/> marked with <see cref="T:Ikarii.Lib.Data.Alpaca.PersistentAttribute"/>.</param>
 /// <param name="parent">Parent <see cref="T:ObjectTypeMap"/> which will be used in operations where the ForeignKey of this object is needed.</param>
 /// <param name="mappingProvider">The <see cref="T:IMappingProvider"/> used to create the <see cref="T:PersistentObject"/>.</param>
 internal ObjectPackage( object o, Type t, TypeMap parent, IMappingProvider mappingProvider )
 {
     this.MappingProvider = mappingProvider;
     this.ParentMap = parent;
     this.Instance = o;
     if ( TypeCache.ContainsType( t ) )
     {
         this.Map = TypeCache.GetType( t );
     }
     else
     {
         this.Map = new TypeMap( t, mappingProvider );
         TypeCache.AddType( t, this.Map );
     }
 }
Пример #4
0
        private void FindChildren( List<PropertyInfo> fields )
        {
            fields.FindAll( f => this.CanMapByType( f.PropertyType ) && f.CanWrite )
                .ForEach( child =>
                {
                    TypeMap childmap = new TypeMap( child.PropertyType, new ActiveMappingProvider() );
                    List<FieldMap> fks = childmap.ForeignKeys.ToList();
                    FieldMap fm = fks.Find( parent => parent.FieldReturnType.Equals( this.Context.Type ) );
                    this.Context.AddChild( new PersistentFieldMap()
                    {
                        Field = child,
                        ChildReturnType = child.PropertyType,
                        Behavior = FieldBehavior.Inherit,
                        Cascade = Cascade.All,
                        Linked = false,
                        Lazy = false
                    } );
                } );

            //Children that are contained in collections MUST be named plural of their type.
            //So if a Car has more than one Tire in a ICollection, the Collection must be named Tires
            fields.FindAll( f => Utility.ImplementsInterface( f.PropertyType, typeof( ICollection ) ) )
                .ForEach( child =>
                {
                    Type innerChild = Type.GetType( String.Format( "{0}.{1}", child.PropertyType.Namespace, Helper.Inflector.Singularize( child.Name ) ) );
                    TypeMap childmap = new TypeMap( innerChild, new ActiveMappingProvider() );
                    List<FieldMap> fks = childmap.ForeignKeys.ToList();
                    FieldMap fm = fks.Find( parent => parent.FieldReturnType.Equals( this.Context.Type ) );

                    this.Context.AddChild( new PersistentFieldMap()
                    {
                        Field = child,
                        ChildReturnType = child.PropertyType,
                        Behavior = FieldBehavior.Inherit,
                        Cascade = ( fm.Null() ? Cascade.Update : Cascade.All ),
                        Linked = ( fm.Null() ? true : false ),
                        Lazy = false
                    } );
                } );
        }
 /// <summary>
 /// Maps the defined <see cref="T:Type"/> to the supplied <see cref="T:TypeMap"/>.
 /// </summary>
 /// <param name="t"><see cref="T:Type"/> to map.</param>
 /// <param name="otm"><see cref="T:TypeMap"/> instance to populate with mappings.</param>
 public abstract void MapByType( Type t, TypeMap otm );
Пример #6
0
 /// <summary>
 /// Instantiates PersistentPackage to be used for persistence operations.
 /// </summary>
 /// <param name="t"><see cref="Type"/> marked with <see cref="Ikarii.Lib.Data.Alpaca.Meta.PersistentAttribute"/>.</param>
 /// <param name="parent">Parent <see cref="PersistentObject"/> which will be used in operations where the ForeignKey of this object is needed.</param>
 /// <param name="mappingProvider">The <see cref="IMappingProvider"/> used to create the <see cref="PersistentObject"/>.</param>
 internal ObjectPackage( Type t, TypeMap parent, IMappingProvider mappingProvider )
     : this(t.Assembly.CreateInstance( t.FullName ), t, parent, mappingProvider)
 {
 }
Пример #7
0
 /// <summary>
 /// Registers a <see cref="T:TypeMap"/> with the Type cache.
 /// </summary>
 /// <param name="typemap"><see cref="T:TypeMap"/> to register.</param>
 public void RegisterTypeMap( TypeMap typemap )
 {
     TypeCache.AddType( typemap.Type, typemap );
 }
Пример #8
0
 private void FindReferencedFields( List<PropertyInfo> fields )
 {
     //if field is object and can be mapped and does not have a reference to this object via identity or type
     fields.FindAll( f => this.CanMapByType( f.PropertyType ) && f.CanWrite )
         .ForEach( child =>
         {
             TypeMap childmap = new TypeMap( child.PropertyType, new ActiveMappingProvider() );
             List<FieldMap> fks = childmap.ForeignKeys.ToList();
             FieldMap fm = fks.Find( parent => parent.FieldReturnType.Equals( this.Context.Type ) );
             if ( fm.Null() )
             {
                 this.Context.AddReferencedField( new FieldMap()
                 {
                     Field = child,
                     Behavior = FieldBehavior.Inherit,
                     Cascade = Cascade.None,
                     MappingType = FieldMappingType.Reference
                 } );
             }
         } );
 }