public RevisionInfoConfigurationResult Configure(Cfg.Configuration cfg)
        {
            IRevisionInfoGenerator revisionInfoGenerator;
            string    revisionAssQName;
            XDocument revisionInfoXmlMapping = null;

            System.Type revisionInfoClass;

            var revEntityType   = nhMappedTypesWithRevisionEntityAttribute(cfg);
            var noOfRevEntities = revEntityType.Count();

            switch (noOfRevEntities)
            {
            case 0:
            {
                if (_globalCfg.IsTrackEntitiesChangedInRevisionEnabled)
                {
                    revisionInfoClass      = typeof(DefaultTrackingModifiedEntitiesRevisionEntity);
                    revisionInfoEntityName = revisionInfoClass.FullName;
                    revisionInfoGenerator  = new DefaultTrackingModifiedEntitiesRevisionInfoGenerator(revisionInfoEntityName,
                                                                                                      revisionInfoClass,
                                                                                                      null,
                                                                                                      revisionInfoTimestampData,
                                                                                                      isTimestampAsDate(),
                                                                                                      modifiedEntityNamesData);
                }
                else
                {
                    revisionInfoClass     = typeof(DefaultRevisionEntity);
                    revisionInfoGenerator = new DefaultRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass,
                                                                             null, revisionInfoTimestampData, isTimestampAsDate());
                }
                revisionAssQName       = revisionInfoClass.AssemblyQualifiedName;
                revisionInfoXmlMapping = generateDefaultRevisionInfoXmlMapping();
                break;
            }

            case 1:
            {
                var clazz         = revEntityType.First();
                var revEntityAttr = _metaDataStore.ClassMeta <RevisionEntityAttribute>(clazz);
                var pc            = cfg.GetClassMapping(clazz);
                // Checking if custom revision entity isn't audited))
                if (_metaDataStore.ClassMeta <AuditedAttribute>(clazz) != null)
                {
                    throw new MappingException("An entity decorated with [RevisionEntity] cannot be audited!");
                }

                var propertiesPlusIdentifier = new List <Property>();
                propertiesPlusIdentifier.AddRange(pc.PropertyIterator);
                propertiesPlusIdentifier.Add(pc.IdentifierProperty);
                var persistentProperties = PropertyAndMemberInfo.PersistentInfo(clazz, propertiesPlusIdentifier);

                if (!searchForRevisionNumberCfg(persistentProperties))
                {
                    throw new MappingException("An entity decorated with [RevisionEntity] must have a field decorated " +
                                               "with [RevisionNumber]!");
                }

                if (!searchForTimestampCfg(persistentProperties))
                {
                    throw new MappingException("An entity decorated with [RevisionEntity] must have a field decorated " +
                                               "with [RevisionTimestamp]!");
                }

                var modifiedEntityNames = searchForEntityNamesCfg(persistentProperties);

                revisionInfoEntityName = pc.EntityName;
                revisionAssQName       = pc.MappedClass.AssemblyQualifiedName;

                revisionInfoClass         = pc.MappedClass;
                revisionInfoTimestampType = pc.GetProperty(revisionInfoTimestampData.Name).Type;

                if (_globalCfg.IsTrackEntitiesChangedInRevisionEnabled ||
                    modifiedEntityNames ||
                    typeof(DefaultTrackingModifiedEntitiesRevisionEntity).IsAssignableFrom(revisionInfoClass))
                {
                    // If tracking modified entities parameter is enabled, custom revision info entity is a subtype
                    // of DefaultTrackingModifiedEntitiesRevisionEntity class, or ModifiedEntityNamesAttribute annotation is used.
                    revisionInfoGenerator = new DefaultTrackingModifiedEntitiesRevisionInfoGenerator(revisionInfoEntityName,
                                                                                                     revisionInfoClass,
                                                                                                     revEntityAttr.Listener,
                                                                                                     revisionInfoTimestampData,
                                                                                                     isTimestampAsDate(),
                                                                                                     modifiedEntityNamesData);
                    _globalCfg.SetTrackEntitiesChangedInRevisionEnabled();
                }
                else
                {
                    revisionInfoGenerator = new DefaultRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass,
                                                                             revEntityAttr.Listener, revisionInfoTimestampData, isTimestampAsDate());
                }
                break;
            }

            default:
            {
                throw new MappingException("Only one entity may be decorated with [RevisionEntity]!");
            }
            }

            return(new RevisionInfoConfigurationResult(
                       revisionInfoGenerator,
                       revisionInfoXmlMapping,
                       new RevisionInfoQueryCreator(revisionInfoEntityName, revisionInfoIdData.Name, revisionInfoTimestampData.Name, isTimestampAsDate(), revisionPropType),
                       generateRevisionInfoRelationMapping(revisionAssQName),
                       new RevisionInfoNumberReader(revisionInfoClass, revisionInfoIdData),
                       _globalCfg.IsTrackEntitiesChangedInRevisionEnabled ? new ModifiedEntityNamesReader(revisionInfoClass, modifiedEntityNamesData) : null,
                       revisionInfoEntityName,
                       revisionInfoClass,
                       revisionInfoTimestampData));
        }
        //@SuppressWarnings({"unchecked"})
        public RevisionInfoConfigurationResult configure(NHibernate.Cfg.Configuration cfg)
        {
            ICollection <PersistentClass> classes = cfg.ClassMappings;
            bool revisionEntityFound = false;
            IRevisionInfoGenerator revisionInfoGenerator = null;

            System.Type revisionInfoClass = null;

            foreach (PersistentClass pc in classes)
            {
                System.Type clazz;
                try {
                    clazz = System.Type.GetType(pc.ClassName, true);
                } catch (System.Exception e) {
                    throw new MappingException(e);
                }

                RevisionEntityAttribute revisionEntity = (RevisionEntityAttribute)Attribute.GetCustomAttribute(clazz, typeof(RevisionEntityAttribute));
                if (revisionEntity != null)
                {
                    if (revisionEntityFound)
                    {
                        throw new MappingException("Only one entity may be decorated with [RevisionEntity]!");
                    }

                    // Checking if custom revision entity isn't audited
                    if (Attribute.GetCustomAttribute(clazz, typeof(AuditedAttribute)) != null)
                    {
                        throw new MappingException("An entity decorated with [RevisionEntity] cannot be audited!");
                    }

                    revisionEntityFound = true;

                    bool revisionNumberFound    = false;
                    bool revisionTimestampFound = false;

                    searchForRevisionInfoCfg(clazz, ref revisionNumberFound, ref revisionTimestampFound);

                    if (!revisionNumberFound)
                    {
                        throw new MappingException("An entity decorated with [RevisionEntity] must have a field decorated " +
                                                   "with [RevisionNumber]!");
                    }

                    if (!revisionTimestampFound)
                    {
                        throw new MappingException("An entity decorated with [RevisionEntity] must have a field decorated " +
                                                   "with [RevisionTimestamp]!");
                    }

                    revisionInfoEntityName = pc.EntityName;

                    revisionInfoClass         = pc.MappedClass;
                    revisionInfoTimestampType = pc.GetProperty(revisionInfoTimestampData.Name).Type;
                    revisionInfoGenerator     = new DefaultRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass,
                                                                                 /*revisionEntity.value, */ revisionInfoTimestampData /*, isTimestampAsDate()*/);
                }
            }

            // In case of a custom revision info generator, the mapping will be null.
            XmlDocument revisionInfoXmlMapping = null;

            if (revisionInfoGenerator == null)
            {
                revisionInfoClass     = typeof(DefaultRevisionEntity);
                revisionInfoGenerator = new DefaultRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass,
                                                                         revisionInfoTimestampData);
                revisionInfoXmlMapping = generateDefaultRevisionInfoXmlMapping();
            }

            return(new RevisionInfoConfigurationResult(
                       revisionInfoGenerator, revisionInfoXmlMapping,
                       new RevisionInfoQueryCreator(revisionInfoEntityName, revisionInfoIdData.Name,
                                                    revisionInfoTimestampData.Name),
                       generateRevisionInfoRelationMapping(),
                       new RevisionInfoNumberReader(revisionInfoClass, revisionInfoIdData), revisionInfoEntityName));
        }