/// <summary> /// Initializes a new instance of IdentityMap. /// </summary> /// <param name="owner"><see cref="T:FieldMap"/> this identity belongs to.</param> /// <param name="format"><see cref="T:IdentityFormat"/> of the identity.</param> /// <param name="increment"><see cref="T:IdentityIncrement"/> of the identity.</param> public IdentityMap( FieldMap owner, IdentityFormat format, IdentityIncrement increment ) { this.Owner = owner; this.Format = format; this.Increment = increment; if ( this.Format == IdentityFormat.Guid ) { this.UnsavedValue = new Guid(); } else if ( this.Format == IdentityFormat.Integer ) { this.UnsavedValue = 0; } else if ( this.Format == IdentityFormat.String ) { this.UnsavedValue = String.Empty; } }
private void HandleField( PropertyInfo f, IFieldAttribute a, Type t ) { if( a is PersistentFieldAttribute ) { PersistentFieldAttribute attribute = a as PersistentFieldAttribute; string tablename = attribute.Name; this.Context.AddChild( new PersistentFieldMap() { Field = f, ChildReturnType = attribute.ChildReturnType ?? f.PropertyType, Cascade = attribute.Cascade, Lazy = ( attribute.Loading == Loading.Active ? false : true ), Linked = attribute.Linked } .WithBehavior( attribute.Behavior ) .WithLinkedTable( attribute.LinkName ) .WithParentKeyColumn( attribute.LinkLeft ) .WithChildKeyColumn( attribute.LinkRight ) .WithTable( tablename ) ); } else if( a is FieldAttribute ) { FieldAttribute attribute = a as FieldAttribute; FieldMap fm = new FieldMap() { Field = f, Behavior = attribute.Behavior, Cascade = attribute.Cascade, DefaultValue = attribute.DefaultValue, MappingType = attribute.MappingType, Name = attribute.Name, Parent = attribute.Parent, Static = attribute.IsStatic, AllowNull = attribute.AllowNull }; switch( attribute.MappingType ) { case FieldMappingType.ForeignKey: { this.HandleForeignKey( fm ); break; } case FieldMappingType.ManagedPrimaryKey: case FieldMappingType.PrimaryKey: { this.Context.SetPrimaryKey( fm, ( ( PrimaryKeyAttribute )attribute ).UnsavedValue ); break; } case FieldMappingType.PrimaryForeignKey: { this.HandlePrimaryForeignKey( fm ); break; } case FieldMappingType.Reference: { this.Context.AddReferencedField( fm ); break; } case FieldMappingType.Value: { this.Context.AddField( fm ); break; } } EncryptedAttribute encrypted = Utility.GetCustomFieldAttribute<EncryptedAttribute>( f ); if( encrypted.NotNull() ) fm.WithEncryption( encrypted.PrivateKey, encrypted.Algorithm ); } }
private void HandlePrimaryForeignKey( FieldMap mapping ) { this.Context.SetPrimaryKey( mapping ); this.Context.AddForeignKey( mapping ); this.Context.AddField( mapping ); }
private void HandleForeignKey( FieldMap mapping ) { if( this.CanMapByType( mapping.FieldReturnType ) || mapping.FieldReturnType.IsIdentity() ) this.Context.AddForeignKey( mapping ); else throw new MappingException( String.Format( System.Globalization.CultureInfo.InvariantCulture, @"Unable to map {0} as a foreign key in type {1}. Type is either not maked as Persistent or the return type of the member is not a compatible identity type (Int, Guid, String).", mapping.Name, this.Context.Type ) ); }
/// <summary> /// Sets this TypeMap's <see cref="P:PrimaryKey"/>. /// </summary> /// <param name="fm"><see cref="T:FieldMap"/> that represents the primary key.</param> /// <param name="unsavedValue">Value for Persist to use as a compare value to determine if the primary key is new or already set.</param> /// <returns><see cref="T:IdentityMap"/> for fluent coding.</returns> public IdentityMap SetPrimaryKey( FieldMap fm, object unsavedValue ) { fm.Map = this; IdentityIncrement increment = ( fm.MappingType == FieldMappingType.ManagedPrimaryKey ? IdentityIncrement.Manual : IdentityIncrement.Auto ); fm.Identity = new IdentityMap( fm, Utility.GetIdentityFormat( fm.FieldReturnType ), increment ); if ( !unsavedValue.Null() ) { fm.Identity.UnsavedValue = unsavedValue; } this.m_primarykey = fm; return ( this.PrimaryKey.Identity ); }
/// <summary> /// Sets this TypeMap's <see cref="P:PrimaryKey"/>. /// </summary> /// <param name="fm"><see cref="T:FieldMap"/> that represents the primary key.</param> /// <returns><see cref="T:IdentityMap"/> for fluent coding.</returns> public IdentityMap SetPrimaryKey( FieldMap fm ) { return ( this.SetPrimaryKey( fm, null ) ); }
/// <summary> /// Adds a reference field to the TypeMap. /// </summary> /// <param name="fm"><see cref="T:FieldMap"/> to add.</param> public void AddReferencedField( FieldMap fm ) { fm.Map = this; this.m_referenced.Add( fm ); }
/// <summary> /// Adds a foreign key to the TypeMap. /// </summary> /// <param name="fm"><see cref="T:FieldMap"/> to add.</param> public void AddForeignKey( FieldMap fm ) { fm.Map = this; this.m_foreignkeys.Add( fm ); }
/// <summary> /// Adds a field to the TypeMap. /// </summary> /// <param name="fm"><see cref="T:FieldMap"/> to add.</param> public void AddField( FieldMap fm ) { fm.Map = this; this.m_fields.Add( fm ); }