Mixer.hpp

Go to the documentation of this file.

#ifndef MIXER_DEFINED
#define MIXER_DEFINED
 
#include <algorithms/Algorithm.hpp>
#include <math/Complex.hpp>
#include <math/FockVector.hpp>
#include <util/SharedPointer.hpp>
 
#include <string>
 
namespace sisi4s {
template <typename F>
class Mixer {
public:
  Mixer(Algorithm *algorithm);
  virtual ~Mixer();
 
  virtual std::string getName() = 0;
 
  virtual void append(const PTR(FockVector<F>) &A,
                      const PTR(FockVector<F>) &R) = 0;
 
  virtual PTR(const FockVector<F>) get() = 0;
 
  virtual PTR(const FockVector<F>) getResiduum() = 0;
 
  Algorithm *algorithm;
};
 
template <typename F>
class MixerFactory {
public:
  // FIXME: find out why typedef doesn't work in this case
  /*
      typedef std::map<
        std::string,
        std::function<Mixer<F> *(Algorithm *)>
      > MixerMap;
  */
  static PTR(Mixer<F>) create(std::string const &name, Algorithm *algorithm) {
    auto iterator(getMixerMap()->find(name));
    return iterator != getMixerMap()->end() ? iterator->second(algorithm)
                                            : PTR(Mixer<F>)();
  }
 
protected:
  static std::map<std::string,
                  std::function<PTR(Mixer<F>)(Algorithm *algorithm)>> *
  getMixerMap() {
    return mixerMap
             ? mixerMap
             : (mixerMap =
                    new std::map<std::string,
                                 std::function<PTR(Mixer<F>)(Algorithm *)>>);
  }
  static std::map<std::string, std::function<PTR(Mixer<F>)(Algorithm *)>>
      *mixerMap;
  /*
      static MixerMap *getMixerMap() {
        return mixerMap ? mixerMap : (mixerMap = new MixerMap);
      }
      static MixerMap *mixerMap;
  */
};
 
template <typename F, typename MixerType>
PTR(Mixer<F>) createMixer(Algorithm *algorithm) {
  return NEW(MixerType, algorithm);
}
 
template <typename F, typename MixerType>
class MixerRegistrar : protected MixerFactory<F> {
public:
  MixerRegistrar(std::string const &name) {
    (*MixerFactory<F>::getMixerMap())[name] = &createMixer<F, MixerType>;
  }
};
 
#define MIXER_REGISTRAR_DECLARATION(NAME)                                      \
  virtual std::string getName() { return #NAME; }                              \
  static MixerRegistrar<F, NAME<F>> registrar_
 
#define MIXER_REGISTRAR_DEFINITION(NAME)                                       \
  template <typename F>                                                        \
  MixerRegistrar<F, NAME<F>> NAME<F>::registrar_(#NAME)
} // namespace sisi4s
 
#endif