NameSelector.h

Go to the documentation of this file.

#ifndef TEST_GEOMETRY_NAMESELECTOR_H
#define TEST_GEOMETRY_NAMESELECTOR_H 1

// C/C++ standard library
#include <string>
#include <set>
#include <map>
#include <ostream>
#include <initializer_list>

// ... and more in the template implementation section below

namespace testing {
  
  class NameSelector {
    
      public:
    using Name_t = std::string; 
    using Names_t = std::set<Name_t>; 
    
    typedef enum {
      rsRejected,   
      rsAccepted,   
      rsThrow,      
      rsDefault = rsAccepted
    } Response_t;
    
    
    using NameList = std::initializer_list<Name_t>;
    
    
    NameSelector(Response_t default_answer = rsDefault)
      { SetDefaultResponse(default_answer); }
    
    template <typename LIST>
    NameSelector(LIST const& items, Response_t default_answer = rsDefault)
      : NameSelector(default_answer)
      { Parse(items); }
    
    void SetDefaultResponse(Response_t default_answer)
      { known_names[DefaultName] = { default_answer }; }
    
    template <typename LIST>
    void Parse(LIST const& items) { BuildNameSet(known_names, items); }
    
    
    void ParseName(Name_t name);
    
    template <typename... NAMES>
    void ParseNames(NAMES... names) { AddFirstName(known_names, names...); }
    
    void Clear() { ClearNameSet(known_names); }
    
    template <typename LIST>
    void Define(std::string set_name, LIST const& items);
    
    template <typename... NAMES>
    void AddToDefinition(std::string set_name, NAMES... names)
      { AddFirstName(definitions[set_name], names...);  }
    
    Response_t Query(Name_t name) const;
    
    bool Accepted(Name_t name) const;
    
    bool Rejected(Name_t name) const { return !Accepted(name); }
    
    Response_t DefaultResponse() const
      { return known_names.find(DefaultName)->second.response; }
    
    bool operator() (Name_t name) const { return Accepted(name); }
    
    void PrintConfiguration(std::ostream&) const;
    
    Names_t AcceptedNames() const { return QueriedWithStatus(rsAccepted); }
    
    Names_t RejectedNames() const { return QueriedWithStatus(rsRejected); }
    
    void ClearQueryRegistry() { query_registry.clear(); }
    
    bool CheckQueryRegistry() const { return DoCheckQueryRegistry(); }
    bool CheckQueryRegistry(std::ostream& out) const
      { return DoCheckQueryRegistry(&out); }
    
    
    static Name_t const DefaultName; 
    static Name_t const ClearAllName; 
    
      protected:
    
    typedef struct {
      Response_t response; 
    } NameResponse_t;
    
    using KnownNames_t = std::map<Name_t, NameResponse_t>;
    
    using Definitions_t = std::map<Name_t, KnownNames_t>;
    
    using QueryRegistry_t = std::map<Name_t, size_t>;
    
    KnownNames_t known_names; 
    
    Definitions_t definitions; 
    
    mutable QueryRegistry_t query_registry; 
    
    Response_t LookupResponse(Name_t name) const;
    
    template <typename LIST>
    void BuildNameSet(KnownNames_t& name_set, LIST const& items) const;
    
    template <typename... NAMES>
    void AddFirstName
      (KnownNames_t& name_set, Name_t name, NAMES... other_names);
    
    void InsertItem
      (KnownNames_t& name_set, Name_t item, Response_t response) const;
    
    void InsertItem(
      KnownNames_t& name_set, KnownNames_t::value_type item,
      Response_t response
      ) const;
    
    void ProcessItem(KnownNames_t& name_set, Name_t item) const;
    
    Definitions_t::const_iterator FindDefinition(Name_t& item) const;
    
    void ClearNameSet(KnownNames_t& name_set) const;
    
    Names_t QueriedWithStatus(Response_t answer) const;
    
    // Performs the actual registry check, optionally printing a message
    bool DoCheckQueryRegistry(std::ostream* out = nullptr) const;
    
    static Response_t ParseMode
      (Name_t& item, Response_t default_answer = rsAccepted);
    
  }; // class NameSelector
  
} // namespace testing


//------------------------------------------------------------------------------
//--- Template implementation
//---

// C/C++ standard library
#include <utility> // std::move()

//------------------------------------------------------------------------------
template <typename LIST>
void testing::NameSelector::Define(std::string set_name, LIST const& items) {
  KnownNames_t name_set;
  BuildNameSet(name_set, items);
  definitions[set_name] = std::move(name_set);
} // testing::NameSelector::Define()


//------------------------------------------------------------------------------
template <typename LIST>
void testing::NameSelector::BuildNameSet
  (KnownNames_t& name_set, LIST const& items) const
{
  for (Name_t item: items) ProcessItem(name_set, item);
} // testing::NameSelector::BuildNameSet()


//------------------------------------------------------------------------------
namespace testing {
  // forward declaration of specialization
  template <>
  void NameSelector::AddFirstName<>(KnownNames_t& name_set, Name_t name);
} // namespace testing

template <typename... NAMES>
void testing::NameSelector::AddFirstName
  (KnownNames_t& name_set, Name_t name, NAMES... other_names)
{
  AddFirstName(name_set, name);
  AddFirstName(name_set, other_names...);
} // testing::NameSelector::AddFirstName()


//------------------------------------------------------------------------------

#endif // TEST_GEOMETRY_NAMESELECTOR_H