internal MutableAmbientProperty(MutableItem owner, AmbientPropertyInfo info) : base(owner, StObjMutableReferenceKind.AmbientProperty) { _info = info; Type = _info.PropertyType; IsOptional = _info.IsOptional; }
internal MutableInjectObject(MutableItem owner, InjectObjectInfo info) : base(owner, StObjMutableReferenceKind.RealObject) { InjecttInfo = info; Type = InjecttInfo.PropertyType; IsOptional = InjecttInfo.IsOptional; }
internal void AddInterfaceMapping(Type t, MutableItem m, MutableItem finalType) { Debug.Assert(t.IsInterface); _map.Add(t, finalType); _map.Add(new RealObjectInterfaceKey(t), m); finalType.RealObjectType.AddUniqueMapping(t); }
/// <summary> /// Initializes a new marker object: the ambient property has not been found. /// A marker is not used. /// </summary> internal MutableAmbientProperty(MutableItem owner, string unexistingPropertyName) : base(owner, StObjMutableReferenceKind.AmbientProperty) { _info = null !; Type = typeof(object); IsOptional = false; _maxSpecializationDepthSet = Int32.MaxValue; }
internal void AddClassMapping(Type t, MutableItem m) { Debug.Assert(t.IsClass); _map.Add(t, m); if (t != m.RealObjectType.Type) { m.RealObjectType.AddUniqueMapping(t); } }
internal MutableParameter(MutableItem owner, ParameterInfo param, bool isContainer) : base(owner, isContainer ? StObjMutableReferenceKind.ConstructParameter | StObjMutableReferenceKind.Container : StObjMutableReferenceKind.ConstructParameter) { _param = param; Type = param.ParameterType; IsOptional = param.IsOptional; if (IsSetupLogger) { StObjRequirementBehavior = Setup.StObjRequirementBehavior.None; } }
internal void RegisterServiceFinalObjectMapping(Type t, CKTypeInfo typeInfo) { Debug.Assert(typeInfo is RealObjectClassInfo); var c = (RealObjectClassInfo)typeInfo; MutableItem mapping = c.AutoServiceImpl; if (mapping == null) { c.AutoServiceImpl = mapping = _map[typeInfo.Type]; _serviceRealObjects.Add(mapping); } _serviceToObjectMap.Add(t, mapping); }
internal MutableReference(MutableItem owner, StObjMutableReferenceKind kind) { Owner = owner; _kind = kind; if (_kind == StObjMutableReferenceKind.Requires || _kind == StObjMutableReferenceKind.Group || _kind == StObjMutableReferenceKind.RealObject || (_kind & StObjMutableReferenceKind.Container) != 0) { StObjRequirementBehavior = StObjRequirementBehavior.ErrorIfNotStObj; } else { Debug.Assert((_kind & StObjMutableReferenceKind.ConstructParameter) != 0 || _kind == StObjMutableReferenceKind.RequiredBy || _kind == StObjMutableReferenceKind.AmbientProperty); StObjRequirementBehavior = StObjRequirementBehavior.None; } }
internal MutableReferenceList(MutableItem owner, StObjMutableReferenceKind kind) { _owner = owner; _kind = kind; }
internal TrackedAmbientPropertyInfo(MutableItem o, AmbientPropertyInfo p) { Owner = o; AmbientPropertyInfo = p; }
RealObjectCollectorResult GetRealObjectResult() { List <MutableItem> allSpecializations = new List <MutableItem>(_roots.Count); StObjObjectEngineMap engineMap = new StObjObjectEngineMap(_names, allSpecializations, KindDetector, _assemblies); List <List <MutableItem> > concreteClasses = new List <List <MutableItem> >(); List <IReadOnlyList <Type> >?classAmbiguities = null; List <Type> abstractTails = new List <Type>(); var deepestConcretes = new List <(MutableItem, ImplementableTypeInfo)>(); Debug.Assert(_roots.All(info => info != null && !info.IsExcluded && info.Generalization == null), "_roots contains only not Excluded types."); foreach (RealObjectClassInfo newOne in _roots) { deepestConcretes.Clear(); newOne.CreateMutableItemsPath(_monitor, _serviceProvider, engineMap, null, _tempAssembly, deepestConcretes, abstractTails); if (deepestConcretes.Count == 1) { MutableItem last = deepestConcretes[0].Item1; allSpecializations.Add(last); var path = new List <MutableItem>(); last.InitializeBottomUp(null); path.Add(last); MutableItem?spec = last, toInit = last; while ((toInit = toInit.Generalization) != null) { toInit.InitializeBottomUp(spec); path.Add(toInit); spec = toInit; } path.Reverse(); concreteClasses.Add(path); foreach (var m in path) { engineMap.AddClassMapping(m.RealObjectType.Type, last); } } else if (deepestConcretes.Count > 1) { List <Type> ambiguousPath = new List <Type>() { newOne.Type }; ambiguousPath.AddRange(deepestConcretes.Select(m => m.Item1.RealObjectType.Type)); if (classAmbiguities == null) { classAmbiguities = new List <IReadOnlyList <Type> >(); } classAmbiguities.Add(ambiguousPath.ToArray()); } } Dictionary <Type, List <Type> >?interfaceAmbiguities = null; foreach (var path in concreteClasses) { MutableItem finalType = path[path.Count - 1]; finalType.RealObjectType.InitializeInterfaces(_monitor, this); foreach (var item in path) { foreach (Type itf in item.RealObjectType.ThisRealObjectInterfaces) { MutableItem?alreadyMapped; if ((alreadyMapped = engineMap.RawMappings.GetValueOrDefault(itf)) != null) { if (interfaceAmbiguities == null) { interfaceAmbiguities = new Dictionary <Type, List <Type> > { { itf, new List <Type>() { itf, alreadyMapped.RealObjectType.Type, item.RealObjectType.Type } } }; } else { var list = interfaceAmbiguities.GetOrSet(itf, t => new List <Type>() { itf, alreadyMapped.RealObjectType.Type }); list.Add(item.RealObjectType.Type); } } else { engineMap.AddInterfaceMapping(itf, item, finalType); } } } } return(new RealObjectCollectorResult(engineMap, concreteClasses, classAmbiguities ?? (IReadOnlyList <IReadOnlyList <Type> >)Array.Empty <IReadOnlyList <Type> >(), interfaceAmbiguities != null ? interfaceAmbiguities.Values.Select(list => list.ToArray()).ToArray() : Array.Empty <IReadOnlyList <Type> >(), abstractTails)); }
public ListInjectSingleton(MutableItem item) { _item = item; _count = _item.RealObjectType.InjectObjects.Count; }
public ListAmbientProperty(MutableItem item) { _item = item; _count = _item.RealObjectType.AmbientProperties.Count; }
#pragma warning disable CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable. public LeafData(MutableItem leaf, List <MutableAmbientProperty> ap, MutableInjectObject[] ac) { LeafSpecialization = leaf; AllAmbientProperties = ap; AllInjectObjects = ac; }
internal MutableReferenceOptional(MutableItem owner, StObjMutableReferenceKind kind) : base(owner, kind) { _resolved = UnresolvedMarker; }
private bool HandleStObjPropertySource(IActivityMonitor monitor, StObjProperty p, MutableItem source, string sourceName, bool doSetOrMerge) { StObjProperty?c = source.GetStObjProperty(p.Name); // Source property is defined somewhere in the source. if (c != null) { // If the property is explicitly defined (Info != null) and its type is not // compatible with our, there is a problem. if (c.InfoOnType != null && !p.Type.IsAssignableFrom(c.Type)) { // It is a warning because if actual values work, everything is okay... but one day, it should fail. var msg = String.Format("StObjProperty '{0}.{1}' of type '{2}' is not compatible with the one of its {6} ('{3}.{4}' of type '{5}'). Type should be compatible since {6}'s property value will be propagated if no explicit value is set for '{7}.{1}' or if '{3}.{4}' is set with an incompatible value.", ToString(), p.Name, p.Type.Name, source.RealObjectType.Type.Name, c.Name, c.Type.Name, sourceName, RealObjectType.Type.Name); monitor.Warn(msg); } if (doSetOrMerge) { // The source value must have been set and not explicitly "removed" with a System.Type.Missing value. if (c.Value != System.Type.Missing) { // We "Set" the value from this source. if (!p.ValueHasBeenSet) { p.Value = c.Value; } else if (p.Value is IMergeable) { using (var services = new SimpleServiceContainer()) { services.Add(monitor); if (!((IMergeable)p.Value).Merge(c.Value, services)) { monitor.Error($"Unable to merge StObjProperty '{ToString()}.{p.Value}' with value from {sourceName}."); } } } return(true); } } } return(false); }