Enumeration.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_ENUMERATION_H_
#define SimTK_SimTKCOMMON_ENUMERATION_H_

/* -------------------------------------------------------------------------- *
 *                      SimTK Core: SimTKcommon                               *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK Core biosimulation toolkit originating from      *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org.               *
 *                                                                            *
 * Portions copyright (c) 2007 Stanford University and the Authors.           *
 * Authors: Peter Eastman                                                     *
 * Contributors:                                                              *
 *                                                                            *
 * Permission is hereby granted, free of charge, to any person obtaining a    *
 * copy of this software and associated documentation files (the "Software"), *
 * to deal in the Software without restriction, including without limitation  *
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
 * and/or sell copies of the Software, and to permit persons to whom the      *
 * Software is furnished to do so, subject to the following conditions:       *
 *                                                                            *
 * The above copyright notice and this permission notice shall be included in *
 * all copies or substantial portions of the Software.                        *
 *                                                                            *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
 * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon/internal/common.h"
#include "SimTKcommon/internal/ExceptionMacros.h"
#include "SimTKcommon/internal/Array.h"

namespace SimTK {

template <class T> class EnumerationSet;

template <class T>
class Enumeration {
public:
    class iterator;
    int getIndex() const {
        init();
        return index;
    }
    const std::string getName() const {
        init();
        return name;
    }
    static int size() {
        return (int)updAllValues().size();
    }
    static const T& getValue(int index) {
        return *updAllValues()[index];
    }
    static iterator begin() {
        iterator first(0);
        return first;
    }
    static iterator end() {
        iterator last(size());
        return last;
    }
    Enumeration(const Enumeration<T>& copy) {
        init();
        index = copy.index;
        name = copy.name;
    }
    Enumeration<T>& operator=(const Enumeration<T>& copy) {
        init();
        index = copy.index;
        name = copy.name;
        return *this;
    }
    // Address operator should usually return a Stage*, not a Enumeration<Stage>*
    // The previous Enumeration<Stage>* return value was causing a problem in 
    // boost.python headers, in a statment equivalent to:
    //    "Stage* const p = &const_cast<Stage&>((Stage const&)stage);"
    // Which looks innocent, except that it fails to compile when that first "&" 
    // generated an Enumeration<Stage>* instead of a Stage*.  Wrapping now works with
    // this method returning a T*.
    T* operator&() {
        init();
        return static_cast<T*>(this);
    }
    bool operator==(const Enumeration<T>& value) const {
        init();
        return (index == value.index);
    }
    bool operator!=(const Enumeration<T>& value) const {
        init();
        return (index != value.index);
    }
    operator int() const {
        return getIndex();
    }
    EnumerationSet<T> operator|(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp |= set;
        return temp;
    }
    EnumerationSet<T> operator&(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp &= set;
        return temp;
    }
    EnumerationSet<T> operator^(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp ^= set;
        return temp;
    }
    Enumeration<T> operator++() {
        assert (index < size()-1);
        ++index;
        name = getValue(index).name;
        return *this;
    }
    Enumeration<T> operator++(int) {
        assert (index < size()-1);
        Enumeration<T> current = *this;
        ++index;
        name = getValue(index).name;
        return current;
    }
    Enumeration<T> operator--() {
        assert (index > 0);
        --index;
        name = getValue(index).name;
        return *this;
    }
    Enumeration<T> operator--(int) {
        assert (index > 0);
        Enumeration<T> current = *this;
        --index;
        name = getValue(index).name;
        return current;
    }
protected:
    // Default construction must not do anything to memory, because the static members
    // may already have been initialized before they get default constructed. If you
    // touch any data here, say by initializing "index" to -1, you may be wiping out a
    // static member constants. The constant will not then get fixed because the init() 
    // call will think it is already done.
    Enumeration() {
        init();
    }
    Enumeration(const T& thisElement, int index, const char* name) : index(index), name(name) {
        SimTK_ASSERT_ALWAYS(index == updAllValues().size(), "Indices must be consecutive ints starting from 0.");
        updAllValues().push_back(&thisElement);
    }
    static Array_<const T*>& updAllValues() {
        static Array_<const T*> allValues;
        return allValues;
    }
private:
    int index;
    const char* name;
    static void init() {
        static bool isInitialized = false;
        if (!isInitialized) {
            isInitialized = true;
            T::initValues();
        }
    }
};

template <class T>
std::ostream& operator<<(std::ostream& stream, const Enumeration<T>& value) {
    return stream << value.getName();
}

template <class T>
class Enumeration<T>::iterator {
public:
    Enumeration<T> operator*() {
        assert (index >= 0 && index < Enumeration<T>::size());
        return Enumeration<T>::getValue(index);
    }
    iterator operator++() {
        assert (index < Enumeration<T>::size());
        ++index;
        return *this;
    }
    iterator operator++(int) {
        assert (index < Enumeration<T>::size());
        iterator current = *this;
        ++index;
        return current;
    }
    bool operator==(const iterator& iter) {
        return (index == iter.index);
    }
    bool operator!=(const iterator& iter) {
        return (index != iter.index);
    }
private:
    iterator(int index) : index(index) {
    }
    int index;
    friend class Enumeration<T>;
};

template <class T>
class EnumerationSet {
public:
    class iterator;
    EnumerationSet() {
        rep = new EnumerationSetRep();
    }
    EnumerationSet(const Enumeration<T>& value) {
        rep = new EnumerationSetRep(value);
    }
    EnumerationSet(const EnumerationSet<T>& set) {
        rep = new EnumerationSetRep(*set.rep);
    }
    ~EnumerationSet() {
        delete rep;
    }
    int size() const {
        return rep->size();
    }
    bool empty() const {
        return (rep->size() == 0);
    }
    bool contains(const Enumeration<T>& value) const {
        return rep->contains(value);
    }
    bool containsAll(const EnumerationSet<T>& set) const {
        return rep->containsAll(*set.rep);
    }
    bool containsAny(const EnumerationSet<T>& set) const {
        return rep->containsAny(*set.rep);
    }
    bool operator==(const EnumerationSet<T>& set) const {
        return *rep == *set.rep;
    }
    bool operator!=(const EnumerationSet<T>& set) const {
        return *rep != *set.rep;
    }
    void clear() {
        rep->clear();
    }
    iterator begin() {
        iterator first(this, 0);
        return first;
    }
    iterator end() {
        iterator last(this, Enumeration<T>::size());
        return last;
    }
    EnumerationSet<T>& operator=(const EnumerationSet<T>& set) {
        *rep = *set.rep;
        return *this;
    }
    EnumerationSet<T>& operator-=(const Enumeration<T>& value) {
        *rep -= value;
        return *this;
    }
    EnumerationSet<T>& operator-=(const EnumerationSet<T>& set) {
        *rep -= *set.rep;
        return *this;
    }
    EnumerationSet<T> operator-(const Enumeration<T>& value) const {
        EnumerationSet<T> temp(*this);
        temp -= value;
        return temp;
    }
    EnumerationSet<T> operator-(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp -= set;
        return temp;
    }
    EnumerationSet<T>& operator|=(const EnumerationSet<T>& set) {
        *rep |= *set.rep;
        return *this;
    }
    EnumerationSet<T> operator|(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp |= set;
        return temp;
    }
    EnumerationSet<T>& operator&=(const EnumerationSet<T>& set) {
        *rep &= *set.rep;
        return *this;
    }
    EnumerationSet<T> operator&(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp &= set;
        return temp;
    }
    EnumerationSet<T>& operator^=(const EnumerationSet<T>& set) {
        *rep ^= *set.rep;
        return *this;
    }
    EnumerationSet<T> operator^(const EnumerationSet<T>& set) const {
        EnumerationSet<T> temp(*this);
        temp ^= set;
        return temp;
    }
    EnumerationSet<T> operator~() const {
        EnumerationSet<T> temp(*this);
        temp.rep->invert();
        return temp;
    }
private:
    class EnumerationSetRep;
    EnumerationSetRep* rep;
};

template <class T>
class EnumerationSet<T>::EnumerationSetRep {
public:
    EnumerationSetRep() {
        init();
    }
    EnumerationSetRep(const Enumeration<T>& value) {
        init();
        flags[word(value)] = mask(value);
        numElements = 1;
    }
    EnumerationSetRep(const EnumerationSetRep& set) {
        init();
        *this = set;
    }
    ~EnumerationSetRep() {
        delete[] flags;
    }
    int size() const {
        if (numElements == -1) {
            numElements = 0;
            for (int i = 0; i < words; ++i) {
                int temp = flags[i];
                while (temp != 0) {
                    ++numElements;
                    temp &= temp-1;
                }
            }
        }
        return numElements;
    }
    bool contains(const Enumeration<T>& value) const {
        return ((flags[word(value)] & mask(value)) != 0);
    }
    bool containsAll(const EnumerationSetRep& set) const {
        for (int i = 0; i < words; ++i)
            if ((flags[i] & set.flags[i]) != set.flags[i])
                return false;
        return true;
    }
    bool containsAny(const EnumerationSetRep& set) const {
        for (int i = 0; i < words; ++i)
            if ((flags[i] & set.flags[i]) != 0)
                return true;
        return false;
    }
    bool operator==(const EnumerationSetRep& set) const {
        for (int i = 0; i < words; ++i)
            if (flags[i] != set.flags[i])
                return false;
        return true;
    }
    bool operator!=(const EnumerationSetRep& set) const {
        for (int i = 0; i < words; ++i)
            if (flags[i] != set.flags[i])
                return true;
        return false;
    }
    void clear() {
        for (int i = 0; i < words; ++i)
            flags[i] = 0;
        numElements = 0;
    }
    EnumerationSetRep& operator=(const EnumerationSetRep& set) {
        for (int i = 0; i < words; ++i)
            flags[i] = set.flags[i];
        numElements = set.numElements;
        return *this;
    }
    EnumerationSetRep& operator-=(const Enumeration<T>& value) {
        flags[word(value)] &= ~mask(value);
        numElements = -1;
        return *this;
    }
    EnumerationSetRep& operator-=(const EnumerationSetRep& set) {
        for (int i = 0; i < words; ++i)
            flags[i] &= ~set.flags[i];
        numElements = -1;
        return *this;
    }
    EnumerationSetRep& operator|=(const EnumerationSetRep& set) {
        for (int i = 0; i < words; ++i)
            flags[i] |= set.flags[i];
        numElements = -1;
        return *this;
    }
    EnumerationSetRep& operator&=(const EnumerationSetRep& set) {
        for (int i = 0; i < words; ++i)
            flags[i] &= set.flags[i];
        numElements = -1;
        return *this;
    }
    EnumerationSetRep& operator^=(const EnumerationSetRep& set) {
        for (int i = 0; i < words; ++i)
            flags[i] ^= set.flags[i];
        numElements = -1;
        return *this;
    }
    void invert() const {
        for (int i = 0; i < words-1; ++i)
            flags[i] = -1-flags[i];
        flags[words-1] = (1<<T::size()%BITS_PER_WORD)-1-flags[words-1];
        numElements = -1;
    }
private:
    void init() {
        numElements = -1;
        words = (T::size()+BITS_PER_WORD-1)/BITS_PER_WORD;
        flags = new int[words];
        for (int i = 0; i < words; ++i)
            flags[i] = 0;
    }
    int mask(const Enumeration<T>& value) const {
        return 1<<(value.getIndex()%BITS_PER_WORD);
    }
    int word(const Enumeration<T>& value) const {
        return value.getIndex()/BITS_PER_WORD;
    }
    int* flags;
    short words;
    mutable short numElements;
    static const int BITS_PER_WORD = 8*sizeof(int);
};

template <class T>
class EnumerationSet<T>::iterator {
public:
    Enumeration<T> operator*() {
        assert (index >= 0 && index < Enumeration<T>::size());
        return Enumeration<T>::getValue(index);
    }
    iterator operator++() {
        assert (index < Enumeration<T>::size());
        ++index;
        findNextElement();
        return *this;
    }
    iterator operator++(int) {
        assert (index < Enumeration<T>::size());
        iterator current = *this;
        ++index;
        findNextElement();
        return current;
    }
    bool operator==(const iterator& iter) {
        return (set == iter.set && index == iter.index);
    }
    bool operator!=(const iterator& iter) {
        return (set != iter.set || index != iter.index);
    }
private:
    iterator(EnumerationSet<T>* set, int index) : set(set), index(index) {
        findNextElement();
    }
    void findNextElement() {
        while (index < Enumeration<T>::size() && !set->contains(Enumeration<T>::getValue(index)))
            ++index;
    }
    int index;
    EnumerationSet<T>* set;
    friend class EnumerationSet<T>;
};

} // namespace SimTK

#endif // SimTK_SimTKCOMMON_ENUMERATION_H_