aboutsummaryrefslogtreecommitdiffstats
path: root/src/engine/Machine.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/engine/Machine.cpp')
-rw-r--r--src/engine/Machine.cpp80
1 files changed, 39 insertions, 41 deletions
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);
}
generated by cgit v1.2.1 (git 2.18.0) at 2024-09-29 06:00:44 +0000