ccstringset.hpp

Go to the documentation of this file.

//
//  stringset: string set and indexed string set
//  (C) Eric Lecolinet 2016/17 - https:www.telecom-paristech.fr/~elc
//

#ifndef __ccuty_stringset__
#define __ccuty_stringset__

#include <string>
#include <vector>
#include <initializer_list>
#include <set>
#include "ccstring.hpp"

namespace ccuty {

#if !defined(NO_STRINGIFY) && !defined(STRINGIFY)
#  define STRINGIFY(s) _STRINGIFY(s)
#  define _STRINGIFY(s...) #s
#endif


#if !defined(NO_STRING_SWITCH) && !defined(STRING_SWITCH)

#define STRING_SWITCH(str, ...) \
enum {__VA_ARGS__}; \
static const ccuty::stringset _stringset_ ## __LINE__(#__VA_ARGS__); \
switch(_stringset_ ## __LINE__[str])
#endif


  class stringset {
  public:
    struct elem {
      elem(const std::string& str, unsigned int id) : str(str), id(id) {}
      const std::string str;
      const unsigned int id;
    };
    
    struct string_comp {
      bool operator()(const elem& left, const elem& right) const {return left.str<right.str;}
    };
    
    using string_set = std::set<elem, string_comp>;

    // - - - -
    
    stringset() {}
    
    explicit stringset(const char* str) {
      std::vector<std::string> v;
      ccuty::strsplit(v, str, ",");
      append(v);
    }
    
    explicit stringset(const std::string& str) {
      std::vector<std::string> v;
      ccuty::strsplit(v, str, ",");
      append(v);
    }
    
    stringset(std::initializer_list<const char*> tokens) {
      append(tokens);
    }
    
    stringset(std::initializer_list<elem> tokens) {
      append(tokens);
    }
    
    template <typename T> explicit stringset(const T& tokens) {
      append(tokens);
    }
    
    bool empty() const {
      return elements_.empty();
    }
    
    size_t size() const {
      return elements_.size();
    }
    
    const string_set& elements() const {return elements_;}
    
    int operator[](const std::string& token) const {
      auto it = elements_.find(elem{token,0});
      return it==elements_.end() ? -1 : it->id;
    }

    int starts_with(const std::string& str) const {
      int count = 0;
      int value = -1;
      for (auto& it : elements_) {
        if (it.str.compare(0, str.length(), str) == 0) {
          if (it.str.length() == str.length()) return it.id;  // exact match
          else value = it.id;
          count++;
        }
      }
      if (count == 0) return -1;          // no match
      else if (count == 1) return value;  // one match
      else return -2;                     // multiple matches
    }
    
    void clear() {
      elements_.clear();
    }
    
    int insert(const std::string& token) {
      auto p = elements_.insert(elem{token, lastid_});
      if (p.second) lastid_++;   // not a duplicate
      return p.first->id;
    }
    
    int insert(const char* token) {
      auto p = elements_.insert(elem{token, lastid_});
      if (p.second) lastid_++;
      return p.first->id;
    }
    
    int insert(const elem& e) {
      auto p = elements_.insert(e);
      if (p.second) {
        if (e.id >= lastid_) lastid_ = e.id + 1;
        //else if (e.id < 0) p.first->id = lastid_++;
      }
      return p.first->id;
    }
    
    template <typename T> void append(const T& cont) {
      for (auto&& it : cont) insert(it);
    }
    
  protected:
    unsigned int lastid_{0};
    string_set elements_;
  };
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  class istringset : public stringset {
  public:
    struct comp_id {
      bool operator()(const elem& left, const elem& right) const {return left.id < right.id;}
    };
    using id_set = std::set<elem, comp_id>;

    static const std::string& none() {
      static std::string empty;
      return empty;
    }
    
    // - - - -

    istringset() {}

    explicit istringset(const char* str) {
      std::vector<std::string> v;
      ccuty::strsplit(v, str, ",");
      append(v);
    }
    
    explicit istringset(const std::string& str) {
      std::vector<std::string> v;
      ccuty::strsplit(v, str, ",");
      append(v);
    }
    
    explicit istringset(std::initializer_list<const char*> tokens) {
      append(tokens);
    }
    
    istringset(std::initializer_list<elem> tokens) {
      append(tokens);
    }
    
    template <typename T> explicit istringset(const T& tokens) {
      append(tokens);
    }

    const id_set& ids() const {return ids_;}
    
    int operator[](const std::string& token) const {
      return stringset::operator[](token);
    }
    
    const std::string& operator[](unsigned int id) const {
      auto it = ids_.find(elem{"", id});
      if (it==ids_.end()) return none(); else return it->str;
    }
    
    void clear() {
      elements_.clear();
      ids_.clear();
    }
    
    int insert(const std::string& token) {
      auto p = elements_.insert(elem{token, lastid_});
      if (p.second) {  // not a duplicate
        lastid_++;
        ids_.insert(*p.first);
      }
      return p.first->id;
    }
    
    int insert(const char* token) {
      auto p = elements_.insert(elem{token, lastid_});
      if (p.second) {
        lastid_++;
        ids_.insert(*p.first);
      }
      return p.first->id;
    }
    
    int insert(const elem& e) {
      auto p = elements_.insert(e);
      if (p.second) {
        if (e.id >= lastid_) lastid_ = e.id + 1;
        //else if (e.id < 0) p.first->id = lastid_++;
        ids_.insert(*p.first);
      }
      return p.first->id;
    }
    
    template <typename T> void append(const T& cont) {
      for (auto& it : cont) insert(it);
    }
    
  protected:
    id_set ids_;
  };

}
#endif