public static bool ReadConfig()
        {
            if (!Directory.Exists(savepath))
                Directory.CreateDirectory(savepath);

            if (!File.Exists(filepath))
            {
                try
                {
                    CreateConfig();
                }
                catch
                {
                    return false;
                }
                return true;
            }

            try
            {
                using (var sr = new StreamReader(filepath))
                {
                    config = JsonConvert.DeserializeObject<Cfg>(sr.ReadToEnd());
                }
            }
            catch (Exception ex)
            {
                Log.ConsoleError(ex.Message);
                return false;
            }
            return true;
        }

		protected override void Configure(Cfg.Configuration configuration)
		{
			configuration.SetProperty(Cfg.Environment.BatchSize, "10");

			configuration.SetProperty(	Cfg.Environment.SqlExceptionConverter,
										typeof (MSSQLExceptionConverterExample).AssemblyQualifiedName);
		}

		private static void SetupSqlServerOdbc(Cfg.Configuration cfg)
		{
			var connStr = cfg.Properties[Cfg.Environment.ConnectionString];

			using (var conn = new OdbcConnection(connStr.Replace("Database=nhibernateOdbc", "Database=master")))
			{
				conn.Open();

				using (var cmd = conn.CreateCommand())
				{
					cmd.CommandText = "drop database nhibernateOdbc";

					try
					{
						cmd.ExecuteNonQuery();
					}
					catch(Exception e)
					{
						Console.WriteLine(e);
					}

					cmd.CommandText = "create database nhibernateOdbc";
					cmd.ExecuteNonQuery();
				}
			}
		}

		protected override void Configure(Cfg.Configuration configuration)
		{
			if(Dialect is MsSql2000Dialect)
			{
				configuration.SetProperty(
					Cfg.Environment.SqlExceptionConverter,
					typeof(MSSQLExceptionConverterExample).AssemblyQualifiedName);
			}

			if (Dialect is Oracle8iDialect)
			{
				configuration.SetProperty(
					Cfg.Environment.SqlExceptionConverter,
					typeof(OracleClientExceptionConverterExample).AssemblyQualifiedName);
			}

			if (Dialect is PostgreSQLDialect)
			{
				configuration.SetProperty(
					Cfg.Environment.SqlExceptionConverter,
					typeof(PostgresExceptionConverterExample).AssemblyQualifiedName);
			}

			if (Dialect is FirebirdDialect)
			{
				configuration.SetProperty(
					Cfg.Environment.SqlExceptionConverter,
					typeof(FbExceptionConverterExample).AssemblyQualifiedName);
			}
		}

		//protected override bool AppliesTo(Dialect.Dialect dialect)
		//{
		//  // this test work only with Field interception (NH-1618)
		//  return FieldInterceptionHelper.IsInstrumented( new Person() );
		//}
		protected override void Configure(Cfg.Configuration configuration)
		{
			configuration.SetProperty(Environment.ProxyFactoryFactoryClass,
										typeof(NHibernate.ByteCode.Castle.ProxyFactoryFactory).AssemblyQualifiedName);
			configuration.SetProperty(Environment.MaxFetchDepth, "2");
			configuration.SetProperty(Environment.UseSecondLevelCache, "false");
		}

		protected override void Configure(Cfg.Configuration configuration)
		{
			configuration.Cache(x =>
								{
									x.Provider<HashtableCacheProvider>();
									x.UseQueryCache = true;
								});
		}

		protected override void AddMappings(Cfg.Configuration configuration)
		{
			// Set some properties that must be set before the mappings are added.
			// (The overridable Configure(cfg) is called AFTER AddMappings(cfg).)
			configuration.SetProperty(Cfg.Environment.PreferPooledValuesLo, _preferLo.ToString().ToLower());

			base.AddMappings(configuration);
		}

		protected override void Configure(Cfg.Configuration configuration)
		{
			configuration.AddProperties(new Dictionary<string, string>
			                            	{
			                            		{
			                            			Cfg.Environment.QueryTranslator,
			                            			typeof (NHibernate.Hql.Classic.ClassicQueryTranslatorFactory).FullName
			                            			}
			                            	}
				);
		}

		protected override void Configure(Cfg.Configuration configuration)
		{
			var assembly = GetType().Assembly;
			string mappingNamespace = GetType().Namespace;
			foreach (var resource in assembly.GetManifestResourceNames())
			{
				if (resource.StartsWith(mappingNamespace) && resource.EndsWith(".hbm.xml"))
				{
					configuration.AddResource(resource, assembly);
				}
			}
		}

        public static AuditConfiguration getFor(Cfg.Configuration cfg) {
            AuditConfiguration verCfg = null;
            if(cfgs.Keys.Contains(cfg))
                verCfg = cfgs[cfg];
            else{
                verCfg = new AuditConfiguration(cfg);
                cfgs.Add(cfg, verCfg);
                
                cfg.BuildMappings();
            }

            return verCfg;
        }

        public void Config(IPersistenceUnitCfg puCfg, Cfg.Configuration configuration)
        {
           if(puCfg.Name ==  MockPersistenceUnitCfg.MockPUName )
           {
                
               configuration.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
               configuration.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
               configuration.SetProperty("connection.connection_string", "Server=(local);initial catalog=NHibernateBurrow;Integrated Security=SSPI");
               configuration.SetProperty("dialect", "NHibernate.Dialect.MsSql2005Dialect");

            configuration.SetProperty("adonet.batch_size", testAdoBatchSize.ToString());
         
           }
        }

		private static void SetupFirebird(Cfg.Configuration cfg)
		{
			try
			{
				if (File.Exists("NHibernate.fdb"))
					File.Delete("NHibernate.fdb");
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			FbConnection.CreateDatabase("Database=NHibernate.fdb;ServerType=1");
		}

 private static void Load()
 {
     if (File.Exists(configName))
     {
         StreamReader sr = new StreamReader(configName);
         cfg = (Cfg)jsonSerializer.Deserialize(sr, typeof(Cfg));
         sr.Close();
     }
     else
     {
         cfg = new Cfg();
         Save();
     }
 }

		protected override void Configure(Cfg.Configuration configuration)
		{
			foreach (var cls in configuration.ClassMappings)
			{
				foreach (var prop in cls.PropertyIterator)
				{
					foreach (var col in prop.ColumnIterator)
					{
						if (col is Column)
						{
							var column = col as Column;
							if (column.SqlType == "nvarchar(max)")
								column.SqlType = Dialect.GetLongestTypeName(DbType.String);
						}
					}
				}
			}
		}

		private static void SetupNpgsql(Cfg.Configuration cfg)
		{
			var connStr = cfg.Properties[Cfg.Environment.ConnectionString];

			using (var conn = new NpgsqlConnection(connStr.Replace("Database=nhibernate", "Database=postgres")))
			{
				conn.Open();

				using (var cmd = conn.CreateCommand())
				{
					cmd.CommandText = "drop database nhibernate";

					try
					{
						cmd.ExecuteNonQuery();
					}
					catch (Exception e)
					{
						Console.WriteLine(e);
					}

					cmd.CommandText = "create database nhibernate";
					cmd.ExecuteNonQuery();
				}
			}

            // Install the GUID generator function that uses the most common "random" algorithm.
            using (var conn = new NpgsqlConnection(connStr))
            {
                conn.Open();

				using (var cmd = conn.CreateCommand())
				{
                    cmd.CommandText =
                        @"CREATE OR REPLACE FUNCTION uuid_generate_v4()
                        RETURNS uuid
                        AS '$libdir/uuid-ossp', 'uuid_generate_v4'
                        VOLATILE STRICT LANGUAGE C;";

					cmd.ExecuteNonQuery();
				}
            }
		}

        public AuditMetadataGenerator(Cfg.Configuration cfg, 
										GlobalConfiguration globalCfg,
										AuditEntitiesConfiguration verEntCfg,
										IAuditStrategy auditStrategy,
										XmlElement revisionInfoRelationMapping,
										AuditEntityNameRegister auditEntityNameRegister)
        {
            Cfg = cfg;
            GlobalCfg = globalCfg;
            VerEntCfg = verEntCfg;
            AuditStrategy = auditStrategy;
            this.revisionInfoRelationMapping = revisionInfoRelationMapping;
            BasicMetadataGenerator = new BasicMetadataGenerator();
            componentMetadataGenerator = new ComponentMetadataGenerator(this);
            idMetadataGenerator = new IdMetadataGenerator(this);
            toOneRelationMetadataGenerator = new ToOneRelationMetadataGenerator(this);
            AuditEntityNameRegister = auditEntityNameRegister;
            EntitiesConfigurations = new Dictionary<string, EntityConfiguration>();
            NotAuditedEntitiesConfigurations = new Dictionary<string, EntityConfiguration>();
            entitiesJoins = new Dictionary<string, IDictionary<Join, XmlElement>>();
        }

 public static void CreateConfig()
 {
     try
     {
         using (var stream = new FileStream(filepath, FileMode.Create, FileAccess.Write, FileShare.Write))
         {
             using (var sr = new StreamWriter(stream))
             {
                 config = new Cfg();
                 var obj = JsonConvert.SerializeObject(config, Formatting.Indented);
                 sr.Write(obj);
             }
         }
         Log.ConsoleInfo("Created AutoRank.json.");
     }
     catch (Exception ex)
     {
         Log.ConsoleError(ex.Message);
         config = new Cfg();
     }
 }

        public AuditMetadataGenerator(Cfg.Configuration cfg, GlobalConfiguration globalCfg,
                                      AuditEntitiesConfiguration verEntCfg,
                                      XmlElement revisionInfoRelationMapping,
                                      AuditEntityNameRegister auditEntityNameRegister,
                                      ClassesAuditingData classesAuditingData)
        {
            this.Cfg = cfg;
            this.GlobalCfg = globalCfg;
            this.VerEntCfg = verEntCfg;
            this.revisionInfoRelationMapping = revisionInfoRelationMapping;

            this.BasicMetadataGenerator = new BasicMetadataGenerator();
            this.componentMetadataGenerator = new ComponentMetadataGenerator(this);
            this.idMetadataGenerator = new IdMetadataGenerator(this);
            this.toOneRelationMetadataGenerator = new ToOneRelationMetadataGenerator(this);

            this.AuditEntityNameRegister = auditEntityNameRegister;
            this.ClassesAuditingData = classesAuditingData;

            EntitiesConfigurations = new Dictionary<String, EntityConfiguration>();
            NotAuditedEntitiesConfigurations = new Dictionary<String, EntityConfiguration>();
            entitiesJoins = new Dictionary<String, IDictionary<Join, XmlElement>>();
        }

 protected override void AddMappings(Cfg.Configuration configuration)
 {
     configuration.AddDeserializedMapping(GetMappings(), "TestDomain");
 }

		private static void SetupMySql(Cfg.Configuration obj)
		{
			//TODO: do nothing
		}