enumset.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* 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
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      enumset.h
 *
 * Requires:  
 * - Mbo.h
 * - MboDebugTrace.h
 */
/* ------------------------------------------------------------------------ */

#ifndef _ENUMSET_H_
#define _ENUMSET_H_

#if defined(_MSC_VER)
# pragma comment (exestr, "This software includes material by M.Boerger (http://marcus-boerger.de/)")
# pragma warning(push)
# pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
# pragma warning(disable: 4702) // unreachable code
#endif

// The ellipsis constructor cannot be used with other calling conventions
// than __cdecl. However you cannot change the calling convention of 
// constructors. Hence we must disable this feature when changing the
// calling convention is an option.
#ifndef ALLOW_ENUM_ELLIPSIS_CTOR
#define ALLOW_ENUM_ELLIPSIS_CTOR 0
#endif

#include <stdarg.h>
#include <exception>
#include "MboDebugTrace.h"

#ifndef _Ty_list_default

#define _Ty_list_default size_t
#endif

#ifndef _Ty_args_default

#define _Ty_args_default int
#endif

/* ------------------------------------------------------------------------ */
namespace mbo {

class enumset_exception: public mbo::exception {};

class input_range_exception: public enumset_exception {};

class demap_value_exception: public enumset_exception {};

class multi_value_exception: public demap_value_exception {};

class empty_value_exception: public demap_value_exception {};

class operator_na_exception: public enumset_exception {};

class iterator_exception: public enumset_exception {};

/* ------------------------------------------------------------------------ */
template < typename _TEnum
         , typename _Ty_list  = _Ty_list_default
         , typename _Ty_args  = _Ty_args_default
         >
class enumset
{
typedef enumset<_TEnum, _Ty_list, _Ty_args>  _MyType;
public:

    typedef _TEnum   TEnum;
    
    typedef _Ty_list Ty_list;
    
    typedef _Ty_args Ty_args;

    typedef enumset<_TEnum, _Ty_list, _Ty_args>  MyType;
    
    enum { invalid_pos = 8 * sizeof(Ty_list) };

    static inline enumset from_set(Ty_list list)
    {
        enumset e;
        e.list = list;
        return e;
    }

    inline enumset () : list(0)
    {
    }

    inline enumset (const enumset & set) : list(set.list)
    {
    }

#if ALLOW_ENUM_ELLIPSIS_CTOR

    inline explicit enumset (size_t count, ...)
        throw(input_range_exception)
        : list(0)
    {
        va_list   args;
        Ty_list   val;

        va_start(args, count);
        while (count--)
        {
            val = (Ty_list)va_arg(args, Ty_args);
            list |= map(val);
        }
        va_end(args);
    }
#endif // ALLOW_ENUM_ELLIPSIS_CTOR

    inline explicit enumset (size_t count, va_list args)
        throw(input_range_exception)
        : list(0)
    {
        Ty_list   val;

        while (count--)
        {
            val = (Ty_list)va_arg(args, Ty_args);
            list |= map(val);
        }
    }

    inline enumset (const TEnum array[], size_t count)
        throw(input_range_exception)
        : list(0)
    {
        while (count)
        {
            list |= map(array[--count]);
        }
    }

    inline enumset (const TEnum & value)
        throw(input_range_exception)
    {
        list = map(value);
    }

    inline enumset & __cdecl dyna_set(size_t count, ...)
        throw(input_range_exception)
    {
        va_list   args;
        Ty_list   val;

        va_start(args, count);
        while (count--)
        {
            val = (Ty_list)va_arg(args, Ty_args);
            list |= map(val);
        }
        va_end(args);
        return *this;
    }

    inline enumset & set(const TEnum & value, bool set_unset = true)
    {
        if (set_unset)
        {
            return *this += value;
        }
        else
        {
            return *this -= value;
        }
    }

    inline bool get(const TEnum & value) const
    {
        return (*this >= value);
    }

    inline enumset & set_set(Ty_list list)
    {
        *this = from_set(list);
        return *this;
    }

    inline enumset & flip(const TEnum & value)
    {
        return set(value, !get(value));
    }

    inline bool contains(const TEnum & value) const
    {
        return (*this >= value);
    }

    inline bool contains(const enumset & set) const
    {
        return (*this >= set);
    }

    inline int count() const
    {
        register int i = 0;
        register Ty_list p = 1;

        while (p)
        {
            i += (list & p) ? 1 : 0;
            p *=2;
        }
        return i;
    }

    inline bool empty() const
    {
        return count() == 0;
    }

    inline enumset & clear()
    {
        list = 0;
        return *this;
    }

    inline enumset & operator = (const TEnum & value)
        throw(input_range_exception)
    {
        list = map(value);
        return *this;
    }

    inline enumset & operator = (const enumset & set)
    {
        list = set.list;
        return *this;
    }

    inline enumset & operator += (const TEnum & value)
        throw(input_range_exception)
    {
        list |= map(value);
        return *this;
    }

    inline enumset & operator += (const enumset & set)
    {
        list |= set.list;
        return *this;
    }

    inline enumset operator + (const TEnum & value) const
    {
        register enumset ret = enumset(*this);
        ret += value;
        return ret;
    }

    inline enumset operator + (const enumset & set) const
    {
        register enumset ret = enumset(*this);
        ret += set;
        return ret;
    }

    inline enumset & operator -= (const TEnum &value)
        throw(input_range_exception)
    {
        list &= ~map(value);
        return *this;
    }

    inline enumset & operator -= (const enumset &set)
    {
        list &= ~set.list;
        return *this;
    }

    inline enumset operator - (const TEnum & value) const
    {
        enumset ret = enumset(*this);
        ret -= value;
        return ret;
    }

    inline enumset operator - (const enumset & set) const
    {
        enumset ret = enumset(*this);
        ret -= set;
        return ret;
    }

    inline enumset & operator *= (const TEnum &value)
        throw(input_range_exception)
    {
        list &= map(value);
        return *this;
    }

    inline enumset & operator *= (const enumset &set)
    {
        list &= set.list;
        return *this;
    }

    inline enumset operator * (const TEnum & value) const
    {
        register enumset ret = enumset(*this);
        ret *= value;
        return ret;
    }

    inline enumset operator * (const enumset & set) const
    {
        register enumset ret = enumset(*this);
        ret *= set;
        return ret;
    }

    inline enumset & operator ^= (const TEnum &value)
        throw(input_range_exception)
    {
        list ^= map(value);
        return *this;
    }

    inline enumset & operator ^= (const enumset &set)
    {
        list ^= set.list;
        return *this;
    }

    inline enumset operator ^ (const TEnum & value) const
    {
        register enumset ret = enumset(*this);
        ret ^= value;
        return ret;
    }

    inline enumset operator ^ (const enumset & set) const
    {
        register enumset ret = enumset(*this);
        ret ^= set;
        return ret;
    }

    inline bool operator & (const TEnum & value) const
        throw(input_range_exception)
    {
        return (list & map(value)) != 0;
    }

    inline bool operator & (const enumset & set) const
    {
        return (list & set.list) != 0;
    }

    inline bool operator | (const TEnum & value) const
        throw(input_range_exception)
    {
        return (list | map(value)) != 0;
    }

    inline bool operator | (const enumset & set) const
    {
        return (list | set.list) != 0;
    }

    inline bool operator == (const TEnum & value) const
        throw(input_range_exception)
    {
        return list == map(value);
    }

    inline bool operator == (const enumset & set) const
    {
        return list == set.list;
    }

    inline bool operator != (const TEnum & value) const
        throw(input_range_exception)
    {
        return list != map(value);
    }

    inline bool operator != (const enumset & set) const
    {
        return list != set.list;
    }

    inline bool operator < (const TEnum & ) const
        throw(input_range_exception)
    {
        return list == 0; // only zero possible then
    }

    inline bool operator < (const enumset & set) const 
    {
        return ((list & ~set.list) == 0) && (list != set.list); // no other but at least one less (e.g. !=)
    }

    inline bool operator <= (const TEnum & value) const 
        throw(input_range_exception)
    {
        register Ty_list comp = map(value);
        return list == 0 || list ==  comp; // zero or same bit
    }

    inline bool operator <= (const enumset & set) const 
    {
        return (list & ~set.list) == 0; // no other bit is set
    }

    inline bool operator > (const TEnum & value) const 
        throw(input_range_exception)
    {
        register Ty_list comp = map(value);
        return ((list & comp) == comp) && (list > comp); // comp and one additional bit
    }

    inline bool operator > (const enumset & set) const 
    {
        return ((list & set.list) == set.list) && (list > set.list); // all from set plus one additional
    }

    inline bool operator >= (const TEnum & value) const
        throw(input_range_exception)
    {
        register Ty_list comp = map(value);
        return (list & comp) == comp; // at least comp is set
    }

    inline bool operator >= (const enumset & set) const
    {
        return (list & set.list) == set.list; // at least all of set
    }

    inline Ty_list to_set() const
    {
        return list;
    }

    inline operator Ty_list() const
    {
        return list;
    }

    inline TEnum to_enum() const
        throw(demap_value_exception, multi_value_exception, multi_value_exception)
    {
        return static_cast<TEnum>(demap(list));
    }

    inline operator TEnum() const
        throw(demap_value_exception, multi_value_exception, multi_value_exception)
    {
        return static_cast<TEnum>(demap(list));
    }

    class const_iterator
        : public std::iterator<std::bidirectional_iterator_tag, TEnum, Ty_list>
    {
    public:
        typedef enumset<TEnum, Ty_list, Ty_args>  MyEnumType;

        inline const_iterator(const MyEnumType& tenum, Ty_list pos = 0)
            : m_tenum(tenum), m_pos(pos)
        {
            /* forward to first element or invalid_pos */
            while (m_pos != invalid_pos
                && !(m_tenum.list & MyEnumType::map(m_pos)))
            {
                ++m_pos;
            }
        }

        inline const TEnum operator * () const throw(iterator_exception)
        {
            if (m_pos == invalid_pos)
            {
                throw iterator_exception();
            }
            return static_cast<TEnum>(m_pos);
        }

        /* no -> operator */

        inline const_iterator & operator ++ ()
        {
            while ((m_pos + 1) < invalid_pos)
            {
                if (m_tenum.list & MyEnumType::map(++m_pos))
                {
                    return *this;
                }
            }
            m_pos = invalid_pos;
            return *this;
        }

        inline const_iterator operator ++ (int)
        {
            /* postfix operator return an unchanged copy prior to the operaration */
            const_iterator it = const_iterator(m_array, m_pos);
            operator ++ ();
            return it;
        }

        inline const_iterator & operator -- ()
        {
            while(m_pos && m_pos != invalid_pos)
            {
                if (m_tenum.list & MyEnumType::map(--m_pos))
                {
                    return *this;
                }
            }
            m_pos = invalid_pos;
            return *this;
        }

        inline const_iterator operator -- (int)
        {
            /* postfix operator return an unchanged copy prior to the operaration */
            const_iterator it = const_iterator(m_array, m_pos);
            operator -- ();
            return it;
        }

        inline bool operator == (const_iterator &rhs) const
        {
            return &m_tenum == &rhs.m_tenum && m_pos == rhs.m_pos;
        }

        inline bool operator != (const_iterator &rhs) const
        {
            return !operator == (rhs);
        }

        inline const_iterator & operator = (const const_iterator & rhs)
        {
            new (this) const_iterator(rhs.m_tenum, rhs.m_pos);
            return *this;
        }

    protected:
        const MyEnumType&  m_tenum;
        Ty_list            m_pos;
    };

    inline const_iterator begin() const
    {
        return const_iterator(*this, 0);
    }

    inline const_iterator end() const
    {
        return const_iterator(*this, invalid_pos);
    }

friend class const_iterator;

private:

    inline enumset & operator ~(void)
        throw(operator_na_exception)
    {
        throw operator_na_exception();
    }

    Ty_list list;

    inline static Ty_list map(Ty_list value) 
        throw(input_range_exception)
    {
        if (value >= invalid_pos)
        {
            throw input_range_exception();
        }
        return (1L << value);
    }

    inline static Ty_list /* not TEnum see comment */ demap(Ty_list mapping) 
        throw(demap_value_exception, multi_value_exception, empty_value_exception)
    {
        register Ty_list i = 0;
        register Ty_list p = 1;

        while (p)
        {
            if (mapping & p) 
            {
                if (mapping & (~p))
                {
                    throw multi_value_exception();
                }
                return i;
            }
            i++;
            p <<= 1;
        }
        throw empty_value_exception();
        return 0;
    }

}; // template class enumset

/****************************************************************************//**************************************************************************/

/****************************************************************************//**************************************************************************/

}; // namespace mbo

#ifdef _MSC_VER
# pragma warning(pop)
#endif

#endif // _ENUMSET_H_

---