nhibernate.mapping-1.1.csgen

mygeneration 自动生成影射文件

	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" );
				}
			}
			else	
			{	// c.IsInPrimaryKey is true here
				if( c.IsInForeignKey )
				{
					//Here's where we handle one-to-many relations.  A column that is in the PK, and is involved in FK relatioships, 
					//means it's the one in the one-to-many. 
					
					foreach( IForeignKey fk in c.ForeignKeys )
					{
						//Use a bag, since we don't know the real relationship.  
						xml.Append( "<bag "); 
						
						//The name for the collection property in the class.  
						//Made from the class name of the "many" side of the 
						//relationship, with "List" appended.  
						xml.Append( "name=\"" )
						   .Append( ToPascalCase( fk.ForeignTable.Alias.Replace( " ", "" ) ) )
						   .Append( "List\" " );
						   
						//This means that persisting the class object that contains this 
						//collection will not cause the collection's elements to be persisted.
						//You have to navigate the collection and persist them individually. 
						xml.Append( "inverse=\"true\" " );
						
						//Lazy loading.  The collection is not filled until the application needs it. 
						xml.Append( "lazy=\"true\" " )
						   .Append( ">\r\n" );
						
						//The key element specifies the column in the owning class/table that is the
						//foreign key for the collection's class/table.  Note this code only supports 
						//single-column foreign keys.  
						if( fk.ForeignColumns.Count > 1 )
						{
							xml.Append( "<!-- Composite foreign keys are not supported in this template. -->\r\n" );
						}
						else
						{
							xml.Append( "\t\t\t<key column=\"" )
							   .Append( fk.ForeignColumns[0].Name )
							   .Append( "\" />\r\n" );
						}
						
						//the one-to-many tag specifies the class of the objects in the 
						//collection, the "many" side.  
						xml.Append( "\t\t\t<one-to-many class=\"" )
						   .Append( _nameSpace )
						   .Append( "." )
						   .Append( ToPascalCase( fk.ForeignTable.Alias.Replace( " ", "" ) ) )
						   .Append( "," )
						   .Append( _nameSpace )
						   .Append( "\" />\r\n" );
						
						//Close the bag tag and indent for the next column. 
						xml.Append( "\t\t</bag>\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 ColumnFKToClassName( IColumn c )
	{
		return ToPascalCase( c.ForeignKeys[0].PrimaryTable.Alias.Replace( " ", "" ) );
	}
	
	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 bool IsValueType( string type )
	{
		switch( type )
		{
			case "sbyte":
			case "byte":
			case "short":
			case "ushort":
			case "int":
			case "uint":
			case "long":
			case "ulong":
			case "char":
			case "float":
			case "double":
			case "bool":
			case "decimal":
				return true;
				break;
				
			default:
				return false;
				break;
		}
	}
	
	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