Vary.h

Go to the documentation of this file.

//useful for simple things where usability is more important than effeciency
//Luke Lenhart (2005)
//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 int &ival) {*this=ival;} 
        inline Vary(const uint &ival) {*this=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;} 
        ~Vary();
    
        inline const Type GetType() const {return type;}
    
        void Clear();
        
        //assignment
        const Vary& operator=(const Vary &vval); 
        const Vary& operator=(const int &ival); 
        inline const Vary& operator=(const uint &ival) {*this=(int)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); 
    
        //conversion (non-altering)
        operator const int() const; 
        operator const std::string&() const; 
        operator const float() const; 
        inline const int AsInt() const {return (int)*this;} 
        inline const std::string& AsString() const {return (const std::string&)*this;} 
        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=(int)*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 v+str; }
        inline friend Vary operator+(const std::string &str, const Vary &v) { return v+str; }
        //...letting implicit conversions take care of the rest
    
        Vary& operator++(); //pre
        Vary operator++(int); //post
        Vary& operator--(); //pre
        Vary operator--(int); //post

        //C++0x features: move semantics
#ifdef USE_CPP_0X
        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;
        }
#endif

    private:
        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 int curInt;
        mutable float curReal;
    
        mutable uint validBits; //which members are up to date
    };

} //namespace MISC