libvaladoc/api/signaturebuilder.vala

   1 /* signaturebuilder.vala
   2  *
   3  * Copyright (C) 2008-2009 Florian Brosch, Didier Villevalois
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Didier 'Ptitjes Villevalois <ptitjes@free.fr>
  21  */
  22
  23
  24 using Valadoc.Content;
  25
  26 /**
  27  * Builds up a signature from the given items.
  28  */
  29 public class Valadoc.Api.SignatureBuilder {
  30         private Run run;
  31         private Inline last_appended;
  32
  33         /**
  34          * Creates a new SignatureBuilder
  35          */
  36         public SignatureBuilder () {
  37                 run = new Run (Run.Style.NONE);
  38         }
  39
  40         private void append_text (string text) {
  41                 if (last_appended is Text) {
  42                         ((Text) last_appended).content += text;
  43                 } else {
  44                         run.content.add (last_appended = new Text (text));
  45                 }
  46         }
  47
  48         /**
  49          * Adds text onto the end of the builder.
  50          *
  51          * @param text a string
  52          * @param spaced add a space at the front of the string if necessary
  53          * @return this
  54          */
  55         public unowned SignatureBuilder append (string text, bool spaced = true) {
  56                 string content = (last_appended != null && spaced ? " " : "") + text;
  57                 append_text (content);
  58                 return this;
  59         }
  60
  61         /**
  62          * Adds text onto the end of the builder.
  63          *
  64          * @param text a string
  65          * @param spaced add a space at the front of the string if necessary
  66          * @return this
  67          */
  68         public unowned SignatureBuilder append_attribute (string text, bool spaced = true) {
  69                 string content = (last_appended != null && spaced ? " " : "") + text;
  70                 append_text (content);
  71                 return this;
  72         }
  73
  74         /**
  75          * Adds highlighted text onto the end of the builder.
  76          *
  77          * @param text a string
  78          * @param spaced add a space at the front of the string if necessary
  79          * @return this
  80          */
  81         public unowned SignatureBuilder append_highlighted (string text, bool spaced = true) {
  82                 string content = (last_appended != null && spaced ? " " : "") + text;
  83                 Run inner = new Run (Run.Style.ITALIC);
  84                 inner.content.add (new Text (content));
  85                 return append_content (inner, spaced);
  86         }
  87
  88         /**
  89          * Adds a Inline onto the end of the builder.
  90          *
  91          * @param content a content
  92          * @param spaced add a space at the front of the inline if necessary
  93          * @return this
  94          */
  95         public unowned SignatureBuilder append_content (Inline content, bool spaced = true) {
  96                 if (last_appended != null && spaced) {
  97                         append_text (" ");
  98                 }
  99                 run.content.add (last_appended = content);
 100                 return this;
 101         }
 102
 103         /**
 104          * Adds a keyword onto the end of the builder.
 105          *
 106          * @param keyword a keyword
 107          * @param spaced add a space at the front of the keyword if necessary
 108          * @return this
 109          */
 110         public unowned SignatureBuilder append_keyword (string keyword, bool spaced = true) {
 111                 Run inner = new Run (Run.Style.LANG_KEYWORD);
 112                 inner.content.add (new Text (keyword));
 113                 return append_content (inner, spaced);
 114         }
 115
 116         /**
 117          * Adds a symbol onto the end of the builder.
 118          *
 119          * @param node a node
 120          * @param spaced add a space at the front of the node if necessary
 121          * @return this
 122          */
 123         public unowned SignatureBuilder append_symbol (Node node, bool spaced = true) {
 124                 Run inner = new Run (Run.Style.BOLD);
 125                 inner.content.add (new SymbolLink (node, node.name));
 126                 return append_content (inner, spaced);
 127         }
 128
 129         /**
 130          * Adds a type onto the end of the builder.
 131          *
 132          * @param node a node
 133          * @param spaced add a space at the front of the node if necessary
 134          * @return this
 135          */
 136         public unowned SignatureBuilder append_type (Node node, bool spaced = true) {
 137                 Run.Style style = Run.Style.LANG_TYPE;
 138                 if (node is TypeSymbol && ((TypeSymbol)node).is_basic_type) {
 139                         style = Run.Style.LANG_BASIC_TYPE;
 140                 }
 141
 142                 Run inner = new Run (style);
 143                 inner.content.add (new SymbolLink (node, node.name));
 144                 return append_content (inner, spaced);
 145         }
 146
 147         /**
 148          * Adds a type name onto the end of the builder.
 149          *
 150          * @param name a type name
 151          * @param spaced add a space at the front of the type name if necessary
 152          * @return this
 153          */
 154         public unowned SignatureBuilder append_type_name (string name, bool spaced = true) {
 155                 Run inner = new Run (Run.Style.LANG_TYPE);
 156                 inner.content.add (new Text (name));
 157                 return append_content (inner, spaced);
 158         }
 159
 160         /**
 161          * Adds a literal onto the end of the builder.
 162          *
 163          * @param literal a literal
 164          * @param spaced add a space at the front of the literal if necessary
 165          * @return this
 166          */
 167         public unowned SignatureBuilder append_literal (string literal, bool spaced = true) {
 168                 Run inner = new Run (Run.Style.LANG_LITERAL);
 169                 inner.content.add (new Text (literal));
 170                 return append_content (inner, spaced);
 171         }
 172
 173         /**
 174          * The content
 175          */
 176         public new Run get () {
 177                 return run;
 178         }
 179 }
 180