UT_Digits.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Digits.h ( UT Library, C++)
 *
 * COMMENTS:
 */

#pragma once

#include "UT_API.h"
//#include <UT/UT_StringHolder.h> // does not work due to recursive include of UT_Format

#include <SYS/SYS_Types.h>
//#include <string>
#include <iosfwd>

///////////////////////////////////////////////////////////////////////////////
//! Converts a double or float or half to the shortest accurate decimal possible.
class UT_API UT_Digits
{
public:
    enum Flags {
        GENERAL    =  0, //!< used FIXED or SCIENTIFIC depending on range, no trailing zeros
        FIXED      =  1, //!< fixed-point
        SCIENTIFIC =  2, //!< exponential notation
        BINARY     =  4,
        OCTAL      =  8,
        HEX        = 12,
        BASE       = 12, //!< mask for BINARY, OCTAL, HEX
        E_PLUS     = 16, //!< put a + sign on exponent (like printf)
        E_2        = 32  //!< use at least 2 digits for exponent (like printf)
    };

    //! Initialize to empty string
    UT_Digits(): mySize(0) { myBuffer[0] = 0; }
    //! Change to a new 64-bit double
    void reset(fpreal64, Flags flags=GENERAL, int precision = -1);
    //! Change to a new 32-bit float
    void reset(fpreal32, Flags flags=GENERAL, int precision = -1);
    //! Change to a 16-bit IEEE "half"
    void reset(fpreal16, Flags flags=GENERAL, int precision = -1);
    //! Change to an integer
    void reset(int64,    Flags flags=GENERAL, int precision = -1);
    //! Change to an integer
    void reset(int32,    Flags flags=GENERAL, int precision = -1);
    //! Change to an unsigned
    void reset(uint64,   Flags flags=GENERAL, int precision = -1);
    //! Change to an unsigned
    void reset(uint32,   Flags flags=GENERAL, int precision = -1);

    //! Constructors that do reset(i)
    explicit UT_Digits(fpreal64 i, Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }
    explicit UT_Digits(fpreal32 i, Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }
    explicit UT_Digits(fpreal16 i, Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }
    explicit UT_Digits(int64 i,    Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }
    explicit UT_Digits(int32 i,    Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }
    explicit UT_Digits(uint64 i,   Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }
    explicit UT_Digits(uint32 i,   Flags flags=GENERAL, int precision = -1) { reset(i, flags, precision); }

    //! Constructors that take precision but no flags
    UT_Digits(fpreal64 i, int precision) { reset(i, GENERAL, precision); }
    UT_Digits(fpreal32 i, int precision) { reset(i, GENERAL, precision); }
    UT_Digits(fpreal16 i, int precision) { reset(i, GENERAL, precision); }

    //! Return the formatted string, which is stored in an internal buffer
    const char* c_str() const { return myBuffer; }
    //! Return the formatted string, which is stored in an internal buffer
    const char* data() const { return myBuffer; }
    //! Length of the string
    unsigned size() const { return mySize; }
    //! get the bytes of the formatted text
    char operator[](unsigned i) const { return myBuffer[i]; }

    //! Return the formatted string, which is stored in an internal buffer
    operator const char*() const { return myBuffer; }

    // operator std::string() const { return std::string(myBuffer, mySize); }
    // operator UT_StringRef() const { return UT_StringRef(myBuffer, mySize); }
    // operator UT_StringHolder() const { return UT_StringHolder(myBuffer, mySize); }
    // operator UT_StringView() const { return UT_StringView(myBuffer, mySize); }

    //! Cast to a double that will format to the same digits. This is useful to
    //! convert a float or half to the "expected" double value.
    explicit operator fpreal64() const;

    //! Returns true if reset to a non-zero value
    explicit operator bool() const;

    //! String equality, useful for testing
    bool operator!=(const char*) const;
    bool operator==(const char* v) const { return !operator!=(v); }

    // Post-format modifications. You must call these in this order!
    void insert(unsigned i, const char* c, unsigned len);
    void insert(unsigned i, char c, unsigned len=1);
    void pad0(Flags flags, int digits); //!< add leading zeros so there are n digits
    void grouping(Flags flags); //!< insert commas every 3 leading digits (or _ every 4 for hex)
    void prefix(Flags flags); //!< add C prefix such as "0x"
    void plus(bool space=false); //!< add a '+' or ' ' to positive numbers
    void uppercase();
    void append(char c) { myBuffer[mySize++] = c; myBuffer[mySize] = 0; }

    // std::to_chars emulation

    char* write(char* start, char* end) const; // returns pointer after last char

    struct to_chars_result { // match syntax of std::to_chars where you do to_chars().ptr
        char* ptr;
    };

    static to_chars_result to_chars(char* start, char* end, fpreal64 v, Flags flags=GENERAL, int precision=-1)
    { return {UT_Digits(v, flags, precision).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, fpreal32 v, Flags flags=GENERAL, int precision=-1)
    { return {UT_Digits(v, flags, precision).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, fpreal16 v, Flags flags=GENERAL, int precision=-1)
    { return {UT_Digits(v, flags, precision).write(start, end)}; }

    static to_chars_result to_chars(char* start, char* end, int64 v)
    { return {UT_Digits(v).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, int32 v)
    { return {UT_Digits(v).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, uint64 v)
    { return {UT_Digits(v).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, uint32 v)
    { return {UT_Digits(v).write(start, end)}; }

    static Flags toFlags(int base) { return base==16 ? HEX : base==8 ? OCTAL : base == 2 ? BINARY : GENERAL; }
    static to_chars_result to_chars(char* start, char* end, int64 v, int base)
    { return {UT_Digits(v, toFlags(base)).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, int32 v, int base)
    { return {UT_Digits(v, toFlags(base)).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, uint64 v, int base)
    { return {UT_Digits(v, toFlags(base)).write(start, end)}; }
    static to_chars_result to_chars(char* start, char* end, uint32 v, int base)
    { return {UT_Digits(v, toFlags(base)).write(start, end)}; }

private:
    unsigned mySize;
    char myBuffer[500]; // this is big enough for largest number with precision=31

    void addSign(bool negative, Flags flags);
    void addNan(bool infinity, Flags flags);
    void addInt(int, Flags flags, int precision);
    void addNumber(int e, uint64 f, Flags flags, int precision);
    void addNumber(int e, uint64 f, int k, bool, Flags flags, int precision);
    void addHex(int e, uint64 f, int k, bool, Flags flags, int precision);
    unsigned addExp(unsigned, int e, Flags flags);
};

UT_API std::ostream& operator<<(std::ostream& o, const UT_Digits& i);

static inline UT_Digits::Flags operator|(UT_Digits::Flags a, UT_Digits::Flags b)
{ return UT_Digits::Flags(int(a) | int(b)); }

static inline UT_Digits::Flags operator|=(UT_Digits::Flags& a, UT_Digits::Flags b)
{ return a = UT_Digits::Flags(int(a) | int(b)); }

/// Replicate EXPRftoa() using UT_Digits, this avoids a temporary WorkBuffer.
/// Larger precision makes any value that fits in an int64 print without
/// an exponent. Also prints -0.0 as "0" for back-compatability
class UT_DigitsEXPR : public UT_Digits
{
public:
    UT_DigitsEXPR(fpreal64 v) : UT_Digits(v==0.0 ? 0.0 : v, 19) {}
    UT_DigitsEXPR(fpreal32 v) : UT_Digits(v==0.0f ? 0.0f : v, 19) {}
};