---

Enum.h

Go to the documentation of this file.

 /* SimData: Data Infrastructure for Simulations
 * Copyright (C) 2002, 2003 Mark Rose <tm2@stm.lbl.gov>
 * 
 * This file is part of SimData.
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef __SIMDATA_ENUM_H__
#define __SIMDATA_ENUM_H__

#include <SimData/Namespace.h>
#include <SimData/BaseType.h>
#include <SimData/Ref.h>
#include <SimData/Exception.h>

#include <string>
#include <vector>
#include <map>
#include <cstdio>
#include <iostream>
#include <sstream>



NAMESPACE_SIMDATA


class EnumLink;
class Enumeration;


SIMDATA_EXCEPTION(EnumError);

SIMDATA_SUBEXCEPTION(EnumIndexError, EnumError);

SIMDATA_SUBEXCEPTION(EnumTypeError, EnumError);



class EnumerationCore: public Referenced {
friend class Enumeration;
        typedef std::pair<std::string, int> Element;
        typedef std::vector<Element> Elements;

        std::map<int, int> __i2idx;

        std::map<std::string, int> __s2idx;

        Elements __elements;

        void __init(std::string const &s) {
                std::stringstream ss(s); 
                std::string token; 
                int value = 0;
                for (int idx = 0; ss >> token; idx++) {
                        std::size_t eq = token.find("=");
                        if (eq != std::string::npos) {
                                value = atoi(std::string(token, eq+1, std::string::npos).c_str());
                                token = std::string(token, 0, eq);
                        }
                        if (__i2idx.find(value) != __i2idx.end()) {
                                std::stringstream msg;
                                msg << "Enumeration value '" << value << "' multiply defined in '" << s << "'";
                                throw EnumError(msg.str());
                        }
                        if (__s2idx.find(token) != __s2idx.end()) {
                                std::stringstream msg;
                                msg << "Enumeration token '" << token << "' multiply defined in '" << s << "'";
                                throw EnumError(msg.str());
                        }
                        __elements.push_back(Element(token, value));
                        __i2idx[value] = idx;
                        __s2idx[token] = idx;
                        value++;
                }
                if (__elements.size() <= 0) throw EnumError("Empty Enumeration");
        }

        Element const &getElementByIndex(int idx) const {
                assert(validIndex(idx));
                return __elements[idx];
        }

        std::string getTokenByIndex(int idx) const { return getElementByIndex(idx).first; }

        int getValueByIndex(int idx) const { return getElementByIndex(idx).second; }

        int getIndexByValue(int value) const {
                std::map<int, int>::const_iterator iter = __i2idx.find(value);
                if (iter == __i2idx.end()) {
                        std::stringstream msg;
                        msg << value;
                        throw EnumIndexError(msg.str());
                }
                return iter->second;
        }

        std::string getTokenByValue(int value) const {
                return __elements[getIndexByValue(value)].first;
        }

        int getIndexByToken(std::string const &token) const {
                std::map<std::string, int>::const_iterator iter = __s2idx.find(token);
                if (iter == __s2idx.end()) {
                        throw EnumIndexError(token);
                }
                return iter->second;
        }

        int getValueByToken(std::string const &token) const {
                return __elements[getIndexByToken(token)].second;
        }

        int size() const { return __elements.size(); }

        bool containsToken(std::string const &token) const {
                return __s2idx.find(token) != __s2idx.end(); 
        }

        bool containsValue(int value) const {
                return __i2idx.find(value) != __i2idx.end(); 
        }

        bool validIndex(int idx) const {
                return idx >= 0 && idx <= size();
        }

        EnumerationCore();

        EnumerationCore(std::string const &s): Referenced() {
                __init(s);
        }
};

class Enumeration {
friend class EnumLink;
        Ref<EnumerationCore const> __core;

        Enumeration() { }

        Enumeration(Enumeration const &e) {
                __core = e.__core;
                assert(__core.valid()); 
        }

        bool operator !() const { return !__core; }

        bool valid() const { return __core.valid(); }

        Enumeration const &operator =(Enumeration const &e) {
                __core = e.__core;
                assert(__core.valid()); 
                return *this;
        }

        int getIndexByToken(std::string const &token) const {
                assert(__core.valid());
                return __core->getIndexByToken(token);
        }

        int getIndexByValue(int value) const {
                assert(__core.valid());
                return __core->getIndexByValue(value);
        }

        std::string getTokenByIndex(int idx) const {
                assert(__core.valid());
                return __core->getTokenByIndex(idx);
        }

        int getValueByIndex(int idx) const {
                assert(__core.valid());
                return __core->getValueByIndex(idx);
        }

        inline const std::vector<EnumLink> __range(int idx1, int idx2) const;

        void __checkIndex(int idx) const {
                assert(__core.valid() && __core->validIndex(idx));
        }

        inline EnumLink makeEnum(int idx) const;

public:
        bool operator ==(Enumeration const &e) const { return __core == e.__core; }

        bool operator !=(Enumeration const &e) const { return __core != e.__core; }

        Enumeration(std::string const &s) {
                __core = new EnumerationCore(s);
        }

        std::string getToken(int value) const {
                assert(__core.valid());
                return __core->getTokenByValue(value);
        }

        int getValue(std::string const &token) const {
                assert(__core.valid());
                return __core->getValueByToken(token);
        }

        int size() const{
                assert(__core.valid());
                return __core->size();
        }

        std::string __repr__() const {
                assert(__core.valid());
                std::stringstream ss;
                ss << "<Enumeration:";
                for (int i = 0; i < size(); i++) {
                        ss << " " << __core->getTokenByIndex(i) 
                           << "=" << __core->getValueByIndex(i);
                }
                ss << ">";
                return ss.str();
        }

        inline const std::vector<EnumLink> each() const;
        
        inline const std::vector<std::string> eachToken() const;

        inline const std::vector<int> eachValue() const;
        
        inline const std::vector<EnumLink> range(EnumLink const &a, EnumLink const &b) const;

        inline const std::vector<EnumLink> range(std::string const &a, std::string const &b) const;

        inline const std::vector<EnumLink> range(int a, int b) const;

        inline bool contains(EnumLink const &x) const;

        bool contains(int value) const { 
                assert(__core.valid());
                return __core->containsValue(value);
        }
        
        bool contains(std::string const &token) const {
                assert(__core.valid());
                return __core->containsToken(token);
        }

        inline EnumLink last() const;

        inline EnumLink first() const;

#ifndef SWIG

        inline EnumLink operator[](int value) const;
        inline EnumLink operator[](std::string const &token) const;
#else
%extend {
        EnumLink get(int idx) { return (*self)[idx]; }
        EnumLink get(std::string const &s) { return (*self)[s]; }
}
%insert(shadow) %{
        def __getitem__(self, idx):
                return self.get(idx)
        def __getattr__(self, attr):
                if self.contains(attr):
                        return self.get(attr)
                return self.__dict__[attr]
%}
#endif
};



class EnumLink: public BaseType {
friend class Enumeration;
        Enumeration __E;
protected:
        int _idx;

        int __size() const { return __E.size(); }

        EnumLink(): __E(), _idx(0) {}

        int getIndex() const { return _idx; }

        EnumLink(int idx, Enumeration const &E): __E(E), _idx(idx) { 
                E.__checkIndex(idx); 
        }

        EnumLink makeEnum(int idx) const {
                return EnumLink(idx, __E);
        }

public:
        // Create a new EnumLink bound to an existing Enumeration.
        EnumLink(Enumeration const &E): __E(E), _idx(0) { }

        // Create a new EnumLink bound to an existing Enumeration.
        EnumLink(Enumeration const &E, int value): __E(E), _idx(0) { 
                _idx = __E.getIndexByValue(value); 
        }

        // Create a new EnumLink bound to an existing Enumeration.
        EnumLink(Enumeration const &E, std::string const &token): __E(E), _idx(0) { 
                _idx = __E.getIndexByToken(token); 
        }

        virtual void serialize(Archive&);

        virtual void parseXML(const char* cdata);
        
        virtual std::string typeString() const;

        virtual std::string asString() const;

        EnumLink(EnumLink const &e): BaseType() {
                __E = e.__E;
                _idx = e._idx;
        }

        void cycle(int n=1) { _idx = (_idx+n+abs(n)*__size()) % __size(); }

        void cycleBack(int n=1) { _idx = (_idx-n+abs(n)*__size()) % __size(); }
        
        void set(std::string const &token) { _idx = __E.getIndexByToken(token); }

        void set(int value) { _idx = __E.getIndexByValue(value); }

        int getValue() const { return __E.getValueByIndex(_idx); }

        // Get the token of this enum.
        std::string getToken() const { return __E.getTokenByIndex(_idx); }

        std::string __repr__() const { 
                std::stringstream repr;
                repr << "<Enum:" << getToken() << "=" << getValue() << ">"; 
                return repr.str();
        }

        EnumLink next(int n=1) const { return makeEnum((_idx+n+abs(n)*__size())%__size()); }

        EnumLink prev(int n=1) const { return makeEnum((_idx-n+abs(n)*__size())%__size()); }

        EnumLink last() const { return makeEnum(__size()-1); }

        EnumLink first() const { return makeEnum(0); }

        Enumeration const &getEnumeration() const { return __E; }

#ifndef SWIG

        operator int() const { return getValue(); }

        operator std::string() const { return getToken(); }

        EnumLink const &operator =(int value) { set(value); return *this; }

        EnumLink const &operator =(std::string const &token) { set(token); return *this; }

        EnumLink const &operator=(EnumLink const &e) { 
                if (!__E) {
                        __E = e.__E;
                } else {
                        if (__E != e.__E) throw EnumTypeError();
                }
                if (__E.valid()) { _idx = e._idx; }
                return *this;
        }
#endif

        bool operator>(std::string const &token) const { return getValue() > __E.getValue(token); }

        bool operator<(std::string const &token) const { return getValue() < __E.getValue(token); }

        bool operator>=(std::string const &token) const { return getValue() >= __E.getValue(token); }

        bool operator<=(std::string const &token) const { return getValue() <= __E.getValue(token); }

        bool operator==(std::string const &token) const { return getValue() == __E.getValue(token); }

        bool operator!=(std::string const &token) const { return getValue() != __E.getValue(token); }
        
        bool operator>(int value) const { return getValue() > value; }

        bool operator<(int value) const { return getValue() < value; };

        bool operator>=(int value) const { return getValue() >= value; };

        bool operator<=(int value) const { return getValue() <= value; };

        bool operator==(int value) const { return getValue() == value; };

        bool operator!=(int value) const { return getValue() != value; };

        bool operator>(EnumLink const &x) const { return *this > x.getValue(); }

        bool operator<(EnumLink const &x) const { return *this < x.getValue(); }

        bool operator>=(EnumLink const &x) const { return *this >= x.getValue(); }

        bool operator<=(EnumLink const &x) const { return *this <= x.getValue(); }

        bool operator==(EnumLink const &x) const { return *this == x.getValue(); }

        bool operator!=(EnumLink const &x) const { return *this != x.getValue(); }
};

template <Enumeration const &E>
class Enum: public EnumLink {
public:
        Enum(std::string const &token): EnumLink(E, token) {}
        Enum(): EnumLink(E) {}
        Enum(int value): EnumLink(E, value) {}
        Enum(EnumLink const &e): EnumLink(e) {}
#ifndef SWIG
        EnumLink const & operator=(EnumLink const &e) { return EnumLink::operator=(e); }
        EnumLink const &operator =(int value) { return EnumLink::operator=(value); }
        EnumLink const &operator =(std::string const &token) { return EnumLink::operator=(token); }
#endif

        std::string __repr__() const { return EnumLink::__repr__(); }
};


// inline Enumeration methods

inline EnumLink Enumeration::makeEnum(int idx) const { return EnumLink(idx, *this); }

inline EnumLink Enumeration::operator[](int value) const { return makeEnum(getIndexByValue(value)); }

inline EnumLink Enumeration::operator[](std::string const &token) const { return makeEnum(getIndexByToken(token)); }

inline const std::vector<EnumLink> Enumeration::__range(int idx1, int idx2) const {
        assert(__core.valid());
        std::vector<EnumLink> v;
        if (idx2 >= idx1) {
                v.reserve(idx2-idx1+1);
        }
        for (int idx = idx1; idx <= idx2; idx++) {
                v.push_back(makeEnum(idx));
        }
        return v;
}

inline const std::vector<EnumLink> Enumeration::range(EnumLink const &a, EnumLink const &b) const {
        if (a.__E != *this || b.__E != *this) throw EnumTypeError();
        return __range(a.getIndex(), b.getIndex());
}

inline const std::vector<EnumLink> Enumeration::range(std::string const &a, std::string const &b) const {
        return __range(getIndexByToken(a), getIndexByToken(b));
}

inline const std::vector<EnumLink> Enumeration::range(int a, int b) const {
        return __range(getIndexByValue(a), getIndexByValue(b));
}

inline const std::vector<EnumLink> Enumeration::each() const {
        std::vector<EnumLink> v;
        v.reserve(size());
        for (int idx = 0; idx < size(); idx++) {
                v.push_back(makeEnum(idx));
        }
        return v;
}

inline const std::vector<std::string> Enumeration::eachToken() const {
        assert(__core.valid());
        std::vector<std::string> v;
        v.reserve(size());
        for (int idx = 0; idx < size(); idx++) {
                v.push_back(__core->getTokenByIndex(idx));
        }
        return v;
}

inline const std::vector<int> Enumeration::eachValue() const {
        assert(__core.valid());
        std::vector<int> v;
        v.reserve(size());
        for (int idx = 0; idx < size(); idx++) {
                v.push_back(__core->getValueByIndex(idx));
        }
        return v;
}

inline bool Enumeration::contains(EnumLink const &x) const { return x.__E == *this; }

inline EnumLink Enumeration::last() const {
        assert(__core.valid());
        return makeEnum(size()-1);
}

inline EnumLink Enumeration::first() const {
        assert(__core.valid());
        return makeEnum(0);
}


NAMESPACE_SIMDATA_END

#endif // __SIMDATA_ENUM_H__

---

SimData version pre-0.4.0. For more information on SimData, visit the SimData Homepage. Generated on Tue Oct 14 12:06:38 2003, using Doxygen 1.2.18.