Enum.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * 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 _ENUM_H_
#define _ENUM_H_
#include <exception>
#include <iosfwd>
#include <string>
#include "Assert.hxx"
#include "Component.hxx"

namespace CLAM {

// TODO: Integrate this excepcion class with CLAM exception standards
class IllegalValue : public std::exception {
        public:
                IllegalValue(const IllegalValue & e): msg(e.msg) {};
                IllegalValue(const std::string & s) : msg(s) {};
                virtual ~IllegalValue() throw() {};
                std::string msg;
};


class Enum : public Component {

// Internal Types
public:
        typedef int tValue;
        typedef struct {tValue value; const char*name;} tEnumValue;

// Attributes
private:
        const tEnumValue * mEnumValues;
        tValue mValue;


protected:
        Enum (const tEnumValue * values, const tValue & value) /* throw IllegalValue */ {
                mEnumValues = values;
                SetValue(value);
        }
        Enum (const tEnumValue * values, const std::string & value) /* throw IllegalValue */ {
                mEnumValues = values;
                SetValue(value);
        };
public:
        virtual ~Enum ();
        const char * GetClassName() const {return NULL;}

// Operations
public:
        const tEnumValue * GetSymbolMap() const {
                return mEnumValues;
        }

        void SetValue(const tValue v) {
                CLAM_BEGIN_DEBUG_CHECK
                        for (int i = 0; mEnumValues[i].name; i++) {
                                if (v==mEnumValues[i].value) {
                                        mValue = v;
                                        return;
                                }
                        }
                        CLAM_ASSERT(false, "Invalid value for an Enum");
                CLAM_END_DEBUG_CHECK
                mValue = v; 
        }
        void SetValueSafely(const tValue v) throw (IllegalValue) {
                for (int i = 0; mEnumValues[i].name; i++) {
                        if (v==mEnumValues[i].value) {
                                mValue = v;
                                return;
                        }
                }
                throw IllegalValue("Invalid value for an Enum");
        }
        void SetValue(const std::string & s) 
        {
                for (int i = 0; mEnumValues[i].name; i++) {
                        if (s.compare(mEnumValues[i].name)==0) {
                                mValue = mEnumValues[i].value;
                                return;
                        }
                }
                CLAM_ASSERT(false, "Illegal literal for an Enum");
        }
        /*
         * Changes the value safely. 
         * That is it checks the value is ok for the enum and throws a
         * catchable exception if not.
         * @param s The new symbolic value
         * @throw IllegalValue when the value is not valid for the enum
         * @todo Fill IllegalValue with useful information to recover 
         * instead a insightfull string.
         */
        void SetValueSafely(const std::string & s) throw (IllegalValue) 
        {
                for (int i = 0; mEnumValues[i].name; i++) {
                        if (s.compare(mEnumValues[i].name)==0) {
                                mValue = mEnumValues[i].value;
                                return;
                        }
                }
                throw IllegalValue("Illegal literal for an Enum.");
        }

        tValue GetValue() const {
                return mValue;
        }

        std::string GetString() const throw (IllegalValue)
        {
                for (int i = 0; mEnumValues[i].name; i++) {
                        if (mValue==mEnumValues[i].value) 
                                return mEnumValues[i].name;
                }
                CLAM_ASSERT(false, "Illegal numeric value for an Enum");
                return "IllegalValue";
        }

        Enum & operator = (const tValue & v) throw (IllegalValue) {
                SetValue(v);
                return *this;
        }

        Enum & operator = (const std::string & v) throw (IllegalValue) {
                SetValue(v);
                return *this;
        }

        Enum & operator = (const Enum & v) throw (IllegalValue) {
                SetValue(tValue(v));
                return *this;
        }

        operator tValue() const {
                return mValue;
        }

// Component Protocol
public:
        virtual Component * Species () const = 0;

        virtual Component * DeepCopy () const {
                Enum * pe = (Enum*)Species();
                pe->SetValue(mValue);
                return pe;
        }

        virtual Component * ShallowCopy () const {
                Enum * pe = (Enum*)Species();
                pe->SetValue(mValue);
                return pe;
        }

        virtual void StoreOn (Storage & storage) const;

        virtual void LoadFrom (Storage & storage);


};

std::ostream & operator << (std::ostream & os, const Enum & e) throw (IllegalValue);

std::istream & operator >> (std::istream & os, Enum & e) throw (IllegalValue);

}
#endif // _ENUM_H_