public void InheritAttributes(MetaMetadataField inheritFrom)
{
var classDescriptor = ClassDescriptor.GetClassDescriptor(this);
foreach (MetaMetadataFieldDescriptor fieldDescriptor in classDescriptor.AllFieldDescriptors)
{
if (fieldDescriptor.IsInheritable)
{
ScalarType scalarType = fieldDescriptor.ScalarType;
try
{
if (scalarType != null &&
scalarType.IsDefaultValue(fieldDescriptor.Field, this) &&
!scalarType.IsDefaultValue(fieldDescriptor.Field, inheritFrom))
{
Object value = fieldDescriptor.Field.GetValue(inheritFrom);
fieldDescriptor.Field.SetValue(this, value);
Debug.WriteLine("inherit\t" + this.Name + "." + fieldDescriptor.Name + "\t= " + value);
}
}
catch (Exception e)
{
Debug.WriteLine(inheritFrom.Name + " doesn't have field " + fieldDescriptor.Name + ", ignore it.");
// e.printStackTrace();
}
}
}
}
public void Pop(MetaMetadataField mmField)
{
MetaMetadataField field = mmStack.Pop();
Debug.WriteLine("popping " + field);
scopeStack.Pop();
if (mmField != field)
{
throw new MetaMetadataException("mmField != field");
}
}
protected override bool InheritMetaMetadataHelper(InheritanceHandler inheritanceHandler)
{
/*
* the childComposite should hide all complexity between collection fields and composite fields,
* through hooks when necessary.
*/
int typeCode = this.GetFieldType();
switch (typeCode)
{
case FieldTypes.CollectionElement:
{
// prepare childComposite: possibly new name, type, extends, tag and inheritedField
MetaMetadataCompositeField childComposite = this.GetChildComposite();
if (childComposite.Name == UNRESOLVED_NAME)
{
childComposite.Name = (childType ?? Name);
}
childComposite.Type = childType; // here not using setter to reduce unnecessary re-assignment of this.childType
childComposite.ExtendsAttribute = ChildExtends;
childComposite.Tag = childTag;
childComposite.Repository = Repository;
childComposite.PackageName = PackageName;
if (SuperField != null)
{
childComposite.SuperField = (SuperField as MetaMetadataCollectionField).GetChildComposite();
}
childComposite.DeclaringMmd = DeclaringMmd;
childComposite.Scope = Scope;
childComposite.InheritMetaMetadata(inheritanceHandler); // inheritedMmd might be inferred from type/extends
TypeMmd = childComposite.TypeMmd;
Scope = childComposite.Scope;
break;
}
case FieldTypes.CollectionScalar:
{
MetaMetadataField inheritedField = SuperField;
if (inheritedField != null)
{
InheritAttributes(inheritedField);
}
break;
}
}
return(true);
}
public String ParentString()
{
StringBuilder result = new StringBuilder();
ElementState parent = this.Parent;
while (parent is MetaMetadataField)
{
MetaMetadataField pf = (MetaMetadataField)parent;
result.Insert(0, "<" + pf.Name + ">");
parent = parent.Parent;
}
return(result.ToString());
}
public bool IsUsingGenerics(MetaMetadataField field)
{
if (field.GenericTypeVars != null && field.GenericTypeVars.Count > 0)
{
return(true);
}
MmdGenericTypeVarScope gtvScope = (MmdGenericTypeVarScope)scopeStack.Peek().Get(
GENERIC_TYPE_VAR_SCOPE);
if (gtvScope == null)
{
return(false);
}
if (((field.GetMmdType() != null) && gtvScope.ContainsKey(field.GetMmdType())) || field.GetMmdType() == null &&
((field.Name != null) && gtvScope.ContainsKey(field.Name)) ||
((field.GetMmdExtendsAttribute() != null) && gtvScope.ContainsKey(field.GetMmdExtendsAttribute())))
{
return(true);
}
return(false);
}
public override String GetTypeName()
{
String result = null;
Type thisType = GetType();
if (thisType == typeof(MetaMetadataCompositeField))
{
MetaMetadataCompositeField mmcf = (MetaMetadataCompositeField)this;
if (mmcf.Type != null)
{
result = mmcf.Type;
}
}
else if (thisType == typeof(MetaMetadataCollectionField))
{
MetaMetadataCollectionField mmcf = (MetaMetadataCollectionField)this;
if (mmcf.ChildType != null)
{
result = mmcf.ChildType;
}
else if (mmcf.ChildScalarType != null)
{
result = mmcf.ChildScalarType.CSharpTypeName;
}
}
if (result == null)
{
MetaMetadataField inherited = SuperField;
if (inherited != null)
{
// use inherited field's type
result = inherited.GetTypeName();
}
}
return(result ?? (Name));
}
public void Push(MetaMetadataField mmField)
{
Debug.WriteLine("pushing " + mmField);
mmStack.Push(mmField);
// put mmd scope
MultiAncestorScope <Object> scope = new MultiAncestorScope <Object>();
if (scopeStack.Count > 0)
{
scope.AddAncestor(scopeStack.Peek());
}
scopeStack.Push(scope);
// put generic type var scope
MmdGenericTypeVarScope existingMmdGenericTypeVarScope = (MmdGenericTypeVarScope)scope.Get(GENERIC_TYPE_VAR_SCOPE);
MmdGenericTypeVarScope currentMmdGenericTypeVarScope = mmField.GenericTypeVars;
if (currentMmdGenericTypeVarScope != null && existingMmdGenericTypeVarScope != null)
{
currentMmdGenericTypeVarScope.InheritFrom(existingMmdGenericTypeVarScope, this);
}
scope.AddIfValueNotNull(GENERIC_TYPE_VAR_SCOPE, mmField.GenericTypeVars);
}
public MetadataFieldDescriptorProxy(MetaMetadataField outer)
{
this.outer = outer;
}
public MetaMetadata ResolveMmdName(String mmdName, NameType[] nameType)
{
if (mmdName == null)
{
return(null);
}
Object resultObj = null;
MetaMetadata result = null;
MetaMetadataField field = mmStack.Peek();
if (nameType != null && nameType.Length > 0)
{
nameType[0] = NameType.NONE;
}
// step 1: try to resolve the name as a concrete meta-metadata name, using the mmdScope.
if (field is MetaMetadataNestedField)
{
MetaMetadataNestedField nested = (MetaMetadataNestedField)field;
nested.Scope.TryGetValue(mmdName, out resultObj);
result = (MetaMetadata)resultObj;
if (result != null)
{
if (nameType != null && nameType.Length > 0)
{
nameType[0] = NameType.MMD;
}
}
}
// step 2: if step 1 failed, try to use it as a generic type var name
if (result == null && mmdName.ToUpper().Equals(mmdName))
{
List <Object> gtvScopes = scopeStack.Peek().GetAll(GENERIC_TYPE_VAR_SCOPE);
foreach (MmdGenericTypeVarScope gtvScope_object in gtvScopes)
{
if (!(gtvScope_object is MmdGenericTypeVarScope))
{
throw new MetaMetadataException("Object is not instance of MmdGenericTypeVarScope");
}
MmdGenericTypeVarScope gtvScope = gtvScope_object;
MmdGenericTypeVar gtv = gtvScope.Get(mmdName);
if (gtv != null)
{
if (gtv.Arg != null)
{
result = ResolveMmdName(gtv.Arg);
}
else if (gtv.ExtendsAttribute != null)
{
result = ResolveMmdName(gtv.ExtendsAttribute);
}
// TODO superAttribute?
}
}
if (result != null)
{
if (nameType != null && nameType.Length > 0)
{
nameType[0] = NameType.GENERIC;
}
}
}
return(result);
}
/**
* bind metadata field descriptors to sub-fields of this nested field, with field names as keys,
* but without mixins field.
* <p>
* sub-fields that lack corresponding field descriptors will be removed from this nested field.
* <p>
* note that this field no longer uses a boolean flag to prevent multiple invocation. this should
* have been done by the bindClassDescriptor() method.
*
* @param metadataTScope
* the translation scope of (generated) metadata classes.
* @param metadataClassDescriptor
* the metadata class descriptor where field descriptors can be found.
*/
protected void BindMetadataFieldDescriptors(SimplTypesScope metadataTScope,
MetadataClassDescriptor metadataClassDescriptorToBind)
{
bool needCloneKids = false;
// check if the class's base class is genereic typed, and make sure itself is not generic.
MetadataClassDescriptor metadataCd = MetadataClassDescriptor;
MetaMetadata baseMmd = TypeMmd;
while (baseMmd != null && metadataCd != null)
{
if (metadataCd.GetGenericTypeVars().Count == 0 && baseMmd.GenericTypeVars != null)
{
needCloneKids = true;
break;
}
metadataCd = baseMmd.MetadataClassDescriptor;
baseMmd = baseMmd.TypeMmd;
}
if (needCloneKids)
{
DictionaryList <string, MetaMetadataField> clonedKids = new DictionaryList <string, MetaMetadataField>();
foreach (KeyValuePair <string, MetaMetadataField> entry in Kids)
{
string key = entry.Key;
MetaMetadataField field = entry.Value;
// look up to see if the field is declared in a generic typed class. If not, it does not need to clone it.
MetaMetadata declaringMmd = field.DeclaringMmd;
if (declaringMmd != null && declaringMmd.GenericTypeVars != null && declaringMmd.IsGenericMetadata)
{
// clone the field
field = field.Clone();
// remove the inherited field descriptor
field.MetadataFieldDescriptor = null;
}
clonedKids.Put(key, field);
}
Kids = clonedKids;
}
// copy the kids collection first to prevent modification to the collection during iteration (which may invalidate the iterator).
List <MetaMetadataField> fields = new List <MetaMetadataField>(Kids.Values);
foreach (MetaMetadataField thatChild in fields)
{
// look up by field name and bind
MetadataFieldDescriptor metadataFd = thatChild.BindMetadataFieldDescriptor(metadataTScope, metadataClassDescriptorToBind);
if (metadataFd == null)
{
Debug.WriteLineIf(BigSemanticsSettings.DebugLevel > 5, "Cannot bind metadata field descriptor for " + thatChild);
Kids.Remove(thatChild.Name);
continue;
}
// set defininig mmdfield
// process hide and shadows
var isImage = thatChild is MetaMetadataCompositeField && "image".Equals(((MetaMetadataCompositeField)thatChild).Type);
HashSet <String> nonDisplayedFieldNames = NonDisplayedFieldNames;
if (thatChild.Hide && !isImage)
{
nonDisplayedFieldNames.Add(thatChild.Name);
}
if (thatChild.Shadows != null)
{
nonDisplayedFieldNames.Add(thatChild.Shadows);
}
// recursively process sub-fields
Int32 fieldType = metadataFd.FdType;
if (fieldType == FieldTypes.CompositeElement || fieldType == FieldTypes.CollectionElement)
{
// bind class descriptor for nested sub-fields
MetaMetadataNestedField nested = (MetaMetadataNestedField)thatChild;
MetadataFieldDescriptor fd = nested.MetadataFieldDescriptor;
if (fd.IsPolymorphic)
{
Debug.WriteLineIf(BigSemanticsSettings.DebugLevel > 5, "Polymorphic field: " + nested + ", not binding an element class descriptor.");
}
else
{
MetadataClassDescriptor elementClassDescriptor =
((MetaMetadataNestedField)thatChild).BindMetadataClassDescriptor(metadataTScope);
if (elementClassDescriptor != null)
{
MetaMetadata mmdForThatChild = nested.TypeMmd;
if (mmdForThatChild != null && mmdForThatChild.MetadataClassDescriptor == null)
{
// mmdForThatChild.setMetadataClassDescriptor(elementClassDescriptor);
mmdForThatChild.BindMetadataClassDescriptor(metadataTScope);
}
}
else
{
Debug.WriteLineIf(BigSemanticsSettings.DebugLevel > 5, "Cannot determine elementClassDescriptor for " + thatChild);
Kids.Remove(thatChild.Name);
}
}
}
if (this is MetaMetadata)
{
MetaMetadata mmd = (MetaMetadata)this;
String naturalId = thatChild.AsNaturalId;
if (naturalId != null)
{
mmd.NaturalIds.Put(naturalId, thatChild);
}
}
}
}