nhibernate[1].mapping.csgen

mygeneration 自动生成影射文件

		
		foreach( IColumn field in Columns )
		{
			if( field.IsInForeignKey && !field.IsInPrimaryKey )
			{%>
		private <%= ToPascalCase( field.ForeignKeys[0].PrimaryTable.Alias.Replace( " ", "" ) ) %> <%= ColumnToMemberVariable( field ) %>; <%
			}
			else
			{%>
		private <%= ColumnToNHibernateType( field ) %> <%= ColumnToMemberVariable( field ) %>; <%
			}
		}
%>		
		#endregion<%
		}
	}
	
	private void BuildInternalAccessors( IColumns Columns )
	{
		if( Columns.Count > 0 )
		{
		%>#region Internal Accessors for NHibernate
		<%
			foreach( IColumn field in Columns )
			{
				string fieldAccessor = ColumnToNHibernateProperty( field );
				string fieldName = ColumnToMemberVariable( field );
			%>
		#region <%= fieldAccessor %>
		/// <summary>
		/// <%= field.Description %>
		/// </summary>
		internal <%= ColumnToNHibernateType( field ) %> <%= fieldAccessor %>
		{
			get { return <%= fieldName %>; }
			set { <%= fieldName %> = value; }
		}
		#endregion
		<%
			}
%>
		#endregion // Internal Accessors for NHibernate <%
		}
	}
	
	private void BuildPublicAccessors( IColumns Columns )
	{
		if( Columns.Count > 0 )
		{
			%>#region Public Properties
			<%
			
			foreach( IColumn field in Columns )
			{
				string fieldAccessor = ColumnToPropertyName( field );
				string fieldName = ColumnToMemberVariable( field );
				string fieldType = ( field.IsInForeignKey && !field.IsInPrimaryKey ? ToPascalCase( field.ForeignKeys[0].PrimaryTable.Alias.Replace( " ", "" ) ) : ColumnToNHibernateType( field ) );
			%>
		/// <summary>
		/// <%= field.Description %>
		/// </summary>		
		public <%= fieldType %> <%= fieldAccessor %>
		{
			get { return <%= fieldName %>; }<%
				if( !_createReadOnly )
				{
					//if(!((field.IsInPrimaryKey && field.IsAutoKey) || field.IsComputed))
					//{
						switch( fieldType )
						{
							default:%>
			set { <%= _prefix %>isChanged |= (<%= fieldName %> != value); <%= fieldName %> = value; }<%						
								break;
							case "byte": %>
			set	
			{
				if( value.Length > <%= field.CharacterMaxLength.ToString() %>)
					throw new ArgumentOutOfRangeException("Invalid value for <%= fieldAccessor %>", value, value.ToString());
				
				<%= _prefix %>isChanged |= (<%= fieldName %> != value); <%= fieldName %> = value;
			}
<%
								break;
							case "string": %>
			set	
			{
				if( value.Length > <%= field.CharacterMaxLength.ToString() %>)
					throw new ArgumentOutOfRangeException("Invalid value for <%= fieldAccessor %>", value, value.ToString());
				
				<%= _prefix %>isChanged |= (<%= fieldName %> != value); <%= fieldName %> = value;
			}<%						
								break;
					}
				//}
			}%>
		}
			<%
			}
			
			%>
		/// <summary>
		/// Returns whether or not the object has changed it's values.
		/// </summary>
		public bool IsChanged
		{
			get { return <%= _prefix %>isChanged; }
		}
		
		/// <summary>
		/// Returns whether or not the object has changed it's values.
		/// </summary>
		public bool IsDeleted
		{
			get { return <%= _prefix %>isDeleted; }
		}
		
		#endregion <%
		}
	}
	
	private void BuildPublicFunctions( IColumns Columns )
	{%>
		#region Public Functions
		
		/// <summary>
		/// mark the item as deleted
		/// </summary>
		public void MarkAsDeleted()
		{
			<%= _prefix %>isDeleted = true;
			<%= _prefix %>isChanged = true;
		}
		
		#endregion<%
	}
	
	private void BuildHBMDefinition( IColumns Columns )
	{
		if( Columns.Count > 0 )
		{
			output.writeln( "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" );
			output.writeln( NHibernateMappingTag() );
			output.writeln( "\t" + NHibernateClassTag( Columns ) );
			output.writeln( "\t\t" + NHibernatePrimaryKeysTag( Columns ) );
			output.writeln( "\t\t" + NHibernateProperties( Columns ) );
			output.writeln( "\t</class>" );
			output.writeln( "</hibernate-mapping>" );
		}
	}
	
	private string NHibernateMappingTag()
	{
		//// can't handle external mappings ?!?
		////string xml = "<hibernate-mapping xmlns=\"http://nhibernate.sourceforge.net/schemas/nhibernate-mapping-2.0.xsd\"";
		//string xml = "<hibernate-mapping xmlns=\"urn:nhibernate-mapping-2.0\"";
		//// handle schemas, cascade, import, and access methods?
		//return xml + ">";
		return "<hibernate-mapping xmlns=\"urn:nhibernate-mapping-2.0\">";
	}
	
	private string NHibernateClassTag( IColumns Columns )
	{
		//ITable t = Columns[0].Table;
		//IView v = Columns[0].View;
		//string desc = ( t == null ) ? v.Description : t.Description;
		StringBuilder xml = new StringBuilder();
		xml.Append( "<class name=\"" ).Append( _nameSpace ).Append( "." ).Append( _className ).Append( "," ).Append( _nameSpace ).Append( "\"" );
		xml.Append( " table=\"" ).Append( _tableName ).Append( "\"" );
		if( _createReadOnly )
		{
			xml.Append( " mutable=\"false\"" );
		}
		// handle schema override, dynamic insert & update, and proxies?
		xml.Append( ">\r\n" );
		return xml.ToString();
	}
	
	private string NHibernatePrimaryKeysTag( IColumns Columns )
	{
		StringBuilder xml = new StringBuilder();
		int i = 0;
		foreach( IColumn c in Columns )
		{
			if( c.IsInPrimaryKey )
			{
				i++;
			}
		}
		if( i == 0 )
		{
			return "<!-- could not find a primary key for this table/view. NHibernate requires an 'id' element, so you'll have to define one manually. -->";
		}
		if( i == 1 )
		{
			foreach( IColumn c in Columns )
			{
				if( c.IsInPrimaryKey )
				{
					xml.Append( "<id name=\"" ).Append( ColumnToPropertyName( c ) ).Append( "\" column=\"" );
					xml.Append( c.Alias ).Append( "\" type=\"" ).Append( ConvertNHibernate( ColumnToNHibernateType( c ) ) ).Append( "\"" );
					switch( ColumnToNHibernateType( c ) )
					{
						case "decimal":
						case "float":
						case "short":
						case "int":
						case "long":
							xml.Append( " unsaved-value=\"0\">\r\n" );
							break;
						default:
							xml.Append( ">\r\n" );
							break;
					}
					xml.Append( "\t\t\t<generator class=\"" );
					xml.Append( ( c.IsAutoKey ) ?  "native" : "assigned" );
					xml.Append( "\"/>\r\n\t\t</id>" );
				}
			}
		}
		if( i > 1 )
		{
			xml.Append( "<!-- composite primary key support is touchy. View the documentation for syntax. -->" );
		}
		return xml.ToString();
	}
	
	private string NHibernateProperties( IColumns Columns )
	{
		StringBuilder xml = new StringBuilder();
		foreach( IColumn c in Columns )
		{
			if( !c.IsInPrimaryKey )
			{
				// create sets & such for foreign keys !!!
				if( c.IsInForeignKey )
				{
					if( c.ForeignKeys.Count > 1 )
					{
						xml.Append( "<!-- more than one foreign column is mapped to " ).Append( c.Name ).Append( " - you're on your own. -->\r\n\t\t" );
					}
					else
					{
						IForeignKey fk = c.ForeignKeys[0];
						xml.Append( "<many-to-one name=\"" ).Append( ColumnToPropertyName( c ) ).Append( "\" column=\"" ).Append( c.Name );
						xml.Append( "\" class=\"" ).Append( _nameSpace ).Append( "." ).Append( ToPascalCase( fk.PrimaryTable.Alias.Replace( " ", "" ) ) ).Append( "," ).Append( _nameSpace ).Append( "\" />\r\n\t\t" );
					}
				}
				else
				{
					xml.Append( "<property column=\"" ).Append( c.Name );
					xml.Append( "\" type=\"" ).Append( ConvertNHibernate( ColumnToNHibernateType( c ) ) ).Append( "\"" );
					if( _createReadOnly )
					{
						xml.Append( " access=\"field\" name=\"" ).Append( ColumnToMemberVariable( c ) ).Append( "\"" );
					}
					else
					{
						 xml.Append( " name=\"" ).Append( ColumnToPropertyName( c ) ).Append( "\"" );
					}
					if( !c.IsNullable )
					{
						xml.Append( " not-null=\"true\"" );
					}
					if( c.LanguageType == "string" )
					{
						xml.Append( " length=\"" ).Append( c.CharacterMaxLength ).Append( "\"" );
					}
					xml.Append( " />\r\n\t\t" );
				}
			}
		}
		return xml.ToString();
	}
	
	private string ConvertNHibernate( string Type )
	{
		string retVal = Type;
		
		switch( Type )
		{
			case "bool":
				retVal = "Boolean";
				break;
			case "byte":
				retVal = "Byte";
				break;
			case "sbyte":
				retVal = "SByte";
				break;
			case "char":
				retVal = "Char";
				break;
			case "decimal":
				retVal = "Decimal";
				break;
			case "double":
				retVal = "Double";
				break;
			case "float":
				retVal = "Single";
				break;
			case "int":
				retVal = "Int32";
				break;
			case "uint":
				retVal = "UInt32";
				break;
			case "long":
				retVal = "Int64";
				break;
			case "ulong":
				retVal = "UInt64";
				break;
			case "short":
				retVal = "Int16";
				break;
			case "ushort":
				retVal = "UInt16";
				break;
			case "string":
				retVal = "String";
				break;
		}
		
		return retVal;
	}
	
	private string ColumnToMemberVariable( IColumn Column )
	{
		return _prefix + UniqueColumn( Column ).ToLower();
	}
	
	private string ColumnToPropertyName( IColumn Column )
	{
		return ToPascalCase( UniqueColumn( Column ) );
	}
	
	private string ColumnToArgumentName( IColumn Column )
	{
		return UniqueColumn( Column ).ToLower();
	}
	
	private string ColumnToNHibernateProperty( IColumn Column )
	{
		return _prefix + UniqueColumn( Column );
	}
	
	private string UniqueColumn( IColumn Column )
	{
		string c = Column.Alias.Replace( " ", "" );
		if( Column.Table != null && Column.Table.Alias.Replace( " ", "" ) == c )
		{
			c += "Name";
		}
		if( Column.View != null && Column.View.Alias.Replace( " ", "" ) == c )
		{
			c += "Name";
		}
		return c;
	}
	
	// nhibernate doesn't have these, so use the existing types
	private string ColumnToNHibernateType( IColumn Column )
	{
		string retVal = Column.LanguageType;
		
		switch( Column.LanguageType )
		{
			case "sbyte":
				retVal = "byte";
				break;
			case "uint":
				retVal = "int";
				break;
			case "ulong":
				retVal = "long";
				break;
			case "ushort":
				retVal = "short";
				break;
		}
		
		return retVal;
	}
	
	private string ToLeadingCaps( string name )
	{
		char[] chars = name.ToLower().ToCharArray();
		chars[0] = Char.ToUpper( chars[0] );
		return new string( chars );
	}
	
	private string ToLeadingLower( string name )
	{
		char[] chars = name.ToCharArray();
		chars[0] = Char.ToLower( chars[0] );
		return new string( chars );
	}
	
	private string ToPascalCase( string name )
	{
		string notStartingAlpha = Regex.Replace( name, "^[^a-zA-Z]+", "" );
		string workingString = ToLowerExceptCamelCase( notStartingAlpha );
		workingString = RemoveSeparatorAndCapNext( workingString );
		return workingString;
	}
	
	private string RemoveSeparatorAndCapNext( string input )
	{
		string dashUnderscore = "-_";
		string workingString = input;
		char[] chars = workingString.ToCharArray();
		int under = workingString.IndexOfAny( dashUnderscore.ToCharArray() );
		while( under > -1 )
		{
			chars[ under + 1 ] = Char.ToUpper( chars[ under + 1 ], CultureInfo.InvariantCulture );
			workingString = new String( chars );
			under = workingString.IndexOfAny( dashUnderscore.ToCharArray(), under + 1 );
		}
		chars[ 0 ] = Char.ToUpper( chars[ 0 ], CultureInfo.InvariantCulture );
		workingString = new string( chars );
		return Regex.Replace( workingString, "[-_]", "" );
	}

	private string ToLowerExceptCamelCase( string input )
	{
		char[] chars = input.ToCharArray();
		for( int i = 0; i < chars.Length; i++ )
		{
			int left = ( i > 0 ? i - 1 : i );
			int right = ( i < chars.Length - 1 ? i + 1 : i );
			if( i != left && i != right )
			{
				if( Char.IsUpper( chars[i] ) && Char.IsLetter( chars[ left ] ) && Char.IsUpper( chars[ left ] ) )
				{
					chars[i] = Char.ToLower( chars[i], CultureInfo.InvariantCulture );
				}
				else if( Char.IsUpper( chars[i] ) && Char.IsLetter( chars[ right ] ) && Char.IsUpper( chars[ right ] ) )
				{
					chars[i] = Char.ToLower( chars[i], CultureInfo.InvariantCulture );
				}
				else if( Char.IsUpper( chars[i] ) && !Char.IsLetter( chars[ right ] ) )
				{
					chars[i] = Char.ToLower( chars[i], CultureInfo.InvariantCulture );
				}
			}
		}
		chars[ chars.Length - 1 ] = Char.ToLower( chars[ chars.Length - 1 ], CultureInfo.InvariantCulture );
		return new string( chars );
	}
	
	private int CountRequiredFields( IColumns Columns )
	{
		return Columns.Count - CountNullableFields( Columns );
	}
	
	private int CountNullableFields( IColumns Columns )
	{
		int i = 0;
		foreach( IColumn c in Columns )
		{
			if( c.IsNullable )
			{
				i++;
			}
		}
		return i;
	}
	
	private int CountUniqueFields( IColumns Columns )
	{
		int i = 0;
		foreach( IColumn c in Columns )
		{
			if( !c.IsNullable && c.IsInPrimaryKey )
			{
				i++;
			}
		}
		return i;
	}
}
%>
##|BODY_END