public CatalogExport(CatalogExportProvider catalogExportProvider,
     ComposablePartDefinition partDefinition, ExportDefinition definition)
 {
     this._catalogExportProvider = catalogExportProvider;
     this._partDefinition = partDefinition;
     this._definition = definition;
 }

        public static IDictionary<string, object> WriteImportDefinition(ComposablePartDefinition owner, ContractBasedImportDefinition importDefinition)
        {
            Assumes.NotNull(owner);
            Assumes.NotNull(importDefinition);

            Lazy<Type> partType = ReflectionModelServices.GetPartType(owner);

            IDictionary<string, object> cache = new Dictionary<string, object>();
            cache.WriteContractName(importDefinition.ContractName);
            cache.WriteValue(AttributedCacheServices.CacheKeys.RequiredTypeIdentity, importDefinition.RequiredTypeIdentity, null);
            cache.WriteRequiredMetadata(importDefinition.RequiredMetadata);
            cache.WriteValue(AttributedCacheServices.CacheKeys.RequiredCreationPolicy, importDefinition.RequiredCreationPolicy, CreationPolicy.Any);
            cache.WriteValue(AttributedCacheServices.CacheKeys.Cardinality, importDefinition.Cardinality, ImportCardinality.ExactlyOne);
            if (ReflectionModelServices.IsImportingParameter(importDefinition))
            {
                cache.WriteValue(AttributedCacheServices.CacheKeys.ImportType, AttributedCacheServices.ImportTypes.Parameter);
                cache.WriteLazyParameter(
                        ReflectionModelServices.GetImportingParameter(importDefinition),
                        partType);
            }
            else
            {
                // don't write anything for import type - member assumed
                LazyMemberInfo importingMemberInfo = ReflectionModelServices.GetImportingMember(importDefinition);
                cache.WriteValue(AttributedCacheServices.CacheKeys.IsRecomposable, importDefinition.IsRecomposable, false);
                cache.WriteValue(AttributedCacheServices.CacheKeys.MemberType, importingMemberInfo.MemberType , MemberTypes.Property);
                cache.WriteLazyAccessors(
                        importingMemberInfo.GetAccessors(),
                        partType);
            }

            return cache;
        }

 private void CheckName(ComposablePartDefinition def)
 {
     if (!def.Metadata.ContainsKey(Keys.PluginId))
     {
         var msg = string.Format("There's a plugin without id. Check you've set the attribute Metadata to the plugin with the key '{0}'", Keys.PluginId);
     #if DEBUG
         throw new NotImplementedException(msg);
     #else
         Logger.Warn(msg);
     #endif
     }
     else
     {
         Guid id;
         if (!(Guid.TryParse(def.Metadata[Keys.PluginId].ToString(), out id)))
         {
             throw new Exception(string.Format(
                 "The plugin doen't have a valid id. Check you've set the attribute Metadata to the plugin with the key '{0}'", Keys.PluginId));
         }
         if (this.IdCollection.Contains(id))
         {
             throw new Exception(string.Format(
                 "A plugin with the same id already exist in the repository [id: {0}]", id.ToString()));
         }
     }
 }

 public PartCreatorExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition exportDefinition)
 {
     this._catalogExportProvider = catalogExportProvider;
     this._partDefinition = partDefinition;
     this._exportDefinition = exportDefinition;
     this._partCreatorExportDefinition = new PartCreatorExportDefinition(this._exportDefinition);
 }

        public AddInComposablePartDefinition(AddInCatalog catalog, ComposablePartDefinition composablePartDefinition)
        {
            this._composablePartDefinition = composablePartDefinition;

            List<KeyValuePair<string, object>> injectedMetadata = new List<KeyValuePair<string, object>>();
            injectedMetadata.Add(new KeyValuePair<string, object>(AddInCatalog.PackageIdMetadataName, catalog.PackageId));
            injectedMetadata.Add(new KeyValuePair<string, object>(AddInCatalog.PackageVersionMetadataName, 
                                                                  catalog.PackageVersion));

            List<ExportDefinition> interceptedExports = new List<ExportDefinition>();

            foreach (ExportDefinition export in composablePartDefinition.ExportDefinitions)
            {
                ICompositionElement compositionElement = export as ICompositionElement;
                if (compositionElement == null)
                    throw new InvalidOperationException("ExportDefinition doesn't implement ICompositionElement");

                Dictionary<string, object> metadata = injectedMetadata.Concat(export.Metadata)
                                                                      .ToDictionary(kvp => kvp.Key, 
                                                                                    kvp => kvp.Value);

                // TODO this will fail if export isn't a ReflectionMemberExportDefinition (Internal, so I can't check)
                LazyMemberInfo lazyMember = ReflectionModelServices.GetExportingMember(export);

                ExportDefinition interceptedExport =
                    ReflectionModelServices.CreateExportDefinition(lazyMember, 
                                                                   export.ContractName, 
                                                                   new Lazy<IDictionary<string, object>>(() => metadata), 
                                                                   compositionElement.Origin);
                interceptedExports.Add(interceptedExport);
            }

            this._exportDefinitions = interceptedExports.ToArray();
        }

        public IDictionary<string, object> CacheImportDefinition(ComposablePartDefinition owner, ImportDefinition importDefinition)
        {
            ContractBasedImportDefinition contractBasedImport = importDefinition as ContractBasedImportDefinition;
            Assumes.NotNull(contractBasedImport);

            return CompositionCacheServices.WriteImportDefinition(owner, contractBasedImport);
        }

        private static ImportDefinition TranslateImport(ImportDefinition import, ComposablePartDefinition part)
        {
            ContractBasedImportDefinition contractBasedImport = import as ContractBasedImportDefinition;
            if (contractBasedImport == null)
            {
                return import;
            }

            int[] importParametersOrder = contractBasedImport.Metadata.GetValue<int[]>(CompositionConstants.GenericImportParametersOrderMetadataName);
            if (importParametersOrder == null)
            {
                return import;
            }

            int partArity = part.Metadata.GetValue<int>(CompositionConstants.GenericPartArityMetadataName);
            if (partArity == 0)
            {
                return import;
            }

            string contractName = GenericServices.GetGenericName(contractBasedImport.ContractName, importParametersOrder, partArity);
            string requiredTypeIdentity = GenericServices.GetGenericName(contractBasedImport.RequiredTypeIdentity, importParametersOrder, partArity);
            return new ContractBasedImportDefinition(
                         contractName,
                         requiredTypeIdentity,
                         contractBasedImport.RequiredMetadata,
                         contractBasedImport.Cardinality,
                         contractBasedImport.IsRecomposable,
                         false,
                         contractBasedImport.RequiredCreationPolicy,
                         contractBasedImport.Metadata);
        }

        /// <summary>
        /// Decides whether given part satisfies a filter.
        /// </summary>
        /// <param name="part"><see cref="ComposablePartDefinition"/> being filtered.</param>
        /// <returns>True if a given <see cref="ComposablePartDefinition"/> satisfies the filter.
        /// False otherwise.</returns>
        public bool Filter(ComposablePartDefinition part)
        {
            // Fetch all metadata
            Dictionary<string, object> metadata = new Dictionary<string, object>(StringComparer.InvariantCultureIgnoreCase);
            foreach (var md in part.Metadata)
            {
                metadata.Add(md.Key, md.Value);
            }
            var additionalMetadata = from ed in part.ExportDefinitions
                                     from md in ed.Metadata
                                     select md;
            foreach (var md in additionalMetadata)
            {
                if (!metadata.ContainsKey(md.Key))
                {
                    metadata.Add(md.Key, md.Value);
                }
            }

            // Fetch "Scope"
            var key = "Scope";
            if (metadata.ContainsKey(key))
            {
                PartCreationScope scope = PartCreationScope.Default;
                Enum.TryParse(metadata[key].ToString(), out scope);

                return scope == _partCreationScope;
            }
            else if (_partCreationScope == PartCreationScope.Default)
            {
                return true;
            }
            return false;
        }

 private static bool GetAllWithinAppScope(ComposablePartDefinition def)
 {
     return def.ExportDefinitions.
             Any(ed =>
                     !ed.Metadata.ContainsKey(ModeKey) ||
                     (ed.Metadata.ContainsKey(ModeKey) && ((WebScopeMode)ed.Metadata[ModeKey]) == WebScopeMode.Application));
 }

 /// <summary>
 ///  Create a PartDefinitionInfo representing partDefinition. 
 /// </summary>
 /// <param name="partDefinition">The part to be analyzed.</param>
 public PartDefinitionInfo(ComposablePartDefinition partDefinition)
 {
     PartDefinition = partDefinition;
     ImportDefinitions = Enumerable.Empty<ImportDefinitionInfo>();
     _isRejected = new Lazy<bool>(() => ImportDefinitions
             .Any(idi => idi.Exception is ImportCardinalityMismatchException));
 }

            public bool TryTraverse(ComposablePartDefinition part, out IEnumerable<ComposablePartDefinition> reachableParts)
            {
                reachableParts = null;
                List<ComposablePartDefinition> reachablePartList = null;

                // Go through all part exports
                foreach (ExportDefinition export in part.ExportDefinitions)
                {
                    // Find all parts that we know will import each export
                    List<ComposablePartDefinition> candidateReachableParts = null;
                    if (this._importersIndex.TryGetValue(export.ContractName, out candidateReachableParts))
                    {
                        // find if they actually match
                        foreach (var candidateReachablePart in candidateReachableParts)
                        {
                            foreach (ImportDefinition import in candidateReachablePart.ImportDefinitions.Where(this._importFilter))
                            {
                                if (import.IsImportDependentOnPart(part, export, part.IsGeneric() != candidateReachablePart.IsGeneric()))
                                {
                                    if (reachablePartList == null)
                                    {
                                        reachablePartList = new List<ComposablePartDefinition>();
                                    }
                                    reachablePartList.Add(candidateReachablePart);
                                }
                            }
                        }
                    }
                }

                reachableParts = reachablePartList;
                return (reachableParts != null);
            }

		protected override bool IsMatch(ComposablePartDefinition composablePartDefinition)
		{
			var element = composablePartDefinition as ICompositionElement;
			if (element == null)
				return true;
			return element.DisplayName.StartsWith("Raven.Database") == false;
		}

 /// <summary>
 /// Initializes the context from a part and the export.
 /// </summary>
 internal DecoratedExport(ComposablePartDefinition part, ExportDefinition export)
 {
     this.ExportDefinition = export;
     this.ExportingMember = ReflectionModelServices.GetExportingMember(export);
     this.ExportingType = ReflectionModelServices.GetPartType(part);
     this.NewMetadata = new Dictionary<string, object>(export.Metadata);
 }

        public static ReflectionComposablePart CreatePart(ComposablePartDefinition partDefinition, object attributedPart)
        {
            Assumes.NotNull(partDefinition);
            Assumes.NotNull(attributedPart);

            return new ReflectionComposablePart((ReflectionComposablePartDefinition)partDefinition, attributedPart);
        }

        /// <summary>
        /// Decides whether given part satisfies a filter.
        /// </summary>
        /// <param name="part"><see cref="ComposablePartDefinition"/> being filtered.</param>
        /// <returns>True if a given <see cref="ComposablePartDefinition"/> satisfies the filter.
        /// False otherwise.</returns>
        public bool Filter(ComposablePartDefinition part)
        {
            if (creationPolicy == CreationPolicy.Any && !part.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName))
                return true;

            return part.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) &&
                   ((CreationPolicy)part.Metadata[CompositionConstants.PartCreationPolicyMetadataName]) == creationPolicy;
        }

        public InterceptingComposablePartDefinition(ComposablePartDefinition interceptedPartDefinition, IExportedValueInterceptor valueInterceptor)
        {
            if (interceptedPartDefinition == null) throw new ArgumentNullException("interceptedPartDefinition");
            if (valueInterceptor == null) throw new ArgumentNullException("valueInterceptor");

            InterceptedPartDefinition = interceptedPartDefinition;
            this.valueInterceptor = valueInterceptor;
        }

        public InterceptingComposablePartDefinition(ComposablePartDefinition interceptedPartDefinition, IExportedValueInterceptor valueInterceptor)
        {
            interceptedPartDefinition.ShouldNotBeNull("interceptedPartDefinition");
            valueInterceptor.ShouldNotBeNull("valueInterceptor");

            InterceptedPartDefinition = interceptedPartDefinition;
            _valueInterceptor = valueInterceptor;
        }

 public void When_calling_create_part_it_should_create_a_disposable_intercepting_part()
 {
     var mockInterceptor = new Mock<IExportedValueInterceptor>();
     interceptedPartDefinition = AttributedModelServices.CreatePartDefinition(typeof(DisposablePart), null);
     interceptingPartDefinition = new InterceptingComposablePartDefinition(interceptedPartDefinition, mockInterceptor.Object);
     var part = interceptingPartDefinition.CreatePart();
     part.ShouldBeOfType<DisposableInterceptingComposablePart>();
 }

        public IDictionary<string, object> CachePartDefinition(ComposablePartDefinition partDefinition)
        {
            ComposablePartDefinition reflectionPartDefition = partDefinition as ComposablePartDefinition;
            Assumes.NotNull(reflectionPartDefition);

            IDictionary<string, object> cache =  CompositionCacheServices.WritePartDefinition(reflectionPartDefition, this.WriteAssemblyForTypes);
            return cache;
        }

        public static Lazy<Type> GetPartType(ComposablePartDefinition partDefinition)
        {
            AddInComposablePartDefinition addinPartDef = partDefinition as AddInComposablePartDefinition;
            
            if (addinPartDef == null)
                throw new ArgumentException("Must be of type AddInComposablePartDefinition", "partDefinition");

            return ReflectionModelServices.GetPartType(addinPartDef.Definition);
        }