protected string GetInterfaceCSTypeFull(ExplicitAttribute attribute) { var baseNamespace = Settings.CrossAccessNamespace.Replace("." + Settings.SchemaInterfacesNamespace, ""); var fullName = TypeHelper.GetInterfaceCSType(attribute, Settings, GetFullNamespace(attribute.Domain, baseNamespace, Settings.CrossAccessStructure)); return(TrimNamespace(fullName)); }
protected bool IsAggregationEntityCompatible(ExplicitAttribute source, ExplicitAttribute target) { if (source.Domain.GetType() != target.Domain.GetType()) { return(false); } var sType = source.Domain; var tType = target.Domain; while (sType is AggregationType) { sType = ((AggregationType)sType).ElementType; tType = ((AggregationType)tType).ElementType; } var sEntity = sType as EntityDefinition; var tEntity = tType as EntityDefinition; if (sEntity != null && tEntity != null) { return(_matches.Any(m => m.Source == sEntity && m.Target == tEntity)); } var sSelect = sType as SelectType; var tSelect = tType as SelectType; if (sSelect != null) { return(IsSelectCompatible(sSelect, tSelect, _matches)); } return(false); }
protected bool IsEntityOrSelectAggregation(ExplicitAttribute attribute) { if (!(attribute.Domain is AggregationType aggr)) { return(false); } return(aggr.ElementType is EntityDefinition || aggr.ElementType is SelectType); }
private ExplicitAttribute NameAttribute(ExplicitAttribute attribute, string name, bool optional) { attribute.Name = name; attribute.PersistentName = name; attribute.OptionalFlag = optional; attribute.Line = Scanner.yylloc.StartLine; return(attribute); }
protected bool IsNew(ExplicitAttribute remoteAttribute) { var hierarchy = _match.Target.AllSupertypes.Select(t => t.Name).Union(new [] { _match.Target.Name }).ToList(); var names = NewTargetAttributes.Where(t => hierarchy.Any(i => t.Item1 == i)).Select(t => t.Item2).ToList(); return(names.Any() && names.Any(n => string.Equals(n, remoteAttribute.Name, StringComparison.InvariantCultureIgnoreCase))); }
protected bool IsSimpleOrDefinedTypeAggregation(ExplicitAttribute attribute) { if (!(attribute.Domain is AggregationType aggr)) { return(false); } return(aggr.ElementType is SimpleType || aggr.ElementType is DefinedType); }
protected ExplicitAttributeMatch GetMatch(ExplicitAttribute remoteAttribute) { var match = _match.AttributeMatches.FirstOrDefault(m => m.TargetAttribute == remoteAttribute); if (match == null && _implementsSupertype) { match = _superMatches.FirstOrDefault(m => m.TargetAttribute == remoteAttribute); } return(match); }
protected bool IsValueTypeAggregation(ExplicitAttribute attribute) { if (!(attribute.Domain is AggregationType agg)) { return(false); } return (agg.ElementType is SimpleType && !(agg.ElementType is StringType || agg.ElementType is LogicalType)); }
protected bool IsReferenceTypeAggregation(ExplicitAttribute attribute) { if (!(attribute.Domain is AggregationType agg)) { return(false); } return (agg.ElementType is EntityDefinition || agg.ElementType is SelectType || agg.ElementType is StringType || agg.ElementType is LogicalType); }
protected int GetUpperBound(ExplicitAttribute attribute) { var aggr = attribute.Domain as VariableSizeAggregationType; if (aggr?.UpperBound != null && aggr.UpperBound.Value > 0) { return(aggr.UpperBound ?? -1); } if (attribute.Domain is ArrayType arr && arr.UpperIndex > 0) { return(arr.UpperIndex); } return(0); }
protected bool IsReferenceType(ExplicitAttribute attribute) { if (attribute.OptionalFlag) { return(true); } return (attribute.Domain is EntityDefinition || attribute.Domain is SelectType || attribute.Domain is StringType || attribute.Domain is LogicalType || attribute.Domain is AggregationType); }
protected string GetAggregationElementType(ExplicitAttribute attribute) { var aggregationType = attribute.Domain as AggregationType; while (aggregationType != null) { var type = aggregationType.ElementType; aggregationType = aggregationType.ElementType as AggregationType; if (aggregationType == null) { return(TypeHelper.GetCSType(type, Settings)); } } throw new Exception("Aggregation type expected"); }
protected int GetLevelOfNesting(ExplicitAttribute attribute) { if (!(attribute.Domain is AggregationType aggr)) { throw new Exception("This is not a nested list attribute."); } var level = -1; while (aggr != null) { level++; aggr = aggr.ElementType as AggregationType; } return(level); }
protected bool IsNestedListCompatible(ExplicitAttribute source, ExplicitAttribute target) { var sType = source.Domain; var tType = target.Domain; var isAggregation = false; var levels = 0; while (sType is AggregationType) { isAggregation = true; levels++; sType = ((AggregationType)sType).ElementType; tType = ((AggregationType)tType).ElementType; } if (!isAggregation || levels < 2) { return(false); } var sEntity = sType as EntityDefinition; var tEntity = tType as EntityDefinition; if (sEntity != null && tEntity != null) { return(_matches.Any(m => m.Source == sEntity && m.Target == tEntity)); } var sSelect = sType as SelectType; var tSelect = tType as SelectType; if (sSelect != null) { return(IsSelectCompatible(sSelect, tSelect, _matches)); } var sDefined = sType as DefinedType; var tDefined = tType as DefinedType; if (sDefined != null) { return(sDefined.Name == tDefined.Name); } return(false); }
public static string GetCSType(ExplicitAttribute attribute, GeneratorSettings settings) { var domain = attribute.Domain; var type = GetCSType(domain, settings); if (attribute.OptionalFlag && ( (domain is SimpleType && !(domain is LogicalType) && !(domain is StringType) && !(domain is BinaryType)) || domain is DefinedType || domain is EnumerationType )) { type += "?"; } if (attribute.OptionalFlag && domain is AggregationType) { type = "IOptional" + type.Substring(1); } return(type); }
protected bool IsSimpleTypeCompatible(ExplicitAttribute n, ExplicitAttribute o) { if (n.OptionalFlag != o.OptionalFlag) { return(false); } var s = n.Domain as SimpleType ?? o.Domain as SimpleType; var d = n.Domain as DefinedType ?? o.Domain as DefinedType; if (s == null || d == null) { return(false); } var nT = TypeHelper.GetCSType(s, null); var oT = TypeHelper.GetCSType(d.Domain, null); return(oT == nT); }
protected bool CanBeNull(ExplicitAttribute attribute) { if (attribute.Domain is EntityDefinition) { return(true); } if (attribute.Domain is SelectType) { return(true); } if (IsStringType(attribute.Domain)) { return(true); } if (attribute.OptionalFlag) { return(true); } return(false); }
private bool IsDirectEntityRefOrAggr(ExplicitAttribute attribute) { if (OverridingAttributes.Any(a => a.Name == attribute.Name)) { return(false); } if (IsEntityReference(attribute)) { return(true); } if (!(attribute.Domain is AggregationType aggr)) { return(false); } var nt = GetNamedElementType(aggr); if (nt is EntityDefinition) { return(true); } return(nt is SelectType select && GetAllSpecific(@select).All(s => s is EntityDefinition)); }
public override void Reflect(RunInvokerTree tree, RunInvokerVertex parent, Type t) { object fixture = null; try { // Check if fixture is ignored or explicit IgnoreAttribute ignore = null; if (TypeHelper.HasCustomAttribute(t, typeof(IgnoreAttribute))) { ignore = TypeHelper.GetFirstCustomAttribute(t, typeof(IgnoreAttribute)) as IgnoreAttribute; } ExplicitAttribute expl = null; if (TypeHelper.HasCustomAttribute(t, typeof(ExplicitAttribute))) { expl = TypeHelper.GetFirstCustomAttribute(t, typeof(ExplicitAttribute)) as ExplicitAttribute; } foreach (MethodInfo method in TypeHelper.GetAttributedMethods(t, typeof(CombinatorialTestAttribute))) { if (fixture == null) { fixture = TypeHelper.CreateInstance(t); } this.ReflectTestMethod(tree, parent, fixture, method, ignore, expl); } } finally { IDisposable disposable = fixture as IDisposable; if (disposable != null) { disposable.Dispose(); } } }
public static string GetInterfaceCSType(ExplicitAttribute attribute, GeneratorSettings settings, string fullNamespace = null) { var domain = attribute.Domain; var type = GetCSType(domain, settings, false, true, fullNamespace); if (attribute.OptionalFlag && ( (domain is SimpleType && !(domain is LogicalType) && !(domain is StringType) && !(domain is BinaryType)) || domain is DefinedType || domain is EnumerationType )) { type += "?"; } if (domain is AggregationType) { if (ReadOnlyItemSets.Any(s => s.Attribute == attribute.Name && s.Class == attribute.ParentEntity.Name)) { //replace item set with IEnumerable type = type.Substring(type.IndexOf('<')); type = "IEnumerable" + type; } } return(type); }
private ExplicitAttribute RedefineAttribute(ExplicitAttribute attribute, IEnumerable <string> accessor, bool optional) { var attrName = accessor.LastOrDefault(); if (attrName == null) { throw new Exception("Name of redeclaring attribute not defined."); } var attr = NameAttribute(attribute, attrName, optional); ToDoPostActions.Add(() => { var entity = attribute.ParentEntity; var redeclaring = entity.AllExplicitAttributes.FirstOrDefault(a => a.Name == attrName); if (redeclaring == null) { throw new InstanceNotFoundException(); } attr.Redeclaring = redeclaring; }); return(attr); }
private static bool IsEntityReference(ExplicitAttribute attribute) { return(IsEntityReference(attribute.Domain)); }
protected bool IsEntityOrSelect(ExplicitAttribute attribute) { return(attribute.Domain is EntityDefinition || attribute.Domain is SelectType); }
protected bool IsAggregation(ExplicitAttribute attribute) { return(attribute.Domain is AggregationType); }
protected bool IsOwnAttribute(ExplicitAttribute attribute) { return(ExplicitAttributes.Contains(attribute)); }
protected bool IsPartOfInverse(ExplicitAttribute attribute) { return(Type.SchemaModel.Get <InverseAttribute>(i => i.InvertedAttr == attribute).Any()); }
protected bool IsSimpleOrDefinedType(ExplicitAttribute attribute) { var domain = attribute.Domain; return(domain is SimpleType || domain is DefinedType); }
// ReSharper disable once InconsistentNaming protected virtual string GetCSTypeNN(ExplicitAttribute attribute) { var result = TypeHelper.GetCSType(attribute, Settings); return(result.Trim('?')); }
protected bool IsOverridenAttribute(ExplicitAttribute attribute) { return(Type.SchemaModel.Get <DerivedAttribute>(d => d.Redeclaring == attribute).Any()); }
private static bool IsEntityReferenceDoubleAggregation(ExplicitAttribute attribute) { return(IsEntityReferenceDoubleAggregation(attribute.Domain)); }