Download / Getting Started

Though the illustration above is a rather static example it is important to mention, that content can be much more than static, predefined pieces. If the program that we write has some sort of conditional content or some sort of repetitive content, we have the flexibility we need to create complex output. Fortunately modern programming paradigms give us the tools to easily express such dynamic content. In any object oriented language it should be quite easy to have abstract content that overrides a write method. In Java it could be similar to this:

public interface Content {
    void write( PrintWriter wr );
}

...
    public void processTemplate( Template t, PrintWriter wr )
    {
        final String[] strls = new String { "foo", "bar", "baz" };
        t.bind( "place", new Content() {
            private List<Template> tls = new ArrayList<>();
            {
                int count = 1;
                for ( String str : strls ) {
                    Template lineTmpl = loadATemplate( "line-template" );
                    lineTmpl.bind( "num", count++ );
                    lineTmpl.bind( "str", str );
                    tls.add( lineTmpl );
                }               
            }
            @Override void write( PrintWriter wr )
            {
                for ( Template t : tls )
                    t.write( wr );
            }
        } );
        t.write( wr );
    }
...

However with functional programming style this would be much more elegant, e.g. with C++ 11 we could allow any std::function<void (std::ostream&)> as content and write:

void process_template( Template& t, std::ostream& os )
{
  using namespace std;
  vector<string> strls{ "foo", "bar", "baz" };
  vector<Template> tls;
  int count = 1;
  for ( const string& str : strls ) {
    Template lineTmpl = load_a_template( "line-template" );
    lineTmpl.bind( "num", count++ );
    lineTmpl.bind( "str", str );
    tls.push_back( lineTmpl );
  }
  t.bind( "place",
          [&tls]( ostream& os ) { for ( const Template& t : tls ) os << t; } );
  os << t;
}

Though the examples in the previous section showed how to nest bound templates as content into templates, the examples also give a hint where the design should be "tuned". We reuse the so called line-template over and over to create output for each element in the strls list of strings. It is very likely, that loading of templates needs quite some processing. At least there has to be some parsing of a template "text" to find the placeholders but locating and loading from disk or somewhere else is very likely too.

This is why we split templates into two parts:

1. The Template that is immutably kept around to be used to generate some output.
2. The bound template, Bount in the following, that references the Template it binds content to and the content that is bound to the placeholders.

With this simple design at the core of Toxic the general ideas should be easy to grasp. Note that there is no special, proprietary template language to learn! You can don anything with templates what your programming language allows you to do when overriding Content::write() and you can do it with your programming language in your IDE.

However that seems to put the burden of overriding Content::write() on you – which indeed is the case. But as one might see in the current Java implementation this could easily be solved by writing useful libraries of special Content.