From 1dad5b5aaa139993fe19e266d08dfc55844e6804 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 12 Jan 2013 23:38:03 +0000 Subject: Remove Raul::SharedPtr and switch to std::shared_ptr. Use project local short type aliases for shared_ptr and friends. Move Raul::Disposable and Raul::Manageable into Raul::Maid. Use sets to store machina nodes and edges to avoid O(n) searches. git-svn-id: http://svn.drobilla.net/lad/trunk/machina@4939 a436a847-0d15-0410-975c-d299462d15a1 --- src/engine/machina/Context.hpp | 2 +- src/engine/machina/Controller.hpp | 22 ++++++++-------- src/engine/machina/Driver.hpp | 16 ++++++------ src/engine/machina/Engine.hpp | 38 ++++++++++++++-------------- src/engine/machina/Evolver.hpp | 19 +++++++------- src/engine/machina/Loader.hpp | 5 ++-- src/engine/machina/Machine.hpp | 53 +++++++++++++++++++-------------------- src/engine/machina/Updates.hpp | 17 ++++++------- src/engine/machina/types.hpp | 26 +++++++++++++++++++ 9 files changed, 111 insertions(+), 87 deletions(-) (limited to 'src/engine/machina') diff --git a/src/engine/machina/Context.hpp b/src/engine/machina/Context.hpp index 8f86602..8195a0e 100644 --- a/src/engine/machina/Context.hpp +++ b/src/engine/machina/Context.hpp @@ -18,8 +18,8 @@ #ifndef MACHINA_CONTEXT_HPP #define MACHINA_CONTEXT_HPP +#include "machina/types.hpp" #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" #include "raul/TimeSlice.hpp" namespace Machina { diff --git a/src/engine/machina/Controller.hpp b/src/engine/machina/Controller.hpp index ddd1d4c..eb04c59 100644 --- a/src/engine/machina/Controller.hpp +++ b/src/engine/machina/Controller.hpp @@ -22,8 +22,8 @@ #include -#include "raul/SharedPtr.hpp" #include "raul/RingBuffer.hpp" +#include "raul/Maid.hpp" #include "machina/types.hpp" #include "machina/URIs.hpp" @@ -31,7 +31,7 @@ #include "Stateful.hpp" namespace Raul { -class Atom; class Maid; +class Atom; } namespace Machina { @@ -47,7 +47,7 @@ class ClientModel; class ClientObject; class Controller { public: - Controller(SharedPtr engine, Client::ClientModel& client_model); + Controller(SPtr engine, Client::ClientModel& client_model); uint64_t create(const Client::ClientObject& obj); uint64_t connect(uint64_t tail_id, uint64_t head_id); @@ -56,32 +56,32 @@ public: URIInt key, const Raul::Atom& value); - void learn(SharedPtr maid, uint64_t node_id); + void learn(SPtr maid, uint64_t node_id); void disconnect(uint64_t tail_id, uint64_t head_id); void erase(uint64_t id); - void announce(SharedPtr machine); + void announce(SPtr machine); void process_updates(); private: - SharedPtr find(uint64_t id); + SPtr find(uint64_t id); struct StatefulComparator { - inline bool operator()(SharedPtr lhs, - SharedPtr rhs) const { + inline bool operator()(SPtr lhs, + SPtr rhs) const { return lhs->id() < rhs->id(); } }; - typedef std::set, StatefulComparator> Objects; + typedef std::set, StatefulComparator> Objects; Objects _objects; - SharedPtr _engine; + SPtr _engine; Client::ClientModel& _client_model; - SharedPtr _updates; + SPtr _updates; }; } diff --git a/src/engine/machina/Driver.hpp b/src/engine/machina/Driver.hpp index 778fd22..ea0bf8f 100644 --- a/src/engine/machina/Driver.hpp +++ b/src/engine/machina/Driver.hpp @@ -32,22 +32,22 @@ class Driver : public MIDISink { public: - Driver(Raul::Forge& forge, SharedPtr machine) + Driver(Raul::Forge& forge, SPtr machine) : _forge(forge) , _machine(machine) {} virtual ~Driver() {} - SharedPtr machine() { return _machine; } + SPtr machine() { return _machine; } - virtual void set_machine(SharedPtr machine) { + virtual void set_machine(SPtr machine) { _machine = machine; } - SharedPtr update_sink() { return _updates; } + SPtr update_sink() { return _updates; } - void set_update_sink(SharedPtr b) { + void set_update_sink(SPtr b) { _updates = b; } @@ -65,9 +65,9 @@ public: virtual void finish_record() {} protected: - Raul::Forge& _forge; - SharedPtr _machine; - SharedPtr _updates; + Raul::Forge& _forge; + SPtr _machine; + SPtr _updates; }; } // namespace Machina diff --git a/src/engine/machina/Engine.hpp b/src/engine/machina/Engine.hpp index 7040082..1c8d6ae 100644 --- a/src/engine/machina/Engine.hpp +++ b/src/engine/machina/Engine.hpp @@ -23,8 +23,8 @@ #include #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" +#include "machina/types.hpp" #include "machina/Driver.hpp" #include "machina/Loader.hpp" @@ -35,26 +35,26 @@ class Machine; class Engine { public: - Engine(Raul::Forge& forge, - SharedPtr driver, - Sord::World& rdf_world); + Engine(Raul::Forge& forge, + SPtr driver, + Sord::World& rdf_world); Sord::World& rdf_world() { return _rdf_world; } - static SharedPtr new_driver(Raul::Forge& forge, - const std::string& name, - SharedPtr machine); + static SPtr new_driver(Raul::Forge& forge, + const std::string& name, + SPtr machine); - SharedPtr driver() { return _driver; } - SharedPtr machine() { return _driver->machine(); } - Raul::Forge& forge() { return _forge; } + SPtr driver() { return _driver; } + SPtr machine() { return _driver->machine(); } + Raul::Forge& forge() { return _forge; } - SharedPtr load_machine(const Glib::ustring& uri); - SharedPtr load_machine_midi(const Glib::ustring& uri, - double q, - Raul::TimeDuration dur); + SPtr load_machine(const Glib::ustring& uri); + SPtr load_machine_midi(const Glib::ustring& uri, + double q, + Raul::TimeDuration dur); - void import_machine(SharedPtr machine); + void import_machine(SPtr machine); void export_midi(const Glib::ustring& filename, Raul::TimeDuration dur); @@ -63,10 +63,10 @@ public: void set_quantization(double beat_fraction); private: - SharedPtr _driver; - Sord::World& _rdf_world; - Loader _loader; - Raul::Forge _forge; + SPtr _driver; + Sord::World& _rdf_world; + Loader _loader; + Raul::Forge _forge; }; } // namespace Machina diff --git a/src/engine/machina/Evolver.hpp b/src/engine/machina/Evolver.hpp index 1aec3e8..7c5504e 100644 --- a/src/engine/machina/Evolver.hpp +++ b/src/engine/machina/Evolver.hpp @@ -19,7 +19,7 @@ #define MACHINA_EVOLVER_HPP #include "eugene/GAImpl.hpp" -#include "raul/SharedPtr.hpp" +#include "machina/types.hpp" #include "raul/Thread.hpp" #include "raul/TimeStamp.hpp" @@ -39,23 +39,24 @@ class Evolver : public Raul::Thread { public: - Evolver(Raul::TimeUnit unit, const string& target_midi, - SharedPtr seed); + Evolver(Raul::TimeUnit unit, + const string& target_midi, + SPtr seed); - void seed(SharedPtr parent); + void seed(SPtr parent); bool improvement() { return _improvement; } - SharedPtr best() { return _ga->best(); } + SPtr best() { return _ga->best(); } typedef Eugene::GAImpl MachinaGA; private: void _run(); - SharedPtr _ga; - SharedPtr _problem; - float _seed_fitness; - Schrodinbit _improvement; + SPtr _ga; + SPtr _problem; + float _seed_fitness; + Schrodinbit _improvement; }; } // namespace Machina diff --git a/src/engine/machina/Loader.hpp b/src/engine/machina/Loader.hpp index f97618a..665f7b7 100644 --- a/src/engine/machina/Loader.hpp +++ b/src/engine/machina/Loader.hpp @@ -20,9 +20,8 @@ #include +#include "machina/types.hpp" #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" - #include "sord/sordmm.hpp" using Sord::Namespaces; @@ -36,7 +35,7 @@ class Loader public: Loader(Raul::Forge& forge, Sord::World& rdf_world); - SharedPtr load(const Glib::ustring& filename); + SPtr load(const Glib::ustring& filename); private: Raul::Forge& _forge; diff --git a/src/engine/machina/Machine.hpp b/src/engine/machina/Machine.hpp index acfc599..1a8f267 100644 --- a/src/engine/machina/Machine.hpp +++ b/src/engine/machina/Machine.hpp @@ -19,15 +19,13 @@ #define MACHINA_MACHINE_HPP #include +#include #include +#include "machina/types.hpp" #include "raul/Atom.hpp" -#include "raul/Maid.hpp" #include "raul/RingBuffer.hpp" -#include "raul/SharedPtr.hpp" #include "raul/TimeSlice.hpp" -#include "raul/WeakPtr.hpp" - #include "sord/sordmm.hpp" #include "types.hpp" @@ -61,49 +59,50 @@ public: bool is_finished() { return _is_finished; } bool is_activated() { return _is_activated; } - void add_node(SharedPtr node); - void remove_node(SharedPtr node); - void learn(SharedPtr maid, SharedPtr node); + void add_node(SPtr node); + void remove_node(SPtr node); + void learn(SPtr maid, SPtr node); void write_state(Sord::Model& model); // Audio context void reset(MIDISink* sink, Raul::TimeStamp time); - uint32_t run(Context& context, SharedPtr updates); + uint32_t run(Context& context, SPtr updates); // Any context inline Raul::TimeStamp time() const { return _time; } - SharedPtr pending_learn() { return _pending_learn; } - void clear_pending_learn() { _pending_learn.reset(); } + SPtr pending_learn() { return _pending_learn; } + void clear_pending_learn() { _pending_learn.reset(); } - typedef std::list< SharedPtr > Nodes; + typedef std::set< SPtr > Nodes; Nodes& nodes() { return _nodes; } const Nodes& nodes() const { return _nodes; } - SharedPtr random_node(); - SharedPtr random_edge(); + SPtr random_node(); + SPtr random_edge(); private: // Audio context - SharedPtr earliest_node() const; + SPtr earliest_node() const; + + bool enter_node(Context& context, + SPtr node, + SPtr updates); - bool enter_node(Context& context, - SharedPtr node, - SharedPtr updates); + void exit_node(Context& context, + SPtr node, + SPtr updates); - void exit_node(Context& context, - SharedPtr node, - SharedPtr updates); + static const size_t MAX_ACTIVE_NODES = 128; - static const size_t MAX_ACTIVE_NODES = 128; - std::vector< SharedPtr > _active_nodes; + std::vector< SPtr > _active_nodes; - SharedPtr _pending_learn; - Nodes _nodes; - Raul::TimeStamp _time; - bool _is_activated; - bool _is_finished; + SPtr _pending_learn; + Nodes _nodes; + Raul::TimeStamp _time; + bool _is_activated; + bool _is_finished; }; } // namespace Machina diff --git a/src/engine/machina/Updates.hpp b/src/engine/machina/Updates.hpp index d2947e7..cf29886 100644 --- a/src/engine/machina/Updates.hpp +++ b/src/engine/machina/Updates.hpp @@ -21,7 +21,6 @@ #include #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" #include "machina/types.hpp" @@ -32,16 +31,16 @@ enum UpdateType { }; void -write_set(SharedPtr buf, - uint64_t subject, - URIInt key, - const Raul::Atom& value); +write_set(SPtr buf, + uint64_t subject, + URIInt key, + const Raul::Atom& value); uint32_t -read_set(SharedPtr buf, - uint64_t* subject, - URIInt* key, - Raul::Atom* value); +read_set(SPtr buf, + uint64_t* subject, + URIInt* key, + Raul::Atom* value); } // namespace Machina diff --git a/src/engine/machina/types.hpp b/src/engine/machina/types.hpp index 7603d3c..d71e144 100644 --- a/src/engine/machina/types.hpp +++ b/src/engine/machina/types.hpp @@ -18,6 +18,8 @@ #ifndef MACHINA_TYPES_HPP #define MACHINA_TYPES_HPP +#include + #include "raul/RingBuffer.hpp" namespace Machina { @@ -28,6 +30,30 @@ typedef Raul::RingBuffer UpdateBuffer; typedef uint32_t URIInt; +template +using SPtr = std::shared_ptr; + +template +using WPtr = std::weak_ptr; + +template +void NullDeleter(T* ptr) {} + +template +SPtr static_ptr_cast(const SPtr& r) { + return std::static_pointer_cast(r); +} + +template +SPtr dynamic_ptr_cast(const SPtr& r) { + return std::dynamic_pointer_cast(r); +} + +template +SPtr const_ptr_cast(const SPtr& r) { + return std::const_pointer_cast(r); +} + } // namespace Machina #endif // MACHINA_TYPES_HPP -- cgit v1.2.1