NumberFormatting.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//

#pragma once

#include <limits>

#include <boost/type_traits.hpp>

#include <OnixS/SgxTitan/MarketData/Itch/String.h>
#include <OnixS/SgxTitan/MarketData/Itch/Integral.h>


#include "NamespaceHelper.h"

ONIXS_HANDLER_NAMESPACE_BEGIN
 
//

template
    <
    typename Integer
    >
    inline
    typename
    boost::enable_if
    <
    boost::is_signed<Integer>,
    bool
    >::
    type
    isNegative(
        Integer& integer)
{
    return (0 > integer);
}

template
    <
    typename Integer
    >
    inline
    typename
    boost::enable_if
    <
    boost::is_unsigned<Integer>,
    bool
    >::
    type
    isNegative(
        Integer&)
{
    return false;
}

//

inline
    void
    addNegativeSign(
        std::string& str)
{
    const Char Minus = '-';

    str += Minus;
}

template
    <
    typename Integer
    >
    inline
    typename
    boost::enable_if
    <
    boost::is_signed<Integer>
    >::
    type
    addNegativeSign(
        std::string& str,
        Integer integer)
{
    if (0 > integer)
        addNegativeSign(str);
}

template
    <
    typename Integer
    >
    inline
    typename
    boost::enable_if
    <
    boost::is_unsigned<Integer>
    >::
    type
    addNegativeSign(
        std::string&,
        Integer)
{
}

//


template
    <
    typename Integer
    >
    inline
    typename
    boost::enable_if
    <
    boost::is_integral<Integer>,
    size_t
    >::
    type
    countDigits(
        Integer integer)
{
    size_t qty = 0;

    do
    {
        ++qty;

        integer /= 10;
    } while (integer);

    return qty;
}

template
    <
    typename Integer
    >
    typename
    boost::enable_if
    <
    boost::is_integral<Integer>,
    size_t
    >::
    type
    digitsToStr(
        Char* str,
        Integer integer)
{
    const Char map[] =
        "9876543210123456789";

    const Char* digits =
        static_cast<const Char*>(map) +
        9;

    Char* carriage = str;

    do
    {
        *carriage++ = *(
            digits + (integer % 10));

        integer /= 10;
    } while (integer);

    const
        size_t
        digitsQty = (
            carriage - str);

    while (
        str != carriage &&
        str != --carriage)
    {
        const Char digit = *str;

        *str++ = *carriage;

        *carriage = digit;
    }

    return digitsQty;
}

//

template
    <
    typename Integer
    >
    inline
    typename
    boost::enable_if
    <
    boost::is_integral<Integer>,
    size_t
    >::
    type
    measureInteger(
        Integer integer)
{
    const
        size_t
        signLength =
        isNegative(integer)
        ? 1
        : 0;

    return (
        signLength +
        countDigits(integer)
        );
}

//

template
    <
    typename Integer
    >
    typename
    boost::enable_if
    <
    boost::is_integral<Integer>
    >::
    type
    integerToStr(
        std::string& str,
        Integer integer)
{
    addNegativeSign(
        str,
        integer);

    Char digits
        [
            std::
            numeric_limits<Integer>::
        digits10 +
        2
        ];

    str.append
    (
        digits,
        digitsToStr
        (
            digits,
            integer
        )
    );
}

/// Functions below serialize integer and decimal
/// numbers in a "%<width>.<precision>" printf format.
/// Formatted value is never truncated if width is less
/// than a number of digits in a whole part of a number.
/// Value truncating is used as rounding strategy when
/// fractional part has grater precision than requested
/// one.

class FormatSpec
{
    size_t width_;
    size_t precision_;
    Char filler_;

public:
    FormatSpec()
        : width_(0)
        , precision_(0)
        , filler_(' ')
    {
    }

    Char filler() const
    {
        return filler_;
    }

    void filler(Char filler)
    {
        filler_ = filler;
    }

    size_t width() const
    {
        return width_;
    }

    void width(size_t width)
    {
        width_ = width;
    }

    size_t precision() const
    {
        return precision_;
    }

    void precision(size_t precision)
    {
        precision_ = precision;
    }
};

inline
    void
    addIntegerAlignmentSpace(
        std::string& str,
        const FormatSpec& format,
        size_t digitsQty)
{
    using namespace std;
    digitsQty =
        max(
            digitsQty,
            format.precision());

    if (format.width() > digitsQty)
    {
        str.append(
            format.width() - digitsQty,
            format.filler());
    }
}

inline
    void
    addIntegerPrecisionZeros(
        std::string& str,
        const FormatSpec& format,
        size_t digitsQty)
{
    if (format.precision() > digitsQty)
    {
        const Char Zero = '0';

        str.append(
            format.precision() - digitsQty,
            Zero);
    }
}

template
    <
    typename Integer
    >
    typename
    boost::enable_if
    <
    boost::is_integral<Integer>
    >::
    type
    integerToStr(
        std::string& str,
        const FormatSpec& format,
        Integer integer)
{
    const
        bool
        negative =
        isNegative(integer);

    Char digits
        [
            std::
            numeric_limits<Integer>::
        digits10 +
        2
        ];

    const
        size_t
        digitsQty =
        digitsToStr(
            digits, integer);

    addIntegerAlignmentSpace
    (
        str,
        format,
        digitsQty +
        (negative ? 1 : 0)
    );

    if (negative)
        addNegativeSign(str);

    addIntegerPrecisionZeros
    (
        str,
        format,
        digitsQty
    );

    str.append
    (
        digits,
        digitsQty
    );
}

ONIXS_HANDLER_NAMESPACE_END