FIX::double_conversion::Single Class Reference

Public Member Functions
	Single ()
	Single (float f)
	Single (uint32_t d32)
DiyFp	AsDiyFp () const
uint32_t	AsUint32 () const
int	Exponent () const
uint32_t	Significand () const
bool	IsDenormal () const
bool	IsSpecial () const
bool	IsNan () const
bool	IsInfinite () const
int	Sign () const
void	NormalizedBoundaries (DiyFp *out_m_minus, DiyFp *out_m_plus) const
DiyFp	UpperBoundary () const
bool	LowerBoundaryIsCloser () const
float	value () const

Static Public Member Functions
static float	Infinity ()
static float	NaN ()

Static Public Attributes
static const uint32_t	kSignMask = 0x80000000
static const uint32_t	kExponentMask = 0x7F800000
static const uint32_t	kSignificandMask = 0x007FFFFF
static const uint32_t	kHiddenBit = 0x00800000
static const int	kPhysicalSignificandSize = 23
static const int	kSignificandSize = 24

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (Single)

Private Attributes
const uint32_t	d32_

Static Private Attributes
static const int	kExponentBias = 0x7F + kPhysicalSignificandSize
static const int	kDenormalExponent = -kExponentBias + 1
static const int	kMaxExponent = 0xFF - kExponentBias
static const uint32_t	kInfinity = 0x7F800000
static const uint32_t	kNaN = 0x7FC00000

Detailed Description

Definition at line 263 of file FieldConvertors.cpp.

Constructor & Destructor Documentation

Single() [1/3]

FIX::double_conversion::Single::Single ( )

inline

Definition at line 272 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Single() [2/3]

FIX::double_conversion::Single::Single ( float f )

inlineexplicit

Definition at line 273 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Single() [3/3]

FIX::double_conversion::Single::Single ( uint32_t d32 )

inlineexplicit

Definition at line 274 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Member Function Documentation

AsDiyFp()

DiyFp FIX::double_conversion::Single::AsDiyFp ( ) const

inline

Definition at line 278 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

AsUint32()

uint32_t FIX::double_conversion::Single::AsUint32 ( ) const

inline

Definition at line 285 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

DISALLOW_COPY_AND_ASSIGN()

FIX::double_conversion::Single::DISALLOW_COPY_AND_ASSIGN ( Single )

private

Exponent()

int FIX::double_conversion::Single::Exponent ( ) const

inline

Definition at line 289 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Infinity()

float FIX::double_conversion::Single::Infinity ( )

inlinestatic

Definition at line 380 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

IsDenormal()

bool FIX::double_conversion::Single::IsDenormal ( ) const

inline

Definition at line 309 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

IsInfinite()

bool FIX::double_conversion::Single::IsInfinite ( ) const

inline

Definition at line 327 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

IsNan()

bool FIX::double_conversion::Single::IsNan ( ) const

inline

Definition at line 321 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

IsSpecial()

bool FIX::double_conversion::Single::IsSpecial ( ) const

inline

Definition at line 316 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

LowerBoundaryIsCloser()

bool FIX::double_conversion::Single::LowerBoundaryIsCloser ( ) const

inline

Definition at line 365 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

NaN()

float FIX::double_conversion::Single::NaN ( )

inlinestatic

Definition at line 384 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

NormalizedBoundaries()

void FIX::double_conversion::Single::NormalizedBoundaries ( DiyFp * out_m_minus, DiyFp * out_m_plus ) const

inline

Definition at line 342 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Sign()

int FIX::double_conversion::Single::Sign ( ) const

inline

Definition at line 333 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Significand()

uint32_t FIX::double_conversion::Single::Significand ( ) const

inline

Definition at line 298 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

UpperBoundary()

DiyFp FIX::double_conversion::Single::UpperBoundary ( ) const

inline

Definition at line 360 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

value()

float FIX::double_conversion::Single::value ( ) const

inline

Definition at line 378 of file FieldConvertors.cpp.

{
 
// we include "double-conversion" project in FIX namespace
// to avoid linking errors if quickfix is linked statically
// and "double-conversion" is already used by target project
 
#include "double-conversion/diy-fp.cc"
#include "double-conversion/fixed-dtoa.cc"
#include "double-conversion/bignum.cc"
#include "double-conversion/bignum-dtoa.cc"
#include "double-conversion/cached-powers.cc"
#include "double-conversion/fast-dtoa.cc"
#include "double-conversion/strtod.cc"
#include "double-conversion/double-conversion.cc"
 
  static double_conversion::DoubleToStringConverter g_dtoa_converter(
    double_conversion::DoubleToStringConverter::NO_FLAGS,
    "INF",
    "NAN",
    'e',
    -DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS,
    DoubleConvertor::SIGNIFICANT_DIGITS - 1,
    0);
 
  static double_conversion::StringToDoubleConverter g_atod_converter(
          double_conversion::StringToDoubleConverter::NO_FLAGS,
          std::numeric_limits<double>::quiet_NaN(),
          std::numeric_limits<double>::quiet_NaN(),
          "INF",
          "NAN");
 
  double DoubleConvertor::fast_strtod( const char * buffer, int size, int * processed_chars )
  {
          return g_atod_converter.StringToDouble( buffer, size, processed_chars );
  }
 
  int DoubleConvertor::fast_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToPrecision( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    builder.TrimTrailingZeros();
    return builder.position();
  }
 
  int DoubleConvertor::fast_fixed_dtoa( char * buffer, int size, double value )
  {
    double_conversion::StringBuilder builder( buffer, size );
    if( !g_dtoa_converter.ToFixed( value, DoubleConvertor::SIGNIFICANT_DIGITS, &builder ) )
    {
      builder.Reset();
      return 0;
    }
 
    return builder.position();
  }
 
}

Member Data Documentation

d32_

const uint32_t FIX::double_conversion::Single::d32_

private

Definition at line 395 of file FieldConvertors.cpp.

kDenormalExponent

const int FIX::double_conversion::Single::kDenormalExponent = -kExponentBias + 1

staticprivate

Definition at line 390 of file FieldConvertors.cpp.

kExponentBias

const int FIX::double_conversion::Single::kExponentBias = 0x7F + kPhysicalSignificandSize

staticprivate

Definition at line 389 of file FieldConvertors.cpp.

kExponentMask

const uint32_t FIX::double_conversion::Single::kExponentMask = 0x7F800000

static

Definition at line 266 of file FieldConvertors.cpp.

kHiddenBit

const uint32_t FIX::double_conversion::Single::kHiddenBit = 0x00800000

static

Definition at line 268 of file FieldConvertors.cpp.

kInfinity

const uint32_t FIX::double_conversion::Single::kInfinity = 0x7F800000

staticprivate

Definition at line 392 of file FieldConvertors.cpp.

kMaxExponent

const int FIX::double_conversion::Single::kMaxExponent = 0xFF - kExponentBias

staticprivate

Definition at line 391 of file FieldConvertors.cpp.

kNaN

const uint32_t FIX::double_conversion::Single::kNaN = 0x7FC00000

staticprivate

Definition at line 393 of file FieldConvertors.cpp.

kPhysicalSignificandSize

const int FIX::double_conversion::Single::kPhysicalSignificandSize = 23

static

Definition at line 269 of file FieldConvertors.cpp.

kSignificandMask

const uint32_t FIX::double_conversion::Single::kSignificandMask = 0x007FFFFF

static

Definition at line 267 of file FieldConvertors.cpp.

kSignificandSize

const int FIX::double_conversion::Single::kSignificandSize = 24

static

Definition at line 270 of file FieldConvertors.cpp.

kSignMask

const uint32_t FIX::double_conversion::Single::kSignMask = 0x80000000

static

Definition at line 265 of file FieldConvertors.cpp.

---

The documentation for this class was generated from the following file:

• FieldConvertors.cpp