Esempio n. 1
0
 public MvcHtmlString Render(LanguageProvider language,
     MethodSignature signature,
     MethodRenderOption options)
 {
     var builder = new HtmlTextWriter(new StringWriter());
     Render(builder, language, signature, options);
     return MvcHtmlString.Create(builder.InnerWriter.ToString());
 }
Esempio n. 2
0
 public SignatureRenderer(
     DocumentModel model,
     LanguageProvider language)
 {
     _typeRenderer     = new TypeRenderer(model, language);
     _methodRenderer   = new MethodRenderer(_typeRenderer);
     _languageProvider = new LanguageProvider();
 }
Esempio n. 3
0
 public SignatureRenderer(
     DocumentModel model,
     LanguageProvider language)
 {
     _typeRenderer = new TypeRenderer(model, language);
     _methodRenderer = new MethodRenderer(_typeRenderer);
     _languageProvider = new LanguageProvider();
 }
Esempio n. 4
0
 public ApiServices(
     DocumentModel model,
     DocumentModelResolver documentModelResolver,
     UrlResolver urlResolver,
     SignatureRenderer signatureRenderer,
     LanguageProvider languageProvider,
     SyntaxRenderer syntaxRenderer,
     SignatureCache signatureResolver)
 {
     Model = model;
     ModelResolver = documentModelResolver;
     UrlResolver = urlResolver;
     SignatureRenderer = signatureRenderer;
     LanguageProvider = languageProvider;
     SyntaxRenderer = syntaxRenderer;
     SignatureResolver = signatureResolver;
 }
Esempio n. 5
0
 public TypeRenderer(DocumentModel model, LanguageProvider language)
 {
     _model = model;
     _language = language;
 }
Esempio n. 6
0
        public void Render(
            HtmlTextWriter writer,
            LanguageProvider language,
            MethodSignature signature,
            MethodRenderOption options)
        {
            // Add link.
            if ((options & MethodRenderOption.Link) == MethodRenderOption.Link)
            {
                writer.AddAttribute(HtmlTextWriterAttribute.Href, signature.Url);
                writer.RenderBeginTag(HtmlTextWriterTag.A);
            }

            // Declaring type (with or without namespace).
            if ((options & MethodRenderOption.TypeName) == MethodRenderOption.TypeName ||
                (options & MethodRenderOption.TypeFullName) == MethodRenderOption.TypeFullName)
            {
                var onlyTypeName = (options & MethodRenderOption.TypeName) == MethodRenderOption.TypeName;
                var typeOptions = onlyTypeName ? TypeRenderOption.Name : TypeRenderOption.Namespace;
                _renderer.Render(writer, signature.DeclaringType, typeOptions);
            }

            var isImplicitOperator = signature.OperatorClassification == OperatorClassification.Implicit;
            var isExplicitOperator = signature.OperatorClassification == OperatorClassification.Explicit;
            var isImplicitOrExplicitOperator = isImplicitOperator || isExplicitOperator;

            if (isImplicitOrExplicitOperator)
            {
                // Implicit operator
                RenderImplicitOrExplicitOperator(writer, signature, options, isImplicitOperator);
            }
            else
            {
                // Everything else.
                if ((options & MethodRenderOption.Name) == MethodRenderOption.Name)
                {
                    if ((options & MethodRenderOption.TypeName) == MethodRenderOption.TypeName ||
                        (options & MethodRenderOption.TypeFullName) == MethodRenderOption.TypeFullName)
                    {

                        writer.WriteEncodedText("\u200B.");
                    }
                    writer.WriteEncodedText(GetMethodName(signature));
                }

                var isPropertyAlias = (options & MethodRenderOption.PropertyAlias) == MethodRenderOption.PropertyAlias;
                if (!isPropertyAlias && (options & MethodRenderOption.Parameters) == MethodRenderOption.Parameters)
                {
                    if (signature.Classification != MethodClassification.Operator)
                    {
                        writer.WriteEncodedText("(");
                        var parameterResult = new List<string>();
                        foreach (var parameter in signature.Parameters)
                        {
                            var parameterBuilder = new StringBuilder();
                            if (parameter.IsOutParameter)
                            {
                                parameterBuilder.Append("out ");
                            }
                            else if (parameter.IsRefParameter)
                            {
                                parameterBuilder.Append("ref ");
                            }
                            var paramType = _renderer.Render(parameter.ParameterType, TypeRenderOption.Name);
                            parameterBuilder.Append(paramType);
                            parameterResult.Add(parameterBuilder.ToString());
                        }
                        if (parameterResult.Count > 0)
                        {
                            var isMethodAlias = (options & MethodRenderOption.MethodAlias) == MethodRenderOption.MethodAlias;
                            if (isMethodAlias || (options & MethodRenderOption.ExtensionMethod) == MethodRenderOption.ExtensionMethod)
                            {
                                if (signature.Classification == MethodClassification.ExtensionMethod)
                                {
                                    // Remove first parameter.
                                    parameterResult.RemoveAt(0);
                                }
                            }
                            writer.Write(string.Join(", \u200B", parameterResult));
                        }
                        writer.WriteEncodedText(")\u200B");
                    }
                }
            }

            if ((options & MethodRenderOption.Link) == MethodRenderOption.Link)
            {
                writer.RenderEndTag();
            }
        }