enum.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  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., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_ENUM_H
#define WT_ENUM_H

#include <map>
#include <vector>
#include <algorithm>
#include <exception>
#include <cassert>

namespace Wt {

/// typesafe enumaration like class
/*!
Usage example
class ColorEnum : public Enum<ColorEnum> {
public:
    static const Member Red;
    static const Member Green;
    static const Member Purple;
    static const Member Black;
};
 
// Initialization
ColorEnum::Member Red = 2;
ColorEnum::Member Green; // implied 3
ColorEnum::Member Purple = 47; // forced 47
ColorEnum::Member Black; // implied 48
 
Now
ColorEnum::Var some_color = Red;  //ok;
some_color = 3 //ok
some_color = 9999 //failed at runtime: assertion && exception
*/
template<typename CHILD>
class Enum {
private:
    static int enum_next;
    static std::vector<int> defined;

    class VarBase {
    public:
        VarBase(int val)
                : value(val) {}
        operator int() const {
            /// \bug GCC bug: requires a (void)
            (void) defined;
            return value;
        }
    private:
        friend class Enum<CHILD>::Var;
        int value;
    };

protected:
class Member : public VarBase {
    private:
        void store(int val) {
            std::vector<int> result(defined.size() + 1);
            std::vector<int> newer(1);
            newer[0] = val;
            std::merge(defined.begin(), defined.end(),
                       newer.begin(), newer.end(), result.begin());
            std::swap(defined, result);
            enum_next = val + 1;
        }
    public:
        Member()
                : VarBase(enum_next) {
            store(enum_next);
        }
        Member(int val)
                : VarBase(val) {
            store(val);
        }
    };

public:
class Var : public VarBase {
    public:
        Var(int val = 0) : VarBase(val) {
            *this = val;
        }
        Var& operator=(int val) {
            bool value_is_valid_enum = std::binary_search(defined.begin(),
                                       defined.end(), val);
            if (value_is_valid_enum) {
                VarBase::value = val;
            } else {
                assert(value_is_valid_enum);
                throw val;
            }
            return *this;
        }
    private:
    };
};

template<typename CHILD>
int Enum<CHILD>::enum_next = 0;

template<typename CHILD>
std::vector<int> Enum<CHILD>::defined;

} // namespace

#endif //WT_ENUM_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.