Warning, /frameworks/ktexteditor/src/script/data/indentation/cppstyle.README.md is written in an unsupported language. File is not indexed.

 C++/boost Style Indenter
 ========================
 
 This indenter (initially) was designed to help code typing in a boost::mpl style
 (i.e. w/ leading comma in formatted parameters list). One may read rationale of such
 approach in the "C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond"
 by David Abrahams and Aleksey Gurtovoy. It is really easy to miss a comma when "calling" templates and
 it would leads to really complicated compile errors. This technique helps to visually control syntax
 in a stricter way.
 
 Example:
 
     typedef typename boost::mpl::eval_if<
         boost::is_same<iter, boost::mpl::end<types_map>::type>
       , boost::mpl::int_<-1>
       , boost::mpl::distance<boost::mpl::begin<types_map>::type, iter>
       >::type type;
 
 In practice I've noticed that this style can be used to format long function calls or even
 `for` statements. Actually everything that can be split into several lines could be formatted that way.
 And yes, it is convenient to have a delimiter (comma, semicolon, whatever) as leading character to
 make it visually noticeable.
 
     // Inheritance list formatting
     struct sample
       : public base_1
       , public base_2
       , ...
       , public base_N
     {
         // Parameter list formatting
         void foo(
             const std::string& param_1                      ///< A string parameter
           , double param_2                                  ///< A double parameter
           , ...
           , const some_type& param_N                        ///< An user defined type parameter
           )
         {
             //
             for (
                 auto first = std::begin(param_1)
               , last = std::end(param_1)
               ; it != last
               ; ++it
               )
             {
                 auto val = check_some_condition()
                   ? get_then_value()
                   : get_else_value()
                   ;
             }
         }
     };
 
 It looks unusual for awhile :) but later it become "normal" and easily to read and edit :)
 Really! When you want to add one more parameter to a function declaration or change order it will
 takes less typing comparing to "traditional" way :) (especially if you have some help from editor,
 like moving current line or selected block up/down by hotkey or having indenter like this :)
 
 Features
 --------
 
 * support for boost-like formatting style everywhere is possible
 * align inline comments to 60th position after typing `'//'`
 * turn `'///'` into `'/// '` or `'///< '` depending on comment placement
 * take care of inline comments when `ENTER` pressed on a commented line (before, middle or after comment start)
 * turn `'/*'` or `'/**'` into multiline (doxygen style) comment
 * auto continue multiline comment on `ENTER`
 * indent preprocessor directives according nesting level of `#if`/`#endif`
 * take care about backslashes alignment in preprocessor macro definitions
 * append a space after comma or some keywords (like `if`,  `for`,  `while`,  etc...) or `operator<<`
 * align access modifiers
 
 
 TODO
 ----
 
 Initially it was designed as typing helper and nowadays it lacks of align functionality (it's capable to
 align only few basic constructs). But I have plans to add some logic here to better align source code keeping
 C++/boost style in mind.