FTransformAgent.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __FTransformAgent_h_
#define __FTransformAgent_h_
 
#include "FTransformPlan.h"
#include "ThreadContext.h"
 
namespace FTransform {

  class Agent : public Reference::Able {
 
  public:
 
    Agent();
 
    virtual ~Agent();

    std::string name;

    normalization norm;

    virtual Plan* get_plan (size_t nfft, type call) = 0;

    virtual Plan2* get_plan2 (size_t nx, size_t ny, type call) = 0;

    virtual void clean_plans () = 0;

    static unsigned get_num_libraries ()
    { return libraries.size(); }

    static std::string get_library_name (unsigned i) 
    { return libraries[i]->name; }

    static void set_library (const std::string& name);

    static Reference::To<Agent> current;

    static ThreadContext* context;
 
  protected:

    void add ();
 
  private:

    static std::vector< Reference::To<Agent> > libraries;
 
    friend void set_library (const std::string& name);
    friend void clean_plans();
 
  };
 


 
  template <class Library>
  class PlanAgent : public Agent {
 
  public:

    PlanAgent (const std::string& name, normalization norm);

    typename Library::Plan* get_plan (size_t nfft, type call);

    typename Library::Plan2* get_plan2 (size_t nx, size_t ny, type call);

    void clean_plans ();

    static void enlist ();
 
  protected:

    std::vector< Reference::To<typename Library::Plan> > plans;

    std::vector< Reference::To<typename Library::Plan2> > plans2;
 
  };

  template<class Library>
  void PlanAgent<Library>::clean_plans ()
  {
    plans.resize (0);
  }
 
  template<class Library>
  PlanAgent<Library>::PlanAgent (const std::string& _name, normalization _norm)
  {
    name = _name;
    norm = _norm;
  }
 
  template<class Library>
  typename Library::Plan*
  PlanAgent<Library>::get_plan (size_t nfft, type t)
  {
    ThreadContext::Lock lock (Agent::context);
 
    for (unsigned iplan=0; iplan<plans.size(); iplan++)
      if (plans[iplan]->matches (nfft, t))
        return plans[iplan];
    
    plans.push_back( new typename Library::Plan (nfft, t) );
    return plans.back();
  }
 
  template<class Library> 
  typename Library::Plan2* 
  PlanAgent<Library>::get_plan2 (size_t nx, size_t ny, type t)
  {
    for (unsigned iplan=0; iplan<plans2.size(); iplan++)
      if (plans2[iplan]->matches (nx, ny, t))
        return plans2[iplan];
    
    plans2.push_back( new typename Library::Plan2 (nx, ny, t) );
    return plans2.back();
    
  }
 
  template<class Library>
  void PlanAgent<Library>::enlist ()
  {
    PlanAgent<Library>* instance = new typename Library::Agent;
    instance->add();
  }
 
}
 
#endif