From df1447c665e6c3631961297a9d3e9aff4e94c47f Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 12 Jan 2013 23:38:03 +0000 Subject: Remove Raul::SharedPtr and switch to std::shared_ptr. Use project local short type aliases for shared_ptr and friends. Move Raul::Disposable and Raul::Manageable into Raul::Maid. Use sets to store machina nodes and edges to avoid O(n) searches. git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@4939 a436a847-0d15-0410-975c-d299462d15a1 --- ingen/Builder.hpp | 6 ++-- ingen/EngineBase.hpp | 7 +++-- ingen/Interface.hpp | 8 +++--- ingen/LV2Features.hpp | 18 ++++++------ ingen/Node.hpp | 6 ++-- ingen/Store.hpp | 10 ++++--- ingen/URIMap.hpp | 12 ++++---- ingen/World.hpp | 40 +++++++++++++------------- ingen/client/ArcModel.hpp | 12 ++++---- ingen/client/BlockModel.hpp | 58 ++++++++++++++++++++------------------ ingen/client/ClientStore.hpp | 56 ++++++++++++++++++------------------ ingen/client/GraphModel.hpp | 20 ++++++------- ingen/client/ObjectModel.hpp | 24 ++++++++-------- ingen/client/PluginModel.hpp | 8 +++--- ingen/client/PluginUI.hpp | 28 +++++++++--------- ingen/client/PortModel.hpp | 16 +++++------ ingen/serialisation/Serialiser.hpp | 19 ++++++------- 17 files changed, 177 insertions(+), 171 deletions(-) (limited to 'ingen') diff --git a/ingen/Builder.hpp b/ingen/Builder.hpp index 96096b3d..728a5cb9 100644 --- a/ingen/Builder.hpp +++ b/ingen/Builder.hpp @@ -17,7 +17,7 @@ #ifndef INGEN_BUILDER_HPP #define INGEN_BUILDER_HPP -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" namespace Ingen { @@ -35,8 +35,8 @@ public: Builder(URIs& uris, Interface& interface); virtual ~Builder() {} - void build(SharedPtr object); - void connect(SharedPtr object); + void build(SPtr object); + void connect(SPtr object); private: URIs& _uris; diff --git a/ingen/EngineBase.hpp b/ingen/EngineBase.hpp index caa1cf00..311bef3a 100644 --- a/ingen/EngineBase.hpp +++ b/ingen/EngineBase.hpp @@ -20,7 +20,8 @@ #include #include "raul/URI.hpp" -#include "raul/SharedPtr.hpp" + +#include "ingen/types.hpp" namespace Ingen { @@ -93,8 +94,8 @@ public: /** Register a client to receive updates about engine changes. */ - virtual void register_client(const Raul::URI& uri, - SharedPtr client) = 0; + virtual void register_client(const Raul::URI& uri, + SPtr client) = 0; /** Unregister a client. diff --git a/ingen/Interface.hpp b/ingen/Interface.hpp index 7f1fe9b7..023221bd 100644 --- a/ingen/Interface.hpp +++ b/ingen/Interface.hpp @@ -25,7 +25,7 @@ #include "ingen/Resource.hpp" #include "ingen/Status.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" namespace Raul { class Atom; @@ -47,11 +47,11 @@ public: virtual Raul::URI uri() const = 0; - virtual SharedPtr respondee() const { - return SharedPtr(); + virtual SPtr respondee() const { + return SPtr(); } - virtual void set_respondee(SharedPtr respondee) {} + virtual void set_respondee(SPtr respondee) {} /** Begin an atomic bundle */ virtual void bundle_begin() = 0; diff --git a/ingen/LV2Features.hpp b/ingen/LV2Features.hpp index 214d62bb..be8f777b 100644 --- a/ingen/LV2Features.hpp +++ b/ingen/LV2Features.hpp @@ -20,10 +20,10 @@ #include #include "lv2/lv2plug.in/ns/lv2core/lv2.h" - -#include "raul/SharedPtr.hpp" #include "raul/Noncopyable.hpp" +#include "ingen/types.hpp" + namespace Ingen { class Node; @@ -42,13 +42,13 @@ public: virtual const char* uri() const = 0; - virtual SharedPtr feature(World* world, - Node* block) = 0; + virtual SPtr feature(World* world, + Node* block) = 0; }; class FeatureArray : public Raul::Noncopyable { public: - typedef std::vector< SharedPtr > FeatureVector; + typedef std::vector< SPtr > FeatureVector; explicit FeatureArray(FeatureVector& features); @@ -61,14 +61,14 @@ public: LV2_Feature** _array; }; - void add_feature(SharedPtr feature); + void add_feature(SPtr feature); bool is_supported(const std::string& uri) const; - SharedPtr lv2_features(World* world, - Node* block) const; + SPtr lv2_features(World* world, + Node* block) const; private: - typedef std::vector< SharedPtr > Features; + typedef std::vector< SPtr > Features; Features _features; }; diff --git a/ingen/Node.hpp b/ingen/Node.hpp index d61732ff..2cbce01c 100644 --- a/ingen/Node.hpp +++ b/ingen/Node.hpp @@ -17,9 +17,9 @@ #ifndef INGEN_NODE_HPP #define INGEN_NODE_HPP -#include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "ingen/Resource.hpp" +#include "ingen/types.hpp" +#include "raul/Path.hpp" namespace Raul { class Atom; @@ -55,7 +55,7 @@ public: }; typedef std::pair ArcsKey; - typedef std::map< ArcsKey, SharedPtr > Arcs; + typedef std::map< ArcsKey, SPtr > Arcs; // Graphs only Arcs& arcs() { return _arcs; } diff --git a/ingen/Store.hpp b/ingen/Store.hpp index c176cdd3..dcab2532 100644 --- a/ingen/Store.hpp +++ b/ingen/Store.hpp @@ -22,10 +22,12 @@ #undef nil #include -#include "ingen/Node.hpp" #include "raul/Deletable.hpp" #include "raul/Noncopyable.hpp" +#include "ingen/Node.hpp" +#include "ingen/types.hpp" + namespace Ingen { /** Store of objects in the graph hierarchy. @@ -33,7 +35,7 @@ namespace Ingen { */ class Store : public Raul::Noncopyable , public Raul::Deletable - , public std::map< const Raul::Path, SharedPtr > { + , public std::map< const Raul::Path, SPtr > { public: void add(Node* o); @@ -44,12 +46,12 @@ public: typedef std::pair const_range; - typedef std::map< Raul::Path, SharedPtr > Objects; + typedef std::map< Raul::Path, SPtr > Objects; iterator find_descendants_end(Store::iterator parent); const_iterator find_descendants_end(Store::const_iterator parent) const; - const_range children_range(SharedPtr o) const; + const_range children_range(SPtr o) const; /** Remove the object at @p top and all its children from the store. * diff --git a/ingen/URIMap.hpp b/ingen/URIMap.hpp index e5ca71e3..a275fdff 100644 --- a/ingen/URIMap.hpp +++ b/ingen/URIMap.hpp @@ -48,8 +48,8 @@ public: const char* uri() const { return _feature.URI; } - SharedPtr feature(World*, Node*) { - return SharedPtr(&_feature, NullDeleter); + SPtr feature(World*, Node*) { + return SPtr(&_feature, NullDeleter); } private: @@ -71,12 +71,12 @@ public: LV2_URID_Unmap urid_unmap; }; - SharedPtr urid_map_feature() { return _urid_map_feature; } - SharedPtr urid_unmap_feature() { return _urid_unmap_feature; } + SPtr urid_map_feature() { return _urid_map_feature; } + SPtr urid_unmap_feature() { return _urid_unmap_feature; } private: - SharedPtr _urid_map_feature; - SharedPtr _urid_unmap_feature; + SPtr _urid_map_feature; + SPtr _urid_unmap_feature; }; } // namespace Ingen diff --git a/ingen/World.hpp b/ingen/World.hpp index 16ad5731..fb412afc 100644 --- a/ingen/World.hpp +++ b/ingen/World.hpp @@ -19,10 +19,10 @@ #include -#include "lv2/lv2plug.in/ns/ext/urid/urid.h" +#include "ingen/types.hpp" #include "lv2/lv2plug.in/ns/ext/log/log.h" +#include "lv2/lv2plug.in/ns/ext/urid/urid.h" #include "raul/Noncopyable.hpp" -#include "raul/SharedPtr.hpp" #include "raul/URI.hpp" typedef struct LilvWorldImpl LilvWorld; @@ -93,10 +93,10 @@ public: virtual bool run_module(const char* name); /** A function to create a new remote Interface. */ - typedef SharedPtr (*InterfaceFactory)( - World* world, - const Raul::URI& engine_uri, - SharedPtr respondee); + typedef SPtr (*InterfaceFactory)( + World* world, + const Raul::URI& engine_uri, + SPtr respondee); /** Register an InterfaceFactory (for module implementations). */ virtual void add_interface_factory(const std::string& scheme, @@ -107,25 +107,25 @@ public: * @param respondee The Interface that will receive responses to commands * and broadcasts, if applicable. */ - virtual SharedPtr new_interface( - const Raul::URI& engine_uri, - SharedPtr respondee); + virtual SPtr new_interface( + const Raul::URI& engine_uri, + SPtr respondee); /** Run a script. */ virtual bool run(const std::string& mime_type, const std::string& filename); - virtual void set_engine(SharedPtr e); - virtual void set_interface(SharedPtr e); - virtual void set_parser(SharedPtr p); - virtual void set_serialiser(SharedPtr s); - virtual void set_store(SharedPtr s); - - virtual SharedPtr engine(); - virtual SharedPtr interface(); - virtual SharedPtr parser(); - virtual SharedPtr serialiser(); - virtual SharedPtr store(); + virtual void set_engine(SPtr e); + virtual void set_interface(SPtr e); + virtual void set_parser(SPtr p); + virtual void set_serialiser(SPtr s); + virtual void set_store(SPtr s); + + virtual SPtr engine(); + virtual SPtr interface(); + virtual SPtr parser(); + virtual SPtr serialiser(); + virtual SPtr store(); virtual int& argc(); virtual char**& argv(); diff --git a/ingen/client/ArcModel.hpp b/ingen/client/ArcModel.hpp index 99d5afa0..4306be09 100644 --- a/ingen/client/ArcModel.hpp +++ b/ingen/client/ArcModel.hpp @@ -19,8 +19,8 @@ #include +#include "ingen/types.hpp" #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "ingen/Arc.hpp" #include "ingen/client/PortModel.hpp" @@ -37,8 +37,8 @@ class ClientStore; class ArcModel : public Arc { public: - SharedPtr tail() const { return _tail; } - SharedPtr head() const { return _head; } + SPtr tail() const { return _tail; } + SPtr head() const { return _head; } const Raul::Path& tail_path() const { return _tail->path(); } const Raul::Path& head_path() const { return _head->path(); } @@ -46,7 +46,7 @@ public: private: friend class ClientStore; - ArcModel(SharedPtr tail, SharedPtr head) + ArcModel(SPtr tail, SPtr head) : _tail(tail) , _head(head) { @@ -57,8 +57,8 @@ private: assert(_tail->path() != _head->path()); } - const SharedPtr _tail; - const SharedPtr _head; + const SPtr _tail; + const SPtr _head; }; } // namespace Client diff --git a/ingen/client/BlockModel.hpp b/ingen/client/BlockModel.hpp index 3262b230..b5db2b0d 100644 --- a/ingen/client/BlockModel.hpp +++ b/ingen/client/BlockModel.hpp @@ -21,11 +21,11 @@ #include #include -#include "raul/SharedPtr.hpp" #include "ingen/Node.hpp" #include "ingen/client/ObjectModel.hpp" #include "ingen/client/PluginModel.hpp" #include "ingen/client/PortModel.hpp" +#include "ingen/types.hpp" namespace Raul { class Path; } @@ -50,31 +50,35 @@ public: GraphType graph_type() const { return Node::GraphType::BLOCK; } - typedef std::vector< SharedPtr > Ports; + typedef std::vector< SPtr > Ports; - SharedPtr get_port(const Raul::Symbol& symbol) const; + SPtr get_port(const Raul::Symbol& symbol) const; Node* port(uint32_t index) const; - const Raul::URI& plugin_uri() const { return _plugin_uri; } - const Plugin* plugin() const { return _plugin.get(); } - Plugin* plugin() { return _plugin.get(); } - SharedPtr plugin_model() const { return _plugin; } - uint32_t num_ports() const { return _ports.size(); } - const Ports& ports() const { return _ports; } + const Raul::URI& plugin_uri() const { return _plugin_uri; } + const Plugin* plugin() const { return _plugin.get(); } + Plugin* plugin() { return _plugin.get(); } + SPtr plugin_model() const { return _plugin; } + uint32_t num_ports() const { return _ports.size(); } + const Ports& ports() const { return _ports; } - void default_port_value_range(SharedPtr port, - float& min, float& max, uint32_t srate=1) const; + void default_port_value_range(SPtr port, + float& min, + float& max, + uint32_t srate = 1) const; - void port_value_range(SharedPtr port, - float& min, float& max, uint32_t srate=1) const; + void port_value_range(SPtr port, + float& min, + float& max, + uint32_t srate = 1) const; std::string label() const; - std::string port_label(SharedPtr port) const; + std::string port_label(SPtr port) const; // Signals - INGEN_SIGNAL(new_port, void, SharedPtr); - INGEN_SIGNAL(removed_port, void, SharedPtr); + INGEN_SIGNAL(new_port, void, SPtr); + INGEN_SIGNAL(removed_port, void, SPtr); protected: friend class ClientStore; @@ -82,23 +86,23 @@ protected: BlockModel(URIs& uris, const Raul::URI& plugin_uri, const Raul::Path& path); - BlockModel(URIs& uris, - SharedPtr plugin, - const Raul::Path& path); + BlockModel(URIs& uris, + SPtr plugin, + const Raul::Path& path); explicit BlockModel(const Raul::Path& path); - void add_child(SharedPtr c); - bool remove_child(SharedPtr c); - void add_port(SharedPtr pm); - void remove_port(SharedPtr pm); + void add_child(SPtr c); + bool remove_child(SPtr c); + void add_port(SPtr pm); + void remove_port(SPtr pm); void remove_port(const Raul::Path& port_path); - void set(SharedPtr model); + void set(SPtr model); virtual void clear(); - Ports _ports; ///< Vector of ports - Raul::URI _plugin_uri; ///< Plugin URI (if PluginModel is unknown) - SharedPtr _plugin; ///< The plugin this block is an instance of + Ports _ports; ///< Vector of ports + Raul::URI _plugin_uri; ///< Plugin URI (if PluginModel is unknown) + SPtr _plugin; ///< The plugin this block is an instance of private: mutable uint32_t _num_values; ///< Size of _min_values and _max_values diff --git a/ingen/client/ClientStore.hpp b/ingen/client/ClientStore.hpp index 3d7d724a..e9c85ba9 100644 --- a/ingen/client/ClientStore.hpp +++ b/ingen/client/ClientStore.hpp @@ -22,10 +22,10 @@ #include #include "ingen/Interface.hpp" -#include "ingen/client/signal.hpp" #include "ingen/Store.hpp" +#include "ingen/client/signal.hpp" +#include "ingen/types.hpp" #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" namespace Raul { class Atom; } @@ -53,23 +53,23 @@ class ClientStore : public Store , public INGEN_TRACKABLE { public: ClientStore( - URIs& uris, - Log& log, - SharedPtr engine = SharedPtr(), - SharedPtr emitter = SharedPtr()); + URIs& uris, + Log& log, + SPtr engine = SPtr(), + SPtr emitter = SPtr()); Raul::URI uri() const { return Raul::URI("ingen:/clients/store"); } - SharedPtr object(const Raul::Path& path) const; - SharedPtr plugin(const Raul::URI& uri) const; - SharedPtr resource(const Raul::URI& uri) const; + SPtr object(const Raul::Path& path) const; + SPtr plugin(const Raul::URI& uri) const; + SPtr resource(const Raul::URI& uri) const; void clear(); - typedef std::map< const Raul::URI, SharedPtr > Plugins; - SharedPtr plugins() const { return _plugins; } - SharedPtr plugins() { return _plugins; } - void set_plugins(SharedPtr p) { _plugins = p; } + typedef std::map< const Raul::URI, SPtr > Plugins; + SPtr plugins() const { return _plugins; } + SPtr plugins() { return _plugins; } + void set_plugins(SPtr p) { _plugins = p; } URIs& uris() { return _uris; } @@ -104,21 +104,21 @@ public: void response(int32_t id, Status status, const std::string& subject) {} void error(const std::string& msg) {} - INGEN_SIGNAL(new_object, void, SharedPtr); - INGEN_SIGNAL(new_plugin, void, SharedPtr); + INGEN_SIGNAL(new_object, void, SPtr); + INGEN_SIGNAL(new_plugin, void, SPtr); private: - SharedPtr _object(const Raul::Path& path); - SharedPtr _plugin(const Raul::URI& uri); - SharedPtr _resource(const Raul::URI& uri); + SPtr _object(const Raul::Path& path); + SPtr _plugin(const Raul::URI& uri); + SPtr _resource(const Raul::URI& uri); - void add_object(SharedPtr object); - SharedPtr remove_object(const Raul::Path& path); + void add_object(SPtr object); + SPtr remove_object(const Raul::Path& path); - void add_plugin(SharedPtr plugin); + void add_plugin(SPtr plugin); - SharedPtr connection_graph(const Raul::Path& tail_path, - const Raul::Path& head_path); + SPtr connection_graph(const Raul::Path& tail_path, + const Raul::Path& head_path); void bundle_begin() {} void bundle_end() {} @@ -127,12 +127,12 @@ private: bool attempt_connection(const Raul::Path& tail_path, const Raul::Path& head_path); - URIs& _uris; - Log& _log; - SharedPtr _engine; - SharedPtr _emitter; + URIs& _uris; + Log& _log; + SPtr _engine; + SPtr _emitter; - SharedPtr _plugins; ///< Map, keyed by plugin URI + SPtr _plugins; ///< Map, keyed by plugin URI }; } // namespace Client diff --git a/ingen/client/GraphModel.hpp b/ingen/client/GraphModel.hpp index 996e9129..7a899ecb 100644 --- a/ingen/client/GraphModel.hpp +++ b/ingen/client/GraphModel.hpp @@ -18,7 +18,7 @@ #define INGEN_CLIENT_GRAPHMODEL_HPP #include "ingen/client/BlockModel.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" namespace Ingen { namespace Client { @@ -37,18 +37,18 @@ public: GraphType graph_type() const { return Node::GraphType::GRAPH; } - SharedPtr get_arc(const Ingen::Node* tail, - const Ingen::Node* head); + SPtr get_arc(const Ingen::Node* tail, + const Ingen::Node* head); bool enabled() const; bool polyphonic() const; uint32_t internal_poly() const; // Signals - INGEN_SIGNAL(new_block, void, SharedPtr); - INGEN_SIGNAL(removed_block, void, SharedPtr); - INGEN_SIGNAL(new_arc, void, SharedPtr); - INGEN_SIGNAL(removed_arc, void, SharedPtr); + INGEN_SIGNAL(new_block, void, SPtr); + INGEN_SIGNAL(removed_block, void, SPtr); + INGEN_SIGNAL(new_arc, void, SPtr); + INGEN_SIGNAL(removed_arc, void, SPtr); private: friend class ClientStore; @@ -58,10 +58,10 @@ private: {} void clear(); - void add_child(SharedPtr c); - bool remove_child(SharedPtr c); + void add_child(SPtr c); + bool remove_child(SPtr c); - void add_arc(SharedPtr arc); + void add_arc(SPtr arc); void remove_arc(const Ingen::Node* tail, const Ingen::Node* head); }; diff --git a/ingen/client/ObjectModel.hpp b/ingen/client/ObjectModel.hpp index 60e873e4..52655949 100644 --- a/ingen/client/ObjectModel.hpp +++ b/ingen/client/ObjectModel.hpp @@ -25,8 +25,8 @@ #include #include +#include "ingen/types.hpp" #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "raul/URI.hpp" #include "ingen/Node.hpp" @@ -63,16 +63,16 @@ public: void on_property(const Raul::URI& uri, const Raul::Atom& value); - const Raul::Path& path() const { return _path; } - const Raul::Symbol& symbol() const { return _symbol; } - SharedPtr parent() const { return _parent; } - bool polyphonic() const; + const Raul::Path& path() const { return _path; } + const Raul::Symbol& symbol() const { return _symbol; } + SPtr parent() const { return _parent; } + bool polyphonic() const; Node* graph_parent() const { return _parent.get(); } // Signals - INGEN_SIGNAL(new_child, void, SharedPtr); - INGEN_SIGNAL(removed_child, void, SharedPtr); + INGEN_SIGNAL(new_child, void, SPtr); + INGEN_SIGNAL(removed_child, void, SPtr); INGEN_SIGNAL(property, void, const Raul::URI&, const Raul::Atom&); INGEN_SIGNAL(destroyed, void); INGEN_SIGNAL(moved, void); @@ -84,13 +84,13 @@ protected: ObjectModel(const ObjectModel& copy); virtual void set_path(const Raul::Path& p); - virtual void set_parent(SharedPtr p); - virtual void add_child(SharedPtr c) {} - virtual bool remove_child(SharedPtr c) { return true; } + virtual void set_parent(SPtr p); + virtual void add_child(SPtr c) {} + virtual bool remove_child(SPtr c) { return true; } - virtual void set(SharedPtr model); + virtual void set(SPtr model); - SharedPtr _parent; + SPtr _parent; private: Raul::Path _path; diff --git a/ingen/client/PluginModel.hpp b/ingen/client/PluginModel.hpp index 4195dfe2..dea85651 100644 --- a/ingen/client/PluginModel.hpp +++ b/ingen/client/PluginModel.hpp @@ -26,8 +26,8 @@ #include "ingen/Resource.hpp" #include "ingen/World.hpp" #include "ingen/client/signal.hpp" +#include "ingen/types.hpp" #include "lilv/lilv.h" -#include "raul/SharedPtr.hpp" #include "raul/Symbol.hpp" #include "sord/sordmm.hpp" @@ -74,8 +74,8 @@ public: bool has_ui() const; - SharedPtr ui(Ingen::World* world, - SharedPtr block) const; + SPtr ui(Ingen::World* world, + SPtr block) const; const std::string& icon_path() const; static std::string get_lv2_icon_path(const LilvPlugin* plugin); @@ -95,7 +95,7 @@ public: protected: friend class ClientStore; - void set(SharedPtr p); + void set(SPtr p); private: Type _type; diff --git a/ingen/client/PluginUI.hpp b/ingen/client/PluginUI.hpp index 60403570..b2a8bd6b 100644 --- a/ingen/client/PluginUI.hpp +++ b/ingen/client/PluginUI.hpp @@ -17,7 +17,7 @@ #ifndef INGEN_CLIENT_PLUGINUI_HPP #define INGEN_CLIENT_PLUGINUI_HPP -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "lilv/lilv.h" @@ -42,9 +42,9 @@ class PluginUI { public: ~PluginUI(); - static SharedPtr create(Ingen::World* world, - SharedPtr block, - const LilvPlugin* plugin); + static SPtr create(Ingen::World* world, + SPtr block, + const LilvPlugin* plugin); SuilWidget get_widget(); @@ -55,22 +55,22 @@ public: bool is_resizable() const; - Ingen::World* world() const { return _world; } - SharedPtr block() const { return _block; } + Ingen::World* world() const { return _world; } + SPtr block() const { return _block; } private: - PluginUI(Ingen::World* world, - SharedPtr block, - const LilvNode* ui_node); + PluginUI(Ingen::World* world, + SPtr block, + const LilvNode* ui_node); - Ingen::World* _world; - SharedPtr _block; - SuilInstance* _instance; - LilvNode* _ui_node; + Ingen::World* _world; + SPtr _block; + SuilInstance* _instance; + LilvNode* _ui_node; static SuilHost* ui_host; - SharedPtr _features; + SPtr _features; }; } // namespace Client diff --git a/ingen/client/PortModel.hpp b/ingen/client/PortModel.hpp index 92379e6e..568975fc 100644 --- a/ingen/client/PortModel.hpp +++ b/ingen/client/PortModel.hpp @@ -20,7 +20,7 @@ #include #include -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h" #include "lv2/lv2plug.in/ns/lv2core/lv2.h" @@ -71,8 +71,8 @@ public: INGEN_SIGNAL(value_changed, void, const Raul::Atom&); INGEN_SIGNAL(voice_changed, void, uint32_t, const Raul::Atom&); INGEN_SIGNAL(activity, void, const Raul::Atom&); - INGEN_SIGNAL(connection, void, SharedPtr); - INGEN_SIGNAL(disconnection, void, SharedPtr); + INGEN_SIGNAL(connection, void, SPtr); + INGEN_SIGNAL(disconnection, void, SPtr); private: friend class ClientStore; @@ -87,20 +87,20 @@ private: , _connections(0) {} - void add_child(SharedPtr c) { throw; } - bool remove_child(SharedPtr c) { throw; } + void add_child(SPtr c) { throw; } + bool remove_child(SPtr c) { throw; } - void connected_to(SharedPtr p) { + void connected_to(SPtr p) { ++_connections; _signal_connection.emit(p); } - void disconnected_from(SharedPtr p) { + void disconnected_from(SPtr p) { --_connections; _signal_disconnection.emit(p); } - void set(SharedPtr model); + void set(SPtr model); uint32_t _index; Direction _direction; diff --git a/ingen/serialisation/Serialiser.hpp b/ingen/serialisation/Serialiser.hpp index 979fee62..d0b65893 100644 --- a/ingen/serialisation/Serialiser.hpp +++ b/ingen/serialisation/Serialiser.hpp @@ -21,7 +21,6 @@ #include #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "sord/sordmm.hpp" @@ -49,23 +48,23 @@ public: typedef Node::Properties Properties; - virtual void to_file(SharedPtr object, - const std::string& filename); + virtual void to_file(SPtr object, + const std::string& filename); - virtual void write_bundle(SharedPtr graph, - const std::string& path); + virtual void write_bundle(SPtr graph, + const std::string& path); - virtual std::string to_string(SharedPtr object, - const std::string& base_uri); + virtual std::string to_string(SPtr object, + const std::string& base_uri); virtual void start_to_string(const Raul::Path& root, const std::string& base_uri); - virtual void serialise(SharedPtr object) + virtual void serialise(SPtr object) throw (std::logic_error); - virtual void serialise_arc(const Sord::Node& parent, - SharedPtr arc) + virtual void serialise_arc(const Sord::Node& parent, + SPtr arc) throw (std::logic_error); virtual std::string finish(); -- cgit v1.2.1