コード例 #1
0
        public TCompositeDeclaration ForExistingComposite <TCompositeDeclaration>(CompositeModelType compositeType)
            where TCompositeDeclaration : AbstractCompositeAssemblyDeclaration
        {
            var infos = this.GetInfosForAssemblingDeclaration(compositeType);

            return(this._assemblyScopeSupport[compositeType].CreateAssemblyDeclarationForExisting <TCompositeDeclaration>(this, infos.MQ.IQ));
        }
コード例 #2
0
        public TCompositeDeclaration NewComposite <TCompositeDeclaration>(CompositeModelType compositeType)
            where TCompositeDeclaration : AbstractCompositeAssemblyDeclaration
        {
            var infos = this.GetInfosForAssemblingDeclaration(compositeType);

            return(this._assemblyScopeSupport[compositeType].CreateAssemblyDeclarationForNew <TCompositeDeclaration>(this, infos, this._assemblyScopeSupport[compositeType].CreateCompositeInfo(this._newCompositeIDRequestor(), this._parentContainer.Query), this._collectionsFactory));
        }
コード例 #3
0
        public CompositeAssemblyInfoImpl(Int32 id, CompositeModelType modelType, UsesContainerQuery parentContainer)
        {
            ArgumentValidator.ValidateNotNull("Composite model type", modelType);

            this._id                = id;
            this._fragmentInfos     = new Dictionary <FragmentModelType, FragmentAssemblyInfo>();
            this._defaultProviders  = new Dictionary <PropertyInfo, Func <PropertyInfo, ApplicationSPI, Object> >();
            this._metaInfoContainer = UsesContainerMutableImpl.CreateWithParent(parentContainer);
            this._modelType         = modelType;
            this._types             = new HashSet <Type>();
        }
コード例 #4
0
        public IEnumerable <CompositeAssemblyInfo> GetInfos(CompositeModelType compositeType)
        {
            IEnumerable <CompositeAssemblyInfo> result = EMPTY_INFOS;
            DictionaryWithRoles <Type, ListProxy <CompositeAssemblyInfo>, ListProxyQuery <CompositeAssemblyInfo>, ListQuery <CompositeAssemblyInfo> > dic;

            if (this._compositeInfos.CQ.TryGetValue(compositeType, out dic))
            {
                result = dic.CQ.Values.SelectMany(list => list.CQ);
            }
            return(result.Distinct(ReferenceEqualityComparer <CompositeAssemblyInfo> .ReferenceBasedComparer));
        }
        public AbstractCompositeAssemblyDeclarationForExistingImpl(Assembler assembler, CompositeModelType compositeModelType, DictionaryQuery <Type, ListQuery <CompositeAssemblyInfo> > compositeAssemblyInfos)
        {
            ArgumentValidator.ValidateNotNull("Assembler", assembler);
            ArgumentValidator.ValidateNotNull("Assembly infos", compositeAssemblyInfos);
            ArgumentValidator.ValidateNotNull("Composite model type", compositeModelType);

            this._assembler          = assembler;
            this._compositeModelType = compositeModelType;
            this._composites         = compositeAssemblyInfos;
            this._affectedTypes      = new HashSet <Type>();
        }
コード例 #6
0
        public CompositeModelInfo GetCompositeModelInfo(CompositeModelType modelType, IEnumerable <Type> compositeTypes)
        {
            ArgumentValidator.ValidateNotNull("Composite model type", modelType);
            ArgumentValidator.ValidateNotNull("Composite types", compositeTypes);

            CompositeModelInfo            result = null;
            SetQuery <CompositeModelInfo> dic    = null;

            if (this._compositeModels.TryGetValue(modelType, out dic))
            {
                result = this.ResolveModelInfo(dic, compositeTypes);
            }
            return(result);
        }
コード例 #7
0
        public CompositeBuilder NewCompositeBuilder(CompositeModelType compositeModelType, IEnumerable <Type> compositeTypes)
        {
            ArgumentValidator.ValidateNotNull("Composite model type", compositeModelType);
            ArgumentValidator.ValidateNotNull("Composite types", compositeTypes);

            CompositeModelTypeInstanceScopeSupport support;

            if (this._modelSupport.TryGetValue(compositeModelType, out support))
            {
                return(support.CreateBuilder(this, compositeTypes.ToArray()));
            }
            else
            {
                throw new InvalidCompositeModelTypeException(compositeModelType, "This application does not support this composite model type.");
            }
        }
コード例 #8
0
        public Boolean ForNewOrExistingComposite <TCompositeDeclaration>(CompositeModelType compositeType, IEnumerable <Type> types, out TCompositeDeclaration result)
            where TCompositeDeclaration : AbstractCompositeAssemblyDeclaration
        {
            var infos = this.GetInfosForAssemblingDeclaration(compositeType);
            var givenExceptExisting = types.Except(types.Where(typeInner => infos.CQ.Keys.Any(key => typeInner.GetGenericDefinitionIfContainsGenericParameters().IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes(key))));
            var returnValue         = givenExceptExisting.Any();

            if (returnValue)
            {
                // Completely new composite assembly declaration
                result = this.NewComposite <TCompositeDeclaration>(compositeType);
            }
            else
            {
                // There is already one or more existing infos
                result = this.ForExistingComposite <TCompositeDeclaration>(compositeType);
            }
            result.OfTypes(types.ToArray());
            return(returnValue);
        }
コード例 #9
0
 public ServiceCompositeAssemblyInfoImpl(Int32 id, CompositeModelType modelType, UsesContainerQuery parent)
     : base(id, modelType, parent)
 {
     this._serviceID = null;
     this._activateWithApplication = false;
 }
コード例 #10
0
        public override CompositeBuilder CreateBuilder(StructureServiceProviderSPI structureServiceProvider, Type[] compositeTypes)
        {
            CompositeModelType mType = this.ModelScopeSupport.AssemblyScopeSupport.ModelType;

            throw new InvalidCompositeModelTypeException(mType, "Composite builders can not be used to create composites of type " + mType + ".");
        }
コード例 #11
0
 internal LayeredPlainCompositeAssemblyDeclarationForExistingImpl(Assembler assembler, CompositeModelType compositeModelType, DictionaryQuery <Type, ListQuery <CompositeAssemblyInfo> > compositeAssemblyInfos)
     : base(assembler, compositeModelType, compositeAssemblyInfos)
 {
 }
コード例 #12
0
ファイル: ModuleImpl.cs プロジェクト: CometaSolutions/Qi4CS
 internal static CompositeBuilder CreateBuilder( CompositeModelTypeInstanceScopeSupport modelSupport, CompositeInstanceStructureOwner structureOwner, CompositeModelType compositeModelType, IEnumerable<Type> compositeTypes )
 {
    var compositeTypesArr = compositeTypes.ToArray();
    var tuple = ( (ModuleImpl) structureOwner ).FindModelForBuilder( compositeModelType, compositeTypesArr );
    var uses = UsesContainerMutableImpl.CreateWithParent( tuple.Item2.UsesContainer );
    return new CompositeBuilderImpl( compositeTypesArr, uses, (CompositeInstanceImpl) modelSupport.CreateInstance( tuple.Item1, tuple.Item2, compositeTypesArr, uses.Query ) );
 }
コード例 #13
0
ファイル: ModuleImpl.cs プロジェクト: CometaSolutions/Qi4CS
      internal Tuple<CompositeInstanceStructureOwner, CompositeModel> FindModelForBuilder( CompositeModelType compositeModelType, Type[] compositeTypes )
      {
         // TODO might get rid of tuple? if lookup is done by target module
#if SILVERLIGHT
         IDictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>> cache;
         lock ( this._compositeTypeLookupCache )
         {
            cache = this._compositeTypeLookupCache.GetOrAdd_NotThreadSafe( compositeModelType, key => new Dictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>>( ArrayEqualityComparer<Type>.DefaultArrayEqualityComparer ) );
#else
         var cache = this._compositeTypeLookupCache.GetOrAdd( compositeModelType, key => new System.Collections.Concurrent.ConcurrentDictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>>( ArrayEqualityComparer<Type>.DefaultArrayEqualityComparer ) );
#endif

#if SILVERLIGHT
         }
#endif

#if SILVERLIGHT
         lock ( cache )
         {
#endif
         return cache.
#if SILVERLIGHT
GetOrAdd_NotThreadSafe(
#else
GetOrAdd(
#endif
 compositeTypes, ( compositeTypez ) => // lambda will need composite model type -> can't fully optimize
            {
               var models = this.FindVisibleModels( compositeModel =>
                  compositeModel.ModelType.Equals( compositeModelType )
                  && compositeTypes.All( cType => compositeModel.PublicTypes.Any( pType => cType.GetGenericDefinitionIfGenericType().IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes( pType ) ) )
                  );

               var array = models.Take( 2 ).ToArray();
               if ( array.Length > 1 )
               {
                  // This can happen when same layer is reachable via two other layers, e.g.
                  //  A  
                  // / \
                  // B C
                  // \ /
                  //  D
                  // If one makes search from module A for composite type present in module D in one composite model, one will get two references to same composite model in D
                  array = models.Distinct().Take( 2 ).ToArray();
               }

               if ( array.Length == 0 )
               {
                  throw new NoSuchCompositeTypeException( compositeTypes );
               }
               else
               {
                  if ( array.Length > 1 )
                  {
                     throw new AmbiguousTypeException( compositeTypes, models.Select( tuple => tuple.Item2.PublicTypes ) );
                  }
                  else
                  {
                     // Try to search for model info. If the composite type is ambiguous in the scope of that module, the exception will be thrown.
                     //( (ModuleInstance) result.Item1 ).ModelInfoContainer.GetCompositeModelInfo( compositeModelType, compositeType );
                     return array[0];
                  }
               }
            } );
#if SILVERLIGHT
         }
#endif
      }
コード例 #14
0
 internal LayeredCompositeAssemblyInfoImpl(Int32 id, CompositeModelType modelType, UsesContainerQuery parentContainer)
     : base(id, modelType, parentContainer)
 {
     this._visibility = DEFAULT_VISIBILITY;
 }
コード例 #15
0
        protected DictionaryWithRoles <Type, ListProxy <CompositeAssemblyInfo>, ListProxyQuery <CompositeAssemblyInfo>, ListQuery <CompositeAssemblyInfo> > GetInfosForAssemblingDeclaration(CompositeModelType compositeModelType)
        {
            ArgumentValidator.ValidateNotNull("Composite model type", compositeModelType);

            DictionaryWithRoles <Type, ListProxy <CompositeAssemblyInfo>, ListProxyQuery <CompositeAssemblyInfo>, ListQuery <CompositeAssemblyInfo> > infos;

            if (!this._compositeInfos.CQ.TryGetValue(compositeModelType, out infos))
            {
                infos = this._collectionsFactory.NewDictionary <Type, ListProxy <CompositeAssemblyInfo>, ListProxyQuery <CompositeAssemblyInfo>, ListQuery <CompositeAssemblyInfo> >();
                this._compositeInfos.Add(compositeModelType, infos);
            }
            return(infos);
        }
コード例 #16
0
 /// <summary>
 /// Shortcut method to create a composite of specified <see cref="CompositeModelType"/> without further setting up of <see cref="CompositeBuilder"/>.
 /// </summary>
 /// <typeparam name="TComposite">The type of the composite.</typeparam>
 /// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
 /// <param name="compositeModelType">The <see cref="CompositeModelType"/> of the composite.</param>
 /// <returns>A new instance of composite with given <see cref="CompositeModelType"/>.</returns>
 /// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
 /// <remarks>
 /// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> and <see cref="CompositeBuilder.InstantiateWithType(Type)"/> methods for more exception scenarios.
 /// </remarks>
 /// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
 /// <seealso cref="CompositeBuilder.InstantiateWithType(Type)"/>
 public static TComposite NewComposite <TComposite>(this StructureServiceProvider ssp, CompositeModelType compositeModelType)
 {
     return(ssp.NewCompositeBuilder <TComposite>(compositeModelType).Instantiate());
 }
コード例 #17
0
 /// <summary>
 /// Helper method to create new composite builder with specified <see cref="CompositeModelType"/> and only one type, known at compile time, to be used as search criteria.
 /// </summary>
 /// <typeparam name="TComposite">The type of the composite, to be used as search criterion when searching for suitable composite model.</typeparam>
 /// <param name="ssp">The <see cref="StructureServiceProvider"/></param>
 /// <param name="compositeModelType">The <see cref="CompositeModelType"/> to be used when searching for suitable composite model.</param>
 /// <returns>A new <see cref="CompositeBuilderInfo{T}"/> instance matching the search criteria.</returns>
 /// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
 /// <remarks>
 /// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> method for more exception scenarios.
 /// </remarks>
 /// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
 /// <seealso cref="CompositeBuilderInfo{T}"/>
 public static CompositeBuilderInfo <TComposite> NewCompositeBuilder <TComposite>(this StructureServiceProvider ssp, CompositeModelType compositeModelType)
 {
     return(new CompositeBuilderInfo <TComposite>(ssp.NewCompositeBuilder(compositeModelType, typeof(TComposite).Singleton())));
 }
コード例 #18
0
 /// <summary>
 /// Helper method to create new composite builder with specified <see cref="CompositeModelType"/> and only one type to be used as search criteria.
 /// </summary>
 /// <param name="ssp">The <see cref="StructureServiceProvider"/>.</param>
 /// <param name="compositeModelType">The <see cref="CompositeModelType"/> to be used when searching for suitable composite model.</param>
 /// <param name="compositeType">The type of the composite, to be used as search criterion when searching for suitable composite model.</param>
 /// <returns>A new <see cref="CompositeBuilder"/> instance matching the search criteria.</returns>
 /// <exception cref="NullReferenceException">If <paramref name="ssp"/> is <c>null</c>.</exception>
 /// <remarks>
 /// See <see cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/> method for more exception scenarios.
 /// </remarks>
 /// <seealso cref="StructureServiceProvider.NewCompositeBuilder(CompositeModelType, IEnumerable{Type})"/>
 public static CompositeBuilder NewCompositeBuilder(this StructureServiceProvider ssp, CompositeModelType compositeModelType, Type compositeType)
 {
     return(ssp.NewCompositeBuilder(compositeModelType, compositeType.Singleton()));
 }
 public ServiceCompositeAssemblyDeclarationForExistingImpl(Assembler assembler, CompositeModelType compositeModelType, DictionaryQuery <Type, ListQuery <CompositeAssemblyInfo> > compositeAssemblyInfos)
     : base(assembler, compositeModelType, compositeAssemblyInfos)
 {
 }