numericVariant.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_STORAGE_NUMERIC_VARIANT_TYPE_HPP_INCLUDED
#define _STRUS_STORAGE_NUMERIC_VARIANT_TYPE_HPP_INCLUDED
#include "strus/base/stdint.h"
#include <cstring>
#include <stdio.h>
#include <limits>

namespace strus {

class NumericVariant
{
public:
        NumericVariant( int64_t value)
        {
                variant.Int = value;
                type = Int;
        }

        NumericVariant( uint64_t value)
        {
                variant.UInt = value;
                type = UInt;
        }

        NumericVariant( double value)
        {
                variant.Float = value;
                type = Float;
        }
        NumericVariant( const char* val_)
        {
                if (!initFromString( val_)) init();
        }
        NumericVariant()
        {
                init();
        }
        static NumericVariant asint( int64_t val)
        {
                return NumericVariant( val);
        }
        static NumericVariant asuint( uint64_t val)
        {
                return NumericVariant( val);
        }
        static NumericVariant asdouble( double val)
        {
                return NumericVariant( val);
        }
        NumericVariant( const NumericVariant& o)
        {
                std::memcpy( this, &o, sizeof(*this));
        }

        void init()
        {
                std::memset( this, 0, sizeof(*this));
        }

        class String
        {
        public:
                String()
                {
                        m_buf[0] = '\0';
                }

                explicit String( const NumericVariant& val, int precision=-1);

                operator const char*() const    {return m_buf;}
                const char* c_str() const       {return m_buf;}

        private:
                char m_buf[ 128];
        };

        String tostring( int precision=-1) const
        {
                return String( *this, precision);
        }

        bool initFromString( const char* src);

        bool defined() const
        {
                return type != Null;
        }

        template <typename TYPE>
        TYPE cast() const
        {
                switch (type)
                {
                        case Null: return TYPE();
                        case Int: return (TYPE)variant.Int;
                        case UInt: return (TYPE)variant.UInt;
                        case Float: return (TYPE)variant.Float;
                }
                return TYPE();
        }

        operator double() const
        {
                return cast<double>();
        }
        operator int64_t() const
        {
                return cast<int>();
        }
        operator uint64_t() const
        {
                return cast<uint64_t>();
        }

        int64_t toint() const
        {
                if (type == Float)
                {
                        if (variant.Float < 0.0)
                        {
                                return (int64_t)(variant.Float - 2*std::numeric_limits<double>::epsilon());
                        }
                        else if (variant.Float > 0.0)
                        {
                                return (int64_t)(variant.Float + 2*std::numeric_limits<double>::epsilon());
                        }
                }
                return cast<int64_t>();
        }

        uint64_t touint() const
        {
                if (type == Float)
                {
                        if (variant.Float < 0.0)
                        {
                                return 0;
                        }
                        else if (variant.Float > 0.0)
                        {
                                return (uint64_t)(variant.Float + 2*std::numeric_limits<double>::epsilon());
                        }
                }
                return cast<uint64_t>();
        }

        double tofloat() const
        {
                return cast<double>();
        }

        bool operator == (const NumericVariant& o) const
        {
                return isequal(o);
        }
        bool operator != (const NumericVariant& o) const
        {
                return !isequal(o);
        }

        bool operator >= (const NumericVariant& o) const
        {
                return compare(o) >= 0;
        }

        bool operator > (const NumericVariant& o) const
        {
                return compare(o) > 0;
        }

        bool operator <= (const NumericVariant& o) const
        {
                return compare(o) <= 0;
        }

        bool operator < (const NumericVariant& o) const
        {
                return compare(o) < 0;
        }

        bool isequal( const NumericVariant& o) const;

        int compare( const NumericVariant& o) const;

        NumericVariant& operator=( int64_t value)
        {
                variant.Int = value;
                type = Int;
                return *this;
        }

        NumericVariant& operator=( uint64_t value)
        {
                variant.UInt = value;
                type = UInt;
                return *this;
        }

        NumericVariant& operator=( double value)
        {
                variant.Float = value;
                type = Float;
                return *this;
        }

        NumericVariant& operator=( const NumericVariant& o)
        {
                std::memcpy( this, &o, sizeof(*this));
                return *this;
        }

        enum Type {
                Null,           
                Int,            
                UInt,           
                Float           
        };
        typedef int64_t IntType;
        typedef uint64_t UIntType;
        typedef double FloatType;

        static const char* typeName( Type type);

        Type type;                              
        union
        {
                int64_t Int;                    
                uint64_t UInt;                  
                double Float;                   
        } variant;                              
};

}//namespace
#endif