Vary.h

Go to the documentation of this file.

//useful for simple things where usability is more important than effeciency
//Luke Lenhart (2005-2011)
//See /docs/License.txt for details on how this code may be used.

//Uninitialized type is a Vary::STRING of length 0.
//Converting a string that doesn't contain a number to a number, is just 0.
//A vectors of char's can be used as an input source, and is treated as a string.
//When converting from real to integral types, number is rounded

#pragma once

#include <string>
#include <vector>
#include "Types.h"

namespace MPMA
{
    class Vary
    {
    public:
        enum Type
        {
            INTEGER, 
            REAL,    
            STRING   
        };

        //ctors and dtor
        Vary(); 
        Vary(const Vary &o); 
        inline Vary(const sint64 &ival) {*this=ival;} 
        inline Vary(const uint64 &ival) {*this=ival;} 
        inline Vary(const sint32 &ival) {*this=(sint64)ival;} 
        inline Vary(const uint32 &ival) {*this=(uint64)ival;} 
        inline Vary(const sint16 &ival) {*this=(sint64)ival;} 
        inline Vary(const uint16 &ival) {*this=(uint64)ival;} 
        inline Vary(const sint8 &ival) {*this=(sint64)ival;} 
        inline Vary(const uint8 &ival) {*this=(uint64)ival;} 
        inline Vary(const float &rval) {*this=rval;} 
        inline Vary(const std::string &sval) {*this=sval;} 
        inline Vary(const char *sval) {*this=sval;} 
        inline Vary(const std::vector<char> &sval) {*this=sval;} 

#if defined(linux) && defined(__amd64) //need a size_t version also for some reason
        inline Vary(const size_t &ival) {*this=(sint64)ival;} 
#endif

        ~Vary();

        inline const Type GetType() const {return type;}

        void Clear();

        //assignment
        const Vary& operator=(const Vary &vval); 
        const Vary& operator=(const sint64 &ival); 
        inline const Vary& operator=(const uint64 &ival) {*this=(sint64)ival; return *this;} 
        const Vary& operator=(const float &rval); 
        const Vary& operator=(const std::string &sval); 
        const Vary& operator=(const char *sval); 
        const Vary& operator=(const std::vector<char> &sval); 

        static Vary FromHexString(const std::string &s); 

        //conversion (non-altering)
        operator const sint64() const; 
        inline operator const uint64() const {return (uint64)(sint64)*this;}
        inline operator const sint32() const {return (sint32)(sint64)*this;}
        inline operator const uint32() const {return (uint32)(sint64)*this;}
        inline operator const sint16() const {return (sint16)(sint64)*this;}
        inline operator const uint16() const {return (uint16)(sint64)*this;}
        inline operator const sint8() const {return (sint8)(sint64)*this;}
        inline operator const uint8() const {return (uint8)(sint64)*this;}
        operator const std::string&() const; 
        operator const float() const; 

#if defined(linux) && defined(__amd64) //need a size_t version also for some reason
        inline operator const size_t() const {return (size_t)(sint64)*this;}
#endif

        inline const sint64 AsInt() const {return (sint64)*this;} 
        inline const std::string& AsString() const {return (const std::string&)*this;} 
        std::string AsHexString() const; 
        inline const float AsFloat() const {return (float)*this;} 
        inline const char* c_str() const { return ((const std::string&)*this).c_str(); } 

        //forced conversion of this instance into another type
        inline void MakeInt() {*this=(sint64)*this;} 
        inline void MakeReal() {*this=(float)*this;} 
        inline void MakeString() {*this=(const std::string&)*this;} 

        const Vary& operator+=(const Vary &var);
        const Vary& operator+=(const std::string &str);
        const Vary& operator+=(const char *str);
        inline friend const std::string& operator+=(std::string &str, const Vary &v) { return str+=(const std::string&)v; }
        //...letting implicit conversions take care of the rest

        const Vary operator+(const Vary &var) const;
        inline const Vary operator+(const std::string &str) const { return *this+Vary(str); }
        inline const Vary operator+(const char *str) const { return *this+Vary(str); }
        inline friend Vary operator+(const char* str, const Vary &v) { return Vary(str)+v; }
        inline friend Vary operator+(const std::string &str, const Vary &v) { return Vary(str)+v; }
        //...letting implicit conversions take care of the rest

        Vary& operator++(); //pre
        Vary operator++(int); //post
        Vary& operator--(); //pre
        Vary operator--(int); //post

        inline Vary(Vary &&o) 
        {
            *this=o;
        }

        inline const Vary& operator=(Vary &&o) 
        {
            type=o.type;
            validBits=o.validBits;
            curInt=o.curInt;
            curReal=o.curReal;
            curStr=(std::string&&)o.curStr;

            return *this;
        }

    protected:
        Type type; //current type of us

        //contents of us (current type has the actual value, the rest are just cache then)
        mutable std::string curStr;
        mutable sint64 curInt;
        mutable float curReal;

        mutable nuint validBits; //which members are up to date
    };


    class VaryString: public Vary
    {
    public:
        //ctors and dtor
        VaryString(); 
        VaryString(const Vary &o); 
        inline VaryString(const sint64 &ival) {*this=ival;} 
        inline VaryString(const uint64 &ival) {*this=ival;} 
        inline VaryString(const sint32 &ival) {*this=(sint64)ival;} 
        inline VaryString(const uint32 &ival) {*this=(uint64)ival;} 
        inline VaryString(const sint16 &ival) {*this=(sint64)ival;} 
        inline VaryString(const uint16 &ival) {*this=(uint64)ival;} 
        inline VaryString(const sint8 &ival) {*this=(sint64)ival;} 
        inline VaryString(const uint8 &ival) {*this=(uint64)ival;} 
        inline VaryString(const float &rval) {*this=rval;} 
        inline VaryString(const std::string &sval) {*this=sval;} 
        inline VaryString(const char *sval) {*this=sval;} 
        inline VaryString(const std::vector<char> &sval) {*this=sval;} 

#if defined(linux) && defined(__amd64) //need a size_t version also for some reason
        inline VaryString(const size_t &ival) {*this=(sint64)ival;} 
#endif

        ~VaryString();

        //assignment
        const VaryString& operator=(const Vary &vval); 
        const VaryString& operator=(const sint64 &ival); 
        inline const VaryString& operator=(const uint64 &ival) {*this=(sint64)ival; return *this;} 
        const VaryString& operator=(const float &rval); 
        const VaryString& operator=(const std::string &sval); 
        const VaryString& operator=(const char *sval); 
        const VaryString& operator=(const std::vector<char> &sval); 

        //hide stuff that doesn't make sense for this type
    private:
        void MakeInt();
        void MakeReal();

        Vary& operator++();
        Vary operator++(int);
    };

} //namespace MPMA