/// <summary>
        /// Interception called before invoking the handler to process the request.
        /// </summary>
        /// <param name="context">The processing context.</param>
        /// <param name="token">The cancellation token.</param>
        /// <returns>
        /// A task.
        /// </returns>
        public Task BeforeProcessAsync(IProcessingContext context, CancellationToken token)
        {
            Contract.Requires(context != null);
            Contract.Ensures(Contract.Result<Task>() != null);

            return Contract.Result<Task>();
        }

        /// <summary>
        /// Processes the provided request asynchronously and returns a response promise.
        /// </summary>
        /// <param name="request">The request to be handled.</param>
        /// <param name="context">The processing context.</param>
        /// <param name="token">The cancellation token.</param>
        /// <returns>
        /// The response promise.
        /// </returns>
        public Task<IResponse> ProcessAsync(IRequest request, IProcessingContext context, CancellationToken token)
        {
            Contract.Requires(request != null);
            Contract.Requires(context != null);
            Contract.Ensures(Contract.Result<Task<IResponse>>() != null);

            return Contract.Result<Task<IResponse>>();
        }

 public void EnrichConstructor(IProcessingContext context, ConstructorInfo ctor)
 {
     XmlDocReader reader = this.GetDocReader(ctor.DeclaringType.Assembly);
     if (reader != null)
     {
         XElement element = reader.GetDocComments(ctor);
         if (element != null)
             this.RewriteXml(context, ctor.ReflectedType.Assembly, element, "param", "typeparam");
     }
 }

 public void EnrichType(IProcessingContext context, Type type)
 {
     XmlDocReader reader = this.GetDocReader(type.Assembly);
     if (reader != null)
     {
         XElement element = reader.GetDocComments(type);
         if (element != null)
             this.RewriteXml(context, type.Assembly, element, "typeparam");
     }
 }

 public void EnrichParameter(IProcessingContext context, ParameterInfo parameter)
 {
     XmlDocReader reader = this.GetDocReader(context, parameter.Member.ReflectedType.Assembly);
     if (reader != null)
     {
         XElement element = reader.GetDocComments(parameter);
         if (element != null)
             this.RewriteXmlContent(context, parameter.Member.ReflectedType.Assembly, "summary", element);
     }
 }

 public void EnrichParameter(IProcessingContext context, ParameterInfo parameter)
 {
     XmlDocReader reader = this.GetDocReader(parameter.Member.DeclaringType.Assembly);
     if (reader != null)
     {
         XNamespace ns = "urn:doc";
         XElement element = reader.GetDocComments(parameter);
         if (element != null)
             this.RewriteXmlContent(context, "summary", element);
     }
 }

 public new void InstallSecurity(string path, IProcessingContext context)
 {
     Assert.ArgumentNotNullOrEmpty(path, "path");
     Assert.ArgumentNotNull((object)context, "context");
     Log.Info("Installing security from package: " + path, (object)this);
     PackageReader packageReader = new PackageReader(path);
     AccountInstaller accountInstaller = new AccountInstaller();
     accountInstaller.Initialize(context);
     packageReader.Populate((ISink<PackageEntry>)accountInstaller);
     accountInstaller.Flush();
     accountInstaller.Finish();
 }

        private XElement GenerateEventElement(IProcessingContext context, AssetIdentifier assetId)
        {
            EventInfo eventInfo = (EventInfo)context.AssetResolver.Resolve(assetId);
            XElement ret = new XElement("event",
                                        new XAttribute("name", eventInfo.Name),
                                        new XAttribute("assetId", assetId),
                                        new XAttribute("phase", context.Phase));


            GenerateTypeRef(context.Clone(ret), eventInfo.EventHandlerType);

            MethodInfo addMethod = eventInfo.GetAddMethod(true);
            MethodInfo removeMethod = eventInfo.GetRemoveMethod(true);
            if (addMethod != null)
            {
                var addElem = new XElement("add");
                if (addMethod.IsPublic)
                    addElem.Add(new XAttribute("isPublic", XmlConvert.ToString(addMethod.IsPublic)));

                if (addMethod.IsPrivate)
                    addElem.Add(new XAttribute("isPrivate", XmlConvert.ToString(addMethod.IsPrivate)));

                if (addMethod.IsFamily)
                    addElem.Add(new XAttribute("isProtected", XmlConvert.ToString(addMethod.IsFamily)));

                ret.Add(addElem);
            }

            if (removeMethod != null)
            {
                var removeElem = new XElement("remove");
                if (removeMethod.IsPublic)
                    removeElem.Add(new XAttribute("isPublic", XmlConvert.ToString(removeMethod.IsPublic)));

                if (removeMethod.IsPrivate)
                    removeElem.Add(new XAttribute("isPrivate", XmlConvert.ToString(removeMethod.IsPrivate)));

                if (removeMethod.IsFamily)
                    removeElem.Add(new XAttribute("isProtected", XmlConvert.ToString(removeMethod.IsFamily)));

                ret.Add(removeElem);
            }

            context.Element.Add(ret);

            this.GenerateImplementsElement(context.Clone(ret), eventInfo);

            foreach (IEnricher item in this.Enrichers)
                item.EnrichEvent(context.Clone(ret), eventInfo);

            return ret;
        }

        private XElement GenerateConstructorElement(IProcessingContext context, AssetIdentifier assetId)
        {
            ConstructorInfo constructorInfo = (ConstructorInfo)context.AssetResolver.Resolve(assetId);
            XElement ret = new XElement("constructor",
                                        new XAttribute("assetId", assetId),
                                        new XAttribute("phase", context.Phase));

            if (constructorInfo.IsStatic)
                ret.Add(new XAttribute("isStatic", XmlConvert.ToString(constructorInfo.IsStatic)));

            if (constructorInfo.IsPublic)
                ret.Add(new XAttribute("isPublic", XmlConvert.ToString(constructorInfo.IsPublic)));

            if (constructorInfo.IsPrivate)
                ret.Add(new XAttribute("isPrivate", XmlConvert.ToString(constructorInfo.IsPrivate)));

            if (constructorInfo.IsFamily)
                ret.Add(new XAttribute("isProtected", XmlConvert.ToString(constructorInfo.IsFamily)));

            context.Element.Add(ret);

            foreach (IEnricher item in this.Enrichers)
                item.EnrichConstructor(context.Clone(ret), constructorInfo);

            ParameterInfo[] methodParams = constructorInfo.GetParameters();
            this.GenerateParameterElements(context.Clone(ret), methodParams);


            return ret;
        }

        private void GenerateImplementsElement(IProcessingContext context, MemberInfo mInfo)
        {
            Type declaringType = mInfo.DeclaringType;

            if (declaringType.IsGenericType && !declaringType.IsGenericTypeDefinition)
                declaringType = declaringType.GetGenericTypeDefinition();

            if (!declaringType.IsInterface)
            {
                Type[] interfaces = declaringType.GetInterfaces();
                foreach (Type ifType in interfaces)
                {
                    if (context.IsFiltered(AssetIdentifier.FromMemberInfo(ifType)))
                        continue;

                    InterfaceMapping ifMap = declaringType.GetInterfaceMap(ifType);
                    if (ifMap.TargetType != declaringType)
                        continue;

                    var targetMethod =
                        ifMap.TargetMethods.SingleOrDefault(mi => mi.MetadataToken == mInfo.MetadataToken &&
                                                                  mi.Module == mInfo.Module);

                    if (targetMethod != null)
                    {
                        int mIx = Array.IndexOf(ifMap.TargetMethods, targetMethod);

                        AssetIdentifier miAid;
                        if (ifMap.InterfaceMethods[mIx].DeclaringType.IsGenericType)
                        {
                            Type declType = ifMap.InterfaceMethods[mIx].DeclaringType.GetGenericTypeDefinition();
                            MethodInfo[] allMethods =
                                declType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
                                                    BindingFlags.Static);

                            miAid =
                                AssetIdentifier.FromMemberInfo(allMethods.Single(mi =>
                                                                                 mi.MetadataToken == ifMap.InterfaceMethods[mIx].MetadataToken &&
                                                                                 mi.Module == ifMap.InterfaceMethods[mIx].Module));
                        }
                        else
                        {
                            miAid = AssetIdentifier.FromMemberInfo(ifMap.InterfaceMethods[mIx]);
                        }

                        context.Element.Add(new XElement("implements", new XAttribute("member", miAid)));
                        context.AddReference(miAid);
                    }
                }
            }
        }

        private void GenerateTypeParamElement(IProcessingContext context, MemberInfo mInfo, Type tp)
        {
            // AssetIdentifier assetId = AssetIdentifier.FromType(mInfo, tp);
            var tpElem = new XElement("typeparam",
                                      new XAttribute("name", tp.Name));

            context.Element.Add(tpElem);

            foreach (Type constraint in tp.GetGenericParameterConstraints())
            {
                var ctElement = new XElement("constraint");
                tpElem.Add(ctElement);
                GenerateTypeRef(context.Clone(ctElement), constraint);
            }

            // enrich typeparam
            foreach (IEnricher enricher in this.Enrichers)
                enricher.EnrichTypeParameter(context.Clone(tpElem), tp);
        }

        private XElement GenerateNamespaceElement(IProcessingContext context, AssetIdentifier assetId)
        {
            string ns = (string)context.AssetResolver.Resolve(assetId);
            var ret = new XElement("namespace",
                                   new XAttribute("name", ns),
                                   new XAttribute("assetId", assetId),
                                   new XAttribute("phase", context.Phase));

            context.Element.Add(ret);

            foreach (IEnricher enricher in this._enrichers)
                enricher.EnrichNamespace(context.Clone(ret), ns);

            return ret;
        }

        public static void GenerateTypeRef(IProcessingContext context, Type pType, string attrName = null)
        {
            if (pType.IsArray)
            {
                var arrayElem = new XElement("arrayOf", new XAttribute("rank", pType.GetArrayRank()));
                context.Element.Add(arrayElem);
                GenerateTypeRef(context.Clone(arrayElem), pType.GetElementType());
            }
            else
            {
                if (pType.IsGenericParameter)
                    context.Element.Add(new XAttribute("param", pType.Name));
                else if (pType.IsGenericType)
                {
                    AssetIdentifier aid = AssetIdentifier.FromType(pType.GetGenericTypeDefinition());
                    context.AddReference(aid);

                    context.Element.Add(new XAttribute(attrName ?? "type", aid));
                    foreach (Type genArg in pType.GetGenericArguments())
                    {
                        XElement argElem = new XElement("with");
                        GenerateTypeRef(context.Clone(argElem), genArg);
                        context.Element.Add(argElem);
                    }
                }
                else
                {
                    AssetIdentifier aid = AssetIdentifier.FromMemberInfo(pType);
                    context.AddReference(aid);

                    context.Element.Add(new XAttribute(attrName ?? "type", aid));
                }
            }
        }

 public void EnrichMethod(IProcessingContext context, MethodInfo mInfo)
 {
     GenerateAttributeElements(context, mInfo.GetCustomAttributesData());
 }

 public void RegisterNamespace(IProcessingContext context)
 {
 }

        private static void GenerateAttributeElements(IProcessingContext context,
                                                      IEnumerable<CustomAttributeData> attrData)
        {
            foreach (CustomAttributeData custAttr in attrData)
            {
                context.AddReference(AssetIdentifier.FromMemberInfo(custAttr.Constructor));

                var attrElem = new XElement("attribute",
                                            new XAttribute("type",
                                                           AssetIdentifier.FromMemberInfo(
                                                                                          custAttr.Constructor.
                                                                                              ReflectedType ??
                                                                                          custAttr.Constructor.
                                                                                              DeclaringType)),
                                            new XAttribute("constructor",
                                                           AssetIdentifier.FromMemberInfo(custAttr.Constructor)));

                foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments)
                {
                    if (cta.Value is ReadOnlyCollection<CustomAttributeTypedArgument>)
                    {
                        AssetIdentifier elementAssetId =
                            AssetIdentifier.FromMemberInfo(cta.ArgumentType.GetElementType());
                        context.AddReference(elementAssetId);
                        attrElem.Add(new XElement("argument",
                                                  new XElement("array",
                                                               new XAttribute("type", elementAssetId),
                                                               ((IEnumerable<CustomAttributeTypedArgument>)cta.Value).
                                                                   Select(
                                                                          ata =>
                                                                          new XElement("element",
                                                                                       GenerateAttributeArgument(
                                                                                                                 context,
                                                                                                                 ata))))));
                    }
                    else
                    {
                        attrElem.Add(new XElement("argument",
                                                  GenerateAttributeArgument(context, cta)));
                    }
                }

                foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments)
                {
                    AssetIdentifier namedMember = AssetIdentifier.FromMemberInfo(cta.MemberInfo);
                    context.AddReference(namedMember);

                    if (cta.TypedValue.Value is ReadOnlyCollection<CustomAttributeTypedArgument>)
                    {
                        context.AddReference(namedMember);
                        AssetIdentifier elementAssetId =
                            AssetIdentifier.FromMemberInfo(cta.TypedValue.ArgumentType.GetElementType());
                        context.AddReference(elementAssetId);
                        attrElem.Add(new XElement("argument",
                                                  new XAttribute("member", namedMember),
                                                  new XElement("array",
                                                               new XAttribute("type", elementAssetId),
                                                               ((IEnumerable<CustomAttributeTypedArgument>)
                                                                cta.TypedValue.Value).Select(
                                                                                             ata =>
                                                                                             new XElement("element",
                                                                                                          GenerateAttributeArgument
                                                                                                              (context,
                                                                                                               ata))))));
                    }
                    else
                    {
                        attrElem.Add(new XElement("argument",
                                                  new XAttribute("member", namedMember),
                                                  GenerateAttributeArgument(context, cta.TypedValue)));
                    }
                }


                context.Element.Add(attrElem);
            }
        }

 // -------------------------------------------------------------------
 // Public
 // -------------------------------------------------------------------
 public void BuildProjectFile(IList<CarbonFileResult> sources, CarbonFile target, IProcessingContext context)
 {
     Diagnostic.Info("Building {0} Sources into {2}", sources.Count, target);
 }

 public void EnrichField(IProcessingContext context, FieldInfo fieldInfo)
 {
     GenerateAttributeElements(context, fieldInfo.GetCustomAttributesData());
 }

        private XElement GenerateAssemblyElement(IProcessingContext context, AssetIdentifier assetId)
        {
            Assembly asm = (Assembly)context.AssetResolver.Resolve(assetId);

            var ret = new XElement("assembly",
                                   new XAttribute("name", asm.GetName().Name),
                                   new XAttribute("filename", asm.ManifestModule.Name),
                                   new XAttribute("assetId", assetId),
                                   new XAttribute("phase", context.Phase),
                                   asm.GetReferencedAssemblies().Select(
                                                                        an =>
                                                                        new XElement("references",
                                                                                     new XAttribute("assembly",
                                                                                                    AssetIdentifier.
                                                                                                        FromAssembly(
                                                                                                                     Assembly
                                                                                                                         .
                                                                                                                         ReflectionOnlyLoad
                                                                                                                         (an
                                                                                                                              .
                                                                                                                              FullName))))));


            context.Element.Add(ret);


            foreach (IEnricher enricher in this._enrichers)
                enricher.EnrichAssembly(context.Clone(ret), asm);

            return ret;
        }

 public void EnrichProperty(IProcessingContext context, PropertyInfo propertyInfo)
 {
     GenerateAttributeElements(context, propertyInfo.GetCustomAttributesData());
 }