public DocumentIdMapping(string name, string propertyName, ITwoWayFieldBridge bridge, IGetter getter)
: base(getter)
{
this.Name = name;
this.PropertyName = propertyName;
this.Bridge = bridge;
}
public DocumentIdMapping(string name, ITwoWayFieldBridge bridge, IGetter getter)
: this(name, RootClass.DefaultIdentifierColumnName, bridge, getter)
{
}
public DocumentIdMapping(string name, string propertyName, ITwoWayFieldBridge bridge, IGetter getter) : base(getter)
{
this.Name = name;
this.PropertyName = propertyName;
this.Bridge = bridge;
}
private void InitializeMember(
MemberInfo member, PropertiesMetadata propertiesMetadata, bool isRoot,
String prefix, ISet<System.Type> processedClasses)
{
DocumentIdAttribute documentIdAnn = AttributeUtil.GetDocumentId(member);
if (documentIdAnn != null)
{
if (isRoot)
{
if (idKeywordName != null)
{
throw new AssertionFailure("Two document id assigned: " + idKeywordName + " and " + documentIdAnn.Name ?? "'Unknown'");
}
idKeywordName = prefix + documentIdAnn.Name;
IFieldBridge fieldBridge = BridgeFactory.GuessType(member);
if (fieldBridge is ITwoWayFieldBridge)
{
idBridge = (ITwoWayFieldBridge)fieldBridge;
}
else
{
throw new SearchException("Bridge for document id does not implement TwoWayFieldBridge: " + member.Name);
}
idBoost = GetBoost(member);
SetAccessible(member);
idGetter = member;
}
else
{
// Component should index their document id
SetAccessible(member);
propertiesMetadata.fieldGetters.Add(member);
string fieldName = prefix + BinderHelper.GetAttributeName(member, documentIdAnn.Name);
propertiesMetadata.fieldNames.Add(fieldName);
propertiesMetadata.fieldStore.Add(GetStore(Attributes.Store.Yes));
propertiesMetadata.fieldIndex.Add(GetIndex(Index.UnTokenized));
propertiesMetadata.fieldBridges.Add(BridgeFactory.GuessType(member));
// Property > entity analyzer - no field analyzer
Analyzer memberAnalyzer = GetAnalyzer(member) ?? propertiesMetadata.analyzer;
if (memberAnalyzer == null)
{
throw new NotSupportedException("Analyzer should not be undefined");
}
analyzer.AddScopedAnalyzer(fieldName, memberAnalyzer);
}
}
List<FieldAttribute> fieldAttributes = AttributeUtil.GetFields(member);
if (fieldAttributes != null)
{
foreach (FieldAttribute fieldAnn in fieldAttributes)
{
BindFieldAnnotation(member, propertiesMetadata, prefix, fieldAnn);
}
}
IndexedEmbeddedAttribute embeddedAttribute = AttributeUtil.GetAttribute<IndexedEmbeddedAttribute>(member);
if (embeddedAttribute != null)
{
int oldMaxLevel = maxLevel;
int potentialLevel = embeddedAttribute.Depth + level;
if (potentialLevel < 0)
{
potentialLevel = int.MaxValue;
}
maxLevel = potentialLevel > maxLevel ? maxLevel : potentialLevel;
level++;
System.Type elementType = embeddedAttribute.TargetElement ?? GetMemberTypeOrGenericArguments(member);
if (maxLevel == int.MaxValue && processedClasses.Contains(elementType))
{
throw new SearchException(
string.Format(
"Circular reference, Duplicate use of {0} in root entity {1}#{2}",
elementType.FullName,
beanClass.FullName,
BuildEmbeddedPrefix(prefix, embeddedAttribute, member)));
}
if (level <= maxLevel)
{
processedClasses.Add(elementType); // push
SetAccessible(member);
propertiesMetadata.embeddedGetters.Add(member);
PropertiesMetadata metadata = new PropertiesMetadata();
propertiesMetadata.embeddedPropertiesMetadata.Add(metadata);
metadata.boost = GetBoost(member);
// property > entity analyzer
metadata.analyzer = GetAnalyzer(member) ?? propertiesMetadata.analyzer;
string localPrefix = BuildEmbeddedPrefix(prefix, embeddedAttribute, member);
InitializeMembers(elementType, metadata, false, localPrefix, processedClasses);
/**
* We will only index the "expected" type but that's OK, HQL cannot do downcasting either
*/
// ayende: because we have to deal with generic collections here, we aren't
// actually using the element type to determine what the value is, since that
// was resolved to the element type of the possible collection
Type actualFieldType = GetMemberTypeOrGenericCollectionType(member);
if (actualFieldType.IsArray)
{
propertiesMetadata.embeddedContainers.Add(Container.Array);
}
else if (typeof(IDictionary).IsAssignableFrom(actualFieldType) || typeof(IDictionary<,>).IsAssignableFrom(actualFieldType))
{
propertiesMetadata.embeddedContainers.Add(Container.Map);
}
else if (typeof(ICollection).IsAssignableFrom(actualFieldType))
{
propertiesMetadata.embeddedContainers.Add(Container.Collection);
}
else if (typeof(IEnumerable).IsAssignableFrom(actualFieldType))
{
// NB We only see ISet as IEnumerable
propertiesMetadata.embeddedContainers.Add(Container.Collection);
}
else
{
propertiesMetadata.embeddedContainers.Add(Container.Object);
}
processedClasses.Remove(actualFieldType); // pop
}
else if (logger.IsDebugEnabled)
{
string localPrefix = BuildEmbeddedPrefix(prefix, embeddedAttribute, member);
logger.Debug("Depth reached, ignoring " + localPrefix);
}
level--;
maxLevel = oldMaxLevel; // set back the old max level
}
ContainedInAttribute containedInAttribute = AttributeUtil.GetAttribute<ContainedInAttribute>(member);
if (containedInAttribute != null)
{
SetAccessible(member);
propertiesMetadata.containedInGetters.Add(member);
}
}
public DocumentIdMapping(string name, ITwoWayFieldBridge bridge, IGetter getter)
: this(name, RootClass.DefaultIdentifierColumnName, bridge, getter)
{
}
