Module.hpp

Go to the documentation of this file.

#ifndef MODULE_HPP
#define MODULE_HPP
/*
This file is part of AlgAudio.

AlgAudio, Copyright (C) 2015 CeTA - Audiovisual Technology Center

AlgAudio is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

AlgAudio is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with AlgAudio.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <memory>
#include <vector>
#include <unordered_set>
#include "DynamicallyLoadableClass.hpp"
#include "Signal.hpp"
#include "Utilities.hpp"
#include "LateReturn.hpp"
#include "Timer.hpp"
// Not really needed here, but all collections need that for strcmp in 
// create instance, so including this is convinient, as all collections include
// at least Module.hpp
#include <cstring>

// Forward declaration to strip rapidxml header dependecncy
namespace rapidxml{
  template <class Ch>
  class xml_node;
}

namespace AlgAudio{

namespace Exceptions{
struct ModuleDoesNotWantToBeCreated : public Exception{
  ModuleDoesNotWantToBeCreated(std::string t) : Exception(t){};
};
} // namespace Exceptions

class ModuleTemplate;
class ParamTemplate;
class Canvas;
class ModuleGUI;
class Window;
class Module;
class ParamController;
class SendReplyController;

class Bus{
public:
  int GetID() const {return id;}
  static LateReturn<std::shared_ptr<Bus>> CreateNew();
  static std::shared_ptr<Bus> CreateFake();
  ~Bus();
private:
  Bus(int id);
  int id;
};

class Group{
public:
  int GetID() const {return id;}
  static LateReturn<std::shared_ptr<Group>> CreateNew(std::shared_ptr<Group> parent);
  static LateReturn<std::shared_ptr<Group>> CreateFake(std::shared_ptr<Group> parent);
  ~Group();
private:
  Group(int id);
  int id;
};

// =================

class Module : public DynamicallyLoadableClass, public virtual SubscriptionsManager, public std::enable_shared_from_this<Module>, public virtual TimerHandleManager{
public:

  Module() {};
  Module(void (*deleter)(void*)) : DynamicallyLoadableClass(deleter) {};
  Module(std::shared_ptr<ModuleTemplate> t) : templ(t) {};

  Module(const Module& other) = delete;
  virtual ~Module();

  virtual void on_init() {};
  virtual LateReturn<> on_init_latereturn() {
    Relay<> r;
    on_init();
    return r.Return();
  };
  virtual void on_destroy() {};
  virtual void on_gui_build(std::shared_ptr<ModuleGUI>) {};
  virtual void on_param_set(std::string, float) {}

  virtual std::string state_store_string() const {return "";}
  virtual void state_load_string(std::string) {}
  virtual void state_store_xml(rapidxml::xml_node<char>*) const {}
  virtual void state_load_xml(rapidxml::xml_node<char>*) {}

  /* The template this module instance is based on. */
  std::shared_ptr<ModuleTemplate> templ;

  int sc_id = -1;

  Point2D position_in_canvas;

  bool enabled_by_factory = false;

  class Inlet; // Forward decl

  // TODO: Common base class
  class Outlet{
  public:
    std::string id;
    std::string name;
    Module& mod;
    // The outlet is not the owner of the buses.
    std::list<std::weak_ptr<Bus>> buses;
    LateReturn<> ConnectToInlet(std::shared_ptr<Inlet> i);
    LateReturn<> DetachFromInlet(std::shared_ptr<Inlet> i);
    LateReturn<> DetachFromAll();
    static std::shared_ptr<Outlet> Create(std::string id, std::string name, std::shared_ptr<Module> mod);
    ~Outlet(){
      std::cout << "Outlet freed" << std::endl;
    }
  private:
    LateReturn<> SendConnections();
    Outlet(std::string i, std::string n, std::shared_ptr<Module> m) : id(i), name(n), mod(*m.get()) {}
  };
  class Inlet{
  public:
    // If fake is set to true, this inlet will have no corresponding bus. Pointless to use, great for debugging.
    static LateReturn<std::shared_ptr<Inlet>> Create(std::string id, std::string name, std::shared_ptr<Module> mod, bool fake = false);
    std::string id;
    std::string name;
    Module& mod;
    // The inlet is the owner of a bus.
    std::shared_ptr<Bus> bus;
  private:
    Inlet(std::string i, std::string n, std::shared_ptr<Module> m, std::shared_ptr<Bus> b) : id(i), name(n), mod(*m.get()), bus(b) {}
  };

  std::shared_ptr<ModuleGUI> GetGUI() const;

  virtual std::shared_ptr<ModuleGUI> BuildGUI(std::shared_ptr<Window> parent_window);

  void DropGUI() {modulegui.reset();}
  
  LateReturn<> CreateIOFromTemplate(bool fake = false);
  std::vector<std::shared_ptr<Inlet>> inlets;
  std::vector<std::shared_ptr<Outlet>> outlets;

  void PrepareParamControllers();

  void ResetControllers();

  // TODO: Make this a map?
  std::vector<std::shared_ptr<ParamController>> param_controllers;

  std::vector<std::shared_ptr<SendReplyController>> reply_controllers;

  std::shared_ptr<ParamController> GetParamControllerByID(std::string) const;

  std::shared_ptr<Inlet >  GetInletByID(std::string id) const;
  std::shared_ptr<Outlet> GetOutletByID(std::string id) const;

  std::weak_ptr<Canvas> canvas;
  
protected:
  std::shared_ptr<ModuleGUI> modulegui;
};

} // namespace AlgAudio

#endif //MODULE_HPP