|  | Home | Libraries | People | FAQ | More | 
          The template is_container
          is a template meta-function used as an attribute customization point. It
          is invoked by the Qi Sequence
          (>>) and Karma
          Sequence (<<) operators in order to determine
          whether a supplied attribute can potentially be treated as a container.
        
#include <boost/spirit/home/support/container.hpp>
Also, see Include Structure.
| ![[Note]](../../../images/note.png) | Note | 
|---|---|
| This header file does not need to be included directly by any user program as it is normally included by other Spirit header files relying on its content. | 
| Name | 
|---|
| 
                     | 
template <typename Container, typename Enable> struct is_container { <unspecified>; };
| Parameter | Description | Default | 
|---|---|---|
| 
                     | 
                    The type,  | none | 
| 
                     | 
                    Helper template parameter usable to selectively enable or disable
                    certain specializations of  | 
                     | 
Notation
CA type to be tested whether it needs to be treated as a container.
T1, T2, ...Arbitrary types
| Expression | Semantics | 
|---|---|
| 
                     | 
                    Result of the metafunction that evaluates to  | 
          Spirit predefines specializations
          of this customization point for several types. The following table lists
          those types together with the conditions for which the corresponding specializations
          will evaluate to mpl::true_ (see MPL
          Boolean Constant):
        
| Template Parameters | Semantics | 
|---|---|
| 
                     | 
                    Returns  | 
| 
                     | 
                    Returns  | 
| 
                     | 
                    Returns  | 
| 
                     | 
                    Returns  | 
          The customization point is_container
          needs to be implemented for a specific type whenever this type is to be
          used as an attribute in place of a STL container. It is applicable for
          parsers (Spirit.Qi) and generators (Spirit.Karma).
          As a rule of thumb: it has to be implemented whenever a certain type is
          to be passed as an attribute to a parser or a generator normally exposing
          a STL container, C and
          if the type does not expose the interface of a STL container (i.e. is_container<C>::type would normally return mpl::false_). These components have an attribute
          propagation rule in the form:
        
a: A --> Op(a): vector<A>
          where Op(a) stands
          for any meaningful operation on the component a.
        
If this customization point is implemented, the following other customization points might need to be implemented as well.
| Name | When to implement | 
|---|---|
| 
                    Needs to be implemented whenever  | |
| 
                    Karma: List
                    ( | |
| 
                    Karma: List
                    ( | |
| 
                    Karma: List
                    ( | |
| 
                    Karma: List
                    ( | |
| 
                    Karma: List
                    ( | |
| 
                    Karma: List
                    ( | |
          For examples of how to use the customization point is_container
          please see here: embedded_container_example,
          use_as_container,
          and counter_example.