public static IndexSearcher BuildSearcher(ISearchFactoryImplementor searchFactory,
out IESI.ISet<System.Type> classesAndSubclasses,
params System.Type[] classes)
{
IDictionary<System.Type, DocumentBuilder> builders = searchFactory.DocumentBuilders;
IESI.ISet<IDirectoryProvider> directories = new IESI.HashedSet<IDirectoryProvider>();
if (classes == null || classes.Length == 0)
{
// no class means all classes
foreach (DocumentBuilder builder in builders.Values)
{
foreach (IDirectoryProvider provider in builder.DirectoryProvidersSelectionStrategy.GetDirectoryProvidersForAllShards())
{
directories.Add(provider);
}
}
// Give them back an empty set
classesAndSubclasses = null;
}
else
{
var involvedClasses = new IESI.HashedSet<System.Type>();
involvedClasses.AddAll(classes);
foreach (System.Type clazz in classes)
{
DocumentBuilder builder;
builders.TryGetValue(clazz, out builder);
if (builder != null)
{
involvedClasses.AddAll(builder.MappedSubclasses);
}
}
foreach (System.Type clazz in involvedClasses)
{
DocumentBuilder builder;
builders.TryGetValue(clazz, out builder);
// TODO should we rather choose a polymorphic path and allow non mapped entities
if (builder == null)
{
throw new HibernateException("Not a mapped entity: " + clazz);
}
foreach (IDirectoryProvider provider in builder.DirectoryProvidersSelectionStrategy.GetDirectoryProvidersForAllShards())
{
directories.Add(provider);
}
}
classesAndSubclasses = involvedClasses;
}
IDirectoryProvider[] directoryProviders = new List<IDirectoryProvider>(directories).ToArray();
return new IndexSearcher(searchFactory.ReaderProvider.OpenReader(directoryProviders));
}
private SearchFactoryImpl(Configuration cfg)
{
CfgHelper.Configure(cfg);
mapping = SearchMappingFactory.CreateMapping(cfg);
Analyzer analyzer = InitAnalyzer(cfg);
InitDocumentBuilders(cfg, analyzer);
IESI.ISet<System.Type> classes = new IESI.HashedSet<System.Type>(documentBuilders.Keys);
foreach (DocumentBuilder documentBuilder in documentBuilders.Values)
documentBuilder.PostInitialize(classes);
worker = WorkerFactory.CreateWorker(cfg, this);
readerProvider = ReaderProviderFactory.CreateReaderProvider(cfg, this);
BuildFilterCachingStrategy(cfg.Properties);
}
public DocumentBuilder(DocumentMapping classMapping, Analyzer defaultAnalyzer, IDirectoryProvider[] directoryProviders,
IIndexShardingStrategy shardingStrategy)
{
analyzer = new ScopedAnalyzer();
this.directoryProviders = directoryProviders;
this.shardingStrategy = shardingStrategy;
if (classMapping == null) throw new AssertionFailure("Unable to build a DocumemntBuilder with a null class");
rootClassMapping = classMapping;
IESI.Set<System.Type> processedClasses = new IESI.HashedSet<System.Type>();
processedClasses.Add(classMapping.MappedClass);
CollectAnalyzers(rootClassMapping, defaultAnalyzer, true, string.Empty, processedClasses);
//processedClasses.remove( clazz ); for the sake of completness
analyzer.GlobalAnalyzer = defaultAnalyzer;
if (idMapping == null)
throw new SearchException("No document id for: " + classMapping.MappedClass.Name);
}
protected override IProxyFactory BuildProxyFactory(PersistentClass persistentClass, IGetter idGetter,
ISetter idSetter)
{
bool needAccesorCheck = true; // NH specific (look the comment below)
// determine the id getter and setter methods from the proxy interface (if any)
// determine all interfaces needed by the resulting proxy
var proxyInterfaces = new IESI.HashedSet<System.Type> {typeof (INHibernateProxy)};
System.Type _mappedClass = persistentClass.MappedClass;
System.Type _proxyInterface = persistentClass.ProxyInterface;
if (_proxyInterface != null && !_mappedClass.Equals(_proxyInterface))
{
if (!_proxyInterface.IsInterface)
{
throw new MappingException("proxy must be either an interface, or the class itself: " + EntityName);
}
needAccesorCheck = false; // NH (the proxy is an interface all properties can be overridden)
proxyInterfaces.Add(_proxyInterface);
}
if (_mappedClass.IsInterface)
{
needAccesorCheck = false; // NH (the mapped class is an interface all properties can be overridden)
proxyInterfaces.Add(_mappedClass);
}
foreach (Subclass subclass in persistentClass.SubclassIterator)
{
System.Type subclassProxy = subclass.ProxyInterface;
System.Type subclassClass = subclass.MappedClass;
if (subclassProxy != null && !subclassClass.Equals(subclassProxy))
{
if (!subclassProxy.IsInterface)
{
throw new MappingException("proxy must be either an interface, or the class itself: " + subclass.EntityName);
}
proxyInterfaces.Add(subclassProxy);
}
}
/*
* NH Different Implementation (for Error logging):
* - Check if the logger is enabled
* - Don't need nothing to check if the mapped-class or proxy is an interface
*/
if (log.IsErrorEnabled && needAccesorCheck)
{
LogPropertyAccessorsErrors(persistentClass);
}
/**********************************************************/
MethodInfo idGetterMethod = idGetter == null ? null : idGetter.Method;
MethodInfo idSetterMethod = idSetter == null ? null : idSetter.Method;
MethodInfo proxyGetIdentifierMethod = idGetterMethod == null || _proxyInterface == null ? null :
ReflectHelper.TryGetMethod(_proxyInterface, idGetterMethod);
MethodInfo proxySetIdentifierMethod = idSetterMethod == null || _proxyInterface == null ? null :
ReflectHelper.TryGetMethod(_proxyInterface, idSetterMethod);
IProxyFactory pf = BuildProxyFactoryInternal(persistentClass, idGetter, idSetter);
try
{
pf.PostInstantiate(EntityName, _mappedClass, proxyInterfaces, proxyGetIdentifierMethod, proxySetIdentifierMethod,
persistentClass.HasEmbeddedIdentifier ? (IAbstractComponentType) persistentClass.Identifier.Type: null);
}
catch (HibernateException he)
{
log.Warn("could not create proxy factory for:" + EntityName, he);
pf = null;
}
return pf;
}
public void PostInitialize(IESI.ISet<System.Type> indexedClasses)
{
// this method does not requires synchronization
Type plainClass = rootClassMapping.MappedClass;
IESI.ISet<Type> tempMappedSubclasses = new IESI.HashedSet<System.Type>();
// together with the caller this creates a o(2), but I think it's still faster than create the up hierarchy for each class
foreach (Type currentClass in indexedClasses)
{
if (plainClass.IsAssignableFrom(currentClass))
{
tempMappedSubclasses.Add(currentClass);
}
}
mappedSubclasses = tempMappedSubclasses;
}
