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 <initializer_list>
#include <iosfwd>
#include <map>
#include <set>
#include <stddef.h>
#include <string>

// ... 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