diff options
Diffstat (limited to 'src/engine')
36 files changed, 501 insertions, 487 deletions
diff --git a/src/engine/Action.hpp b/src/engine/Action.hpp index f954a39..7397eaa 100644 --- a/src/engine/Action.hpp +++ b/src/engine/Action.hpp @@ -21,9 +21,8 @@ #include <string> #include <iostream> -#include "raul/SharedPtr.hpp" +#include "raul/Maid.hpp" #include "raul/TimeSlice.hpp" -#include "raul/Manageable.hpp" #include "machina/types.hpp" @@ -35,15 +34,14 @@ namespace Machina { /** An Action, executed on entering or exiting of a state. */ struct Action - : public Raul::Manageable - , public Stateful { + : public Raul::Maid::Manageable + , public Stateful { virtual void execute(MIDISink* sink, Raul::TimeStamp time) = 0; virtual void write_state(Sord::Model& model); }; -class PrintAction - : public Action +class PrintAction : public Action { public: PrintAction(const std::string& msg) diff --git a/src/engine/ActionFactory.cpp b/src/engine/ActionFactory.cpp index 92bc114..afcc178 100644 --- a/src/engine/ActionFactory.cpp +++ b/src/engine/ActionFactory.cpp @@ -20,18 +20,18 @@ namespace Machina { -SharedPtr<Action> -ActionFactory::copy(SharedPtr<Action> copy) +SPtr<Action> +ActionFactory::copy(SPtr<Action> copy) { - SharedPtr<MidiAction> ma = PtrCast<MidiAction>(copy); + SPtr<MidiAction> ma = dynamic_ptr_cast<MidiAction>(copy); if (ma) { - return SharedPtr<Action>(new MidiAction(ma->event_size(), ma->event())); + return SPtr<Action>(new MidiAction(ma->event_size(), ma->event())); } else { - return SharedPtr<Action>(); + return SPtr<Action>(); } } -SharedPtr<Action> +SPtr<Action> ActionFactory::note_on(unsigned char note) { unsigned char buf[3]; @@ -39,10 +39,10 @@ ActionFactory::note_on(unsigned char note) buf[1] = note; buf[2] = 0x40; - return SharedPtr<Action>(new MidiAction(3, buf)); + return SPtr<Action>(new MidiAction(3, buf)); } -SharedPtr<Action> +SPtr<Action> ActionFactory::note_off(unsigned char note) { unsigned char buf[3]; @@ -50,7 +50,7 @@ ActionFactory::note_off(unsigned char note) buf[1] = note; buf[2] = 0x40; - return SharedPtr<Action>(new MidiAction(3, buf)); + return SPtr<Action>(new MidiAction(3, buf)); } } // namespace Machine diff --git a/src/engine/ActionFactory.hpp b/src/engine/ActionFactory.hpp index 1ae47c4..d273274 100644 --- a/src/engine/ActionFactory.hpp +++ b/src/engine/ActionFactory.hpp @@ -18,16 +18,16 @@ #ifndef MACHINA_ACTIONFACTORY_HPP #define MACHINA_ACTIONFACTORY_HPP -#include "raul/SharedPtr.hpp" +#include "machina/types.hpp" namespace Machina { struct Action; namespace ActionFactory { -SharedPtr<Action> copy(SharedPtr<Action> copy); -SharedPtr<Action> note_on(unsigned char note); -SharedPtr<Action> note_off(unsigned char note); +SPtr<Action> copy(SPtr<Action> copy); +SPtr<Action> note_on(unsigned char note); +SPtr<Action> note_off(unsigned char note); } } // namespace Machina diff --git a/src/engine/Controller.cpp b/src/engine/Controller.cpp index f29d10e..df60c97 100644 --- a/src/engine/Controller.cpp +++ b/src/engine/Controller.cpp @@ -27,7 +27,7 @@ namespace Machina { -Controller::Controller(SharedPtr<Engine> engine, +Controller::Controller(SPtr<Engine> engine, Client::ClientModel& client_model) : _engine(engine) , _client_model(client_model) @@ -41,8 +41,8 @@ Controller::create(const Client::ClientObject& properties) { TimeDuration dur(_engine->machine()->time().unit(), properties.get(URIs::instance().machina_duration).get_float()); - SharedPtr<Machina::Node> node(new Machina::Node(dur)); - SharedPtr<Client::ClientObject> obj( + SPtr<Machina::Node> node(new Machina::Node(dur)); + SPtr<Client::ClientObject> obj( new Client::ClientObject(properties, node->id())); _objects.insert(node); _client_model.new_object(obj); @@ -51,13 +51,13 @@ Controller::create(const Client::ClientObject& properties) } void -Controller::announce(SharedPtr<Machine> machine) +Controller::announce(SPtr<Machine> machine) { Raul::Forge& forge = _engine->forge(); for (Machina::Machine::Nodes::const_iterator n = machine->nodes().begin(); n != machine->nodes().end(); ++n) { - SharedPtr<Machina::Client::ClientObject> obj( + SPtr<Machina::Client::ClientObject> obj( new Machina::Client::ClientObject((*n)->id())); obj->set(URIs::instance().rdf_type, forge.make_urid(URIs::instance().machina_Node)); @@ -75,7 +75,7 @@ Controller::announce(SharedPtr<Machine> machine) for (Machina::Node::Edges::const_iterator e = (*n)->edges().begin(); e != (*n)->edges().end(); ++e) { _objects.insert(*e); - SharedPtr<Client::ClientObject> eobj( + SPtr<Client::ClientObject> eobj( new Client::ClientObject((*e)->id())); eobj->set(URIs::instance().rdf_type, forge.make_urid(URIs::instance().machina_Edge)); @@ -91,21 +91,21 @@ Controller::announce(SharedPtr<Machine> machine) } } -SharedPtr<Stateful> +SPtr<Stateful> Controller::find(uint64_t id) { - SharedPtr<StatefulKey> key(new StatefulKey(id)); - Objects::iterator i = _objects.find(key); + SPtr<StatefulKey> key(new StatefulKey(id)); + Objects::iterator i = _objects.find(key); if (i != _objects.end()) { return *i; } - return SharedPtr<Stateful>(); + return SPtr<Stateful>(); } void -Controller::learn(SharedPtr<Raul::Maid> maid, uint64_t node_id) +Controller::learn(SPtr<Raul::Maid> maid, uint64_t node_id) { - SharedPtr<Machina::Node> node = PtrCast<Machina::Node>(find(node_id)); + SPtr<Machina::Node> node = dynamic_ptr_cast<Machina::Node>(find(node_id)); if (node) { _engine->machine()->learn(maid, node); } else { @@ -119,7 +119,7 @@ Controller::set_property(uint64_t object_id, URIInt key, const Raul::Atom& value) { - SharedPtr<Stateful> object = find(object_id); + SPtr<Stateful> object = find(object_id); if (object) { object->set(key, value); _client_model.property(object_id, key, value); @@ -129,17 +129,16 @@ Controller::set_property(uint64_t object_id, uint64_t Controller::connect(uint64_t tail_id, uint64_t head_id) { - SharedPtr<Machina::Node> tail = PtrCast<Machina::Node>(find(tail_id)); - SharedPtr<Machina::Node> head = PtrCast<Machina::Node>(find(head_id)); + SPtr<Machina::Node> tail = dynamic_ptr_cast<Machina::Node>(find(tail_id)); + SPtr<Machina::Node> head = dynamic_ptr_cast<Machina::Node>(find(head_id)); - SharedPtr<Machina::Edge> edge(new Machina::Edge(tail, head)); + SPtr<Machina::Edge> edge(new Machina::Edge(tail, head)); tail->add_edge(edge); _objects.insert(edge); Raul::Forge& forge = _engine->forge(); - SharedPtr<Client::ClientObject> obj( - new Client::ClientObject(edge->id())); + SPtr<Client::ClientObject> obj(new Client::ClientObject(edge->id())); obj->set(URIs::instance().rdf_type, forge.make_urid(URIs::instance().machina_Edge)); obj->set(URIs::instance().machina_probability, forge.make(1.0f)); @@ -154,10 +153,10 @@ Controller::connect(uint64_t tail_id, uint64_t head_id) void Controller::disconnect(uint64_t tail_id, uint64_t head_id) { - SharedPtr<Machina::Node> tail = PtrCast<Machina::Node>(find(tail_id)); - SharedPtr<Machina::Node> head = PtrCast<Machina::Node>(find(head_id)); + SPtr<Machina::Node> tail = dynamic_ptr_cast<Machina::Node>(find(tail_id)); + SPtr<Machina::Node> head = dynamic_ptr_cast<Machina::Node>(find(head_id)); - SharedPtr<Edge> edge = tail->remove_edge_to(head); + SPtr<Edge> edge = tail->remove_edge_to(head); if (edge) { _client_model.erase_object(edge->id()); } else { @@ -168,13 +167,13 @@ Controller::disconnect(uint64_t tail_id, uint64_t head_id) void Controller::erase(uint64_t id) { - SharedPtr<StatefulKey> key(new StatefulKey(id)); + SPtr<StatefulKey> key(new StatefulKey(id)); Objects::iterator i = _objects.find(key); if (i == _objects.end()) { return; } - SharedPtr<Node> node = PtrCast<Node>(*i); + SPtr<Node> node = dynamic_ptr_cast<Node>(*i); if (node) { _engine->machine()->remove_node(node); } @@ -193,13 +192,11 @@ Controller::process_updates() Raul::Atom value; for (uint32_t i = 0; i < read_space; ) { i += read_set(_updates, &subject, &key, &value); - SharedPtr<Machina::Client::ClientObject> obj = _client_model.find( - subject); + SPtr<Machina::Client::ClientObject> obj = _client_model.find(subject); if (obj) { obj->set(key, value); } else { - SharedPtr<Client::ClientObject> obj( - new Client::ClientObject(subject)); + SPtr<Client::ClientObject> obj(new Client::ClientObject(subject)); obj->set(key, value); _client_model.new_object(obj); } diff --git a/src/engine/Edge.cpp b/src/engine/Edge.cpp index 9aee198..e43efa1 100644 --- a/src/engine/Edge.cpp +++ b/src/engine/Edge.cpp @@ -42,8 +42,8 @@ Edge::write_state(Sord::Model& model) Sord::Curie(model.world(), "rdf:type"), Sord::Curie(model.world(), "machina:Edge")); - SharedPtr<Node> tail = _tail.lock(); - SharedPtr<Node> head = _head; + SPtr<Node> tail = _tail.lock(); + SPtr<Node> head = _head; if (!tail || !head) return; diff --git a/src/engine/Edge.hpp b/src/engine/Edge.hpp index 10c7ab8..6d916c1 100644 --- a/src/engine/Edge.hpp +++ b/src/engine/Edge.hpp @@ -22,8 +22,6 @@ #include <boost/utility.hpp> #include "raul/DoubleBuffer.hpp" -#include "raul/SharedPtr.hpp" -#include "raul/WeakPtr.hpp" #include "machina/types.hpp" @@ -38,7 +36,7 @@ class Edge : public Stateful { public: - Edge(WeakPtr<Node> tail, SharedPtr<Node> head) + Edge(WPtr<Node> tail, SPtr<Node> head) : _probability(1.0f) , _tail(tail) , _head(head) @@ -47,11 +45,11 @@ public: void set(URIInt key, const Raul::Atom& value); void write_state(Sord::Model& model); - WeakPtr<Node> tail() { return _tail; } - SharedPtr<Node> head() { return _head; } + WPtr<Node> tail() { return _tail; } + SPtr<Node> head() { return _head; } - void set_tail(WeakPtr<Node> tail) { _tail = tail; } - void set_head(SharedPtr<Node> head) { _head = head; } + void set_tail(WPtr<Node> tail) { _tail = tail; } + void set_head(SPtr<Node> head) { _head = head; } inline float probability() { return _probability.get(); } inline void set_probability(float p) { _probability.set(p); } @@ -59,8 +57,8 @@ public: private: Raul::DoubleBuffer<float> _probability; - WeakPtr<Node> _tail; - SharedPtr<Node> _head; + WPtr<Node> _tail; + SPtr<Node> _head; }; } // namespace Machina diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index b103310..e151cae 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -28,43 +28,43 @@ namespace Machina { -Engine::Engine(Raul::Forge& forge, - SharedPtr<Driver> driver, - Sord::World& rdf_world) +Engine::Engine(Raul::Forge& forge, + SPtr<Driver> driver, + Sord::World& rdf_world) : _driver(driver) , _rdf_world(rdf_world) , _loader(_forge, _rdf_world) , _forge(forge) {} -SharedPtr<Driver> +SPtr<Driver> Engine::new_driver(Raul::Forge& forge, const std::string& name, - SharedPtr<Machine> machine) + SPtr<Machine> machine) { #ifdef HAVE_JACK if (name == "jack") { JackDriver* driver = new JackDriver(forge, machine); driver->attach("machina"); - return SharedPtr<Driver>(driver); + return SPtr<Driver>(driver); } #endif if (name == "smf") { - return SharedPtr<Driver>(new SMFDriver(forge, machine->time().unit())); + return SPtr<Driver>(new SMFDriver(forge, machine->time().unit())); } std::cerr << "Error: Unknown driver type `" << name << "'" << std::endl; - return SharedPtr<Driver>(); + return SPtr<Driver>(); } /** Load the machine at @a uri, and run it (replacing current machine). * Safe to call while engine is processing. */ -SharedPtr<Machine> +SPtr<Machine> Engine::load_machine(const Glib::ustring& uri) { - SharedPtr<Machine> machine = _loader.load(uri); - SharedPtr<Machine> old_machine; + SPtr<Machine> machine = _loader.load(uri); + SPtr<Machine> old_machine; if (machine) { old_machine = _driver->machine(); // Keep a reference to old machine... machine->activate(); @@ -79,13 +79,14 @@ Engine::load_machine(const Glib::ustring& uri) /** Build a machine from the MIDI at @a uri, and run it (replacing current machine). * Safe to call while engine is processing. */ -SharedPtr<Machine> -Engine::load_machine_midi(const Glib::ustring& uri, double q, - Raul::TimeDuration dur) +SPtr<Machine> +Engine::load_machine_midi(const Glib::ustring& uri, + double q, + Raul::TimeDuration dur) { - SharedPtr<SMFDriver> file_driver(new SMFDriver(_forge, dur.unit())); - SharedPtr<Machine> machine = file_driver->learn(uri, q, dur); - SharedPtr<Machine> old_machine; + SPtr<SMFDriver> file_driver(new SMFDriver(_forge, dur.unit())); + SPtr<Machine> machine = file_driver->learn(uri, q, dur); + SPtr<Machine> old_machine; if (machine) { old_machine = _driver->machine(); // Keep a reference to old machine... machine->activate(); @@ -98,11 +99,10 @@ Engine::load_machine_midi(const Glib::ustring& uri, double q, } void -Engine::import_machine(SharedPtr<Machine> machine) +Engine::import_machine(SPtr<Machine> machine) { machine->activate(); - _driver->machine()->nodes().insert(_driver->machine()->nodes().end(), - machine->nodes().begin(), + _driver->machine()->nodes().insert(machine->nodes().begin(), machine->nodes().end()); // FIXME: thread safe? // FIXME: announce @@ -111,8 +111,8 @@ Engine::import_machine(SharedPtr<Machine> machine) void Engine::export_midi(const Glib::ustring& filename, Raul::TimeDuration dur) { - SharedPtr<Machine> machine = _driver->machine(); - SharedPtr<Machina::SMFDriver> file_driver( + SPtr<Machine> machine = _driver->machine(); + SPtr<Machina::SMFDriver> file_driver( new Machina::SMFDriver(_forge, dur.unit())); const bool activated = _driver->is_activated(); diff --git a/src/engine/Evolver.cpp b/src/engine/Evolver.cpp index a71d64b..56b3b45 100644 --- a/src/engine/Evolver.cpp +++ b/src/engine/Evolver.cpp @@ -32,12 +32,13 @@ using namespace boost; namespace Machina { -Evolver::Evolver(TimeUnit unit, const string& target_midi, - SharedPtr<Machine> seed) +Evolver::Evolver(TimeUnit unit, + const string& target_midi, + SPtr<Machine> seed) : _problem(new Problem(unit, target_midi, seed)) , _seed_fitness(-FLT_MAX) { - SharedPtr<Eugene::HybridMutation<Machine> > m(new HybridMutation<Machine>()); + SPtr<Eugene::HybridMutation<Machine> > m(new HybridMutation<Machine>()); m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation<Machine> >( new Mutation::Compress())); @@ -59,14 +60,14 @@ Evolver::Evolver(TimeUnit unit, const string& target_midi, boost::shared_ptr< Selection<Machine> > s(new TournamentSelection<Machine>( _problem, 3, 0.8)); boost::shared_ptr< Crossover<Machine> > crossover; - _ga = SharedPtr<MachinaGA>(new MachinaGA(_problem, s, crossover, m, - 20, 20, 2, 1.0, 0.0)); + _ga = SPtr<MachinaGA>( + new MachinaGA(_problem, s, crossover, m, 20, 20, 2, 1.0, 0.0)); } void -Evolver::seed(SharedPtr<Machine> parent) +Evolver::seed(SPtr<Machine> parent) { - /*_best = SharedPtr<Machine>(new Machine(*parent.get())); + /*_best = SPtr<Machine>(new Machine(*parent.get())); _best_fitness = _problem->fitness(*_best.get());*/ _problem->seed(parent); _seed_fitness = _problem->fitness(*parent.get()); diff --git a/src/engine/JackDriver.cpp b/src/engine/JackDriver.cpp index d13bbdd..d8442b1 100644 --- a/src/engine/JackDriver.cpp +++ b/src/engine/JackDriver.cpp @@ -32,7 +32,7 @@ using namespace std; namespace Machina { -JackDriver::JackDriver(Raul::Forge& forge, SharedPtr<Machine> machine) +JackDriver::JackDriver(Raul::Forge& forge, SPtr<Machine> machine) : Driver(forge, machine) , _client(NULL) , _machine_changed(0) @@ -107,9 +107,9 @@ JackDriver::attach(const std::string& client_name) } if (!_machine) { - _machine = SharedPtr<Machine>( - new Machine(TimeUnit::frames(jack_get_sample_rate( - jack_client())))); + _machine = SPtr<Machine>( + new Machine(TimeUnit::frames( + jack_get_sample_rate(jack_client())))); } _machine->activate(); @@ -160,13 +160,13 @@ JackDriver::deactivate() } void -JackDriver::set_machine(SharedPtr<Machine> machine) +JackDriver::set_machine(SPtr<Machine> machine) { if (machine == _machine) { return; } - SharedPtr<Machine> last_machine = _last_machine; // Keep a reference + SPtr<Machine> last_machine = _last_machine; // Keep a reference _machine_changed.reset(0); assert(!last_machine.unique()); _machine = machine; @@ -178,7 +178,7 @@ JackDriver::set_machine(SharedPtr<Machine> machine) } void -JackDriver::read_input_recording(SharedPtr<Machine> machine, +JackDriver::read_input_recording(SPtr<Machine> machine, const Raul::TimeSlice& time) { const jack_nframes_t nframes = time.length_ticks().ticks(); @@ -203,7 +203,7 @@ JackDriver::read_input_recording(SharedPtr<Machine> machine, } void -JackDriver::read_input_playing(SharedPtr<Machine> machine, +JackDriver::read_input_playing(SPtr<Machine> machine, const Raul::TimeSlice& time) { const jack_nframes_t nframes = time.length_ticks().ticks(); @@ -215,7 +215,7 @@ JackDriver::read_input_playing(SharedPtr<Machine> machine, jack_midi_event_get(&ev, buf, i); if (ev.buffer[0] == 0x90) { - const SharedPtr<LearnRequest> learn = machine->pending_learn(); + const SPtr<LearnRequest> learn = machine->pending_learn(); if (learn) { learn->enter_action()->set_event(ev.size, ev.buffer); learn->start(_quantization.get(), @@ -225,7 +225,7 @@ JackDriver::read_input_playing(SharedPtr<Machine> machine, } } else if (ev.buffer[0] == 0x80) { - const SharedPtr<LearnRequest> learn = machine->pending_learn(); + const SPtr<LearnRequest> learn = machine->pending_learn(); if (learn && learn->started()) { learn->exit_action()->set_event(ev.size, ev.buffer); learn->finish( @@ -323,7 +323,7 @@ JackDriver::on_process(jack_nframes_t nframes) /* Take a reference to machine here and use only it during the process * cycle so _machine can be switched with set_machine during a cycle. */ - SharedPtr<Machine> machine = _machine; + SPtr<Machine> machine = _machine; // Machine was switched since last cycle, finalize old machine. if (machine != _last_machine) { @@ -411,9 +411,8 @@ void JackDriver::start_record(bool step) { // FIXME: Choose an appropriate maximum ringbuffer size - _recorder - = SharedPtr<Recorder>(new Recorder(_forge, 1024, _beats_unit, - _quantization.get(), step)); + _recorder = SPtr<Recorder>( + new Recorder(_forge, 1024, _beats_unit, _quantization.get(), step)); _recorder->start(); _record_dur = 0; _recording = true; @@ -423,12 +422,10 @@ void JackDriver::finish_record() { _recording = false; - SharedPtr<Machine> machine = _recorder->finish(); + SPtr<Machine> machine = _recorder->finish(); _recorder.reset(); machine->activate(); - _machine->nodes().insert(_machine->nodes().end(), - machine->nodes().begin(), - machine->nodes().end()); + _machine->nodes().insert(machine->nodes().begin(), machine->nodes().end()); } int diff --git a/src/engine/JackDriver.hpp b/src/engine/JackDriver.hpp index c0f94ff..06ffabe 100644 --- a/src/engine/JackDriver.hpp +++ b/src/engine/JackDriver.hpp @@ -25,11 +25,11 @@ #include "raul/DoubleBuffer.hpp" #include "raul/Semaphore.hpp" -#include "raul/SharedPtr.hpp" #include "machina/Context.hpp" #include "machina/Driver.hpp" #include "machina/Machine.hpp" +#include "machina/types.hpp" #include "Recorder.hpp" @@ -47,8 +47,8 @@ class JackDriver : public Machina::Driver { public: - JackDriver(Raul::Forge& forge, - SharedPtr<Machine> machine = SharedPtr<Machine>()); + JackDriver(Raul::Forge& forge, + SPtr<Machine> machine = SPtr<Machine>()); ~JackDriver(); void attach(const std::string& client_name); @@ -57,7 +57,7 @@ public: void activate(); void deactivate(); - void set_machine(SharedPtr<Machine> machine); + void set_machine(SPtr<Machine> machine); void write_event(Raul::TimeStamp time, size_t size, @@ -90,10 +90,10 @@ public: jack_client_t* jack_client() const { return _client; } private: - void read_input_recording(SharedPtr<Machine> machine, + void read_input_recording(SPtr<Machine> machine, const Raul::TimeSlice& time); - void read_input_playing(SharedPtr<Machine> machine, + void read_input_playing(SPtr<Machine> machine, const Raul::TimeSlice& time); static void jack_error_cb(const char* msg); @@ -104,8 +104,8 @@ private: jack_client_t* _client; - Raul::Semaphore _machine_changed; - SharedPtr<Machine> _last_machine; + Raul::Semaphore _machine_changed; + SPtr<Machine> _last_machine; jack_port_t* _input_port; jack_port_t* _output_port; @@ -121,10 +121,10 @@ private: Raul::Semaphore _stop; bool _stop_flag; - Raul::TimeDuration _record_dur; - std::atomic<bool> _recording; - SharedPtr<Recorder> _recorder; - bool _is_activated; + Raul::TimeDuration _record_dur; + std::atomic<bool> _recording; + SPtr<Recorder> _recorder; + bool _is_activated; }; } // namespace Machina diff --git a/src/engine/LearnRequest.cpp b/src/engine/LearnRequest.cpp index 81ef0e3..acf5bf0 100644 --- a/src/engine/LearnRequest.cpp +++ b/src/engine/LearnRequest.cpp @@ -20,7 +20,7 @@ namespace Machina { -LearnRequest::LearnRequest(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node) +LearnRequest::LearnRequest(SPtr<Raul::Maid> maid, SPtr<Node> node) : _started(false) , _start_time(TimeUnit(TimeUnit::BEATS, 19200), 0, 0) // irrelevant , _quantization(0) // irrelevant @@ -32,10 +32,10 @@ LearnRequest::LearnRequest(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node) maid->manage(_exit_action); } -SharedPtr<LearnRequest> -LearnRequest::create(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node) +SPtr<LearnRequest> +LearnRequest::create(SPtr<Raul::Maid> maid, SPtr<Node> node) { - SharedPtr<LearnRequest> ret(new LearnRequest(maid, node)); + SPtr<LearnRequest> ret(new LearnRequest(maid, node)); maid->manage(ret); return ret; } diff --git a/src/engine/LearnRequest.hpp b/src/engine/LearnRequest.hpp index af28017..4093d24 100644 --- a/src/engine/LearnRequest.hpp +++ b/src/engine/LearnRequest.hpp @@ -19,8 +19,6 @@ #define MACHINA_LEARNREQUEST_HPP #include "raul/Maid.hpp" -#include "raul/SharedPtr.hpp" -#include "raul/Manageable.hpp" #include "machina/types.hpp" @@ -34,31 +32,30 @@ class MidiAction; /** A request to MIDI learn a certain node. */ -class LearnRequest - : public Raul::Manageable +class LearnRequest : public Raul::Maid::Manageable { public: - static SharedPtr<LearnRequest>create(SharedPtr<Raul::Maid> maid, - SharedPtr<Node> node); + static SPtr<LearnRequest>create(SPtr<Raul::Maid> maid, + SPtr<Node> node); void start(double q, Raul::TimeStamp time); void finish(TimeStamp time); inline bool started() const { return _started; } - const SharedPtr<Node>& node() { return _node; } - const SharedPtr<MidiAction>& enter_action() { return _enter_action; } - const SharedPtr<MidiAction>& exit_action() { return _exit_action; } + const SPtr<Node>& node() { return _node; } + const SPtr<MidiAction>& enter_action() { return _enter_action; } + const SPtr<MidiAction>& exit_action() { return _exit_action; } private: - LearnRequest(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node); + LearnRequest(SPtr<Raul::Maid> maid, SPtr<Node> node); bool _started; TimeStamp _start_time; double _quantization; - SharedPtr<Node> _node; - SharedPtr<MidiAction> _enter_action; - SharedPtr<MidiAction> _exit_action; + SPtr<Node> _node; + SPtr<MidiAction> _enter_action; + SPtr<MidiAction> _exit_action; }; } // namespace Machina diff --git a/src/engine/Loader.cpp b/src/engine/Loader.cpp index 32e8d19..c206c4c 100644 --- a/src/engine/Loader.cpp +++ b/src/engine/Loader.cpp @@ -50,12 +50,12 @@ Loader::Loader(Raul::Forge& forge, Sord::World& rdf_world) * @param uri URI of machine (resolvable URI to an RDF document). * @return Loaded Machine. */ -SharedPtr<Machine> +SPtr<Machine> Loader::load(const Glib::ustring& uri) { using Glib::ustring; - SharedPtr<Machine> machine; + SPtr<Machine> machine; ustring document_uri = uri; @@ -68,10 +68,10 @@ Loader::load(const Glib::ustring& uri) cout << "[Loader] Loading " << document_uri << endl; - machine = SharedPtr<Machine>( + machine = SPtr<Machine>( new Machine(TimeUnit::beats(MACHINA_PPQN))); - typedef std::map<Sord::Node, SharedPtr<Node> > Created; + typedef std::map<Sord::Node, SPtr<Node> > Created; Created created; Sord::Model model(_rdf_world, document_uri); @@ -98,11 +98,10 @@ Loader::load(const Glib::ustring& uri) !i.end(); ++i) { const Sord::Node& node_id = i.get_object(); Sord::Iter d = model.find(node_id, machina_duration, nil); - SharedPtr<Node> node( - new Node( - TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), - d.get_object().to_float()), - true)); + SPtr<Node> node( + new Node(TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), + d.get_object().to_float()), + true)); Sord::Iter s = model.find(node_id, rdf_type, machina_SelectorNode); if (!s.end()) { @@ -119,10 +118,10 @@ Loader::load(const Glib::ustring& uri) const Sord::Node& node_id = i.get_object(); Sord::Iter d = model.find(node_id, machina_duration, nil); if (created.find(node_id) == created.end()) { - SharedPtr<Node> node(new Node( - TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), - d.get_object().to_float()), - false)); + SPtr<Node> node( + new Node(TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), + d.get_object().to_float()), + false)); machine->add_node(node); created[node_id] = node; } @@ -143,8 +142,8 @@ Loader::load(const Glib::ustring& uri) Created::iterator node_i = created.find((const char*)results->get("node")); if (node_i != created.end()) { - SharedPtr<Node> node = node_i->second; - const int note_num = results->get("note").to_int(); + SPtr<Node> node = node_i->second; + const int note_num = results->get("note").to_int(); if (note_num >= 0 && note_num <= 127) { node->set_enter_action( ActionFactory::note_on((uint8_t)note_num)); @@ -179,10 +178,10 @@ Loader::load(const Glib::ustring& uri) Created::iterator head_i = created.find(head); if (tail_i != created.end() && head_i != created.end()) { - const SharedPtr<Node> tail = tail_i->second; - const SharedPtr<Node> head = head_i->second; + const SPtr<Node> tail = tail_i->second; + const SPtr<Node> head = head_i->second; - SharedPtr<Edge> edge(new Edge(tail, head)); + SPtr<Edge> edge(new Edge(tail, head)); edge->set_probability(prob); tail->add_edge(edge); @@ -197,7 +196,7 @@ Loader::load(const Glib::ustring& uri) machine->reset(NULL, machine->time()); return machine; } else { - return SharedPtr<Machine>(); + return SPtr<Machine>(); } } diff --git a/src/engine/Machine.cpp b/src/engine/Machine.cpp index 4b548a7..73eba15 100644 --- a/src/engine/Machine.cpp +++ b/src/engine/Machine.cpp @@ -19,14 +19,14 @@ #include <map> #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" #include "sord/sordmm.hpp" +#include "machina/Context.hpp" #include "machina/Machine.hpp" -#include "machina/Updates.hpp" #include "machina/URIs.hpp" -#include "machina/Context.hpp" +#include "machina/Updates.hpp" +#include "machina/types.hpp" #include "Edge.hpp" #include "Node.hpp" @@ -39,7 +39,7 @@ using namespace Raul; namespace Machina { Machine::Machine(TimeUnit unit) - : _active_nodes(MAX_ACTIVE_NODES, SharedPtr<Node>()) + : _active_nodes(MAX_ACTIVE_NODES, SPtr<Node>()) , _time(unit, 0, 0) , _is_activated(false) , _is_finished(false) @@ -52,17 +52,17 @@ Machine::Machine(TimeUnit unit) */ Machine::Machine(const Machine& copy) : Stateful() // don't copy RDF ID - , _active_nodes(MAX_ACTIVE_NODES, SharedPtr<Node>()) + , _active_nodes(MAX_ACTIVE_NODES, SPtr<Node>()) , _time(copy.time()) , _is_activated(false) , _is_finished(false) { - std::map< SharedPtr<Node>, SharedPtr<Node> > replacements; + std::map< SPtr<Node>, SPtr<Node> > replacements; for (Nodes::const_iterator n = copy._nodes.begin(); n != copy._nodes.end(); ++n) { - SharedPtr<Machina::Node> node(new Machina::Node(*n->get())); - _nodes.push_back(node); + SPtr<Machina::Node> node(new Machina::Node(*n->get())); + _nodes.insert(node); replacements[*n] = node; } @@ -79,20 +79,20 @@ Machine::Machine(const Machine& copy) Machine& Machine::operator=(const Machine& other) { - _active_nodes = std::vector< SharedPtr<Node> >(MAX_ACTIVE_NODES, - SharedPtr<Node>()); + _active_nodes = std::vector< SPtr<Node> >(MAX_ACTIVE_NODES, + SPtr<Node>()); _is_activated = false; _is_finished = false; _time = other._time; - _pending_learn = SharedPtr<LearnRequest>(); + _pending_learn = SPtr<LearnRequest>(); _nodes.clear(); - map< SharedPtr<Node>, SharedPtr<Node> > replacements; + map< SPtr<Node>, SPtr<Node> > replacements; for (Nodes::const_iterator n = other._nodes.begin(); n != other._nodes.end(); ++n) { - SharedPtr<Machina::Node> node(new Machina::Node(*n->get())); - _nodes.push_back(node); + SPtr<Machina::Node> node(new Machina::Node(*n->get())); + _nodes.insert(node); replacements[*n] = node; } @@ -109,11 +109,11 @@ Machine::operator=(const Machine& other) } /** Always returns a node, unless there are none */ -SharedPtr<Node> +SPtr<Node> Machine::random_node() { if (_nodes.empty()) { - return SharedPtr<Node>(); + return SPtr<Node>(); } size_t i = rand() % _nodes.size(); @@ -126,33 +126,32 @@ Machine::random_node() } } - return SharedPtr<Node>(); + return SPtr<Node>(); } /** May return NULL even if edges exist (with low probability) */ -SharedPtr<Edge> +SPtr<Edge> Machine::random_edge() { - SharedPtr<Node> tail = random_node(); + SPtr<Node> tail = random_node(); for (size_t i = 0; i < _nodes.size() && tail->edges().empty(); ++i) { tail = random_node(); } - return tail ? tail->random_edge() : SharedPtr<Edge>(); + return tail ? tail->random_edge() : SPtr<Edge>(); } void -Machine::add_node(SharedPtr<Node> node) +Machine::add_node(SPtr<Node> node) { - assert(std::find(_nodes.begin(), _nodes.end(), node) == _nodes.end()); - _nodes.push_back(node); + _nodes.insert(node); } void -Machine::remove_node(SharedPtr<Node> node) +Machine::remove_node(SPtr<Node> node) { - _nodes.erase(std::find(_nodes.begin(), _nodes.end(), node)); + _nodes.erase(node); for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { (*n)->remove_edge_to(node); @@ -165,9 +164,8 @@ void Machine::reset(MIDISink* sink, Raul::TimeStamp time) { if (!_is_finished) { - for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); - ++n) { - SharedPtr<Node> node = (*n); + for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { + SPtr<Node> node = (*n); if (node->is_active()) { node->exit(sink, time); @@ -187,13 +185,13 @@ Machine::reset(MIDISink* sink, Raul::TimeStamp time) /** Return the active Node with the earliest exit time. */ -SharedPtr<Node> +SPtr<Node> Machine::earliest_node() const { - SharedPtr<Node> earliest; + SPtr<Node> earliest; for (size_t i = 0; i < MAX_ACTIVE_NODES; ++i) { - SharedPtr<Node> node = _active_nodes.at(i); + SPtr<Node> node = _active_nodes.at(i); if (node) { if (!node->is_active()) { @@ -214,9 +212,9 @@ Machine::earliest_node() const * Returns true if node was entered, or false if the maximum active nodes has been reached. */ bool -Machine::enter_node(Context& context, - SharedPtr<Node> node, - SharedPtr<UpdateBuffer> updates) +Machine::enter_node(Context& context, + SPtr<Node> node, + SPtr<UpdateBuffer> updates) { assert(!node->is_active()); @@ -245,9 +243,9 @@ Machine::enter_node(Context& context, /** Exit an active node at the current _time. */ void -Machine::exit_node(Context& context, - SharedPtr<Node> node, - SharedPtr<UpdateBuffer> updates) +Machine::exit_node(Context& context, + SPtr<Node> node, + SPtr<UpdateBuffer> updates) { node->exit(context.sink(), _time); write_set(updates, @@ -294,7 +292,7 @@ Machine::exit_node(Context& context, const double rand_normal = rand() / (double)RAND_MAX; // [0, 1] if (rand_normal <= (*e)->probability()) { - SharedPtr<Node> head = (*e)->head(); + SPtr<Node> head = (*e)->head(); if (!head->is_active()) { enter_node(context, head, updates); @@ -315,7 +313,7 @@ Machine::exit_node(Context& context, * with sample accuracy if necessary). */ uint32_t -Machine::run(Context& context, SharedPtr<UpdateBuffer> updates) +Machine::run(Context& context, SPtr<UpdateBuffer> updates) { if (_is_finished) { return 0; @@ -357,7 +355,7 @@ Machine::run(Context& context, SharedPtr<UpdateBuffer> updates) while (true) { - SharedPtr<Node> earliest = earliest_node(); + SPtr<Node> earliest = earliest_node(); if (!earliest) { // No more active states, machine is finished @@ -393,7 +391,7 @@ Machine::run(Context& context, SharedPtr<UpdateBuffer> updates) * NOT realtime (actions are allocated here). */ void -Machine::learn(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node) +Machine::learn(SPtr<Raul::Maid> maid, SPtr<Node> node) { _pending_learn = LearnRequest::create(maid, node); } diff --git a/src/engine/MachineBuilder.cpp b/src/engine/MachineBuilder.cpp index 0a6dbfc..57d6c2f 100644 --- a/src/engine/MachineBuilder.cpp +++ b/src/engine/MachineBuilder.cpp @@ -19,9 +19,8 @@ #include "lv2/lv2plug.in/ns/ext/midi/midi.h" -#include "raul/SharedPtr.hpp" - #include "machina/Machine.hpp" +#include "machina/types.hpp" #include "Edge.hpp" #include "MachineBuilder.hpp" @@ -34,7 +33,7 @@ using namespace Raul; namespace Machina { -MachineBuilder::MachineBuilder(SharedPtr<Machine> machine, double q, bool step) +MachineBuilder::MachineBuilder(SPtr<Machine> machine, double q, bool step) : _quantization(q) , _time(machine->time().unit()) // = 0 , _machine(machine) @@ -48,13 +47,13 @@ void MachineBuilder::reset() { _time = TimeStamp(_machine->time().unit()); // = 0 - _initial_node = SharedPtr<Node>(new Node(_time, true)); // duration 0 + _initial_node = SPtr<Node>(new Node(_time, true)); // duration 0 _connect_node = _initial_node; _connect_node_end_time = _time; // = 0 } bool -MachineBuilder::is_delay_node(SharedPtr<Node> node) const +MachineBuilder::is_delay_node(SPtr<Node> node) const { return !node->enter_action() && !node->exit_action(); } @@ -62,7 +61,7 @@ MachineBuilder::is_delay_node(SharedPtr<Node> node) const /** Set the duration of a node, with quantization. */ void -MachineBuilder::set_node_duration(SharedPtr<Node> node, +MachineBuilder::set_node_duration(SPtr<Node> node, Raul::TimeDuration d) const { if (_step) { @@ -83,31 +82,31 @@ MachineBuilder::set_node_duration(SharedPtr<Node> node, * * If a delay node is added to the machine, it is returned. */ -SharedPtr<Node> -MachineBuilder::connect_nodes(SharedPtr<Machine> m, - SharedPtr<Node> tail, - Raul::TimeStamp tail_end_time, - SharedPtr<Node> head, - Raul::TimeStamp head_start_time) +SPtr<Node> +MachineBuilder::connect_nodes(SPtr<Machine> m, + SPtr<Node> tail, + Raul::TimeStamp tail_end_time, + SPtr<Node> head, + Raul::TimeStamp head_start_time) { assert(tail != head); assert(head_start_time >= tail_end_time); - SharedPtr<Node> delay_node; + SPtr<Node> delay_node; if (is_delay_node(tail) && tail->edges().size() == 0) { // Tail is a delay node, just accumulate the time difference into it set_node_duration(tail, tail->duration() + head_start_time - tail_end_time); - tail->add_edge(SharedPtr<Edge>(new Edge(tail, head))); + tail->add_edge(SPtr<Edge>(new Edge(tail, head))); } else if (_step || (head_start_time == tail_end_time)) { // Connect directly - tail->add_edge(SharedPtr<Edge>(new Edge(tail, head))); + tail->add_edge(SPtr<Edge>(new Edge(tail, head))); } else { // Need to actually create a delay node - delay_node = SharedPtr<Node>(new Node(head_start_time - tail_end_time)); - tail->add_edge(SharedPtr<Edge>(new Edge(tail, delay_node))); - delay_node->add_edge(SharedPtr<Edge>(new Edge(delay_node, head))); + delay_node = SPtr<Node>(new Node(head_start_time - tail_end_time)); + tail->add_edge(SPtr<Edge>(new Edge(tail, delay_node))); + delay_node->add_edge(SPtr<Edge>(new Edge(delay_node, head))); m->add_node(delay_node); } @@ -117,10 +116,10 @@ MachineBuilder::connect_nodes(SharedPtr<Machine> m, void MachineBuilder::note_on(Raul::TimeStamp t, size_t ev_size, uint8_t* buf) { - SharedPtr<Node> node(new Node(TimeStamp(t.unit()))); - node->set_enter_action(SharedPtr<Action>(new MidiAction(ev_size, buf))); + SPtr<Node> node(new Node(TimeStamp(t.unit()))); + node->set_enter_action(SPtr<Action>(new MidiAction(ev_size, buf))); - SharedPtr<Node> this_connect_node; + SPtr<Node> this_connect_node; Raul::TimeStamp this_connect_node_end_time(t.unit()); /* If currently polyphonic, use a poly node with no successors as connect @@ -143,7 +142,7 @@ MachineBuilder::note_on(Raul::TimeStamp t, size_t ev_size, uint8_t* buf) this_connect_node_end_time = _connect_node_end_time; } - SharedPtr<Node> delay_node = connect_nodes( + SPtr<Node> delay_node = connect_nodes( _machine, this_connect_node, this_connect_node_end_time, node, t); if (delay_node) { @@ -159,10 +158,10 @@ void MachineBuilder::resolve_note(Raul::TimeStamp t, size_t ev_size, uint8_t* buf, - SharedPtr<Node> resolved) + SPtr<Node> resolved) { resolved->set_exit_action( - SharedPtr<Action>(new MidiAction(ev_size, buf))); + SPtr<Action>(new MidiAction(ev_size, buf))); set_node_duration(resolved, t - resolved->enter_time()); if (_active_nodes.size() == 1) { @@ -171,7 +170,7 @@ MachineBuilder::resolve_note(Raul::TimeStamp t, if (!_poly_nodes.empty()) { // Finish a polyphonic section - _connect_node = SharedPtr<Node>(new Node(TimeStamp(t.unit()))); + _connect_node = SPtr<Node>(new Node(TimeStamp(t.unit()))); _machine->add_node(_connect_node); connect_nodes(_machine, resolved, t, _connect_node, t); @@ -201,8 +200,8 @@ MachineBuilder::resolve_note(Raul::TimeStamp t, assert(_connect_node->edges().empty()); _connect_node->set_enter_action(resolved->enter_action()); _connect_node->set_exit_action(resolved->exit_action()); - resolved->set_enter_action(SharedPtr<Action>()); - resolved->set_exit_action(SharedPtr<Action>()); + resolved->set_enter_action(SPtr<Action>()); + resolved->set_exit_action(SPtr<Action>()); set_node_duration(_connect_node, resolved->duration()); resolved = _connect_node; if (std::find(_machine->nodes().begin(), @@ -246,8 +245,7 @@ MachineBuilder::event(Raul::TimeStamp time_offset, } else if ((buf[0] & 0xF0) == LV2_MIDI_MSG_NOTE_OFF) { for (ActiveList::iterator i = _active_nodes.begin(); i != _active_nodes.end(); ++i) { - SharedPtr<MidiAction> action = PtrCast<MidiAction>( - (*i)->enter_action()); + SPtr<MidiAction> action = dynamic_ptr_cast<MidiAction>((*i)->enter_action()); if (!action) { continue; } @@ -275,10 +273,10 @@ MachineBuilder::resolve() { // Resolve stuck notes if (!_active_nodes.empty()) { - for (list<SharedPtr<Node> >::iterator i = _active_nodes.begin(); + for (list<SPtr<Node> >::iterator i = _active_nodes.begin(); i != _active_nodes.end(); ++i) { cerr << "WARNING: Resolving stuck note." << endl; - SharedPtr<MidiAction> action = PtrCast<MidiAction>( + SPtr<MidiAction> action = dynamic_ptr_cast<MidiAction>( (*i)->enter_action()); if (!action) { continue; @@ -293,7 +291,7 @@ MachineBuilder::resolve() 0x40 }; (*i)->set_exit_action( - SharedPtr<Action>(new MidiAction(3, note_off))); + SPtr<Action>(new MidiAction(3, note_off))); set_node_duration((*i), _time - (*i)->enter_time()); (*i)->exit(NULL, _time); _machine->add_node((*i)); @@ -312,7 +310,7 @@ MachineBuilder::resolve() } -SharedPtr<Machine> +SPtr<Machine> MachineBuilder::finish() { resolve(); diff --git a/src/engine/MachineBuilder.hpp b/src/engine/MachineBuilder.hpp index cb3ccea..4a915aa 100644 --- a/src/engine/MachineBuilder.hpp +++ b/src/engine/MachineBuilder.hpp @@ -22,7 +22,7 @@ #include <list> -#include "raul/SharedPtr.hpp" +#include "machina/types.hpp" #include "raul/TimeStamp.hpp" namespace Machina { @@ -33,9 +33,9 @@ class Node; class MachineBuilder { public: - MachineBuilder(SharedPtr<Machine> machine, - double quantization, - bool step); + MachineBuilder(SPtr<Machine> machine, + double quantization, + bool step); void set_time(Raul::TimeStamp time) { _time = time; } @@ -44,38 +44,38 @@ public: void reset(); void resolve(); - SharedPtr<Machine> finish(); + SPtr<Machine> finish(); private: - bool is_delay_node(SharedPtr<Node> node) const; - void set_node_duration(SharedPtr<Node> node, Raul::TimeDuration d) const; + bool is_delay_node(SPtr<Node> node) const; + void set_node_duration(SPtr<Node> node, Raul::TimeDuration d) const; void note_on(Raul::TimeStamp t, size_t ev_size, uint8_t* buf); void resolve_note(Raul::TimeStamp t, size_t ev_size, uint8_t* buf, - SharedPtr<Node> resolved); + SPtr<Node> resolved); - SharedPtr<Node>connect_nodes(SharedPtr<Machine> m, - SharedPtr<Node> tail, - Raul::TimeStamp tail_end_time, - SharedPtr<Node> head, - Raul::TimeStamp head_start_time); + SPtr<Node>connect_nodes(SPtr<Machine> m, + SPtr<Node> tail, + Raul::TimeStamp tail_end_time, + SPtr<Node> head, + Raul::TimeStamp head_start_time); - typedef std::list<SharedPtr<Node> > ActiveList; + typedef std::list<SPtr<Node> > ActiveList; ActiveList _active_nodes; - typedef std::list<std::pair<Raul::TimeStamp, SharedPtr<Node> > > PolyList; + typedef std::list<std::pair<Raul::TimeStamp, SPtr<Node> > > PolyList; PolyList _poly_nodes; double _quantization; Raul::TimeStamp _time; - SharedPtr<Machine> _machine; - SharedPtr<Node> _initial_node; - SharedPtr<Node> _connect_node; - Raul::TimeStamp _connect_node_end_time; + SPtr<Machine> _machine; + SPtr<Node> _initial_node; + SPtr<Node> _connect_node; + Raul::TimeStamp _connect_node_end_time; bool _step; }; diff --git a/src/engine/MidiAction.cpp b/src/engine/MidiAction.cpp index 268279f..cac01a3 100644 --- a/src/engine/MidiAction.cpp +++ b/src/engine/MidiAction.cpp @@ -17,7 +17,6 @@ #include <iostream> -#include "raul/SharedPtr.hpp" #include "raul/Atom.hpp" #include "machina/types.hpp" diff --git a/src/engine/Mutation.cpp b/src/engine/Mutation.cpp index e25cdbb..fde1ba6 100644 --- a/src/engine/Mutation.cpp +++ b/src/engine/Mutation.cpp @@ -55,17 +55,17 @@ AddNode::mutate(Machine& machine) //cout << "ADD NODE" << endl; // Create random node - SharedPtr<Node> node(new Node(machine.time().unit())); + SPtr<Node> node(new Node(machine.time().unit())); node->set_selector(true); - SharedPtr<Node> note_node = machine.random_node(); + SPtr<Node> note_node = machine.random_node(); if (!note_node) { return; } uint8_t note = rand() % 128; - SharedPtr<MidiAction> enter_action = PtrCast<MidiAction>( + SPtr<MidiAction> enter_action = dynamic_ptr_cast<MidiAction>( note_node->enter_action()); if (enter_action) { note = enter_action->event()[1]; @@ -76,15 +76,15 @@ AddNode::mutate(Machine& machine) machine.add_node(node); // Insert after some node - SharedPtr<Node> tail = machine.random_node(); + SPtr<Node> tail = machine.random_node(); if (tail && (tail != node) /* && !node->connected_to(tail)*/) { - tail->add_edge(boost::shared_ptr<Edge>(new Edge(tail, node))); + tail->add_edge(SPtr<Edge>(new Edge(tail, node))); } // Insert before some other node - SharedPtr<Node> head = machine.random_node(); + SPtr<Node> head = machine.random_node(); if (head && (head != node) /* && !head->connected_to(node)*/) { - node->add_edge(boost::shared_ptr<Edge>(new Edge(node, head))); + node->add_edge(SPtr<Edge>(new Edge(node, head))); } } @@ -93,7 +93,7 @@ RemoveNode::mutate(Machine& machine) { //cout << "REMOVE NODE" << endl; - SharedPtr<Node> node = machine.random_node(); + SPtr<Node> node = machine.random_node(); if (node && !node->is_initial()) { machine.remove_node(node); } @@ -104,11 +104,11 @@ AdjustNode::mutate(Machine& machine) { //cout << "ADJUST NODE" << endl; - SharedPtr<Node> node = machine.random_node(); + SPtr<Node> node = machine.random_node(); if (node) { - SharedPtr<MidiAction> enter_action = PtrCast<MidiAction>( + SPtr<MidiAction> enter_action = dynamic_ptr_cast<MidiAction>( node->enter_action()); - SharedPtr<MidiAction> exit_action = PtrCast<MidiAction>( + SPtr<MidiAction> exit_action = dynamic_ptr_cast<MidiAction>( node->exit_action()); if (enter_action && exit_action) { const uint8_t note = rand() % 128; @@ -128,16 +128,16 @@ SwapNodes::mutate(Machine& machine) return; } - SharedPtr<Node> a = machine.random_node(); - SharedPtr<Node> b = machine.random_node(); + SPtr<Node> a = machine.random_node(); + SPtr<Node> b = machine.random_node(); while (b == a) { b = machine.random_node(); } - SharedPtr<MidiAction> a_enter = PtrCast<MidiAction>(a->enter_action()); - SharedPtr<MidiAction> a_exit = PtrCast<MidiAction>(a->exit_action()); - SharedPtr<MidiAction> b_enter = PtrCast<MidiAction>(b->enter_action()); - SharedPtr<MidiAction> b_exit = PtrCast<MidiAction>(b->exit_action()); + SPtr<MidiAction> a_enter = dynamic_ptr_cast<MidiAction>(a->enter_action()); + SPtr<MidiAction> a_exit = dynamic_ptr_cast<MidiAction>(a->exit_action()); + SPtr<MidiAction> b_enter = dynamic_ptr_cast<MidiAction>(b->enter_action()); + SPtr<MidiAction> b_exit = dynamic_ptr_cast<MidiAction>(b->exit_action()); uint8_t note_a = a_enter->event()[1]; uint8_t note_b = b_enter->event()[1]; @@ -153,14 +153,14 @@ AddEdge::mutate(Machine& machine) { //cout << "ADJUST EDGE" << endl; - SharedPtr<Node> tail = machine.random_node(); - SharedPtr<Node> head = machine.random_node(); + SPtr<Node> tail = machine.random_node(); + SPtr<Node> head = machine.random_node(); if (tail && head && tail != head) { // && !tail->connected_to(head) && !head->connected_to(tail) - SharedPtr<Edge> edge(new Edge(tail, head)); + SPtr<Edge> edge(new Edge(tail, head)); edge->set_probability(rand() / (float)RAND_MAX); - tail->add_edge(boost::shared_ptr<Edge>(new Edge(tail, head))); + tail->add_edge(SPtr<Edge>(new Edge(tail, head))); } } @@ -169,7 +169,7 @@ RemoveEdge::mutate(Machine& machine) { //cout << "REMOVE EDGE" << endl; - SharedPtr<Node> tail = machine.random_node(); + SPtr<Node> tail = machine.random_node(); if (tail && !(tail->is_initial() && tail->edges().size() == 1)) { tail->remove_edge(tail->random_edge()); } @@ -180,7 +180,7 @@ AdjustEdge::mutate(Machine& machine) { //cout << "ADJUST EDGE" << endl; - SharedPtr<Edge> edge = machine.random_edge(); + SPtr<Edge> edge = machine.random_edge(); if (edge) { edge->set_probability(rand() / (float)RAND_MAX); edge->tail().lock()->edges_changed(); diff --git a/src/engine/Node.cpp b/src/engine/Node.cpp index 4de00d2..d8d89b9 100644 --- a/src/engine/Node.cpp +++ b/src/engine/Node.cpp @@ -53,16 +53,16 @@ Node::Node(const Node& copy) { for (Edges::const_iterator i = copy._edges.begin(); i != copy._edges.end(); ++i) { - SharedPtr<Edge> edge(new Edge(*i->get())); - _edges.push_back(edge); + SPtr<Edge> edge(new Edge(*i->get())); + _edges.insert(edge); } } /** Always returns an edge, unless there are none */ -SharedPtr<Edge> +SPtr<Edge> Node::random_edge() { - SharedPtr<Edge> ret; + SPtr<Edge> ret; if (_edges.empty()) { return ret; } @@ -115,14 +115,14 @@ Node::set_selector(bool yn) } void -Node::set_enter_action(SharedPtr<Action> action) +Node::set_enter_action(SPtr<Action> action) { _enter_action = action; _changed = true; } void -Node::set_exit_action(SharedPtr<Action> action) +Node::set_exit_action(SPtr<Action> action) { _exit_action = action; _changed = true; @@ -156,52 +156,52 @@ Node::exit(MIDISink* sink, TimeStamp time) _enter_time = 0; } -void -Node::add_edge(SharedPtr<Edge> edge) +SPtr<Edge> +Node::edge_to(SPtr<Node> head) const { - assert(edge->tail().lock().get() == this); + // TODO: Make logarithmic for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i) { - if ((*i)->head() == edge->head()) { - return; + if ((*i)->head() == head) { + return *i; } } + return SPtr<Edge>(); +} + +void +Node::add_edge(SPtr<Edge> edge) +{ + assert(edge->tail().lock().get() == this); + if (edge_to(edge->head())) { + return; + } - _edges.push_back(edge); + _edges.insert(edge); edges_changed(); } void -Node::remove_edge(SharedPtr<Edge> edge) +Node::remove_edge(SPtr<Edge> edge) { - _edges.erase(std::find(_edges.begin(), _edges.end(), edge)); + _edges.erase(edge); edges_changed(); } bool -Node::connected_to(SharedPtr<Node> node) +Node::connected_to(SPtr<Node> node) { - for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i) { - if ((*i)->head() == node) { - return true; - } - } - - return false; + return bool(edge_to(node)); } -SharedPtr<Edge> -Node::remove_edge_to(SharedPtr<Node> node) +SPtr<Edge> +Node::remove_edge_to(SPtr<Node> node) { - for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i) { - if ((*i)->head() == node) { - SharedPtr<Edge> edge(*i); - _edges.erase(i); - edges_changed(); - return edge; - } + SPtr<Edge> edge = edge_to(node); + if (edge) { + _edges.erase(edge); // TODO: avoid double search + edges_changed(); } - - return SharedPtr<Edge>(); + return edge; } void diff --git a/src/engine/Node.hpp b/src/engine/Node.hpp index cf41b26..953f652 100644 --- a/src/engine/Node.hpp +++ b/src/engine/Node.hpp @@ -18,9 +18,9 @@ #ifndef MACHINA_NODE_HPP #define MACHINA_NODE_HPP -#include <list> +#include <set> -#include "raul/SharedPtr.hpp" +#include "machina/types.hpp" #include "Action.hpp" #include "Schrodinbit.hpp" @@ -36,34 +36,33 @@ using Raul::TimeUnit; /** A node is a state (as in a FSM diagram), or "note". * - * It contains a action, as well as a duration and pointers to it's + * It contains a action, as well as a duration and pointers to its * successors (states/nodes that (may) follow it). * * Initial nodes do not have enter actions (since they are entered at * an undefined point in time <= 0). */ -class Node - : public Stateful +class Node : public Stateful { public: Node(TimeDuration duration, bool initial = false); Node(const Node& copy); - void set_enter_action(SharedPtr<Action> action); - void set_exit_action(SharedPtr<Action> action); + void set_enter_action(SPtr<Action> action); + void set_exit_action(SPtr<Action> action); - SharedPtr<Action> enter_action() { return _enter_action; } - SharedPtr<Action> exit_action() { return _exit_action; } + SPtr<Action> enter_action() { return _enter_action; } + SPtr<Action> exit_action() { return _exit_action; } void enter(MIDISink* sink, TimeStamp time); void exit(MIDISink* sink, TimeStamp time); void edges_changed(); - void add_edge(SharedPtr<Edge> edge); - void remove_edge(SharedPtr<Edge> edge); - SharedPtr<Edge> remove_edge_to(SharedPtr<Node> node); - bool connected_to(SharedPtr<Node> node); + void add_edge(SPtr<Edge> edge); + void remove_edge(SPtr<Edge> edge); + SPtr<Edge> remove_edge_to(SPtr<Node> node); + bool connected_to(SPtr<Node> node); void set(URIInt key, const Raul::Atom& value); void write_state(Sord::Model& model); @@ -81,23 +80,32 @@ public: inline bool changed() { return _changed; } inline void set_changed() { _changed = true; } - typedef std::list< SharedPtr<Edge> > Edges; + struct EdgeHeadOrder { + inline bool operator()(const SPtr<Edge>& a, const SPtr<Edge>& b) { + return a < b; + } + }; + + SPtr<Edge> edge_to(SPtr<Node> head) const; + + typedef std::set<SPtr<Edge>, EdgeHeadOrder> Edges; + Edges& edges() { return _edges; } - SharedPtr<Edge> random_edge(); + SPtr<Edge> random_edge(); private: Node& operator=(const Node& other); // undefined - TimeStamp _enter_time; ///< valid iff _is_active - TimeDuration _duration; - SharedPtr<Action> _enter_action; - SharedPtr<Action> _exit_action; - Edges _edges; - Schrodinbit _changed; - bool _is_initial; - bool _is_selector; - bool _is_active; + TimeStamp _enter_time; ///< valid iff _is_active + TimeDuration _duration; + SPtr<Action> _enter_action; + SPtr<Action> _exit_action; + Edges _edges; + Schrodinbit _changed; + bool _is_initial; + bool _is_selector; + bool _is_active; }; } // namespace Machina diff --git a/src/engine/Problem.cpp b/src/engine/Problem.cpp index 2db4f45..3540b2b 100644 --- a/src/engine/Problem.cpp +++ b/src/engine/Problem.cpp @@ -38,8 +38,9 @@ using namespace std; namespace Machina { -Problem::Problem(TimeUnit unit, const std::string& target_midi, - SharedPtr<Machine> seed) +Problem::Problem(TimeUnit unit, + const std::string& target_midi, + SPtr<Machine> seed) : _unit(unit) , _target(*this) , _seed(new Machine(*seed.get())) @@ -86,7 +87,7 @@ Problem::fitness(const Machine& const_machine) const return cached->second; } - SharedPtr<Evaluator> eval(new Evaluator(*this)); + SPtr<Evaluator> eval(new Evaluator(*this)); //machine.reset(); machine.deactivate(); @@ -230,11 +231,11 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const // FIXME: ignores _seed and builds based on MIDI // evolution of the visible machine would be nice.. - SharedPtr<Machine> base = SharedPtr<Machine>(new Machine(_unit)); + SPtr<Machine> base = SPtr<Machine>(new Machine(_unit)); for (uint8_t i = 0; i < 128; ++i) { if (_target._counts[i] > 0) { //cout << "Initial note: " << (int)i << endl; - SharedPtr<Node> node(new Node(TimeDuration(_unit, 1 / 2.0))); + SPtr<Node> node(new Node(TimeDuration(_unit, 1 / 2.0))); node->set_enter_action(ActionFactory::note_on(i)); node->set_exit_action(ActionFactory::note_off(i)); node->set_selector(true); @@ -246,12 +247,12 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const // FIXME: double copy Machine m(*base.get()); - set< SharedPtr<Node> > unreachable; - SharedPtr<Node> initial; + set< SPtr<Node> > unreachable; + SPtr<Node> initial; for (Machine::Nodes::iterator i = m.nodes().begin(); i != m.nodes().end(); ++i) { - if (PtrCast<MidiAction>((*i)->enter_action())->event()[1] == + if (dynamic_ptr_cast<MidiAction>((*i)->enter_action())->event()[1] == _target.first_note()) { (*i)->set_initial(true); initial = *i; @@ -260,9 +261,9 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const } } - SharedPtr<Node> cur = initial; + SPtr<Node> cur = initial; unreachable.erase(cur); - SharedPtr<Node> head; + SPtr<Node> head; while (!unreachable.empty()) { if (rand() % 2) { @@ -272,7 +273,7 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const } if (!head->connected_to(head) ) { - cur->add_edge(SharedPtr<Edge>(new Edge(cur, head))); + cur->add_edge(SPtr<Edge>(new Edge(cur, head))); unreachable.erase(head); cur = head; } diff --git a/src/engine/Problem.hpp b/src/engine/Problem.hpp index a5fe853..7d96250 100644 --- a/src/engine/Problem.hpp +++ b/src/engine/Problem.hpp @@ -29,10 +29,12 @@ namespace Machina { class Problem : public Eugene::Problem<Machine> { public: - Problem(TimeUnit unit, const std::string& target_midi, SharedPtr<Machine> seed = SharedPtr<Machine>()); + Problem(TimeUnit unit, + const std::string& target_midi, + SPtr<Machine> seed = SPtr<Machine>()); virtual ~Problem() {} - void seed(SharedPtr<Machine> parent) { _seed = parent; } + void seed(SPtr<Machine> parent) { _seed = parent; } float fitness(const Machine& machine) const; @@ -109,8 +111,8 @@ private: TimeUnit _unit; - Evaluator _target; - SharedPtr<Machine> _seed; + Evaluator _target; + SPtr<Machine> _seed; /// for levenshtein distance mutable std::vector< std::vector<uint16_t> > _matrix; diff --git a/src/engine/Recorder.cpp b/src/engine/Recorder.cpp index 8bc9a4a..df9a200 100644 --- a/src/engine/Recorder.cpp +++ b/src/engine/Recorder.cpp @@ -34,8 +34,7 @@ Recorder::Recorder(Raul::Forge& forge, : _forge(forge) , _unit(unit) , _record_buffer(buffer_size) - , _builder(new MachineBuilder( - SharedPtr<Machine>(new Machine(unit)), q, step)) + , _builder(new MachineBuilder(SPtr<Machine>(new Machine(unit)), q, step)) {} void @@ -62,10 +61,10 @@ Recorder::_whipped() } } -SharedPtr<Machine> +SPtr<Machine> Recorder::finish() { - SharedPtr<Machine> machine = _builder->finish(); + SPtr<Machine> machine = _builder->finish(); _builder.reset(); return machine; } diff --git a/src/engine/Recorder.hpp b/src/engine/Recorder.hpp index ce9cad8..62295cf 100644 --- a/src/engine/Recorder.hpp +++ b/src/engine/Recorder.hpp @@ -18,10 +18,10 @@ #ifndef MACHINA_RECORDER_HPP #define MACHINA_RECORDER_HPP -#include "raul/SharedPtr.hpp" #include "raul/RingBuffer.hpp" #include "machina/Machine.hpp" +#include "machina/types.hpp" #include "Slave.hpp" @@ -52,15 +52,15 @@ public: } } - SharedPtr<Machine> finish(); + SPtr<Machine> finish(); private: virtual void _whipped(); - Raul::Forge& _forge; - TimeUnit _unit; - Raul::RingBuffer _record_buffer; - SharedPtr<MachineBuilder> _builder; + Raul::Forge& _forge; + TimeUnit _unit; + Raul::RingBuffer _record_buffer; + SPtr<MachineBuilder> _builder; }; } // namespace Machina diff --git a/src/engine/SMFDriver.cpp b/src/engine/SMFDriver.cpp index da7fecb..7401755 100644 --- a/src/engine/SMFDriver.cpp +++ b/src/engine/SMFDriver.cpp @@ -20,10 +20,9 @@ #include <glibmm/convert.h> -#include "raul/SharedPtr.hpp" - #include "machina/Context.hpp" #include "machina/Machine.hpp" +#include "machina/types.hpp" #include "Edge.hpp" #include "SMFDriver.hpp" @@ -36,9 +35,9 @@ using namespace std; namespace Machina { SMFDriver::SMFDriver(Raul::Forge& forge, Raul::TimeUnit unit) - : Driver(forge, SharedPtr<Machine>()) + : Driver(forge, SPtr<Machine>()) { - _writer = SharedPtr<SMFWriter>(new SMFWriter(unit)); + _writer = SPtr<SMFWriter>(new SMFWriter(unit)); } /** Learn a single track from the MIDI file at @a uri @@ -48,23 +47,25 @@ SMFDriver::SMFDriver(Raul::Forge& forge, Raul::TimeUnit unit) * Currently only file:// URIs are supported. * @return the resulting machine. */ -SharedPtr<Machine> -SMFDriver::learn(const string& filename, unsigned track, double q, +SPtr<Machine> +SMFDriver::learn(const string& filename, + unsigned track, + double q, Raul::TimeDuration max_duration) { //assert(q.unit() == max_duration.unit()); - SharedPtr<Machine> m(new Machine(max_duration.unit())); - SharedPtr<MachineBuilder> builder = SharedPtr<MachineBuilder>( + SPtr<Machine> m(new Machine(max_duration.unit())); + SPtr<MachineBuilder> builder = SPtr<MachineBuilder>( new MachineBuilder(m, q, false)); SMFReader reader; if (!reader.open(filename)) { cerr << "Unable to open MIDI file " << filename << endl; - return SharedPtr<Machine>(); + return SPtr<Machine>(); } if (track > reader.num_tracks()) { - return SharedPtr<Machine>(); + return SPtr<Machine>(); } else { learn_track(builder, reader, track, q, max_duration); } @@ -74,7 +75,7 @@ SMFDriver::learn(const string& filename, unsigned track, double q, if (m->nodes().size() > 1) { return m; } else { - return SharedPtr<Machine>(); + return SPtr<Machine>(); } } @@ -82,17 +83,17 @@ SMFDriver::learn(const string& filename, unsigned track, double q, * * This will result in one disjoint subgraph in the machine for each track. */ -SharedPtr<Machine> +SPtr<Machine> SMFDriver::learn(const string& filename, double q, Raul::TimeStamp max_duration) { - SharedPtr<Machine> m(new Machine(max_duration.unit())); - SharedPtr<MachineBuilder> builder = SharedPtr<MachineBuilder>( + SPtr<Machine> m(new Machine(max_duration.unit())); + SPtr<MachineBuilder> builder = SPtr<MachineBuilder>( new MachineBuilder(m, q, false)); SMFReader reader; if (!reader.open(filename)) { cerr << "Unable to open MIDI file " << filename << endl; - return SharedPtr<Machine>(); + return SPtr<Machine>(); } for (unsigned t = 1; t <= reader.num_tracks(); ++t) { @@ -105,16 +106,16 @@ SMFDriver::learn(const string& filename, double q, Raul::TimeStamp max_duration) if (m->nodes().size() > 1) { return m; } else { - return SharedPtr<Machine>(); + return SPtr<Machine>(); } } void -SMFDriver::learn_track(SharedPtr<MachineBuilder> builder, - SMFReader& reader, - unsigned track, - double q, - Raul::TimeDuration max_duration) +SMFDriver::learn_track(SPtr<MachineBuilder> builder, + SMFReader& reader, + unsigned track, + double q, + Raul::TimeDuration max_duration) { const bool found_track = reader.seek_to_track(track); if (!found_track) { @@ -153,7 +154,7 @@ SMFDriver::learn_track(SharedPtr<MachineBuilder> builder, } void -SMFDriver::run(SharedPtr<Machine> machine, Raul::TimeStamp max_time) +SMFDriver::run(SPtr<Machine> machine, Raul::TimeStamp max_time) { // FIXME: unit kludge (tempo only) Context context(_forge, machine->time().unit().ppt(), @@ -161,7 +162,7 @@ SMFDriver::run(SharedPtr<Machine> machine, Raul::TimeStamp max_time) context.set_sink(this); context.time().set_slice(TimeStamp(max_time.unit(), 0, 0), context.time().beats_to_ticks(max_time)); - machine->run(context, SharedPtr<UpdateBuffer>()); + machine->run(context, SPtr<UpdateBuffer>()); } } // namespace Machina diff --git a/src/engine/SMFDriver.hpp b/src/engine/SMFDriver.hpp index abed40d..ee3c220 100644 --- a/src/engine/SMFDriver.hpp +++ b/src/engine/SMFDriver.hpp @@ -20,8 +20,6 @@ #include <glibmm/ustring.h> -#include "raul/SharedPtr.hpp" - #include "machina/Driver.hpp" #include "machina/types.hpp" @@ -40,16 +38,16 @@ class SMFDriver public: SMFDriver(Raul::Forge& forge, Raul::TimeUnit unit); - SharedPtr<Machine> learn(const std::string& filename, - double q, - Raul::TimeDuration max_duration); + SPtr<Machine> learn(const std::string& filename, + double q, + Raul::TimeDuration max_duration); - SharedPtr<Machine> learn(const std::string& filename, - unsigned track, - double q, - Raul::TimeDuration max_duration); + SPtr<Machine> learn(const std::string& filename, + unsigned track, + double q, + Raul::TimeDuration max_duration); - void run(SharedPtr<Machine> machine, Raul::TimeStamp max_time); + void run(SPtr<Machine> machine, Raul::TimeStamp max_time); void write_event(Raul::TimeStamp time, size_t ev_size, @@ -59,16 +57,16 @@ public: void set_bpm(double /*bpm*/) {} void set_quantization(double /*quantization*/) {} - SharedPtr<SMFWriter> writer() { return _writer; } + SPtr<SMFWriter> writer() { return _writer; } private: - SharedPtr<SMFWriter> _writer; + SPtr<SMFWriter> _writer; - void learn_track(SharedPtr<MachineBuilder> builder, - SMFReader& reader, - unsigned track, - double q, - Raul::TimeDuration max_duration); + void learn_track(SPtr<MachineBuilder> builder, + SMFReader& reader, + unsigned track, + double q, + Raul::TimeDuration max_duration); }; } // namespace Machina diff --git a/src/engine/Updates.cpp b/src/engine/Updates.cpp index 16717e4..275ca2b 100644 --- a/src/engine/Updates.cpp +++ b/src/engine/Updates.cpp @@ -18,7 +18,6 @@ #include "lv2/lv2plug.in/ns/ext/atom/atom.h" #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" #include "machina/types.hpp" #include "machina/Updates.hpp" @@ -26,10 +25,10 @@ namespace Machina { void -write_set(SharedPtr<UpdateBuffer> buf, - uint64_t subject, - URIInt key, - const Raul::Atom& value) +write_set(SPtr<UpdateBuffer> buf, + uint64_t subject, + URIInt key, + const Raul::Atom& value) { const uint32_t update_type = UPDATE_SET; buf->write(sizeof(update_type), &update_type); @@ -42,10 +41,10 @@ write_set(SharedPtr<UpdateBuffer> buf, } uint32_t -read_set(SharedPtr<UpdateBuffer> buf, - uint64_t* subject, - URIInt* key, - Raul::Atom* value) +read_set(SPtr<UpdateBuffer> buf, + uint64_t* subject, + URIInt* key, + Raul::Atom* value) { uint32_t update_type; buf->read(sizeof(update_type), &update_type); 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 <set> -#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> engine, Client::ClientModel& client_model); + Controller(SPtr<Engine> 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<Raul::Maid> maid, uint64_t node_id); + void learn(SPtr<Raul::Maid> maid, uint64_t node_id); void disconnect(uint64_t tail_id, uint64_t head_id); void erase(uint64_t id); - void announce(SharedPtr<Machine> machine); + void announce(SPtr<Machine> machine); void process_updates(); private: - SharedPtr<Stateful> find(uint64_t id); + SPtr<Stateful> find(uint64_t id); struct StatefulComparator { - inline bool operator()(SharedPtr<Stateful> lhs, - SharedPtr<Stateful> rhs) const { + inline bool operator()(SPtr<Stateful> lhs, + SPtr<Stateful> rhs) const { return lhs->id() < rhs->id(); } }; - typedef std::set<SharedPtr<Stateful>, StatefulComparator> Objects; + typedef std::set<SPtr<Stateful>, StatefulComparator> Objects; Objects _objects; - SharedPtr<Engine> _engine; + SPtr<Engine> _engine; Client::ClientModel& _client_model; - SharedPtr<UpdateBuffer> _updates; + SPtr<UpdateBuffer> _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> machine) + Driver(Raul::Forge& forge, SPtr<Machine> machine) : _forge(forge) , _machine(machine) {} virtual ~Driver() {} - SharedPtr<Machine> machine() { return _machine; } + SPtr<Machine> machine() { return _machine; } - virtual void set_machine(SharedPtr<Machine> machine) { + virtual void set_machine(SPtr<Machine> machine) { _machine = machine; } - SharedPtr<UpdateBuffer> update_sink() { return _updates; } + SPtr<UpdateBuffer> update_sink() { return _updates; } - void set_update_sink(SharedPtr<UpdateBuffer> b) { + void set_update_sink(SPtr<UpdateBuffer> b) { _updates = b; } @@ -65,9 +65,9 @@ public: virtual void finish_record() {} protected: - Raul::Forge& _forge; - SharedPtr<Machine> _machine; - SharedPtr<UpdateBuffer> _updates; + Raul::Forge& _forge; + SPtr<Machine> _machine; + SPtr<UpdateBuffer> _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 <glibmm/ustring.h> #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> driver, - Sord::World& rdf_world); + Engine(Raul::Forge& forge, + SPtr<Driver> driver, + Sord::World& rdf_world); Sord::World& rdf_world() { return _rdf_world; } - static SharedPtr<Driver> new_driver(Raul::Forge& forge, - const std::string& name, - SharedPtr<Machine> machine); + static SPtr<Driver> new_driver(Raul::Forge& forge, + const std::string& name, + SPtr<Machine> machine); - SharedPtr<Driver> driver() { return _driver; } - SharedPtr<Machine> machine() { return _driver->machine(); } - Raul::Forge& forge() { return _forge; } + SPtr<Driver> driver() { return _driver; } + SPtr<Machine> machine() { return _driver->machine(); } + Raul::Forge& forge() { return _forge; } - SharedPtr<Machine> load_machine(const Glib::ustring& uri); - SharedPtr<Machine> load_machine_midi(const Glib::ustring& uri, - double q, - Raul::TimeDuration dur); + SPtr<Machine> load_machine(const Glib::ustring& uri); + SPtr<Machine> load_machine_midi(const Glib::ustring& uri, + double q, + Raul::TimeDuration dur); - void import_machine(SharedPtr<Machine> machine); + void import_machine(SPtr<Machine> 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> _driver; - Sord::World& _rdf_world; - Loader _loader; - Raul::Forge _forge; + SPtr<Driver> _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<Machine> seed); + Evolver(Raul::TimeUnit unit, + const string& target_midi, + SPtr<Machine> seed); - void seed(SharedPtr<Machine> parent); + void seed(SPtr<Machine> parent); bool improvement() { return _improvement; } - SharedPtr<const Machine> best() { return _ga->best(); } + SPtr<const Machine> best() { return _ga->best(); } typedef Eugene::GAImpl<Machine> MachinaGA; private: void _run(); - SharedPtr<MachinaGA> _ga; - SharedPtr<Problem> _problem; - float _seed_fitness; - Schrodinbit _improvement; + SPtr<MachinaGA> _ga; + SPtr<Problem> _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 <glibmm/ustring.h> +#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<Machine> load(const Glib::ustring& filename); + SPtr<Machine> 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 <vector> +#include <set> #include <boost/utility.hpp> +#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> node); - void remove_node(SharedPtr<Node> node); - void learn(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node); + void add_node(SPtr<Node> node); + void remove_node(SPtr<Node> node); + void learn(SPtr<Raul::Maid> maid, SPtr<Node> node); void write_state(Sord::Model& model); // Audio context void reset(MIDISink* sink, Raul::TimeStamp time); - uint32_t run(Context& context, SharedPtr<UpdateBuffer> updates); + uint32_t run(Context& context, SPtr<UpdateBuffer> updates); // Any context inline Raul::TimeStamp time() const { return _time; } - SharedPtr<LearnRequest> pending_learn() { return _pending_learn; } - void clear_pending_learn() { _pending_learn.reset(); } + SPtr<LearnRequest> pending_learn() { return _pending_learn; } + void clear_pending_learn() { _pending_learn.reset(); } - typedef std::list< SharedPtr<Node> > Nodes; + typedef std::set< SPtr<Node> > Nodes; Nodes& nodes() { return _nodes; } const Nodes& nodes() const { return _nodes; } - SharedPtr<Node> random_node(); - SharedPtr<Edge> random_edge(); + SPtr<Node> random_node(); + SPtr<Edge> random_edge(); private: // Audio context - SharedPtr<Node> earliest_node() const; + SPtr<Node> earliest_node() const; + + bool enter_node(Context& context, + SPtr<Node> node, + SPtr<UpdateBuffer> updates); - bool enter_node(Context& context, - SharedPtr<Node> node, - SharedPtr<UpdateBuffer> updates); + void exit_node(Context& context, + SPtr<Node> node, + SPtr<UpdateBuffer> updates); - void exit_node(Context& context, - SharedPtr<Node> node, - SharedPtr<UpdateBuffer> updates); + static const size_t MAX_ACTIVE_NODES = 128; - static const size_t MAX_ACTIVE_NODES = 128; - std::vector< SharedPtr<Node> > _active_nodes; + std::vector< SPtr<Node> > _active_nodes; - SharedPtr<LearnRequest> _pending_learn; - Nodes _nodes; - Raul::TimeStamp _time; - bool _is_activated; - bool _is_finished; + SPtr<LearnRequest> _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 <stdint.h> #include "raul/Atom.hpp" -#include "raul/SharedPtr.hpp" #include "machina/types.hpp" @@ -32,16 +31,16 @@ enum UpdateType { }; void -write_set(SharedPtr<UpdateBuffer> buf, - uint64_t subject, - URIInt key, - const Raul::Atom& value); +write_set(SPtr<UpdateBuffer> buf, + uint64_t subject, + URIInt key, + const Raul::Atom& value); uint32_t -read_set(SharedPtr<UpdateBuffer> buf, - uint64_t* subject, - URIInt* key, - Raul::Atom* value); +read_set(SPtr<UpdateBuffer> 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 <memory> + #include "raul/RingBuffer.hpp" namespace Machina { @@ -28,6 +30,30 @@ typedef Raul::RingBuffer UpdateBuffer; typedef uint32_t URIInt; +template <class T> +using SPtr = std::shared_ptr<T>; + +template <class T> +using WPtr = std::weak_ptr<T>; + +template <class T> +void NullDeleter(T* ptr) {} + +template<class T, class U> +SPtr<T> static_ptr_cast(const SPtr<U>& r) { + return std::static_pointer_cast<T>(r); +} + +template<class T, class U> +SPtr<T> dynamic_ptr_cast(const SPtr<U>& r) { + return std::dynamic_pointer_cast<T>(r); +} + +template<class T, class U> +SPtr<T> const_ptr_cast(const SPtr<U>& r) { + return std::const_pointer_cast<T>(r); +} + } // namespace Machina #endif // MACHINA_TYPES_HPP |