|  | Home | Libraries | People | FAQ | More | 
            The int_generator can
            generate signed integers of arbitrary length and size. This is almost
            the same as the uint_generator.
            The only difference is the additional task of generating the '+' or '-'
            sign preceding the number. The class interface is the same as that of
            the uint_generator.
          
            The int_generator generator
            can be used to emit ordinary primitive C/C++ integers or even user defined
            scalars such as bigints (unlimited precision integers) if the type follows
            certain expression requirements (for more information about the requirements,
            see below).
          
// forwards to <boost/spirit/home/karma/numeric/int.hpp> #include <boost/spirit/include/karma_int.hpp>
Also, see Include Structure.
| Name | 
|---|
| 
                       | 
| 
                       | 
| 
                       | 
| 
                       | 
| 
                       | 
| ![[Note]](../../../../images/note.png) | Note | 
|---|---|
| 
              The generators  | 
| ![[Note]](../../../../images/note.png) | Note | 
|---|---|
| 
               | 
template < typename T , unsigned Radix , bool force_sign> struct int_generator;
| Parameter | Description | Default | 
|---|---|---|
| 
                       | The numeric base type of the numeric parser. | 
                       | 
| 
                       | The radix base. This can be either 2: binary, 8: octal, 10: decimal and 16: hexadecimal. | 
                       | 
| 
                       | 
                      If  | 
                       | 
Notation
num
                  Numeric literal, any signed integer value, or a Lazy
                  Argument that evaluates to a signed integer value of type
                  Num
                
Num
                  Type of num: any
                  signed integer type
                
Radix
                  A constant integer literal specifying the required radix for the
                  output conversion. Valid values are 2,
                  8, 10,
                  and 16.
                
force_sign
                  A constant boolean literal specifying whether the generated number
                  should always have a sign ('+'
                  for positive numbers, '-'
                  for negative numbers and a ' ' for zero).
                
            Semantics of an expression is defined only where it differs from, or
            is not defined in PrimitiveGenerator.
          
| Expression | Semantics | 
|---|---|
| 
                       | 
                      Generate the integer literal  | 
| 
 short_ int_ long_ long_long 
 | 
                      Generate the integer provided by a mandatory attribute using
                      the default formatting (radix is  | 
| 
 short_(num) int_(num) long_(num) long_long(num) 
 | 
                      Generate the integer provided by the immediate literal value
                      the generator is initialized from using the default formatting
                      (radix is  | 
            All generators listed in the table above (except lit(num)) are predefined specializations of the
            int_generator<Num, Radix, force_sign>
            basic integer number generator type described below. It is possible to
            directly use this type to create integer generators using a wide range
            of formatting options.
          
| Expression | Semantics | 
|---|---|
| 
 int_generator< Num, Radix, force_sign >() 
 | 
                      Generate the integer of type  | 
| 
 int_generator< Num, Radix, force_sign >()(num) 
 | 
                      Generate the integer of type  | 
            The following lists enumerate the requirements which must be met in order
            to use a certain type Num
            to instantiate and use a int_generator<Num, Radix, force_sign>.
          
            If boost::is_integral<Num>::value is true
            the type Num must have
            defined:
          
<,
                <=, ==, !=,
                >, and >=
              +,
                -, /,
                *, %,
                and unary -
              
            If boost::is_integral<Num>::value is false
            the type Num must have
            defined:
          
<,
                <=, ==, !=,
                >, and >=
              +,
                -, /,
                *, %,
                and unary -
              std::fmod, std::fabs,
                std::pow, std::lround,
                std::ltrunc, std::floor,
                and std::ceil. These need to be defined
                in a way so that they will be found using argument dependent lookup
                (ADL).
              | Expression | Attribute | 
|---|---|
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
                       | 
                       | 
| 
 int_generator< Num, Radix, force_sign >() 
 | 
                       | 
| 
 int_generator< Num, Radix, force_sign >()(num) 
 | 
                       | 
| ![[Note]](../../../../images/note.png) | Note | 
|---|---|
| 
              In addition to their usual attribute of type  | 
O(N), where
Nis the number of digits needed to represent the generated integer number
| ![[Note]](../../../../images/note.png) | Note | 
|---|---|
| The test harness for the example(s) below is presented in the Basics Examples section. | 
Some includes:
#include <boost/spirit/include/karma.hpp> #include <boost/spirit/include/support_utree.hpp> #include <boost/spirit/include/phoenix_core.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <boost/fusion/include/std_pair.hpp> #include <iostream> #include <string>
Some using declarations:
using boost::spirit::karma::int_; using boost::spirit::karma::lit;
            Basic usage of an int_
            generator:
          
test_generator("-2", lit(-2)); test_generator("-2", int_(-2)); test_generator_attr("-2", int_(-2), -2); test_generator_attr("", int_(-2), 3); // fails (as -2 != 3)! test_generator_attr("-2", int_, -2);