aboutsummaryrefslogtreecommitdiffstats
path: root/src/engine
diff options
context:
space:
mode:
Diffstat (limited to 'src/engine')
-rw-r--r--src/engine/Action.hpp10
-rw-r--r--src/engine/ActionFactory.cpp18
-rw-r--r--src/engine/ActionFactory.hpp8
-rw-r--r--src/engine/Controller.cpp51
-rw-r--r--src/engine/Edge.cpp4
-rw-r--r--src/engine/Edge.hpp16
-rw-r--r--src/engine/Engine.cpp44
-rw-r--r--src/engine/Evolver.cpp15
-rw-r--r--src/engine/JackDriver.cpp33
-rw-r--r--src/engine/JackDriver.hpp24
-rw-r--r--src/engine/LearnRequest.cpp8
-rw-r--r--src/engine/LearnRequest.hpp23
-rw-r--r--src/engine/Loader.cpp37
-rw-r--r--src/engine/Machine.cpp80
-rw-r--r--src/engine/MachineBuilder.cpp64
-rw-r--r--src/engine/MachineBuilder.hpp38
-rw-r--r--src/engine/MidiAction.cpp1
-rw-r--r--src/engine/Mutation.cpp46
-rw-r--r--src/engine/Node.cpp66
-rw-r--r--src/engine/Node.hpp56
-rw-r--r--src/engine/Problem.cpp23
-rw-r--r--src/engine/Problem.hpp10
-rw-r--r--src/engine/Recorder.cpp7
-rw-r--r--src/engine/Recorder.hpp12
-rw-r--r--src/engine/SMFDriver.cpp47
-rw-r--r--src/engine/SMFDriver.hpp32
-rw-r--r--src/engine/Updates.cpp17
-rw-r--r--src/engine/machina/Context.hpp2
-rw-r--r--src/engine/machina/Controller.hpp22
-rw-r--r--src/engine/machina/Driver.hpp16
-rw-r--r--src/engine/machina/Engine.hpp38
-rw-r--r--src/engine/machina/Evolver.hpp19
-rw-r--r--src/engine/machina/Loader.hpp5
-rw-r--r--src/engine/machina/Machine.hpp53
-rw-r--r--src/engine/machina/Updates.hpp17
-rw-r--r--src/engine/machina/types.hpp26
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