MethodSet.h

Go to the documentation of this file.

#ifndef PMPL_METHOD_SET_H_
#define PMPL_METHOD_SET_H_
 
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <string>
 
#include <boost/mpl/list.hpp>
#include <boost/mpl/next_prior.hpp>
 
#include "IOUtils.h"
#include "XMLNode.h"
 
class MPLibrary;
 
 
template <typename Method>
struct MethodFactory final {
 
 
  typedef std::shared_ptr<Method> OwningPointer;
 
 
  OwningPointer operator()(XMLNode& _node) const {
    return OwningPointer(new Method(_node));
  }
 
 
};
 
 
template <typename Method>
class MethodSet final {
 
  public:
 
 
    typedef Method*                                       MethodPointer;
    typedef std::shared_ptr<Method>                       OwningPointer;
    typedef typename std::map<std::string, OwningPointer> MethodMap;
 
    typedef std::function<OwningPointer(XMLNode&)>        FactoryType;
    typedef typename std::map<std::string, FactoryType>   FactoryMap;
 
    typedef typename MethodMap::iterator                  iterator;
    typedef typename MethodMap::const_iterator            const_iterator;
 
 
    template <typename MethodTypeList>
    MethodSet(MPLibrary* const _p, const MethodTypeList& _mtl,
        const std::string& _name);
 
 
    void ParseXML(XMLNode& _node);
 
    void AddMethod(XMLNode& _node);
 
    void AddMethod(MethodPointer _e, const std::string& _label);
 
    void AddMethod(OwningPointer _e, const std::string& _label);
 
    MethodPointer GetMethod(const std::string& _label);
 
    void Initialize();
 
    void Print(std::ostream& _os) const;
 
 
    iterator begin() noexcept;
    iterator end() noexcept;
    const_iterator begin() const noexcept;
    const_iterator end() const noexcept;
 
 
  private:
 
 
    template <typename First, typename Last>
    void AddToUniverse(First, Last);
 
    template <typename Last>
    void AddToUniverse(Last, Last);
 
 
    MPLibrary* const m_library; 
 
    std::string m_name;     
 
    FactoryMap m_universe;  
    MethodMap m_elements;   
 
 
};
 
/*------------------------------- Method Set ---------------------------------*/
 
template <typename Method>
template <typename MethodTypeList>
MethodSet<Method>::
MethodSet(MPLibrary* const _p, const MethodTypeList& _mtl,
    const std::string& _name) : m_library(_p), m_name(_name) {
  AddToUniverse(typename boost::mpl::begin<MethodTypeList>::type(),
                typename boost::mpl::end<MethodTypeList>::type());
}
 
 
template <typename Method>
void
MethodSet<Method>::
ParseXML(XMLNode& _node) {
  for(auto& child : _node)
    AddMethod(child);
}
 
 
template <typename Method>
void
MethodSet<Method>::
AddMethod(XMLNode& _node) {
  auto iter = m_universe.find(_node.Name());
 
  // Skip if method isn't in universe.
  if(iter == m_universe.end())
    return;
 
  OwningPointer e = iter->second(_node);
  AddMethod(e, e->m_label);
}
 
 
template <typename Method>
void
MethodSet<Method>::
AddMethod(MethodPointer _e, const std::string& _label) {
  AddMethod(OwningPointer(_e), _label);
}
 
 
template <typename Method>
void
MethodSet<Method>::
AddMethod(OwningPointer _e, const std::string& _label) {
  auto iter = m_universe.find(_e->m_name);
 
  // Throw exception if method isn't in universe.
  if(iter == m_universe.end())
    throw ParseException(WHERE) << "Method set '" << m_name << "' has no "
                                << "method type '" << _e->m_name << "'.";
  // Also throw if the label already exists.
  if(m_elements.count(_label))
    throw ParseException(WHERE) << "Method set '" << m_name << "' already has "
                                << "label '" << _label << "'.";
  // And also for empty labels.
  if(_label.empty())
    throw ParseException(WHERE) << "Method label cannot be empty.";
 
  _e->SetMPLibrary(m_library);
  _e->SetLabel(_label);
  m_elements[_label] = _e;
}
 
 
template <typename Method>
typename MethodSet<Method>::MethodPointer
MethodSet<Method>::
GetMethod(const std::string& _label) {
  // Find the method and ensure it exists.
  auto iter = m_elements.find(_label);
 
  if(iter == m_elements.end()) {
    std::ostringstream choices;
    Print(choices);
    throw RunTimeException(WHERE) << "Method '" << _label << "' does not exist "
                                  << "in set " << m_name << "."
                                  << choices.str();
  }
 
  return iter->second.get();
}
 
 
template <typename Method>
void
MethodSet<Method>::
Initialize() {
  for(auto& elem : m_elements)
    elem.second->Initialize();
}
 
 
template <typename Method>
void
MethodSet<Method>::
Print(std::ostream& _os) const {
  size_t count = 0;
 
  _os << "\n" << m_name << " has these methods available:";
  for(const auto& elem : m_elements)
    _os << "\n\t"
        << ++count << ") '" << elem.first << "' (" << elem.second->m_name << ")";
  _os << std::endl;
}
 
/*--------------------------------- Iteration --------------------------------*/
 
template <typename Method>
inline
typename MethodSet<Method>::iterator
MethodSet<Method>::
begin() noexcept {
  return m_elements.begin();
}
 
 
template <typename Method>
inline
typename MethodSet<Method>::iterator
MethodSet<Method>::
end() noexcept {
  return m_elements.end();
}
 
 
template <typename Method>
inline
typename MethodSet<Method>::const_iterator
MethodSet<Method>::
begin() const noexcept {
  return m_elements.begin();
}
 
 
template <typename Method>
inline
typename MethodSet<Method>::const_iterator
MethodSet<Method>::
end() const noexcept {
  return m_elements.end();
}
 
/*-------------------------- Initialization Helpers --------------------------*/
 
template <typename Method>
template <typename First, typename Last>
void
MethodSet<Method>::
AddToUniverse(First, Last) {
  using FirstType = typename boost::mpl::deref<First>::type;
  FirstType first;
  m_universe[first.m_name] = MethodFactory<FirstType>();
  AddToUniverse(typename boost::mpl::next<First>::type(), Last());
}
 
 
template <typename Method>
template <typename Last>
void
MethodSet<Method>::
AddToUniverse(Last, Last) {}
 
/*----------------------------------------------------------------------------*/
 
#endif