mootEnum.h

Go to the documentation of this file.

/* -*- Mode: C++ -*- */

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2003-2017 by Bryan Jurish <moocow@cpan.org>

   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 3 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 USA
*/

/*============================================================================
 * File: mootEnum.h
 * Author:  Bryan Jurish <moocow@cpan.org>
 * Description:
 *    Templates & classes for runtime enumerations (Identifier<->unsigned maps)
 *============================================================================*/

#ifndef _moot_ENUM_H
#define _moot_ENUM_H

#include <mootTypes.h>

using namespace std;
using namespace moot_STL_NAMESPACE;

typedef moot::UInt mootEnumID;

const mootEnumID mootEnumNone = 0;

template <class NameType,
          class NameHashFcn  = moot_hash <NameType>,
          class NameEqualFcn = equal_to <NameType>  >
class mootEnum {
public:
  //------ public typedefs
  typedef hash_map<NameType,mootEnumID,NameHashFcn,NameEqualFcn> Name2IdMap;

  typedef vector<NameType>                                       Id2NameMap;

public:
  //------ public data
  Name2IdMap names2ids;  
  Id2NameMap ids2names;  

public:
  mootEnum(void)
  {
    unknown_name(NameType());
  };
  
  mootEnum(const NameType &unknownName)
  {
    unknown_name(unknownName);
  };

  ~mootEnum(void)
  {
    /*clear();*/
  };

  //------ access
  inline void unknown_name(const NameType &name)
  {
    if (ids2names.empty()) ids2names.resize(1);
    ids2names[0]    = name;
    names2ids[name] = 0;
  };

  //------ sanity checking
  inline bool nameExists(const NameType &name) const
  {
    return names2ids.find(name) != names2ids.end();
  };

  inline bool idExists(const mootEnumID id) const
  {
    return id && ids2names.size() > id;
  };


  //------ access
  inline mootEnumID size(void) const
  {
    return ids2names.size();
  };

  inline mootEnumID name2id(const NameType &name) const
  {
    typename Name2IdMap::const_iterator i = names2ids.find(name);
    return i == names2ids.end() ? 0 : i->second;
  };

  inline const NameType &id2name(const mootEnumID id) const
  {
    return ids2names.size() <= id ? ids2names[0] : ids2names[id];
  };

  //------ manipulation

  inline mootEnumID insert(const NameType &name, mootEnumID id=0)
  {
    if (!id) id = ids2names.size();
    if (ids2names.size() <= id) ids2names.resize(id+1);
    ids2names[id] = name;
    names2ids[name] = id;
    return id;
  };

  inline void remove(const NameType &name, mootEnumID id=mootEnumNone)
  {
    names2ids.erase(name);
    if (id != mootEnumNone) ids2names[id] = ids2names[mootEnumNone];
  };

  inline void remove(mootEnumID id)
  {
    remove(ids2names[id],id);
  };


  inline mootEnumID get_id(const NameType &name)
  {
    typename Name2IdMap::const_iterator i = names2ids.find(name);
    return i == names2ids.end() ? insert(name,0) : i->second;
  };

  inline void clear(void)
  {
    names2ids.clear();
    //--
    ids2names.resize(1); //-- keep "unknown" name
    //--
    //ids2names.clear();     //-- clear *everything*
  };

  void resize(size_t newsize)
  {
    if (newsize < 1) newsize=1;  //-- minimum size = 1 (always keep "unknown")
    if (newsize > size()) {      //-- grow (only ids2names)
      ids2names.resize(newsize);
    }
    else if (newsize < size()) { //-- shrink
      for (mootEnumID id = newsize; id < size(); id++) {
        names2ids.erase(ids2names[id]);
      }
      ids2names.resize(newsize);
    }
  };
};

#endif /* _moot_ENUM_H */