How to generate code to satisfy a concept?

Question

If I write code (for example a custom container) that should satisfy a specific concept (for example an InputIterator), I have to write much boilerplate (for example method/operator signatures and typedefs) to get started (write method/operator bodies and types in typedefs). This boilerplate code could be generated by a tool and I only have to fill gaps or change some parts.

The following is an excerpt of the Iterator concept (reference):

Requirements

The type It satisfies Iterator if

• The type It satisfies CopyConstructible, and
• The type It satisfies CopyAssignable, and
• The type It satisfies Destructible, and
• lvalues of type It satisfy Swappable, and
• std::iterator_traits<It> has member typedefs value_type, difference_type, reference, pointer, and iterator_category, and

Given

• r, an lvalue of type It.

The following expressions must be valid and have their specified effects:

| **Expression** | **Return Type** |           **Precondition**                                               |
|----------------|-----------------|--------------------------------------------------------------------------|
|    `*r`        |   unspecified   | **r** is dereferenceable (see below)                                     |
|----------------|-----------------|--------------------------------------------------------------------------|
|    `++r`       |      `It&`      | **r** is incrementable (the behavior of the expression `++r` is defined) |

A tool could generate code that looks something like this:

template <typename T>
class my_iterator {
public:
  typedef my_iterator<T> self_type;
  typedef std::input_iterator_tag iterator_category;
  typedef T value_type;
  typedef T & reference;
  typedef T * pointer;

  reference operator*() const 
  {
    // TODO
  }

  self_type operator++()
  {
    // TODO
  }

  // ...
  // more operator and method stubs of required concepts
  // ...

}

How can I generate such code? Which tool can I use? In the Java-World, the IDE Eclipse can "implement interfaces" (create method stubs). Is there any C++ IDE that supports a similar feature for concepts? Or are there maybe any (predefined) code snippets I can use for this purpose?

Answer 1

Our DMS Software Reengineering Toolkit can instantiate target-language surface-syntax patterns with placeholders that are themselves generated by other patterns or primitive values.

The patterns represent syntax constructs drawn from an underlying grammar for the target language, e.g., identifier, expression, declaration, statement, block, method, class or any sequence of these, with placeholders being similarly syntactically typed. The patterns are checked for syntax validity statically before any use, and well-define composition of such patterns using subpatterns for parameters are thus also syntactically well typed.

DMS has language definitions (and can therefore provide patterns for) many mainstream languages including Java, JavaScript, C# and C++14.

Op's sample could be coded as:

domain Cpp; -- tells pattern parser to use C++ grammar definition

pattern MyIterator(name:IDENTIFIER,
                   operator_star_body: method_body,
                   operator_pp_body: method_body,
                   additional_methods: class_body
                   ): template_declaration =
"   template <typename T>
    class \name {
    public:
      typedef \name<T> self_type;
      typedef std::input_iterator_tag iterator_category;
      typedef T value_type;
      typedef T & reference;
      typedef T * pointer;

      reference operator*() const 
      { \operator_star_body }

      self_type operator++()
      { \operator_pp_body }

      \additional_methods

    }";

[Forgive any C++ coding sins; I'm not a C++ template expert. It should be obvious they are easily fixed.].

The pattern has a head, declaring the pattern name and its syntax category, and the names and syntax categories of the parameters, and body in metaquotes ", whose text is parsed for validity and contains meta-escaped \parameternames. Details of the pattern language can be found here.

Typically one builds up a library of these patterns and composes them to generate big chunks of code. One also uses custom metaprogramming to generate certain types of substituted parameters, such as identifiers, etc.

One can define patterns for other elements, e.g, a method body looping over the elements of an array. Using DMS's metaprogramming langauge PARLANSE, these subpatterns can be instantiated (recursively) and then substituted for parameters in this pattern. This is all done using abstract syntax trees, and thus the final result is also an abstract syntax tree, but DMS's prettyprinter can convert this AST back into valid source text.

In addition to code generation, one can write transformation rules that map a found pattern into a replacement pattern. Massive sets of C++ patterns and transforms have been used with DMS to carry out massive reengineering of existing C++ codes.

Summary:

• Parameterized code templates whose syntax is enforced
• Works for many langauges including C++

This is a product of my company, so this is not a recommendation. I note that it exists.

Answer 2

There is T4 for Visual Studio.

a T4 text template is a mixture of text blocks and control logic that can generate a text file

Since a .cpp file (and others as well) is also "a text file", this is used for code generation.

Hopefully they provide better syntax highlighting in the new versions. I last used it on VS 2010. It worked well, but coding code in code was quite un-readable that time.

<#@ template hostspecific="false" language="C#" #>  
<#@ output extension=".cpp" #>  
class my_iterator {
public:
<#      
for (int i = 0; i<=10; i++)   
{ #>  
   int member<#= i #> = <#= i #>;
<# } #> 
} // end class