/// <summary>
		/// Generates all the 'find by' methods of this interface.
		/// </summary>
		/// <param name="classMap">The class map.</param>
		/// <param name="file">The file.</param>
		private static void GenerateFindByMethods(IClassMap classMap, StreamWriter file)
		{
			foreach (KeyValuePair<int, IList<IPropertyMap>> pair in classMap.DOLGetFindByGroups())
			{
				IList<IPropertyMap> paramProps = pair.Value;
				
				string findBy = StringUtility.CombineObjects(paramProps, MapToStringConverters.PropertyAnd)
					.ToString();
				
				// method name
				file.Write("		IList<" + EntityGenerator.GetTypeName(classMap) + "> FindBy" + findBy);
				
				// method's params
				file.Write("(");
				bool first = true;
				foreach (IPropertyMap propertyMap in paramProps)
				{
					if (!first)
					{
						file.Write(", ");
					}
						
					// param type and name
					string paramName = ClassUtility.GetParamName(propertyMap);
					string paramType = ClassUtility.ConvertColumnTypeToCsType(propertyMap.GetColumnMap().DataType);
					file.Write(paramType + " " + paramName);
					first = false;
				}
				file.Write(");");
					
				file.WriteLine();

			}
		}

		/// <summary>
		/// Generates the DAO interface file.
		/// </summary>
		/// <param name="path">The path.</param>
		/// <param name="classMap">The class map.</param>
		private static void GenerateDai(string path, IClassMap classMap)
		{
			
			using (StreamWriter file = new StreamWriter(path + GetInterfaceName(classMap) + ".cs", false))
			{
				ClassUtility.AppendHeader(file);
				
				file.WriteLine("using System.Collections.Generic;");
				file.WriteLine("using DOL.Database.DataTransferObjects;");
				file.WriteLine();

				file.WriteLine("namespace DOL.Database.DataAccessInterfaces");
				file.WriteLine("{");
				file.WriteLine("	public interface " + GetInterfaceName(classMap) + " : IGenericDao<" + EntityGenerator.GetTypeName(classMap) + ">");
				file.WriteLine("	{");

				// generate 'find' methods
				GenerateFindMethods(classMap, file);

				// generate 'find by' methods
				GenerateFindByMethods(classMap, file);
				
				// generate 'cout by' methods
				GenerateCountByMethods(classMap, file);

				file.WriteLine("	}");
				file.WriteLine("}");
			}
		}

		/// <summary>
		/// Generates the public access properties.
		/// </summary>
		/// <param name="file">The file.</param>
		/// <param name="classMap">The class map.</param>
		private static void GenerateProperties(StreamWriter file, IClassMap classMap)
		{
			foreach (IPropertyMap property in classMap.PropertyMaps)
			{
				ClassUtility.GenerateProperty(file, property, false);
			}
		}

		/// <summary>
		/// Generates the private fields of the entity.
		/// </summary>
		/// <param name="file">The file.</param>
		/// <param name="classMap">The class map.</param>
		private static void GeneratePrivateFields(StreamWriter file, IClassMap classMap)
		{
			foreach (IPropertyMap property in classMap.PropertyMaps)
			{
				ClassUtility.GenerateField(file, property);
			}
		}

 protected override string GetParameterName(IClassMap classMap, string prefix)
 {
     string name = prefix;
     name = name + classMap.Name;
     name = ":" + name;
     return name;
 }

		public static CodeCompileUnit GetFactoryClassCompileUnit(IClassMap classMap)
		{			
			CodeCompileUnit codeCompileUnit = new CodeCompileUnit();

			codeCompileUnit.Namespaces.Add(GenerateFactoryClass(classMap));

			return codeCompileUnit ;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="DocumentClassMapPropertyDescriptor"/> class.
        /// </summary>
        /// <param name="mappingStore">The mapping store.</param>
        /// <param name="classMap">The class map.</param>
        /// <param name="document">The document.</param>
        public DocumentClassMapPropertyDescriptor(IMappingStore mappingStore, IClassMap classMap, Document document)
            : base(mappingStore, classMap)
        {
            if (document == null)
                throw new ArgumentNullException("document");

            _document = document;
        }

        public string AliasForTable(IClassMap classMap)
        {
            if (classMap != null)
                foreach (var pair in _classMaps)
                    if (pair.Value == classMap)
                        return pair.Key;

            return String.Format("t_{0}", _tIndex++);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExampleClassMapPropertyDescriptor"/> class.
        /// </summary>
        /// <param name="mappingStore">The mapping store.</param>
        /// <param name="classMap">The class map.</param>
        /// <param name="example">The example.</param>
        public ExampleClassMapPropertyDescriptor(IMappingStore mappingStore, IClassMap classMap, object example)
            : base(mappingStore, classMap)
        {
            if (example == null)
                throw new ArgumentNullException("example");

            _example = example;
            _exampleType = _example.GetType();
        }

		public SqlEmitter(INPathEngine npathEngine, NPathSelectQuery query,NPathQueryType queryType, IClassMap rootClassMap, Hashtable propertyColumnMap)
		{
			this.npathEngine = npathEngine;
			this.query = query;
			this.rootClassMap = rootClassMap;
			propertyPathTraverser = new PropertyPathTraverser(this);
			this.propertyColumnMap = propertyColumnMap;
			this.npathQueryType = queryType;
		}

		public virtual Type MustGetTypeFromClassMap(IClassMap classMap)
		{
			Type type = GetTypeFromClassMap(classMap);

			if (type == null)
				throw new MappingException("Could not find the type for the class " + classMap.Name + " (found in the map file) in any loaded Assembly!");
 
			return type;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ClassMapPropertyDescriptor"/> class.
        /// </summary>
        /// <param name="mappingStore">The mapping store.</param>
        /// <param name="classMap">The class map.</param>
        /// <param name="instance">The instance.</param>
        public ClassMapPropertyDescriptor(IMappingStore mappingStore, IClassMap classMap, object instance)
            : base(mappingStore, classMap)
        {
            if (instance == null)
                throw new ArgumentNullException("instance");

            _instance = instance;
            if (ClassMap.HasExtendedProperties)
                _extendedProperties = (IDictionary<string, object>)ClassMap.ExtendedPropertiesMap.GetValue(instance);
        }

        public static string GetRepositoryClassCsharp(IClassMap classMap)
        {
            CodeCompileUnit compileunit = CodeDomGenerator.GetRepositoryClassCompileUnit(classMap);

            CodeDomProvider provider = new CSharpCodeProvider();

            string code = CodeDomGenerator.ToCode(compileunit, provider);

            return code;
        }

		/// <summary>
		/// Generates custom fields and methods of the class.
		/// </summary>
		/// <param name="file">The file.</param>
		/// <param name="classMap">The class map.</param>
		public override void GenerateCustomFieldsAndMethods(StreamWriter file, IClassMap classMap)
		{
			ArrayList		allColumns = classMap.GetTableMap().ColumnMaps;
			IColumnMap[]	allColumnsTyped = (IColumnMap[]) allColumns.ToArray(typeof (IColumnMap));
			string			columnNames = StringUtility.CombineObjects(allColumnsTyped, MapToStringConverters.Columns).ToString();

			file.WriteLine("		protected static readonly string c_rowFields = \"" + columnNames + "\";");
			
			base.GenerateCustomFieldsAndMethods(file, classMap);
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ClassMapPropertyDescriptorBase"/> class.
        /// </summary>
        /// <param name="mappingStore">The mapping store.</param>
        /// <param name="classMap">The class map.</param>
        protected ClassMapPropertyDescriptorBase(IMappingStore mappingStore, IClassMap classMap)
        {
            if (mappingStore == null)
                throw new ArgumentNullException("mappingStore");
            if (classMap == null)
                throw new ArgumentNullException("classMap");

            _mappingStore = mappingStore;
            ClassMap = classMap;
            _codeReplacer = new JavascriptMemberNameReplacer(_mappingStore);
        }

 public static void GenerateDLinqField(IClassMap classMap, IPropertyMap propertyMap, CodeTypeDeclaration classDecl)
 {
     switch (propertyMap.ReferenceType)
     {
         case ReferenceType.None :
             classDecl.Members.Add(GenerateDLinqPrimitiveField(classMap, propertyMap));
         break;
         case ReferenceType.OneToMany :
             GenerateDLinqOneToManyFields(classMap, propertyMap, classDecl);
         break;
     }
 }

        public ConcreteClassMapBuilder(IClassMap classMap)
        {
            _classMap = classMap;
            _instance = classMap.CreateInstance();

            if(!_classMap.HasExtendedProperties)
                return;
            
            var extPropType = _classMap.ExtendedPropertiesMap.MemberReturnType;
            if (extPropType == typeof(IDictionary<string, object>))
                extPropType = typeof(Dictionary<string, object>);
            _extendedProperties = (IDictionary<string, object>)Activator.CreateInstance(extPropType);
            _classMap.ExtendedPropertiesMap.SetValue(_instance, _extendedProperties);
        }

 public static PluginOutput GetDataSet(IClassMap classMap)
 {
     Assembly domainAssembly = GetDomain(classMap.DomainMap);
     if (domainAssembly != null)
     {
         List<DataTable> dtList = new List<DataTable>();
         dtList.Add(ClassToTable(classMap.DomainMap, domainAssembly, classMap.Name));
         string res = GetDataSet(dtList, classMap.DomainMap.Name + "DataSet");
         res = res.Replace(domainAssembly.FullName, classMap.DomainMap.AssemblyName);
         return new PluginOutput(res, classMap.DomainMap.Name + "DataSet");
     }
     else
         throw new Exception("Could not compile domain model !");
 }

		public static void GenerateFactoryMethods(IClassMap classMap, CodeTypeDeclaration classDecl)
		{
			IList propertyMaps = GetRequiredPropertyMaps(classMap);
			classDecl.Members.Add(GenerateFactoryMethod(classMap, propertyMaps));					

			IList optionalPropertyMaps = GetOptionalPropertyMaps(classMap);
			if (optionalPropertyMaps.Count > 0)
			{
				foreach (IPropertyMap propertyMap in optionalPropertyMaps)
					propertyMaps.Add(propertyMap);

				classDecl.Members.Add(GenerateFactoryMethod(classMap, propertyMaps));					
			}
		}

		//non-cached
		protected virtual string LoadFile(object obj, IClassMap classMap, string fileName)
		{
			this.Context.LogManager.Debug(this, "Loading object from file", "File: " + fileName + ", Object Type: " + obj.GetType().ToString()); // do not localize

			if (!(File.Exists(fileName)))
				return "";
			else
			{
				StreamReader fileReader = File.OpenText(fileName);
				string xml =  fileReader.ReadToEnd() ;
				fileReader.Close();

				return xml;
			}
		}