HOM/HOM_EnumValue.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * COMMENTS:
 *      An enum value object is an immutable object inside a module containing
 *      other enum values.
 */

#ifndef __HOM_EnumValue_h__
#define __HOM_EnumValue_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_PtrOrNull.h"
#include <SYS/SYS_Math.h>
#include <string>
#include <typeinfo>

SWIGOUT(%rename(EnumValue) HOM_EnumValue;)

class HOM_API HOM_EnumValue
{
public:
    SWIGOUT(%ignore HOM_EnumValue;)
    SWIGOUT(%ignore ~HOM_EnumValue;)

    // The id is a unique id for this enumeration value with its set of values.
    // We use the type info to quickly compare two enum values to make sure
    // they're from the same set of values.  We use repr for the __repr__
    // method (unfortunately, type_info.name() varies between platforms,
    // contains mangling information, and contains the "HOM_" prefix).  We
    // assume that repr is a string constant (we don't store a deep copy).
    // We similarly use name to hold the name of this particular enum value.
    HOM_EnumValue(const std::type_info& enum_class, const char *repr,
                  const char *name, int id)
    : myEnumClass(enum_class), myRepr(repr), myName(name), myId(id)
    {}

    // Swig doesn't properly let you ignore only one overloaded operator==.
    // So, the methods wrapped by swig for Python are named __eq__.
    bool __eq__(HOM_PtrOrNull<HOM_EnumValue> value)
    { return value.myPointer && *this == *value.myPointer; }

    bool __ne__(HOM_PtrOrNull<HOM_EnumValue> value)
    { return !__eq__(value); }

    std::string __repr__()
    { return myRepr; }

    int __hash__()
    { return (int)SYSmultiplicative_inthash(myId); }

    std::string name()
    { return myName; }

    // These methods are used by the implementation and are not wrapped by
    // swig.
    SWIGOUT(%ignore operator==;)
    bool operator==(const HOM_EnumValue &value) const
    { return myEnumClass == value.myEnumClass && myId == value.myId; }

    SWIGOUT(%ignore operator!=;)
    bool operator!=(const HOM_EnumValue &value) const
    { return myEnumClass != value.myEnumClass || myId != value.myId; }

    SWIGOUT(%ignore enumClass;)
    const std::type_info &enumClass()
    { return myEnumClass; }

    SWIGOUT(%ignore id;)
    int id()
    { return myId; }

private:
    HOM_EnumValue(const HOM_EnumValue &); // unimplemented
    HOM_EnumValue &operator=(const HOM_EnumValue &); // unimplemented

    const std::type_info &myEnumClass;
    const char *myRepr;
    const char *myName;
    const int myId;
};


// Use the HOM_DECLARE_ENUM_MODULE macro to declare an enumeration module
// class in the header file.
//     HOM_DEFINE_ENUM_MODULE(enum_module, num_values, values_list)
//     - enum_module is the name of the module (without the HOM_) prefix.
//     - values_list is a comma-separated list of the enumeration values
//       (set this in a define)
//     - num_values is the number of enumeration values
// Use HOM_DEFINE_ENUM_MODULE to define its contents in the .C file.  It
// takes the same parameters.

// This pair of macros is used to build the class definition for the
// enumeration module.
#define HOM_DECLARE_ENUM_MODULE_START(enum_module) \
    SWIGOUT(%nodefaultctor HOM_ ## enum_module;) \
    SWIGOUT(%rename(enum_module) HOM_ ## enum_module;) \
    class HOM_API HOM_ ## enum_module \
    { \
    public:
#define HOM_DECLARE_ENUM_MODULE_END \
    }; \

#ifndef SWIG
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp>
#include <boost/preprocessor/tuple/rem.hpp>
#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/stringize.hpp>

// For an enum value, we declare a static const HOM_EnumValue member.
// (It will be initialized with the HOM_DEFINE_ENUM_* macros).  For
// each "Foo" enum value we also declare a "Foo_Id" constant.  This constant
// is used so we can use enum values in switch statements in C++.  It doesn't
// need a definition because it's a static const int that's initialized
// inside the class declaration.
//
// r will be the iteration value (plus 1, for some reason).  We use it
// to give each enumeration value a unique id number.
#define HOM_DECLARE_ENUM_VALUE(r, unused_data, elem) \
    static HOM_EnumValue elem; \
    static const int BOOST_PP_CAT(elem, _Id) = BOOST_PP_DEC(r);

// Call HOM_DECLARE_ENUM_VALUE for each enumeration value in the sequence.
// The whole thing is wrapped in the class definition.
#define HOM_DECLARE_ENUM_MODULE_FROM_SEQ(enum_module, values_seq) \
    HOM_DECLARE_ENUM_MODULE_START(enum_module) \
    BOOST_PP_SEQ_FOR_EACH(HOM_DECLARE_ENUM_VALUE, _, values_seq) \
    HOM_DECLARE_ENUM_MODULE_END

// We wrap the comma-separated tuples of values in () to build what the boost
// preprocessor calls a tuple.  We then convert that to a boost sequence
// and call the above macro.  This macro is more convenient to use than the
// one above, though you might need to use the one above if you hit boost's
// maximum tuple size.
#define HOM_DECLARE_ENUM_MODULE(enum_module, num_values, values_tuple) \
    HOM_DECLARE_ENUM_MODULE_FROM_SEQ(enum_module, \
        BOOST_PP_TUPLE_TO_SEQ(num_values, (values_tuple)))


// For each enum value we provide the definition of the static member variable,
// passing the enum class's type_info, the enum value's repr string, and
// the enum value's id into the constructor.
#define HOM_DEFINE_ENUM_VALUE(r, enum_module, elem) \
    HOM_EnumValue BOOST_PP_CAT(HOM_, enum_module)::elem \
        (typeid(BOOST_PP_CAT(HOM_, enum_module)), \
         BOOST_PP_STRINGIZE(enum_module) "." BOOST_PP_STRINGIZE(elem), \
         BOOST_PP_STRINGIZE(elem), \
         BOOST_PP_DEC(r));

// The .C file contains all the definitions for the static member variables.
#define HOM_DEFINE_ENUM_MODULE_FROM_SEQ(enum_module, values_seq) \
    BOOST_PP_SEQ_FOR_EACH(HOM_DEFINE_ENUM_VALUE, enum_module, values_seq)

#define HOM_DEFINE_ENUM_MODULE(enum_module, num_values, values_tuple) \
    HOM_DEFINE_ENUM_MODULE_FROM_SEQ(enum_module, \
        BOOST_PP_TUPLE_TO_SEQ(num_values, (values_tuple)))

#else // SWIG

// Swig can't handle boost's proprocessor macros, so we create a simple
// class for swig to wrap that just contains static HOM_EnumValue members.
// Because values_tuple is a comma-separated list, we don't need any boost
// preprocessor stuff.
#define HOM_DECLARE_ENUM_MODULE(enum_module, num_values, values_tuple) \
    HOM_DECLARE_ENUM_MODULE_START(enum_module) \
    static const HOM_EnumValue values_tuple; \
    HOM_DECLARE_ENUM_MODULE_END

#endif // SWIG

#endif

---