libstx-exparser/AnyScalar.h

Go to the documentation of this file.

// $Id: AnyScalar.h 59 2007-07-17 14:43:23Z tb $

/*
 * STX Expression Parser C++ Framework v0.7
 * Copyright (C) 2007 Timo Bingmann
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef _STX_AnyScalar_H_
#define _STX_AnyScalar_H_

#include <string>
#include <stdexcept>
#include <functional>
#include <ostream>
#include <assert.h>

namespace stx {

class AnyScalar
{
public:
    enum attrtype_t
    {
        ATTRTYPE_INVALID = 0x00,

        ATTRTYPE_BOOL = 0x01,

        ATTRTYPE_CHAR = 0x10,

        ATTRTYPE_SHORT = 0x11,

        ATTRTYPE_INTEGER = 0x12,

        ATTRTYPE_LONG = 0x13,

        ATTRTYPE_BYTE = 0x20,

        ATTRTYPE_WORD = 0x21,

        ATTRTYPE_DWORD = 0x22,

        ATTRTYPE_QWORD = 0x23,

        ATTRTYPE_FLOAT = 0x30,

        ATTRTYPE_DOUBLE = 0x31,

        ATTRTYPE_STRING = 0x40
    };

private:
    attrtype_t          atype;

    union value_t
    {
        int                     _int;

        unsigned int            _uint;

        long long               _long;

        unsigned long long      _ulong;

        float                   _float;

        double                  _double;

        std::string*            _string;
    };

    union value_t       val;
    
public:
    explicit inline AnyScalar(attrtype_t t = ATTRTYPE_INVALID)
        : atype(t)
    { 
        if (atype == ATTRTYPE_STRING) {
            val._string = new std::string;
        }
        else {
            val._ulong = 0;
        }
    }

    // *** Constructors for the various types

    inline AnyScalar(bool b)
        : atype(ATTRTYPE_BOOL)
    {
        val._int = b;
    }

#ifndef SWIG    // This constructor confuses SWIG into calling it with
                // one-character strings
    inline AnyScalar(char c)
        : atype(ATTRTYPE_CHAR)
    {
        val._int = c;
    }
#endif
    inline AnyScalar(short s)
        : atype(ATTRTYPE_SHORT)
    {
        val._int = s;
    }
    inline AnyScalar(int i)
        : atype(ATTRTYPE_INTEGER)
    {
        val._int = i;
    }
    inline AnyScalar(long i)
        : atype(ATTRTYPE_INTEGER)
    {
        val._int = i;
    }
    inline AnyScalar(long long l)
        : atype(ATTRTYPE_LONG)
    {
        val._long = l;
    }
    inline AnyScalar(unsigned char c)
        : atype(ATTRTYPE_BYTE)
    {
        val._uint = c;
    }
    inline AnyScalar(unsigned short s)
        : atype(ATTRTYPE_WORD)
    {
        val._uint = s;
    }
    inline AnyScalar(unsigned int i)
        : atype(ATTRTYPE_DWORD)
    {
        val._uint = i;
    }
    inline AnyScalar(unsigned long i)
        : atype(ATTRTYPE_DWORD)
    {
        val._uint = i;
    }
    inline AnyScalar(unsigned long long l)
        : atype(ATTRTYPE_QWORD)
    {
        val._ulong = l;
    }
    inline AnyScalar(float f)
        : atype(ATTRTYPE_FLOAT)
    {
        val._float = f;
    }
    inline AnyScalar(double d)
        : atype(ATTRTYPE_DOUBLE)
    {
        val._double = d;
    }
    inline AnyScalar(const char *s)
        : atype(ATTRTYPE_STRING)
    {
        if (s == NULL) 
            val._string = new std::string;
        else
            val._string = new std::string(s);
    }
    inline AnyScalar(const std::string &s)
        : atype(ATTRTYPE_STRING)
    {
        val._string = new std::string(s);
    }

    inline ~AnyScalar()
    {
        if (atype == ATTRTYPE_STRING) {
            delete val._string;
            val._string = NULL;
        }
    }
    
    inline AnyScalar(const AnyScalar &a)
        : atype(a.atype)
    {
        switch(atype)
        {
        case ATTRTYPE_INVALID:
            break;

        case ATTRTYPE_BOOL:
        case ATTRTYPE_CHAR:
        case ATTRTYPE_SHORT:
        case ATTRTYPE_INTEGER:
            val._int = a.val._int;
            break;

        case ATTRTYPE_BYTE:
        case ATTRTYPE_WORD:
        case ATTRTYPE_DWORD:
            val._uint = a.val._uint;
            break;

        case ATTRTYPE_LONG:
            val._long = a.val._long;
            break;

        case ATTRTYPE_QWORD:
            val._ulong = a.val._ulong;
            break;

        case ATTRTYPE_FLOAT:
            val._float = a.val._float;
            break;

        case ATTRTYPE_DOUBLE:
            val._double = a.val._double;
            break;

        case ATTRTYPE_STRING:
            val._string = new std::string(*a.val._string);
            break;
        }
    }

    inline AnyScalar& operator=(const AnyScalar &a)
    {
        // check if we are to assign ourself
        if (this == &a) return *this;

        if (atype == ATTRTYPE_STRING) {
            delete val._string;
            val._string = NULL;
        }

        atype = a.atype;
        
        switch(atype)
        {
        case ATTRTYPE_INVALID:
            assert(0);
            break;

        case ATTRTYPE_BOOL:
        case ATTRTYPE_CHAR:
        case ATTRTYPE_SHORT:
        case ATTRTYPE_INTEGER:
            val._int = a.val._int;
            break;

        case ATTRTYPE_BYTE:
        case ATTRTYPE_WORD:
        case ATTRTYPE_DWORD:
            val._uint = a.val._uint;
            break;

        case ATTRTYPE_LONG:
            val._long = a.val._long;
            break;

        case ATTRTYPE_QWORD:
            val._ulong = a.val._ulong;
            break;

        case ATTRTYPE_FLOAT:
            val._float = a.val._float;
            break;

        case ATTRTYPE_DOUBLE:
            val._double = a.val._double;
            break;

        case ATTRTYPE_STRING:
            val._string = new std::string(*a.val._string);
            break;
        }

        return *this;
    }

    bool operator==(const AnyScalar &a) const;

    inline bool operator!=(const AnyScalar &a) const
    { return !(*this == a); }

    inline attrtype_t   getType() const
    {
        return atype;
    }

    inline bool         isBooleanType() const
    {
        return (atype == ATTRTYPE_BOOL);
    }

    inline bool         isIntegerType() const
    {
        return (atype == ATTRTYPE_BOOL ||
                atype == ATTRTYPE_CHAR || atype == ATTRTYPE_SHORT ||
                atype == ATTRTYPE_INTEGER || atype == ATTRTYPE_LONG ||
                atype == ATTRTYPE_BYTE || atype == ATTRTYPE_WORD ||
                atype == ATTRTYPE_DWORD || atype == ATTRTYPE_QWORD);
    }

    inline bool         isFloatingType() const
    {
        return (atype == ATTRTYPE_FLOAT || atype == ATTRTYPE_DOUBLE);
    }

    bool        convertType(attrtype_t t);

    void        resetType(attrtype_t t);

    // *** attrtype_t to string and string to attrtype_t functions

    static bool isValidAttrtype(attrtype_t at);
    
    static attrtype_t stringToType(const std::string &s)
    {
        return stringToType(s.c_str());
    }

    static attrtype_t stringToType(const char *s);

    static std::string getTypeString(attrtype_t at);

    inline std::string getTypeString() const
    {
        return getTypeString(atype);
    }

    // *** Type and Value Length Functions
    
    inline int  getTypeLength() const
    {
        return getTypeLength(atype);
    }

    static int  getTypeLength(attrtype_t t);

    static bool isFixedLength(attrtype_t t)
    {
        return getTypeLength(t) >= 0;
    }

    inline bool isFixedLength() const
    {
        return isFixedLength(atype);
    }

    unsigned int getValueLength() const;

    // *** Setters

    // Sets the value, converting the input to the currently set type if
    // necessary. Returns false if the input could not be converted into the
    // right type.

    bool                setInteger(int i);

    bool                setLong(long long l);

    bool                setDouble(double d);

    bool                setString(const std::string &s);
    
    bool                setStringQuoted(const std::string &s);


    AnyScalar&          setAutoString(const std::string &input);

    // *** Getters

    // Return the enclosed value in different types, converting if
    // necessary. If the enclosed value cannot be converted these functions
    // throw a ConversionError exception.

    bool                getBoolean() const;

    int                 getInteger() const;

    unsigned int        getUnsignedInteger() const;

    inline int          getInt() const
    {
        return getInteger();
    }

    inline unsigned int getUInt() const
    {
        return getUnsignedInteger();
    }

    long long           getLong() const;

    unsigned long long  getUnsignedLong() const;

    unsigned long long  getULong() const
    {
        return getUnsignedLong();
    }

    double              getDouble() const;

    std::string         getString() const;

    std::string         getStringQuoted() const;
    
    // *** Unary Operators
    
    AnyScalar           operator-() const;

    // *** Binary Operators

    // These will convert the two operands to the largest common type of the
    // same field.

#ifndef SWIG    // obviously too strange for SWIG
private:
    template <template <typename Type> class Operator, char OpName>
    AnyScalar           binary_arith_op(const AnyScalar &b) const;
#endif
    
public:
    inline AnyScalar    operator+(const AnyScalar &b) const
    {
        return binary_arith_op<std::plus, '+'>(b);
    }

    inline AnyScalar    operator-(const AnyScalar &b) const
    {
        return binary_arith_op<std::minus, '-'>(b);
    }

    inline AnyScalar    operator*(const AnyScalar &b) const
    {
        return binary_arith_op<std::multiplies, '*'>(b);
    }

    inline AnyScalar    operator/(const AnyScalar &b) const
    {
        return binary_arith_op<std::divides, '/'>(b);
    }

    inline AnyScalar    add(const AnyScalar &b) const
    {
        return (*this + b);
    }

    inline AnyScalar    subtract(const AnyScalar &b) const
    {
        return (*this - b);
    }

    inline AnyScalar    multiply(const AnyScalar &b) const
    {
        return (*this * b);
    }

    inline AnyScalar    divide(const AnyScalar &b) const
    {
        return (*this / b);
    }

#ifndef SWIG    // obviously too strange for SWIG
private:
    template <template <typename Type> class Operator, int OpNum>
    bool                binary_comp_op(const AnyScalar &b) const;
#endif

    // *** Don't use the operators themselves, because operator== is defined
    // *** differently above.
public:
    inline bool         equal_to(const AnyScalar &b) const
    {
        return binary_comp_op<std::equal_to, 0>(b);
    }

    inline bool         not_equal_to(const AnyScalar &b) const
    {
        return binary_comp_op<std::not_equal_to, 1>(b);
    }

    inline bool         less(const AnyScalar &b) const
    {
        return binary_comp_op<std::less, 2>(b);
    }

    inline bool         " greater-than.">greater(const AnyScalar &b) const
    {
        return binary_comp_op<std::greater, 3>(b);
    }

    inline bool         less_equal(const AnyScalar &b) const
    {
        return binary_comp_op<std::less_equal, 4>(b);
    }

    inline bool         =" greater-or-equal-than.">greater_equal(const AnyScalar &b) const
    {
        return binary_comp_op<std::greater_equal, 5>(b);
    }
};

static inline std::ostream& operator<< (std::ostream &stream, const AnyScalar &as)
{
    return stream << as.getString();
}

} // namespace stx

#endif // VGS_AnyScalar_H

---