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 ++++---- src/Builder.cpp | 4 +- src/LV2Features.cpp | 8 ++-- src/Store.cpp | 4 +- src/World.cpp | 62 ++++++++++++------------ src/client/BlockModel.cpp | 42 +++++++++-------- src/client/ClientStore.cpp | 94 ++++++++++++++++++------------------- src/client/GraphModel.cpp | 26 +++++----- src/client/ObjectModel.cpp | 4 +- src/client/PluginModel.cpp | 10 ++-- src/client/PluginUI.cpp | 20 ++++---- src/client/PortModel.cpp | 4 +- src/client/ingen_client.cpp | 4 +- src/gui/App.cpp | 18 +++---- src/gui/App.hpp | 24 +++++----- src/gui/Arc.cpp | 10 ++-- src/gui/Arc.hpp | 16 +++---- src/gui/BreadCrumbs.cpp | 12 ++--- src/gui/BreadCrumbs.hpp | 24 +++++----- src/gui/ConnectWindow.cpp | 16 +++---- src/gui/ConnectWindow.hpp | 4 +- src/gui/GraphBox.cpp | 20 ++++---- src/gui/GraphBox.hpp | 28 +++++------ src/gui/GraphCanvas.cpp | 43 ++++++++--------- src/gui/GraphCanvas.hpp | 38 +++++++-------- src/gui/GraphPortModule.cpp | 12 ++--- src/gui/GraphPortModule.hpp | 16 +++---- src/gui/GraphTreeWindow.cpp | 32 ++++++------- src/gui/GraphTreeWindow.hpp | 24 +++++----- src/gui/GraphView.cpp | 10 ++-- src/gui/GraphView.hpp | 18 +++---- src/gui/GraphWindow.hpp | 6 +-- src/gui/LoadGraphWindow.cpp | 8 ++-- src/gui/LoadGraphWindow.hpp | 13 +++-- src/gui/LoadPluginWindow.cpp | 36 +++++++------- src/gui/LoadPluginWindow.hpp | 28 +++++------ src/gui/NewSubgraphWindow.cpp | 6 +-- src/gui/NewSubgraphWindow.hpp | 13 +++-- src/gui/NodeMenu.cpp | 2 +- src/gui/NodeMenu.hpp | 4 +- src/gui/NodeModule.cpp | 18 +++---- src/gui/NodeModule.hpp | 28 +++++------ src/gui/ObjectMenu.cpp | 2 +- src/gui/ObjectMenu.hpp | 23 +++++---- src/gui/Port.cpp | 46 +++++++++--------- src/gui/Port.hpp | 37 +++++++-------- src/gui/PortMenu.cpp | 32 ++++++------- src/gui/PortMenu.hpp | 8 ++-- src/gui/PortPropertiesWindow.cpp | 4 +- src/gui/PortPropertiesWindow.hpp | 17 ++++--- src/gui/PropertiesWindow.cpp | 4 +- src/gui/PropertiesWindow.hpp | 35 +++++++------- src/gui/RDFS.cpp | 4 +- src/gui/RDFS.hpp | 6 +-- src/gui/RenameWindow.cpp | 4 +- src/gui/RenameWindow.hpp | 9 ++-- src/gui/Style.hpp | 2 - src/gui/SubgraphModule.cpp | 8 ++-- src/gui/SubgraphModule.hpp | 8 ++-- src/gui/ThreadedLoader.cpp | 12 ++--- src/gui/ThreadedLoader.hpp | 24 +++++----- src/gui/WindowFactory.cpp | 38 +++++++-------- src/gui/WindowFactory.hpp | 30 ++++++------ src/gui/ingen_gui.cpp | 2 +- src/gui/ingen_gui_lv2.cpp | 32 +++++++------ src/ingen/main.cpp | 17 ++++--- src/serialisation/Serialiser.cpp | 70 +++++++++++++-------------- src/serialisation/serialisation.cpp | 4 +- src/server/BlockFactory.cpp | 8 ++-- src/server/BlockFactory.hpp | 10 ++-- src/server/Broadcaster.cpp | 8 ++-- src/server/Broadcaster.hpp | 9 ++-- src/server/Buffer.hpp | 2 +- src/server/BufferFactory.hpp | 6 +-- src/server/CompiledGraph.hpp | 4 +- src/server/ControlBindings.cpp | 16 +++---- src/server/ControlBindings.hpp | 16 +++---- src/server/Engine.cpp | 22 ++++----- src/server/Engine.hpp | 32 ++++++------- src/server/Event.hpp | 18 +++---- src/server/EventWriter.hpp | 12 ++--- src/server/GraphImpl.cpp | 8 ++-- src/server/GraphImpl.hpp | 6 +-- src/server/InputPort.hpp | 2 +- src/server/JackDriver.cpp | 4 +- src/server/LV2Block.cpp | 16 +++---- src/server/LV2Block.hpp | 26 +++++----- src/server/LV2Info.cpp | 2 +- src/server/LV2Options.hpp | 6 +-- src/server/LV2Plugin.cpp | 2 +- src/server/LV2Plugin.hpp | 10 ++-- src/server/LV2ResizeFeature.hpp | 6 +-- src/server/NodeImpl.hpp | 1 - src/server/Worker.cpp | 6 +-- src/server/Worker.hpp | 6 +-- src/server/events/Connect.cpp | 14 +++--- src/server/events/Connect.hpp | 14 +++--- src/server/events/CreateBlock.cpp | 2 +- src/server/events/CreateBlock.hpp | 2 +- src/server/events/CreateGraph.cpp | 2 +- src/server/events/CreateGraph.hpp | 2 +- src/server/events/CreatePort.cpp | 2 +- src/server/events/CreatePort.hpp | 2 +- src/server/events/Delete.cpp | 14 +++--- src/server/events/Delete.hpp | 32 ++++++------- src/server/events/Delta.cpp | 18 +++---- src/server/events/Delta.hpp | 4 +- src/server/events/Disconnect.cpp | 12 ++--- src/server/events/Disconnect.hpp | 14 +++--- src/server/events/DisconnectAll.cpp | 12 ++--- src/server/events/DisconnectAll.hpp | 12 ++--- src/server/events/Get.cpp | 10 ++-- src/server/events/Get.hpp | 10 ++-- src/server/events/Move.cpp | 12 ++--- src/server/events/Move.hpp | 12 ++--- src/server/events/SetPortValue.cpp | 12 ++--- src/server/events/SetPortValue.hpp | 12 ++--- src/server/ingen_engine.cpp | 5 +- src/server/ingen_jack.cpp | 2 +- src/server/ingen_lv2.cpp | 31 ++++++------ src/socket/Socket.cpp | 7 +-- src/socket/Socket.hpp | 5 +- src/socket/SocketClient.hpp | 16 +++---- src/socket/SocketListener.cpp | 4 +- src/socket/SocketListener.hpp | 1 - src/socket/SocketReader.cpp | 6 +-- src/socket/SocketReader.hpp | 18 +++---- src/socket/SocketServer.hpp | 10 ++-- src/socket/SocketWriter.cpp | 8 ++-- src/socket/SocketWriter.hpp | 28 +++++------ src/socket/ingen_socket_client.cpp | 14 +++--- src/socket/ingen_socket_server.cpp | 4 +- tests/ingen_test.cpp | 6 +-- 149 files changed, 1143 insertions(+), 1147 deletions(-) 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(); diff --git a/src/Builder.cpp b/src/Builder.cpp index a4a519b4..dedd5cca 100644 --- a/src/Builder.cpp +++ b/src/Builder.cpp @@ -33,13 +33,13 @@ Builder::Builder(URIs& uris, Interface& interface) } void -Builder::build(SharedPtr object) +Builder::build(SPtr object) { _interface.put(object->uri(), object->properties()); } void -Builder::connect(SharedPtr object) +Builder::connect(SPtr object) { if (object->graph_type() == Node::GraphType::GRAPH) { for (auto a : object->arcs()) { diff --git a/src/LV2Features.cpp b/src/LV2Features.cpp index a7069a75..3941d92c 100644 --- a/src/LV2Features.cpp +++ b/src/LV2Features.cpp @@ -27,7 +27,7 @@ LV2Features::LV2Features() } void -LV2Features::add_feature(SharedPtr feature) +LV2Features::add_feature(SPtr feature) { _features.push_back(feature); } @@ -53,17 +53,17 @@ LV2Features::is_supported(const std::string& uri) const return false; } -SharedPtr +SPtr LV2Features::lv2_features(World* world, Node* node) const { FeatureArray::FeatureVector vec; for (const auto& f : _features) { - SharedPtr fptr = f->feature(world, node); + SPtr fptr = f->feature(world, node); if (fptr) { vec.push_back(fptr); } } - return SharedPtr(new FeatureArray(vec)); + return SPtr(new FeatureArray(vec)); } } // namespace Ingen diff --git a/src/Store.cpp b/src/Store.cpp index fda93474..560c2de9 100644 --- a/src/Store.cpp +++ b/src/Store.cpp @@ -29,7 +29,7 @@ Store::add(Node* o) return; } - insert(make_pair(o->path(), SharedPtr(o))); + insert(make_pair(o->path(), SPtr(o))); for (uint32_t i = 0; i < o->num_ports(); ++i) { add(o->port(i)); @@ -72,7 +72,7 @@ Store::find_descendants_end(const const_iterator parent) const } Store::const_range -Store::children_range(SharedPtr o) const +Store::children_range(SPtr o) const { const const_iterator parent = find(o->path()); if (parent != end()) { diff --git a/src/World.cpp b/src/World.cpp index 0b56262c..218da83c 100644 --- a/src/World.cpp +++ b/src/World.cpp @@ -191,23 +191,23 @@ public: typedef std::map ScriptRunners; ScriptRunners script_runners; - int& argc; - char**& argv; - LV2Features* lv2_features; - Sord::World* rdf_world; - URIMap* uri_map; - Forge* forge; - URIs* uris; - LV2_Log_Log* lv2_log; - Log log; - Configuration conf; - SharedPtr interface; - SharedPtr engine; - SharedPtr serialiser; - SharedPtr parser; - SharedPtr store; - LilvWorld* lilv_world; - std::string jack_uuid; + int& argc; + char**& argv; + LV2Features* lv2_features; + Sord::World* rdf_world; + URIMap* uri_map; + Forge* forge; + URIs* uris; + LV2_Log_Log* lv2_log; + Log log; + Configuration conf; + SPtr interface; + SPtr engine; + SPtr serialiser; + SPtr parser; + SPtr store; + LilvWorld* lilv_world; + std::string jack_uuid; }; World::World(int& argc, @@ -224,17 +224,17 @@ World::~World() delete _impl; } -void World::set_engine(SharedPtr e) { _impl->engine = e; } -void World::set_interface(SharedPtr i) { _impl->interface = i; } -void World::set_parser(SharedPtr p) { _impl->parser = p; } -void World::set_serialiser(SharedPtr s) { _impl->serialiser = s; } -void World::set_store(SharedPtr s) { _impl->store = s; } +void World::set_engine(SPtr e) { _impl->engine = e; } +void World::set_interface(SPtr i) { _impl->interface = i; } +void World::set_parser(SPtr p) { _impl->parser = p; } +void World::set_serialiser(SPtr s) { _impl->serialiser = s; } +void World::set_store(SPtr s) { _impl->store = s; } -SharedPtr World::engine() { return _impl->engine; } -SharedPtr World::interface() { return _impl->interface; } -SharedPtr World::parser() { return _impl->parser; } -SharedPtr World::serialiser() { return _impl->serialiser; } -SharedPtr World::store() { return _impl->store; } +SPtr World::engine() { return _impl->engine; } +SPtr World::interface() { return _impl->interface; } +SPtr World::parser() { return _impl->parser; } +SPtr World::serialiser() { return _impl->serialiser; } +SPtr World::store() { return _impl->store; } int& World::argc() { return _impl->argc; } char**& World::argv() { return _impl->argv; } @@ -288,14 +288,14 @@ World::run_module(const char* name) /** Get an interface for a remote engine at @a url */ -SharedPtr -World::new_interface(const Raul::URI& engine_uri, - SharedPtr respondee) +SPtr +World::new_interface(const Raul::URI& engine_uri, + SPtr respondee) { const Impl::InterfaceFactories::const_iterator i = _impl->interface_factories.find(engine_uri.scheme()); if (i == _impl->interface_factories.end()) { log().warn(Raul::fmt("Unknown URI scheme `%1%'\n") % engine_uri.scheme()); - return SharedPtr(); + return SPtr(); } return i->second(this, engine_uri, respondee); diff --git a/src/client/BlockModel.cpp b/src/client/BlockModel.cpp index eb982f0d..0ed58c7a 100644 --- a/src/client/BlockModel.cpp +++ b/src/client/BlockModel.cpp @@ -25,9 +25,9 @@ namespace Ingen { namespace Client { -BlockModel::BlockModel(URIs& uris, - SharedPtr plugin, - const Raul::Path& path) +BlockModel::BlockModel(URIs& uris, + SPtr plugin, + const Raul::Path& path) : ObjectModel(uris, path) , _plugin_uri(plugin->uri()) , _plugin(plugin) @@ -65,7 +65,7 @@ BlockModel::~BlockModel() } void -BlockModel::remove_port(SharedPtr port) +BlockModel::remove_port(SPtr port) { for (Ports::iterator i = _ports.begin(); i != _ports.end(); ++i) { if ((*i) == port) { @@ -99,26 +99,26 @@ BlockModel::clear() } void -BlockModel::add_child(SharedPtr c) +BlockModel::add_child(SPtr c) { assert(c->parent().get() == this); //ObjectModel::add_child(c); - SharedPtr pm = PtrCast(c); + SPtr pm = dynamic_ptr_cast(c); assert(pm); add_port(pm); } bool -BlockModel::remove_child(SharedPtr c) +BlockModel::remove_child(SPtr c) { assert(c->path().is_child_of(path())); assert(c->parent().get() == this); //bool ret = ObjectModel::remove_child(c); - SharedPtr pm = PtrCast(c); + SPtr pm = dynamic_ptr_cast(c); assert(pm); remove_port(pm); @@ -127,7 +127,7 @@ BlockModel::remove_child(SharedPtr c) } void -BlockModel::add_port(SharedPtr pm) +BlockModel::add_port(SPtr pm) { assert(pm); assert(pm->path().is_child_of(path())); @@ -140,13 +140,13 @@ BlockModel::add_port(SharedPtr pm) _signal_new_port.emit(pm); } -SharedPtr +SPtr BlockModel::get_port(const Raul::Symbol& symbol) const { for (auto p : _ports) if (p->symbol() == symbol) return p; - return SharedPtr(); + return SPtr(); } Ingen::Node* @@ -158,10 +158,10 @@ BlockModel::port(uint32_t index) const } void -BlockModel::default_port_value_range(SharedPtr port, - float& min, - float& max, - uint32_t srate) const +BlockModel::default_port_value_range(SPtr port, + float& min, + float& max, + uint32_t srate) const { // Default control values min = 0.0; @@ -190,8 +190,10 @@ BlockModel::default_port_value_range(SharedPtr port, } void -BlockModel::port_value_range(SharedPtr port, - float& min, float& max, uint32_t srate) const +BlockModel::port_value_range(SPtr port, + float& min, + float& max, + uint32_t srate) const { assert(port->parent().get() == this); @@ -228,7 +230,7 @@ BlockModel::label() const } std::string -BlockModel::port_label(SharedPtr port) const +BlockModel::port_label(SPtr port) const { const Raul::Atom& name = port->get_property(Raul::URI(LV2_CORE__name)); if (name.is_valid()) { @@ -255,9 +257,9 @@ BlockModel::port_label(SharedPtr port) const } void -BlockModel::set(SharedPtr model) +BlockModel::set(SPtr model) { - SharedPtr block = PtrCast(model); + SPtr block = dynamic_ptr_cast(model); if (block) { _plugin_uri = block->_plugin_uri; _plugin = block->_plugin; diff --git a/src/client/ClientStore.cpp b/src/client/ClientStore.cpp index 318d31a5..8c48ab72 100644 --- a/src/client/ClientStore.cpp +++ b/src/client/ClientStore.cpp @@ -31,10 +31,10 @@ using namespace std; namespace Ingen { namespace Client { -ClientStore::ClientStore(URIs& uris, - Log& log, - SharedPtr engine, - SharedPtr emitter) +ClientStore::ClientStore(URIs& uris, + Log& log, + SPtr engine, + SPtr emitter) : _uris(uris) , _log(log) , _engine(engine) @@ -66,16 +66,16 @@ ClientStore::clear() } void -ClientStore::add_object(SharedPtr object) +ClientStore::add_object(SPtr object) { // If we already have "this" object, merge the existing one into the new // one (with precedence to the new values). iterator existing = find(object->path()); if (existing != end()) { - PtrCast(existing->second)->set(object); + dynamic_ptr_cast(existing->second)->set(object); } else { if (!object->path().is_root()) { - SharedPtr parent = _object(object->path().parent()); + SPtr parent = _object(object->path().parent()); if (parent) { assert(object->path().is_child_of(parent->path())); object->set_parent(parent); @@ -97,13 +97,13 @@ ClientStore::add_object(SharedPtr object) object->signal_property().emit(p.first, p.second); } -SharedPtr +SPtr ClientStore::remove_object(const Raul::Path& path) { // Find the object, the "top" of the tree to remove const iterator top = find(path); if (top == end()) { - return SharedPtr(); + return SPtr(); } // Remove the object and all its descendants @@ -111,7 +111,7 @@ ClientStore::remove_object(const Raul::Path& path) remove(top, removed); // Notify everything that needs to know this object is going away - SharedPtr object = PtrCast(top->second); + SPtr object = dynamic_ptr_cast(top->second); if (object) { // Notify the program this object is going away object->signal_destroyed().emit(); @@ -125,43 +125,43 @@ ClientStore::remove_object(const Raul::Path& path) return object; } -SharedPtr +SPtr ClientStore::_plugin(const Raul::URI& uri) { Plugins::iterator i = _plugins->find(uri); if (i == _plugins->end()) - return SharedPtr(); + return SPtr(); else return (*i).second; } -SharedPtr +SPtr ClientStore::plugin(const Raul::URI& uri) const { return const_cast(this)->_plugin(uri); } -SharedPtr +SPtr ClientStore::_object(const Raul::Path& path) { const iterator i = find(path); if (i == end()) { - return SharedPtr(); + return SPtr(); } else { - SharedPtr model = PtrCast(i->second); + SPtr model = dynamic_ptr_cast(i->second); assert(model); assert(model->path().is_root() || model->parent()); return model; } } -SharedPtr +SPtr ClientStore::object(const Raul::Path& path) const { return const_cast(this)->_object(path); } -SharedPtr +SPtr ClientStore::_resource(const Raul::URI& uri) { if (Node::uri_is_path(uri)) { @@ -171,16 +171,16 @@ ClientStore::_resource(const Raul::URI& uri) } } -SharedPtr +SPtr ClientStore::resource(const Raul::URI& uri) const { return const_cast(this)->_resource(uri); } void -ClientStore::add_plugin(SharedPtr pm) +ClientStore::add_plugin(SPtr pm) { - SharedPtr existing = _plugin(pm->uri()); + SPtr existing = _plugin(pm->uri()); if (existing) { existing->set(pm); } else { @@ -235,7 +235,7 @@ ClientStore::put(const Raul::URI& uri, if (plugin_type == Plugin::Graph) { is_graph = true; } else if (plugin_type != Plugin::NIL) { - SharedPtr p( + SPtr p( new PluginModel(uris(), uri, type_uri, properties)); add_plugin(p); return; @@ -250,7 +250,7 @@ ClientStore::put(const Raul::URI& uri, const Raul::Path path(Node::uri_to_path(uri)); - SharedPtr obj = PtrCast(_object(path)); + SPtr obj = dynamic_ptr_cast(_object(path)); if (obj) { obj->set_properties(properties); return; @@ -261,15 +261,15 @@ ClientStore::put(const Raul::URI& uri, } if (is_graph) { - SharedPtr model(new GraphModel(uris(), path)); + SPtr model(new GraphModel(uris(), path)); model->set_properties(properties); add_object(model); } else if (is_block) { const Iterator p = properties.find(_uris.ingen_prototype); - SharedPtr plug; + SPtr plug; if (p->second.is_valid() && p->second.type() == _uris.forge.URI) { if (!(plug = _plugin(Raul::URI(p->second.get_uri())))) { - plug = SharedPtr( + plug = SPtr( new PluginModel(uris(), Raul::URI(p->second.get_uri()), _uris.ingen_nil, @@ -277,7 +277,7 @@ ClientStore::put(const Raul::URI& uri, add_plugin(plug); } - SharedPtr bm(new BlockModel(uris(), plug, path)); + SPtr bm(new BlockModel(uris(), plug, path)); bm->set_properties(properties); add_object(bm); } else { @@ -291,7 +291,7 @@ ClientStore::put(const Raul::URI& uri, const Iterator i = properties.find(_uris.lv2_index); if (i != properties.end() && i->second.type() == _uris.forge.Int) { const uint32_t index = i->second.get_int32(); - SharedPtr p( + SPtr p( new PortModel(uris(), path, index, pdir)); p->set_properties(properties); add_object(p); @@ -331,7 +331,7 @@ ClientStore::delta(const Raul::URI& uri, const Raul::Path path(Node::uri_to_path(uri)); - SharedPtr obj = _object(path); + SPtr obj = _object(path); if (obj) { obj->remove_properties(remove); obj->add_properties(add); @@ -351,7 +351,7 @@ ClientStore::set_property(const Raul::URI& subject_uri, % predicate.c_str() % _uris.forge.str(value)); return; } - SharedPtr subject = _resource(subject_uri); + SPtr subject = _resource(subject_uri); if (subject) { if (predicate == _uris.ingen_activity) { /* Activity is transient, trigger any live actions (like GUI @@ -361,7 +361,7 @@ ClientStore::set_property(const Raul::URI& subject_uri, subject->set_property(predicate, value); } } else { - SharedPtr plugin = _plugin(subject_uri); + SPtr plugin = _plugin(subject_uri); if (plugin) { plugin->set_property(predicate, value); } else if (predicate != _uris.ingen_activity) { @@ -371,23 +371,23 @@ ClientStore::set_property(const Raul::URI& subject_uri, } } -SharedPtr +SPtr ClientStore::connection_graph(const Raul::Path& tail_path, const Raul::Path& head_path) { - SharedPtr graph; + SPtr graph; if (tail_path.parent() == head_path.parent()) - graph = PtrCast(_object(tail_path.parent())); + graph = dynamic_ptr_cast(_object(tail_path.parent())); if (!graph && tail_path.parent() == head_path.parent().parent()) - graph = PtrCast(_object(tail_path.parent())); + graph = dynamic_ptr_cast(_object(tail_path.parent())); if (!graph && tail_path.parent().parent() == head_path.parent()) - graph = PtrCast(_object(head_path.parent())); + graph = dynamic_ptr_cast(_object(head_path.parent())); if (!graph) - graph = PtrCast(_object(tail_path.parent().parent())); + graph = dynamic_ptr_cast(_object(tail_path.parent().parent())); if (!graph) _log.error(Raul::fmt("Unable to find graph for arc %1% => %2%\n") @@ -400,12 +400,12 @@ bool ClientStore::attempt_connection(const Raul::Path& tail_path, const Raul::Path& head_path) { - SharedPtr tail = PtrCast(_object(tail_path)); - SharedPtr head = PtrCast(_object(head_path)); + SPtr tail = dynamic_ptr_cast(_object(tail_path)); + SPtr head = dynamic_ptr_cast(_object(head_path)); if (tail && head) { - SharedPtr graph = connection_graph(tail_path, head_path); - SharedPtr arc(new ArcModel(tail, head)); + SPtr graph = connection_graph(tail_path, head_path); + SPtr arc(new ArcModel(tail, head)); tail->connected_to(head); head->connected_to(tail); @@ -430,8 +430,8 @@ void ClientStore::disconnect(const Raul::Path& src_path, const Raul::Path& dst_path) { - SharedPtr tail = PtrCast(_object(src_path)); - SharedPtr head = PtrCast(_object(dst_path)); + SPtr tail = dynamic_ptr_cast(_object(src_path)); + SPtr head = dynamic_ptr_cast(_object(dst_path)); if (tail) tail->disconnected_from(head); @@ -439,7 +439,7 @@ ClientStore::disconnect(const Raul::Path& src_path, if (head) head->disconnected_from(tail); - SharedPtr graph = connection_graph(src_path, dst_path); + SPtr graph = connection_graph(src_path, dst_path); if (graph) graph->remove_arc(tail.get(), head.get()); } @@ -448,8 +448,8 @@ void ClientStore::disconnect_all(const Raul::Path& parent_graph, const Raul::Path& path) { - SharedPtr graph = PtrCast(_object(parent_graph)); - SharedPtr object = _object(path); + SPtr graph = dynamic_ptr_cast(_object(parent_graph)); + SPtr object = _object(path); if (!graph || !object) { _log.error(Raul::fmt("Bad disconnect all notification %1% in %2%\n") @@ -459,7 +459,7 @@ ClientStore::disconnect_all(const Raul::Path& parent_graph, const GraphModel::Arcs arcs = graph->arcs(); for (auto a : arcs) { - SharedPtr arc = PtrCast(a.second); + SPtr arc = dynamic_ptr_cast(a.second); if (arc->tail()->parent() == object || arc->head()->parent() == object || arc->tail()->path() == path diff --git a/src/client/GraphModel.cpp b/src/client/GraphModel.cpp index 98155138..8586f168 100644 --- a/src/client/GraphModel.cpp +++ b/src/client/GraphModel.cpp @@ -28,24 +28,24 @@ namespace Ingen { namespace Client { void -GraphModel::add_child(SharedPtr c) +GraphModel::add_child(SPtr c) { assert(c->parent().get() == this); - SharedPtr pm = PtrCast(c); + SPtr pm = dynamic_ptr_cast(c); if (pm) { add_port(pm); return; } - SharedPtr bm = PtrCast(c); + SPtr bm = dynamic_ptr_cast(c); if (bm) { _signal_new_block.emit(bm); } } bool -GraphModel::remove_child(SharedPtr o) +GraphModel::remove_child(SPtr o) { assert(o->path().is_child_of(path())); assert(o->parent().get() == this); @@ -56,7 +56,7 @@ GraphModel::remove_child(SharedPtr o) Arcs::iterator next = j; ++next; - SharedPtr arc = PtrCast(j->second); + SPtr arc = dynamic_ptr_cast(j->second); if (arc->tail_path().parent() == o->path() || arc->tail_path() == o->path() || arc->head_path().parent() == o->path() @@ -67,11 +67,11 @@ GraphModel::remove_child(SharedPtr o) j = next; } - SharedPtr pm = PtrCast(o); + SPtr pm = dynamic_ptr_cast(o); if (pm) remove_port(pm); - SharedPtr bm = PtrCast(o); + SPtr bm = dynamic_ptr_cast(o); if (bm) { _signal_removed_block.emit(bm); } @@ -90,14 +90,14 @@ GraphModel::clear() assert(_ports.empty()); } -SharedPtr +SPtr GraphModel::get_arc(const Node* tail, const Node* head) { Arcs::iterator i = _arcs.find(make_pair(tail, head)); if (i != _arcs.end()) - return PtrCast(i->second); + return dynamic_ptr_cast(i->second); else - return SharedPtr(); + return SPtr(); } /** Add a connection to this graph. @@ -108,7 +108,7 @@ GraphModel::get_arc(const Node* tail, const Node* head) * this graph is a fatal error. */ void -GraphModel::add_arc(SharedPtr arc) +GraphModel::add_arc(SPtr arc) { // Store should have 'resolved' the connection already assert(arc); @@ -122,7 +122,7 @@ GraphModel::add_arc(SharedPtr arc) assert(arc->head()->parent().get() == this || arc->head()->parent()->parent().get() == this); - SharedPtr existing = get_arc( + SPtr existing = get_arc( arc->tail().get(), arc->head().get()); if (existing) { @@ -141,7 +141,7 @@ GraphModel::remove_arc(const Node* tail, const Node* head) { Arcs::iterator i = _arcs.find(make_pair(tail, head)); if (i != _arcs.end()) { - SharedPtr arc = PtrCast(i->second); + SPtr arc = dynamic_ptr_cast(i->second); _signal_removed_arc.emit(arc); _arcs.erase(i); } diff --git a/src/client/ObjectModel.cpp b/src/client/ObjectModel.cpp index 51427f90..9fc22c03 100644 --- a/src/client/ObjectModel.cpp +++ b/src/client/ObjectModel.cpp @@ -73,7 +73,7 @@ ObjectModel::polyphonic() const * @a o as correct. The paths of the two models MUST be equal. */ void -ObjectModel::set(SharedPtr o) +ObjectModel::set(SPtr o) { assert(_path == o->path()); if (o->_parent) @@ -94,7 +94,7 @@ ObjectModel::set_path(const Raul::Path& p) } void -ObjectModel::set_parent(SharedPtr p) +ObjectModel::set_parent(SPtr p) { assert(_path.is_child_of(p->path())); _parent = p; diff --git a/src/client/PluginModel.cpp b/src/client/PluginModel.cpp index 5dc6ec2a..206aebab 100644 --- a/src/client/PluginModel.cpp +++ b/src/client/PluginModel.cpp @@ -151,7 +151,7 @@ PluginModel::get_property(const Raul::URI& key) const } void -PluginModel::set(SharedPtr p) +PluginModel::set(SPtr p) { _type = p->_type; @@ -229,12 +229,12 @@ PluginModel::has_ui() const } -SharedPtr -PluginModel::ui(Ingen::World* world, - SharedPtr block) const +SPtr +PluginModel::ui(Ingen::World* world, + SPtr block) const { if (!_lilv_plugin) { - return SharedPtr(); + return SPtr(); } return PluginUI::create(world, block, _lilv_plugin); diff --git a/src/client/PluginUI.cpp b/src/client/PluginUI.cpp index 7a4c88e8..24144b42 100644 --- a/src/client/PluginUI.cpp +++ b/src/client/PluginUI.cpp @@ -47,7 +47,7 @@ lv2_ui_write(SuilController controller, return; } - SharedPtr port = ports[port_index]; + SPtr port = ports[port_index]; const URIs& uris = ui->world()->uris(); @@ -77,9 +77,9 @@ lv2_ui_write(SuilController controller, } } -PluginUI::PluginUI(Ingen::World* world, - SharedPtr block, - const LilvNode* ui_node) +PluginUI::PluginUI(Ingen::World* world, + SPtr block, + const LilvNode* ui_node) : _world(world) , _block(block) , _instance(NULL) @@ -93,10 +93,10 @@ PluginUI::~PluginUI() lilv_node_free(_ui_node); } -SharedPtr -PluginUI::create(Ingen::World* world, - SharedPtr block, - const LilvPlugin* plugin) +SPtr +PluginUI::create(Ingen::World* world, + SPtr block, + const LilvPlugin* plugin) { if (!PluginUI::ui_host) { PluginUI::ui_host = suil_host_new(lv2_ui_write, NULL, NULL, NULL); @@ -123,10 +123,10 @@ PluginUI::create(Ingen::World* world, if (!ui) { lilv_node_free(gtk_ui); - return SharedPtr(); + return SPtr(); } - SharedPtr ret(new PluginUI(world, block, lilv_ui_get_uri(ui))); + SPtr ret(new PluginUI(world, block, lilv_ui_get_uri(ui))); ret->_features = world->lv2_features().lv2_features( world, const_cast(block.get())); diff --git a/src/client/PortModel.cpp b/src/client/PortModel.cpp index a4261202..eb645791 100644 --- a/src/client/PortModel.cpp +++ b/src/client/PortModel.cpp @@ -64,11 +64,11 @@ PortModel::is_uri() const } void -PortModel::set(SharedPtr model) +PortModel::set(SPtr model) { ObjectModel::set(model); - SharedPtr port = PtrCast(model); + SPtr port = dynamic_ptr_cast(model); if (port) { _index = port->_index; _direction = port->_direction; diff --git a/src/client/ingen_client.cpp b/src/client/ingen_client.cpp index 46a14dc1..6f873f14 100644 --- a/src/client/ingen_client.cpp +++ b/src/client/ingen_client.cpp @@ -16,15 +16,13 @@ #include "ingen/Module.hpp" #include "ingen/World.hpp" -#include "raul/SharedPtr.hpp" #include "ingen_config.h" using namespace Ingen; struct IngenClientModule : public Ingen::Module { - void load(Ingen::World* world) { - } + void load(Ingen::World* world) {} }; extern "C" { diff --git a/src/gui/App.cpp b/src/gui/App.cpp index 11da12f0..5fcfb57d 100644 --- a/src/gui/App.cpp +++ b/src/gui/App.cpp @@ -97,7 +97,7 @@ App::~App() delete _window_factory; } -SharedPtr +SPtr App::create(Ingen::World* world) { _main = Gtk::Main::instance(); @@ -136,7 +136,7 @@ App::create(Ingen::World* world) Gtk::RC::parse_string(rc_style); - return SharedPtr(app); + return SPtr(app); } void @@ -155,7 +155,7 @@ App::run() } void -App::attach(SharedPtr client) +App::attach(SPtr client) { assert(!_client); assert(!_store); @@ -166,8 +166,8 @@ App::attach(SharedPtr client) } _client = client; - _store = SharedPtr(new ClientStore(_world->uris(), _world->log(), _world->interface(), client)); - _loader = SharedPtr(new ThreadedLoader(*this, _world->interface())); + _store = SPtr(new ClientStore(_world->uris(), _world->log(), _world->interface(), client)); + _loader = SPtr(new ThreadedLoader(*this, _world->interface())); _graph_tree_window->init(*this, *_store); @@ -189,7 +189,7 @@ App::detach() _loader.reset(); _store.reset(); _client.reset(); - _world->set_interface(SharedPtr()); + _world->set_interface(SPtr()); } } @@ -202,7 +202,7 @@ App::request_plugins_if_necessary() } } -SharedPtr +SPtr App::serialiser() { if (!_world->serialiser()) @@ -376,10 +376,6 @@ struct IconDestroyNotification { Glib::RefPtr App::icon_from_path(const string& path, int size) { - /* If weak references to Glib::Objects are needed somewhere else it will - probably be a good idea to create a proper WeakPtr class instead of - using raw pointers, but for a single use this will do. */ - Glib::RefPtr buf; if (path.length() == 0) return buf; diff --git a/src/gui/App.hpp b/src/gui/App.hpp index 2b27de25..e435c4a5 100644 --- a/src/gui/App.hpp +++ b/src/gui/App.hpp @@ -28,9 +28,9 @@ #include "ingen/Status.hpp" #include "ingen/World.hpp" +#include "ingen/types.hpp" #include "raul/Atom.hpp" #include "raul/Deletable.hpp" -#include "raul/SharedPtr.hpp" #include "raul/URI.hpp" namespace Ingen { @@ -74,7 +74,7 @@ public: void error_message(const std::string& msg); - void attach(SharedPtr client); + void attach(SPtr client); void detach(); @@ -108,15 +108,15 @@ public: Glib::RefPtr icon_from_path(const std::string& path, int size); - Ingen::Forge& forge() const { return _world->forge(); } - SharedPtr interface() const { return _world->interface(); } - SharedPtr client() const { return _client; } - SharedPtr store() const { return _store; } - SharedPtr loader() const { return _loader; } + Ingen::Forge& forge() const { return _world->forge(); } + SPtr interface() const { return _world->interface(); } + SPtr client() const { return _client; } + SPtr store() const { return _store; } + SPtr loader() const { return _loader; } - SharedPtr serialiser(); + SPtr serialiser(); - static SharedPtr create(Ingen::World* world); + static SPtr create(Ingen::World* world); void run(); inline Ingen::World* world() const { return _world; } @@ -152,9 +152,9 @@ protected: static Gtk::Main* _main; - SharedPtr _client; - SharedPtr _store; - SharedPtr _loader; + SPtr _client; + SPtr _store; + SPtr _loader; Style* _style; diff --git a/src/gui/Arc.cpp b/src/gui/Arc.cpp index b75f30ae..0289d2b7 100644 --- a/src/gui/Arc.cpp +++ b/src/gui/Arc.cpp @@ -19,11 +19,11 @@ namespace Ingen { namespace GUI { -Arc::Arc(Ganv::Canvas& canvas, - boost::shared_ptr model, - Ganv::Node* src, - Ganv::Node* dst, - uint32_t color) +Arc::Arc(Ganv::Canvas& canvas, + SPtr model, + Ganv::Node* src, + Ganv::Node* dst, + uint32_t color) : Ganv::Edge(canvas, src, dst, color) , _arc_model(model) { diff --git a/src/gui/Arc.hpp b/src/gui/Arc.hpp index df6dfbfb..52a03a23 100644 --- a/src/gui/Arc.hpp +++ b/src/gui/Arc.hpp @@ -20,7 +20,7 @@ #include #include "ganv/Edge.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" namespace Ingen { @@ -35,16 +35,16 @@ namespace GUI { class Arc : public Ganv::Edge { public: - Arc(Ganv::Canvas& canvas, - boost::shared_ptr model, - Ganv::Node* src, - Ganv::Node* dst, - uint32_t color); + Arc(Ganv::Canvas& canvas, + SPtr model, + Ganv::Node* src, + Ganv::Node* dst, + uint32_t color); - SharedPtr model() const { return _arc_model; } + SPtr model() const { return _arc_model; } private: - SharedPtr _arc_model; + SPtr _arc_model; }; } // namespace GUI diff --git a/src/gui/BreadCrumbs.cpp b/src/gui/BreadCrumbs.cpp index 22142285..8073f933 100644 --- a/src/gui/BreadCrumbs.cpp +++ b/src/gui/BreadCrumbs.cpp @@ -39,14 +39,14 @@ BreadCrumbs::BreadCrumbs(App& app) set_can_focus(false); } -SharedPtr +SPtr BreadCrumbs::view(const Raul::Path& path) { for (const auto& b : _breadcrumbs) if (b->path() == path) return b->view(); - return SharedPtr(); + return SPtr(); } /** Sets up the crumbs to display @a path. @@ -55,7 +55,7 @@ BreadCrumbs::view(const Raul::Path& path) * children preserved. */ void -BreadCrumbs::build(Raul::Path path, SharedPtr view) +BreadCrumbs::build(Raul::Path path, SPtr view) { bool old_enable_signal = _enable_signal; _enable_signal = false; @@ -146,11 +146,11 @@ BreadCrumbs::build(Raul::Path path, SharedPtr view) * match, otherwise ignoring @a view. */ BreadCrumbs::BreadCrumb* -BreadCrumbs::create_crumb(const Raul::Path& path, - SharedPtr view) +BreadCrumbs::create_crumb(const Raul::Path& path, + SPtr view) { BreadCrumb* but = manage(new BreadCrumb(path, - (view && path == view->graph()->path()) ? view : SharedPtr())); + (view && path == view->graph()->path()) ? view : SPtr())); but->signal_toggled().connect(sigc::bind(sigc::mem_fun( this, &BreadCrumbs::breadcrumb_clicked), but)); diff --git a/src/gui/BreadCrumbs.hpp b/src/gui/BreadCrumbs.hpp index cdb11583..933a28dc 100644 --- a/src/gui/BreadCrumbs.hpp +++ b/src/gui/BreadCrumbs.hpp @@ -24,9 +24,9 @@ #include #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "ingen/client/GraphModel.hpp" +#include "ingen/types.hpp" #include "GraphView.hpp" @@ -43,11 +43,11 @@ class BreadCrumbs : public Gtk::HBox public: explicit BreadCrumbs(App& app); - SharedPtr view(const Raul::Path& path); + SPtr view(const Raul::Path& path); - void build(Raul::Path path, SharedPtr view); + void build(Raul::Path path, SPtr view); - sigc::signal > signal_graph_selected; + sigc::signal > signal_graph_selected; private: /** Breadcrumb button. @@ -62,7 +62,7 @@ private: class BreadCrumb : public Gtk::ToggleButton { public: - BreadCrumb(const Raul::Path& path, SharedPtr view = SharedPtr()) + BreadCrumb(const Raul::Path& path, SPtr view = SPtr()) : _path(path) , _view(view) { @@ -73,13 +73,13 @@ private: show_all(); } - void set_view(SharedPtr view) { + void set_view(SPtr view) { assert(!view || view->graph()->path() == _path); _view = view; } - const Raul::Path& path() const { return _path; } - SharedPtr view() const { return _view; } + const Raul::Path& path() const { return _path; } + SPtr view() const { return _view; } void set_path(const Raul::Path& path) { remove(); @@ -94,12 +94,12 @@ private: } private: - Raul::Path _path; - SharedPtr _view; + Raul::Path _path; + SPtr _view; }; - BreadCrumb* create_crumb(const Raul::Path& path, - SharedPtr view = SharedPtr()); + BreadCrumb* create_crumb(const Raul::Path& path, + SPtr view = SPtr()); void breadcrumb_clicked(BreadCrumb* crumb); diff --git a/src/gui/ConnectWindow.cpp b/src/gui/ConnectWindow.cpp index ab889461..ca4836b7 100644 --- a/src/gui/ConnectWindow.cpp +++ b/src/gui/ConnectWindow.cpp @@ -82,11 +82,11 @@ ConnectWindow::start(App& app, Ingen::World* world) } set_connected_to(world->interface()); - connect(world->interface()); + connect(bool(world->interface())); } void -ConnectWindow::set_connected_to(SharedPtr engine) +ConnectWindow::set_connected_to(SPtr engine) { _app->world()->set_interface(engine); @@ -174,9 +174,9 @@ ConnectWindow::connect(bool existing) uri = world->interface()->uri(); } - SharedPtr tsci; + SPtr tsci; if (world->interface()) { - tsci = PtrCast( + tsci = dynamic_ptr_cast( world->interface()->respondee()); } @@ -200,7 +200,7 @@ ConnectWindow::connect(bool existing) if (Raul::Process::launch(cmd)) { const Raul::URI engine_uri(string("tcp://localhost:") + port_str); - SharedPtr tsci(new ThreadedSigClientInterface(1024)); + SPtr tsci(new ThreadedSigClientInterface(1024)); world->set_interface(world->new_interface(engine_uri, tsci)); _app->attach(tsci); @@ -221,7 +221,7 @@ ConnectWindow::connect(bool existing) world->engine()->activate(); } - SharedPtr client(new SigClientInterface()); + SPtr client(new SigClientInterface()); world->interface()->set_respondee(client); _app->attach(client); @@ -239,7 +239,7 @@ ConnectWindow::disconnect() _attached = false; _app->detach(); - set_connected_to(SharedPtr()); + set_connected_to(SPtr()); if (!_widgets_loaded) return; @@ -418,7 +418,7 @@ ConnectWindow::gtk_callback() ++_connect_stage; } else if (_connect_stage == 3) { if (_app->store()->size() > 0) { - SharedPtr root = PtrCast( + SPtr root = dynamic_ptr_cast( _app->store()->object(Raul::Path("/"))); if (root) { set_connected_to(_app->interface()); diff --git a/src/gui/ConnectWindow.hpp b/src/gui/ConnectWindow.hpp index ade0f3b1..2efa394f 100644 --- a/src/gui/ConnectWindow.hpp +++ b/src/gui/ConnectWindow.hpp @@ -26,8 +26,8 @@ #include #include +#include "ingen/types.hpp" #include "lilv/lilv.h" -#include "raul/SharedPtr.hpp" #include "Window.hpp" @@ -49,7 +49,7 @@ public: ConnectWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); - void set_connected_to(SharedPtr engine); + void set_connected_to(SPtr engine); void start(App& app, Ingen::World* world); void ingen_response(int32_t id, Status status, const std::string& subject) { _attached = true; diff --git a/src/gui/GraphBox.cpp b/src/gui/GraphBox.cpp index fd47ee26..84116196 100644 --- a/src/gui/GraphBox.cpp +++ b/src/gui/GraphBox.cpp @@ -157,15 +157,15 @@ GraphBox::~GraphBox() delete _breadcrumbs; } -SharedPtr -GraphBox::create(App& app, SharedPtr graph) +SPtr +GraphBox::create(App& app, SPtr graph) { GraphBox* result = NULL; Glib::RefPtr xml = WidgetFactory::create("graph_win"); xml->get_widget_derived("graph_win_vbox", result); result->init_box(app); - result->set_graph(graph, SharedPtr()); - return SharedPtr(result); + result->set_graph(graph, SPtr()); + return SPtr(result); } void @@ -193,13 +193,13 @@ GraphBox::init_box(App& app) } void -GraphBox::set_graph_from_path(const Raul::Path& path, SharedPtr view) +GraphBox::set_graph_from_path(const Raul::Path& path, SPtr view) { if (view) { assert(view->graph()->path() == path); _app->window_factory()->present_graph(view->graph(), _window, view); } else { - SharedPtr model = PtrCast( + SPtr model = dynamic_ptr_cast( _app->store()->object(path)); if (model) { _app->window_factory()->present_graph(model, _window); @@ -212,8 +212,8 @@ GraphBox::set_graph_from_path(const Raul::Path& path, SharedPtr view) * If @a view is NULL, a new view will be created. */ void -GraphBox::set_graph(SharedPtr graph, - SharedPtr view) +GraphBox::set_graph(SPtr graph, + SPtr view) { if (!graph || graph == _graph) return; @@ -287,7 +287,7 @@ GraphBox::set_graph(SharedPtr graph, } void -GraphBox::graph_port_added(SharedPtr port) +GraphBox::graph_port_added(SPtr port) { if (port->is_input() && _app->can_control(port.get())) { _menu_view_control_window->property_sensitive() = true; @@ -295,7 +295,7 @@ GraphBox::graph_port_added(SharedPtr port) } void -GraphBox::graph_port_removed(SharedPtr port) +GraphBox::graph_port_removed(SPtr port) { if (!(port->is_input() && _app->can_control(port.get()))) return; diff --git a/src/gui/GraphBox.hpp b/src/gui/GraphBox.hpp index f78d8a2b..663a3c14 100644 --- a/src/gui/GraphBox.hpp +++ b/src/gui/GraphBox.hpp @@ -28,7 +28,7 @@ #include #include -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "Window.hpp" @@ -67,33 +67,33 @@ public: const Glib::RefPtr& xml); ~GraphBox(); - static SharedPtr create( - App& app, SharedPtr graph); + static SPtr create( + App& app, SPtr graph); void init_box(App& app); - void set_graph(SharedPtr graph, - SharedPtr view); + void set_graph(SPtr graph, + SPtr view); void set_window(GraphWindow* win) { _window = win; } bool documentation_is_visible() { return _doc_scrolledwindow->is_visible(); } void set_documentation(const std::string& doc, bool html); - SharedPtr graph() const { return _graph; } - SharedPtr view() const { return _view; } + SPtr graph() const { return _graph; } + SPtr view() const { return _view; } void show_port_status(const Client::PortModel* model, const Raul::Atom& value); - void set_graph_from_path(const Raul::Path& path, SharedPtr view); + void set_graph_from_path(const Raul::Path& path, SPtr view); void object_entered(const Client::ObjectModel* model); void object_left(const Client::ObjectModel* model); private: - void graph_port_added(SharedPtr port); - void graph_port_removed(SharedPtr port); + void graph_port_added(SPtr port); + void graph_port_removed(SPtr port); void show_status(const Client::ObjectModel* model); int message_dialog(const Glib::ustring& message, @@ -124,10 +124,10 @@ private: void event_show_engine(); void event_clipboard_changed(GdkEventOwnerChange* ev); - App* _app; - SharedPtr _graph; - SharedPtr _view; - GraphWindow* _window; + App* _app; + SPtr _graph; + SPtr _view; + GraphWindow* _window; sigc::connection new_port_connection; sigc::connection removed_port_connection; diff --git a/src/gui/GraphCanvas.cpp b/src/gui/GraphCanvas.cpp index 371f7444..3d742e1d 100644 --- a/src/gui/GraphCanvas.cpp +++ b/src/gui/GraphCanvas.cpp @@ -59,10 +59,10 @@ using namespace Client; namespace GUI { -GraphCanvas::GraphCanvas(App& app, - SharedPtr graph, - int width, - int height) +GraphCanvas::GraphCanvas(App& app, + SPtr graph, + int width, + int height) : Canvas(width, height) , _app(app) , _graph(graph) @@ -207,7 +207,7 @@ GraphCanvas::build_menus() } // Add known plugins to menu heirarchy - SharedPtr plugins = _app.store()->plugins(); + SPtr plugins = _app.store()->plugins(); for (const auto& p : *plugins.get()) add_plugin(p.second); } @@ -306,7 +306,7 @@ GraphCanvas::build() // Create modules for blocks for (Store::const_iterator i = kids.first; i != kids.second; ++i) { - SharedPtr block = PtrCast(i->second); + SPtr block = dynamic_ptr_cast(i->second); if (block && block->parent() == _graph) add_block(block); } @@ -318,7 +318,7 @@ GraphCanvas::build() // Create arcs for (const auto& a : _graph->arcs()) { - connection(PtrCast(a.second)); + connection(dynamic_ptr_cast(a.second)); } } @@ -352,7 +352,7 @@ GraphCanvas::show_port_names(bool b) } void -GraphCanvas::add_plugin(SharedPtr p) +GraphCanvas::add_plugin(SPtr p) { typedef ClassMenus::iterator iterator; if (_internal_menu && p->type() == Plugin::Internal) { @@ -406,10 +406,10 @@ GraphCanvas::add_plugin(SharedPtr p) } void -GraphCanvas::add_block(SharedPtr bm) +GraphCanvas::add_block(SPtr bm) { - SharedPtr pm = PtrCast(bm); - NodeModule* module; + SPtr pm = dynamic_ptr_cast(bm); + NodeModule* module; if (pm) { module = SubgraphModule::create(*this, pm, _human_names); } else { @@ -427,7 +427,7 @@ GraphCanvas::add_block(SharedPtr bm) } void -GraphCanvas::remove_block(SharedPtr bm) +GraphCanvas::remove_block(SPtr bm) { Views::iterator i = _views.find(bm); @@ -442,7 +442,7 @@ GraphCanvas::remove_block(SharedPtr bm) } void -GraphCanvas::add_port(SharedPtr pm) +GraphCanvas::add_port(SPtr pm) { GraphPortModule* view = GraphPortModule::create(*this, pm, _human_names); _views.insert(std::make_pair(pm, view)); @@ -450,7 +450,7 @@ GraphCanvas::add_port(SharedPtr pm) } void -GraphCanvas::remove_port(SharedPtr pm) +GraphCanvas::remove_port(SPtr pm) { Views::iterator i = _views.find(pm); @@ -468,7 +468,7 @@ GraphCanvas::remove_port(SharedPtr pm) } Ganv::Port* -GraphCanvas::get_port_view(SharedPtr port) +GraphCanvas::get_port_view(SPtr port) { Ganv::Module* module = _views[port]; @@ -493,7 +493,7 @@ GraphCanvas::get_port_view(SharedPtr port) } void -GraphCanvas::connection(SharedPtr arc) +GraphCanvas::connection(SPtr arc) { Ganv::Port* const tail = get_port_view(arc->tail()); Ganv::Port* const head = get_port_view(arc->head()); @@ -507,7 +507,7 @@ GraphCanvas::connection(SharedPtr arc) } void -GraphCanvas::disconnection(SharedPtr arc) +GraphCanvas::disconnection(SPtr arc) { Ganv::Port* const src = get_port_view(arc->tail()); Ganv::Port* const dst = get_port_view(arc->head()); @@ -713,7 +713,7 @@ void GraphCanvas::paste() { Glib::ustring str = Gtk::Clipboard::get()->wait_for_text(); - SharedPtr parser = _app.loader()->parser(); + SPtr parser = _app.loader()->parser(); if (!parser) { _app.log().error("Unable to load parser, paste unavailable\n"); return; @@ -782,7 +782,8 @@ GraphCanvas::paste() _pastees.insert(c.first); } - builder.connect(PtrCast(clipboard.object(_graph->path()))); + builder.connect( + dynamic_ptr_cast(clipboard.object(_graph->path()))); } void @@ -837,9 +838,9 @@ GraphCanvas::menu_add_port(const string& sym_base, const string& name_base, } void -GraphCanvas::load_plugin(WeakPtr weak_plugin) +GraphCanvas::load_plugin(WPtr weak_plugin) { - SharedPtr plugin = weak_plugin.lock(); + SPtr plugin = weak_plugin.lock(); if (!plugin) return; diff --git a/src/gui/GraphCanvas.hpp b/src/gui/GraphCanvas.hpp index 6d4bbc87..77498748 100644 --- a/src/gui/GraphCanvas.hpp +++ b/src/gui/GraphCanvas.hpp @@ -27,12 +27,12 @@ #include "ganv/Canvas.hpp" #include "ganv/Module.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/Node.hpp" +#include "ingen/client/ArcModel.hpp" +#include "ingen/types.hpp" #include "raul/Path.hpp" #include "NodeModule.hpp" -#include "ingen/Node.hpp" -#include "ingen/client/ArcModel.hpp" namespace Ingen { @@ -49,10 +49,10 @@ class NodeModule; class GraphCanvas : public Ganv::Canvas { public: - GraphCanvas(App& app, - SharedPtr graph, - int width, - int height); + GraphCanvas(App& app, + SPtr graph, + int width, + int height); virtual ~GraphCanvas() {} @@ -63,13 +63,13 @@ public: void show_port_names(bool show); bool show_port_names() const { return _show_port_names; } - void add_plugin(SharedPtr pm); - void add_block(SharedPtr bm); - void remove_block(SharedPtr bm); - void add_port(SharedPtr pm); - void remove_port(SharedPtr pm); - void connection(SharedPtr am); - void disconnection(SharedPtr am); + void add_plugin(SPtr pm); + void add_block(SPtr bm); + void remove_block(SPtr bm); + void add_port(SPtr pm); + void remove_port(SPtr pm); + void connection(SPtr am); + void disconnection(SPtr am); void get_new_module_location(double& x, double& y); @@ -96,7 +96,7 @@ private: void menu_new_graph(); void menu_load_graph(); void menu_properties(); - void load_plugin(WeakPtr plugin); + void load_plugin(WPtr plugin); void build_menus(); @@ -116,7 +116,7 @@ private: Node::Properties get_initial_data(Resource::Graph ctx=Resource::Graph::DEFAULT); - Ganv::Port* get_port_view(SharedPtr port); + Ganv::Port* get_port_view(SPtr port); void connect(Ganv::Node* src, Ganv::Node* dst); @@ -124,10 +124,10 @@ private: void disconnect(Ganv::Node* src, Ganv::Node* dst); - App& _app; - SharedPtr _graph; + App& _app; + SPtr _graph; - typedef std::map, Ganv::Module*> Views; + typedef std::map, Ganv::Module*> Views; Views _views; int _auto_position_count; diff --git a/src/gui/GraphPortModule.cpp b/src/gui/GraphPortModule.cpp index d495cbe4..402da865 100644 --- a/src/gui/GraphPortModule.cpp +++ b/src/gui/GraphPortModule.cpp @@ -42,14 +42,14 @@ using namespace Client; namespace GUI { -GraphPortModule::GraphPortModule(GraphCanvas& canvas, - SharedPtr model) +GraphPortModule::GraphPortModule(GraphCanvas& canvas, + SPtr model) : Ganv::Module(canvas, "", 0, 0, false) // FIXME: coords? , _model(model) { assert(model); - assert(PtrCast(model->parent())); + assert(dynamic_ptr_cast(model->parent())); set_stacked(model->polyphonic()); @@ -61,9 +61,9 @@ GraphPortModule::GraphPortModule(GraphCanvas& canvas, } GraphPortModule* -GraphPortModule::create(GraphCanvas& canvas, - SharedPtr model, - bool human) +GraphPortModule::create(GraphCanvas& canvas, + SPtr model, + bool human) { GraphPortModule* ret = new GraphPortModule(canvas, model); Port* port = Port::create(canvas.app(), *ret, model, human, true); diff --git a/src/gui/GraphPortModule.hpp b/src/gui/GraphPortModule.hpp index 722f35c3..9f2c96fd 100644 --- a/src/gui/GraphPortModule.hpp +++ b/src/gui/GraphPortModule.hpp @@ -49,9 +49,9 @@ class GraphPortModule : public Ganv::Module { public: static GraphPortModule* create( - GraphCanvas& canvas, - SharedPtr model, - bool human); + GraphCanvas& canvas, + SPtr model, + bool human); App& app() const; @@ -60,11 +60,11 @@ public: void set_name(const std::string& n); - SharedPtr port() const { return _model; } + SPtr port() const { return _model; } protected: - GraphPortModule(GraphCanvas& canvas, - SharedPtr model); + GraphPortModule(GraphCanvas& canvas, + SPtr model); bool show_menu(GdkEventButton* ev); void set_selected(gboolean b); @@ -73,8 +73,8 @@ protected: void property_changed(const Raul::URI& predicate, const Raul::Atom& value); - SharedPtr _model; - Port* _port; + SPtr _model; + Port* _port; }; } // namespace GUI diff --git a/src/gui/GraphTreeWindow.cpp b/src/gui/GraphTreeWindow.cpp index 7ddbb23a..ff38e707 100644 --- a/src/gui/GraphTreeWindow.cpp +++ b/src/gui/GraphTreeWindow.cpp @@ -75,15 +75,15 @@ GraphTreeWindow::init(App& app, ClientStore& store) } void -GraphTreeWindow::new_object(SharedPtr object) +GraphTreeWindow::new_object(SPtr object) { - SharedPtr graph = PtrCast(object); + SPtr graph = dynamic_ptr_cast(object); if (graph) add_graph(graph); } void -GraphTreeWindow::add_graph(SharedPtr pm) +GraphTreeWindow::add_graph(SPtr pm) { if (!pm->parent()) { Gtk::TreeModel::iterator iter = _graph_treestore->append(); @@ -124,7 +124,7 @@ GraphTreeWindow::add_graph(SharedPtr pm) } void -GraphTreeWindow::remove_graph(SharedPtr pm) +GraphTreeWindow::remove_graph(SPtr pm) { Gtk::TreeModel::iterator i = find_graph(_graph_treestore->children(), pm); if (i != _graph_treestore->children().end()) @@ -132,12 +132,11 @@ GraphTreeWindow::remove_graph(SharedPtr pm) } Gtk::TreeModel::iterator -GraphTreeWindow::find_graph( - Gtk::TreeModel::Children root, - SharedPtr graph) +GraphTreeWindow::find_graph(Gtk::TreeModel::Children root, + SPtr graph) { for (Gtk::TreeModel::iterator c = root.begin(); c != root.end(); ++c) { - SharedPtr pm = (*c)[_graph_tree_columns.graph_model_col]; + SPtr pm = (*c)[_graph_tree_columns.graph_model_col]; if (graph == pm) { return c; } else if ((*c)->children().size() > 0) { @@ -157,7 +156,7 @@ GraphTreeWindow::show_graph_menu(GdkEventButton* ev) Gtk::TreeModel::iterator active = _graph_tree_selection->get_selected(); if (active) { Gtk::TreeModel::Row row = *active; - SharedPtr pm = row[_graph_tree_columns.graph_model_col]; + SPtr pm = row[_graph_tree_columns.graph_model_col]; if (pm) { _app->log().warn("TODO: graph menu from tree window"); } @@ -165,11 +164,12 @@ GraphTreeWindow::show_graph_menu(GdkEventButton* ev) } void -GraphTreeWindow::event_graph_activated(const Gtk::TreeModel::Path& path, Gtk::TreeView::Column* col) +GraphTreeWindow::event_graph_activated(const Gtk::TreeModel::Path& path, + Gtk::TreeView::Column* col) { Gtk::TreeModel::iterator active = _graph_treestore->get_iter(path); Gtk::TreeModel::Row row = *active; - SharedPtr pm = row[_graph_tree_columns.graph_model_col]; + SPtr pm = row[_graph_tree_columns.graph_model_col]; _app->window_factory()->present_graph(pm); } @@ -181,7 +181,7 @@ GraphTreeWindow::event_graph_enabled_toggled(const Glib::ustring& path_str) Gtk::TreeModel::iterator active = _graph_treestore->get_iter(path); Gtk::TreeModel::Row row = *active; - SharedPtr pm = row[_graph_tree_columns.graph_model_col]; + SPtr pm = row[_graph_tree_columns.graph_model_col]; assert(pm); if (_enable_signal) @@ -192,9 +192,9 @@ GraphTreeWindow::event_graph_enabled_toggled(const Glib::ustring& path_str) } void -GraphTreeWindow::graph_property_changed(const Raul::URI& key, - const Raul::Atom& value, - SharedPtr graph) +GraphTreeWindow::graph_property_changed(const Raul::URI& key, + const Raul::Atom& value, + SPtr graph) { const URIs& uris = _app->uris(); _enable_signal = false; @@ -212,7 +212,7 @@ GraphTreeWindow::graph_property_changed(const Raul::URI& key, } void -GraphTreeWindow::graph_moved(SharedPtr graph) +GraphTreeWindow::graph_moved(SPtr graph) { _enable_signal = false; diff --git a/src/gui/GraphTreeWindow.hpp b/src/gui/GraphTreeWindow.hpp index 3bd50b76..eec8b0d8 100644 --- a/src/gui/GraphTreeWindow.hpp +++ b/src/gui/GraphTreeWindow.hpp @@ -47,16 +47,16 @@ public: void init(App& app, Client::ClientStore& store); - void new_object(SharedPtr object); + void new_object(SPtr object); - void graph_property_changed(const Raul::URI& key, - const Raul::Atom& value, - SharedPtr gm); + void graph_property_changed(const Raul::URI& key, + const Raul::Atom& value, + SPtr gm); - void graph_moved(SharedPtr graph); + void graph_moved(SPtr graph); - void add_graph(SharedPtr gm); - void remove_graph(SharedPtr gm); + void add_graph(SPtr gm); + void remove_graph(SPtr gm); void show_graph_menu(GdkEventButton* ev); protected: @@ -66,8 +66,8 @@ protected: void event_graph_enabled_toggled(const Glib::ustring& path_str); Gtk::TreeModel::iterator find_graph( - Gtk::TreeModel::Children root, - SharedPtr graph); + Gtk::TreeModel::Children root, + SPtr graph); GraphTreeView* _graphs_treeview; @@ -79,9 +79,9 @@ protected: add(graph_model_col); } - Gtk::TreeModelColumn name_col; - Gtk::TreeModelColumn enabled_col; - Gtk::TreeModelColumn > graph_model_col; + Gtk::TreeModelColumn name_col; + Gtk::TreeModelColumn enabled_col; + Gtk::TreeModelColumn > graph_model_col; }; App* _app; diff --git a/src/gui/GraphView.cpp b/src/gui/GraphView.cpp index c795861d..8452e9cf 100644 --- a/src/gui/GraphView.cpp +++ b/src/gui/GraphView.cpp @@ -67,14 +67,14 @@ GraphView::init(App& app) } void -GraphView::set_graph(SharedPtr graph) +GraphView::set_graph(SPtr graph) { assert(!_canvas); // FIXME: remove assert(_breadcrumb_container); // ensure created _graph = graph; - _canvas = SharedPtr(new GraphCanvas(*_app, graph, 1600*2, 1200*2)); + _canvas = SPtr(new GraphCanvas(*_app, graph, 1600*2, 1200*2)); _canvas->build(); _canvas_scrolledwindow->add(_canvas->widget()); @@ -116,15 +116,15 @@ GraphView::set_graph(SharedPtr graph) _canvas->widget().grab_focus(); } -SharedPtr -GraphView::create(App& app, SharedPtr graph) +SPtr +GraphView::create(App& app, SPtr graph) { GraphView* result = NULL; Glib::RefPtr xml = WidgetFactory::create("warehouse_win"); xml->get_widget_derived("graph_view_box", result); result->init(app); result->set_graph(graph); - return SharedPtr(result); + return SPtr(result); } #if 0 diff --git a/src/gui/GraphView.hpp b/src/gui/GraphView.hpp index cae073af..c060d02e 100644 --- a/src/gui/GraphView.hpp +++ b/src/gui/GraphView.hpp @@ -26,7 +26,7 @@ #include #include -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "raul/URI.hpp" namespace Raul { class Atom; } @@ -61,18 +61,18 @@ public: void init(App& app); - SharedPtr canvas() const { return _canvas; } - SharedPtr graph() const { return _graph; } - Gtk::ToolItem* breadcrumb_container() const { return _breadcrumb_container; } + SPtr canvas() const { return _canvas; } + SPtr graph() const { return _graph; } + Gtk::ToolItem* breadcrumb_container() const { return _breadcrumb_container; } - static SharedPtr create(App& app, - SharedPtr graph); + static SPtr create(App& app, + SPtr graph); sigc::signal signal_object_entered; sigc::signal signal_object_left; private: - void set_graph(SharedPtr graph); + void set_graph(SPtr graph); void process_toggled(); void poly_changed(); @@ -90,8 +90,8 @@ private: App* _app; - SharedPtr _graph; - SharedPtr _canvas; + SPtr _graph; + SPtr _canvas; Gtk::ScrolledWindow* _canvas_scrolledwindow; Gtk::Toolbar* _toolbar; diff --git a/src/gui/GraphWindow.hpp b/src/gui/GraphWindow.hpp index a45177ce..bbb25a27 100644 --- a/src/gui/GraphWindow.hpp +++ b/src/gui/GraphWindow.hpp @@ -21,7 +21,7 @@ #include -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "GraphBox.hpp" #include "Window.hpp" @@ -48,8 +48,8 @@ public: void init_window(App& app); - SharedPtr graph() const { return _box->graph(); } - GraphBox* box() const { return _box; } + SPtr graph() const { return _box->graph(); } + GraphBox* box() const { return _box; } bool documentation_is_visible() { return _box->documentation_is_visible(); } diff --git a/src/gui/LoadGraphWindow.cpp b/src/gui/LoadGraphWindow.cpp index c7e94a0e..1229dd25 100644 --- a/src/gui/LoadGraphWindow.cpp +++ b/src/gui/LoadGraphWindow.cpp @@ -95,9 +95,9 @@ LoadGraphWindow::LoadGraphWindow(BaseObjectType* cobject, } void -LoadGraphWindow::present(SharedPtr graph, - bool import, - Node::Properties data) +LoadGraphWindow::present(SPtr graph, + bool import, + Node::Properties data) { _import = import; set_graph(graph); @@ -115,7 +115,7 @@ LoadGraphWindow::present(SharedPtr graph, * This function MUST be called before using the window in any way! */ void -LoadGraphWindow::set_graph(SharedPtr graph) +LoadGraphWindow::set_graph(SPtr graph) { _graph = graph; _symbol_entry->set_text(""); diff --git a/src/gui/LoadGraphWindow.hpp b/src/gui/LoadGraphWindow.hpp index 64ebe99b..a6fa84c8 100644 --- a/src/gui/LoadGraphWindow.hpp +++ b/src/gui/LoadGraphWindow.hpp @@ -25,9 +25,8 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/Node.hpp" +#include "ingen/types.hpp" namespace Ingen { @@ -49,11 +48,11 @@ public: void init(App& app) { _app = &app; } - void set_graph(SharedPtr graph); + void set_graph(SPtr graph); - void present(SharedPtr graph, - bool import, - Node::Properties data); + void present(SPtr graph, + bool import, + Node::Properties data); protected: void on_show(); @@ -73,7 +72,7 @@ private: Node::Properties _initial_data; - SharedPtr _graph; + SPtr _graph; Gtk::Label* _symbol_label; Gtk::Entry* _symbol_entry; diff --git a/src/gui/LoadPluginWindow.cpp b/src/gui/LoadPluginWindow.cpp index 7e61d48d..7b1ac5c7 100644 --- a/src/gui/LoadPluginWindow.cpp +++ b/src/gui/LoadPluginWindow.cpp @@ -129,8 +129,8 @@ LoadPluginWindow::LoadPluginWindow(BaseObjectType* cobject, } void -LoadPluginWindow::present(SharedPtr graph, - Node::Properties data) +LoadPluginWindow::present(SPtr graph, + Node::Properties data) { set_graph(graph); _initial_data = data; @@ -170,7 +170,7 @@ LoadPluginWindow::name_cleared(Gtk::EntryIconPosition pos, const GdkEventButton* * This function MUST be called before using the window in any way! */ void -LoadPluginWindow::set_graph(SharedPtr graph) +LoadPluginWindow::set_graph(SPtr graph) { if (_graph) { _graph = graph; @@ -205,7 +205,7 @@ LoadPluginWindow::on_show() } void -LoadPluginWindow::set_plugins(SharedPtr plugins) +LoadPluginWindow::set_plugins(SPtr plugins) { _rows.clear(); _plugins_liststore->clear(); @@ -219,7 +219,7 @@ LoadPluginWindow::set_plugins(SharedPtr plugins) } void -LoadPluginWindow::new_plugin(SharedPtr pm) +LoadPluginWindow::new_plugin(SPtr pm) { if (is_visible()) add_plugin(pm); @@ -228,7 +228,7 @@ LoadPluginWindow::new_plugin(SharedPtr pm) } static std::string -get_project_name(SharedPtr plugin) +get_project_name(SPtr plugin) { std::string name; if (plugin->lilv_plugin()) { @@ -254,7 +254,7 @@ get_project_name(SharedPtr plugin) } static std::string -get_author_name(SharedPtr plugin) +get_author_name(SPtr plugin) { std::string name; if (plugin->lilv_plugin()) { @@ -269,7 +269,7 @@ get_author_name(SharedPtr plugin) void LoadPluginWindow::set_row(Gtk::TreeModel::Row& row, - SharedPtr plugin) + SPtr plugin) { const URIs& uris = _app->uris(); const Raul::Atom& name = plugin->get_property(uris.doap_name); @@ -303,7 +303,7 @@ LoadPluginWindow::set_row(Gtk::TreeModel::Row& row, } void -LoadPluginWindow::add_plugin(SharedPtr plugin) +LoadPluginWindow::add_plugin(SPtr plugin) { if (plugin->lilv_plugin() && lilv_plugin_is_replaced(plugin->lilv_plugin())) { return; @@ -342,7 +342,7 @@ LoadPluginWindow::plugin_selection_changed() *_selection->get_selected_rows().begin()); if (iter) { Gtk::TreeModel::Row row = *iter; - boost::shared_ptr p = row.get_value( + SPtr p = row.get_value( _plugins_columns._col_plugin); _name_offset = _app->store()->child_name_offset( _graph->path(), p->default_block_symbol()); @@ -366,8 +366,8 @@ LoadPluginWindow::plugin_selection_changed() * sends the notification back. */ string -LoadPluginWindow::generate_module_name(SharedPtr plugin, - int offset) +LoadPluginWindow::generate_module_name(SPtr plugin, + int offset) { std::stringstream ss; ss << plugin->default_block_symbol(); @@ -379,11 +379,11 @@ LoadPluginWindow::generate_module_name(SharedPtr plugin, void LoadPluginWindow::load_plugin(const Gtk::TreeModel::iterator& iter) { - const URIs& uris = _app->uris(); - Gtk::TreeModel::Row row = *iter; - SharedPtr plugin = row.get_value(_plugins_columns._col_plugin); - bool polyphonic = _polyphonic_checkbutton->get_active(); - string name = _name_entry->get_text(); + const URIs& uris = _app->uris(); + Gtk::TreeModel::Row row = *iter; + SPtr plugin = row.get_value(_plugins_columns._col_plugin); + bool polyphonic = _polyphonic_checkbutton->get_active(); + string name = _name_entry->get_text(); if (name.empty()) name = generate_module_name(plugin, _name_offset); @@ -446,7 +446,7 @@ LoadPluginWindow::filter_changed() const URIs& uris = _app->uris(); for (const auto& p : *_app->store()->plugins().get()) { - const SharedPtr plugin = p.second; + const SPtr plugin = p.second; const Raul::Atom& name = plugin->get_property(uris.doap_name); switch (criteria) { diff --git a/src/gui/LoadPluginWindow.hpp b/src/gui/LoadPluginWindow.hpp index ed2e979c..5c8fad19 100644 --- a/src/gui/LoadPluginWindow.hpp +++ b/src/gui/LoadPluginWindow.hpp @@ -26,10 +26,9 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/Node.hpp" #include "ingen/client/ClientStore.hpp" +#include "ingen/types.hpp" #include "ingen_config.h" #include "Window.hpp" @@ -55,13 +54,13 @@ public: LoadPluginWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); - void set_graph(SharedPtr graph); - void set_plugins(SharedPtr plugins); + void set_graph(SPtr graph); + void set_plugins(SPtr plugins); - void add_plugin(SharedPtr plugin); + void add_plugin(SPtr plugin); - void present(SharedPtr graph, - Node::Properties data); + void present(SPtr graph, + Node::Properties data); protected: void on_show(); @@ -87,7 +86,7 @@ private: Gtk::TreeModelColumn _col_uri; // Not displayed: - Gtk::TreeModelColumn< SharedPtr > _col_plugin; + Gtk::TreeModelColumn< SPtr > _col_plugin; }; /** Column for the filter criteria combo box. */ @@ -112,8 +111,10 @@ private: void name_cleared(Gtk::EntryIconPosition pos, const GdkEventButton* event); #endif - void set_row(Gtk::TreeModel::Row& row, SharedPtr plugin); - void new_plugin(SharedPtr plugin); + void set_row(Gtk::TreeModel::Row& row, + SPtr plugin); + + void new_plugin(SPtr plugin); void plugin_property_changed(const Raul::URI& plugin, const Raul::URI& predicate, @@ -122,15 +123,14 @@ private: void plugin_activated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* col); void plugin_selection_changed(); - std::string generate_module_name( - SharedPtr plugin, - int offset=0); + std::string generate_module_name(SPtr plugin, + int offset=0); void load_plugin(const Gtk::TreeModel::iterator& iter); Node::Properties _initial_data; - SharedPtr _graph; + SPtr _graph; typedef std::map Rows; Rows _rows; diff --git a/src/gui/NewSubgraphWindow.cpp b/src/gui/NewSubgraphWindow.cpp index f2457843..b17cc100 100644 --- a/src/gui/NewSubgraphWindow.cpp +++ b/src/gui/NewSubgraphWindow.cpp @@ -49,8 +49,8 @@ NewSubgraphWindow::NewSubgraphWindow(BaseObjectType* cobject, } void -NewSubgraphWindow::present(SharedPtr graph, - Node::Properties data) +NewSubgraphWindow::present(SPtr graph, + Node::Properties data) { set_graph(graph); _initial_data = data; @@ -62,7 +62,7 @@ NewSubgraphWindow::present(SharedPtr graph, * This function MUST be called before using the window in any way! */ void -NewSubgraphWindow::set_graph(SharedPtr graph) +NewSubgraphWindow::set_graph(SPtr graph) { _graph = graph; } diff --git a/src/gui/NewSubgraphWindow.hpp b/src/gui/NewSubgraphWindow.hpp index 4fef4831..7f3c855b 100644 --- a/src/gui/NewSubgraphWindow.hpp +++ b/src/gui/NewSubgraphWindow.hpp @@ -23,9 +23,8 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/Node.hpp" +#include "ingen/types.hpp" #include "Window.hpp" @@ -47,18 +46,18 @@ public: NewSubgraphWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); - void set_graph(SharedPtr graph); + void set_graph(SPtr graph); - void present(SharedPtr graph, - Node::Properties data); + void present(SPtr graph, + Node::Properties data); private: void name_changed(); void ok_clicked(); void cancel_clicked(); - Node::Properties _initial_data; - SharedPtr _graph; + Node::Properties _initial_data; + SPtr _graph; Gtk::Entry* _name_entry; Gtk::Label* _message_label; diff --git a/src/gui/NodeMenu.cpp b/src/gui/NodeMenu.cpp index 548aa68a..9fe43562 100644 --- a/src/gui/NodeMenu.cpp +++ b/src/gui/NodeMenu.cpp @@ -49,7 +49,7 @@ NodeMenu::NodeMenu(BaseObjectType* cobject, } void -NodeMenu::init(App& app, SharedPtr block) +NodeMenu::init(App& app, SPtr block) { ObjectMenu::init(app, block); diff --git a/src/gui/NodeMenu.hpp b/src/gui/NodeMenu.hpp index b307b9a4..969afecf 100644 --- a/src/gui/NodeMenu.hpp +++ b/src/gui/NodeMenu.hpp @@ -25,7 +25,7 @@ #include "ObjectMenu.hpp" #include "ingen/client/BlockModel.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" namespace Ingen { namespace GUI { @@ -40,7 +40,7 @@ public: NodeMenu(BaseObjectType* cobject, const Glib::RefPtr& xml); - void init(App& app, SharedPtr block); + void init(App& app, SPtr block); bool has_control_inputs(); diff --git a/src/gui/NodeModule.cpp b/src/gui/NodeModule.cpp index 46588e6e..77ec41ca 100644 --- a/src/gui/NodeModule.cpp +++ b/src/gui/NodeModule.cpp @@ -51,8 +51,8 @@ using namespace Client; namespace GUI { -NodeModule::NodeModule(GraphCanvas& canvas, - SharedPtr block) +NodeModule::NodeModule(GraphCanvas& canvas, + SPtr block) : Ganv::Module(canvas, block->path().symbol(), 0, 0, true) , _block(block) , _gui_widget(NULL) @@ -103,11 +103,11 @@ NodeModule::show_menu(GdkEventButton* ev) } NodeModule* -NodeModule::create(GraphCanvas& canvas, - SharedPtr block, - bool human) +NodeModule::create(GraphCanvas& canvas, + SPtr block, + bool human) { - SharedPtr graph = PtrCast(block); + SPtr graph = dynamic_ptr_cast(block); NodeModule* ret = (graph) ? new SubgraphModule(canvas, graph) @@ -262,7 +262,7 @@ NodeModule::rename() } void -NodeModule::new_port_view(SharedPtr port) +NodeModule::new_port_view(SPtr port) { Port::create(app(), *this, port, app().world()->conf().option("human-names").get_bool()); @@ -277,7 +277,7 @@ NodeModule::new_port_view(SharedPtr port) } Port* -NodeModule::port(boost::shared_ptr model) +NodeModule::port(SPtr model) { for (iterator p = begin(); p != end(); ++p) { Port* const port = dynamic_cast(*p); @@ -288,7 +288,7 @@ NodeModule::port(boost::shared_ptr model) } void -NodeModule::delete_port_view(SharedPtr model) +NodeModule::delete_port_view(SPtr model) { Port* p = port(model); if (p) { diff --git a/src/gui/NodeModule.hpp b/src/gui/NodeModule.hpp index 3dc7e93e..f1521c5f 100644 --- a/src/gui/NodeModule.hpp +++ b/src/gui/NodeModule.hpp @@ -18,7 +18,7 @@ #define INGEN_GUI_NODEMODULE_HPP #include "ganv/Module.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "Port.hpp" @@ -47,25 +47,25 @@ class NodeModule : public Ganv::Module { public: static NodeModule* create( - GraphCanvas& canvas, - SharedPtr block, - bool human_names); + GraphCanvas& canvas, + SPtr block, + bool human_names); virtual ~NodeModule(); App& app() const; - Port* port(boost::shared_ptr model); + Port* port(SPtr model); - void delete_port_view(SharedPtr port); + void delete_port_view(SPtr port); virtual void store_location(double x, double y); void show_human_names(bool b); - SharedPtr block() const { return _block; } + SPtr block() const { return _block; } protected: - NodeModule(GraphCanvas& canvas, SharedPtr block); + NodeModule(GraphCanvas& canvas, SPtr block); virtual bool on_double_click(GdkEventButton* ev); @@ -80,7 +80,7 @@ protected: void rename(); void property_changed(const Raul::URI& predicate, const Raul::Atom& value); - void new_port_view(SharedPtr port); + void new_port_view(SPtr port); void value_changed(uint32_t index, const Raul::Atom& value); void port_activity(uint32_t index, const Raul::Atom& value); @@ -89,11 +89,11 @@ protected: bool show_menu(GdkEventButton* ev); - SharedPtr _block; - NodeMenu* _menu; - SharedPtr _plugin_ui; - Gtk::Widget* _gui_widget; - Gtk::Window* _gui_window; ///< iff popped up + SPtr _block; + NodeMenu* _menu; + SPtr _plugin_ui; + Gtk::Widget* _gui_widget; + Gtk::Window* _gui_window; ///< iff popped up }; } // namespace GUI diff --git a/src/gui/ObjectMenu.cpp b/src/gui/ObjectMenu.cpp index 46437e2e..d963aa90 100644 --- a/src/gui/ObjectMenu.cpp +++ b/src/gui/ObjectMenu.cpp @@ -51,7 +51,7 @@ ObjectMenu::ObjectMenu(BaseObjectType* cobject, } void -ObjectMenu::init(App& app, SharedPtr object) +ObjectMenu::init(App& app, SPtr object) { _app = &app; _object = object; diff --git a/src/gui/ObjectMenu.hpp b/src/gui/ObjectMenu.hpp index c4648443..63ca666d 100644 --- a/src/gui/ObjectMenu.hpp +++ b/src/gui/ObjectMenu.hpp @@ -22,9 +22,8 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/client/ObjectModel.hpp" +#include "ingen/types.hpp" namespace Ingen { namespace GUI { @@ -43,7 +42,7 @@ public: ObjectMenu(BaseObjectType* cobject, const Glib::RefPtr& xml); - void init(App& app, SharedPtr object); + void init(App& app, SPtr object); protected: void on_menu_learn(); @@ -55,15 +54,15 @@ protected: void property_changed(const Raul::URI& predicate, const Raul::Atom& value); - App* _app; - SharedPtr _object; - Gtk::MenuItem* _learn_menuitem; - Gtk::MenuItem* _unlearn_menuitem; - Gtk::CheckMenuItem* _polyphonic_menuitem; - Gtk::MenuItem* _disconnect_menuitem; - Gtk::MenuItem* _rename_menuitem; - Gtk::MenuItem* _destroy_menuitem; - Gtk::MenuItem* _properties_menuitem; + App* _app; + SPtr _object; + Gtk::MenuItem* _learn_menuitem; + Gtk::MenuItem* _unlearn_menuitem; + Gtk::CheckMenuItem* _polyphonic_menuitem; + Gtk::MenuItem* _disconnect_menuitem; + Gtk::MenuItem* _rename_menuitem; + Gtk::MenuItem* _destroy_menuitem; + Gtk::MenuItem* _properties_menuitem; bool _enable_signal; }; diff --git a/src/gui/Port.cpp b/src/gui/Port.cpp index 0b85b286..b22339a0 100644 --- a/src/gui/Port.cpp +++ b/src/gui/Port.cpp @@ -40,11 +40,11 @@ namespace Ingen { namespace GUI { Port* -Port::create(App& app, - Ganv::Module& module, - SharedPtr pm, - bool human_name, - bool flip) +Port::create(App& app, + Ganv::Module& module, + SPtr pm, + bool human_name, + bool flip) { Glib::ustring label; if (app.world()->conf().option("port-labels").get_bool()) { @@ -53,7 +53,7 @@ Port::create(App& app, if (name.type() == app.forge().String) { label = name.get_string(); } else { - const SharedPtr parent(PtrCast(pm->parent())); + const SPtr parent(dynamic_ptr_cast(pm->parent())); if (parent && parent->plugin_model()) label = parent->plugin_model()->port_human_name(pm->index()); } @@ -66,11 +66,11 @@ Port::create(App& app, /** @a flip Make an input port appear as an output port, and vice versa. */ -Port::Port(App& app, - Ganv::Module& module, - SharedPtr pm, - const string& name, - bool flip) +Port::Port(App& app, + Ganv::Module& module, + SPtr pm, + const string& name, + bool flip) : Ganv::Port(module, name, flip ? (!pm->is_input()) : pm->is_input(), app.style()->get_port_color(pm.get())) @@ -115,9 +115,9 @@ Port::~Port() void Port::update_metadata() { - SharedPtr pm = _port_model.lock(); + SPtr pm = _port_model.lock(); if (_app.can_control(pm.get()) && pm->is_numeric()) { - boost::shared_ptr parent = PtrCast(pm->parent()); + SPtr parent = dynamic_ptr_cast(pm->parent()); if (parent) { float min = 0.0f; float max = 1.0f; @@ -190,8 +190,8 @@ Port::on_scale_point_activated(float f) Gtk::Menu* Port::build_enum_menu() { - SharedPtr block = PtrCast(model()->parent()); - Gtk::Menu* menu = Gtk::manage(new Gtk::Menu()); + SPtr block = dynamic_ptr_cast(model()->parent()); + Gtk::Menu* menu = Gtk::manage(new Gtk::Menu()); PluginModel::ScalePoints points = block->plugin_model()->port_scale_points( model()->index()); @@ -220,9 +220,9 @@ Port::on_uri_activated(const Raul::URI& uri) Gtk::Menu* Port::build_uri_menu() { - World* world = _app.world(); - SharedPtr block = PtrCast(model()->parent()); - Gtk::Menu* menu = Gtk::manage(new Gtk::Menu()); + World* world = _app.world(); + SPtr block = dynamic_ptr_cast(model()->parent()); + Gtk::Menu* menu = Gtk::manage(new Gtk::Menu()); // Get the port designation, which should be a rdf:Property const Raul::Atom& designation_atom = model()->get_property( @@ -370,7 +370,7 @@ Port::activity(const Raul::Atom& value) } void -Port::disconnected_from(SharedPtr port) +Port::disconnected_from(SPtr port) { if (!model()->connected() && model()->is_a(_app.uris().lv2_AudioPort)) { set_fill_color(peak_color(0.0f)); @@ -380,9 +380,9 @@ Port::disconnected_from(SharedPtr port) GraphBox* Port::get_graph_box() const { - SharedPtr graph = PtrCast(model()->parent()); + SPtr graph = dynamic_ptr_cast(model()->parent()); if (!graph) { - graph = PtrCast(model()->parent()->parent()); + graph = dynamic_ptr_cast(model()->parent()->parent()); } return _app.window_factory()->graph_box(graph); @@ -424,9 +424,9 @@ Port::set_selected(gboolean b) { if (b != get_selected()) { Ganv::Port::set_selected(b); - SharedPtr pm = _port_model.lock(); + SPtr pm = _port_model.lock(); if (pm && b) { - SharedPtr block = PtrCast(pm->parent()); + SPtr block = dynamic_ptr_cast(pm->parent()); GraphWindow* win = _app.window_factory()->parent_graph_window(block); if (win && win->documentation_is_visible() && block->plugin_model()) { const std::string& doc = block->plugin_model()->port_documentation( diff --git a/src/gui/Port.hpp b/src/gui/Port.hpp index 94f66ecd..a9d24c1f 100644 --- a/src/gui/Port.hpp +++ b/src/gui/Port.hpp @@ -23,8 +23,7 @@ #include #include "ganv/Port.hpp" -#include "raul/SharedPtr.hpp" -#include "raul/WeakPtr.hpp" +#include "ingen/types.hpp" namespace Raul { class Atom; @@ -48,31 +47,31 @@ class Port : public Ganv::Port { public: static Port* create( - App& app, - Ganv::Module& module, - SharedPtr pm, - bool human_name, - bool flip = false); + App& app, + Ganv::Module& module, + SPtr pm, + bool human_name, + bool flip = false); ~Port(); - SharedPtr model() const { return _port_model.lock(); } + SPtr model() const { return _port_model.lock(); } bool show_menu(GdkEventButton* ev); void update_metadata(); void value_changed(const Raul::Atom& value); void activity(const Raul::Atom& value); - void disconnected_from(SharedPtr port); + void disconnected_from(SPtr port); void set_selected(gboolean b); private: - Port(App& app, - Ganv::Module& module, - SharedPtr pm, - const std::string& name, - bool flip = false); + Port(App& app, + Ganv::Module& module, + SPtr pm, + const std::string& name, + bool flip = false); Gtk::Menu* build_enum_menu(); Gtk::Menu* build_uri_menu(); @@ -86,11 +85,11 @@ private: void on_uri_activated(const Raul::URI& uri); bool on_event(GdkEvent* ev); - App& _app; - WeakPtr _port_model; - bool _pressed : 1; - bool _entered : 1; - bool _flipped : 1; + App& _app; + WPtr _port_model; + bool _pressed : 1; + bool _entered : 1; + bool _flipped : 1; }; } // namespace GUI diff --git a/src/gui/PortMenu.cpp b/src/gui/PortMenu.cpp index 18e16aa3..76dff135 100644 --- a/src/gui/PortMenu.cpp +++ b/src/gui/PortMenu.cpp @@ -19,7 +19,7 @@ #include "ingen/Interface.hpp" #include "ingen/client/GraphModel.hpp" #include "ingen/client/PortModel.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "App.hpp" #include "PortMenu.hpp" @@ -44,7 +44,7 @@ PortMenu::PortMenu(BaseObjectType* cobject, } void -PortMenu::init(App& app, SharedPtr port, bool is_graph_port) +PortMenu::init(App& app, SPtr port, bool is_graph_port) { const URIs& uris = app.uris(); @@ -63,8 +63,8 @@ PortMenu::init(App& app, SharedPtr port, bool is_graph_port) _expose_menuitem->signal_activate().connect( sigc::mem_fun(this, &PortMenu::on_menu_expose)); - const bool is_control = app.can_control(port.get()) && port->is_numeric(); - const bool is_on_graph = PtrCast(port->parent()); + const bool is_control(app.can_control(port.get()) && port->is_numeric()); + const bool is_on_graph(dynamic_ptr_cast(port->parent())); if (!_is_graph_port) { _polyphonic_menuitem->set_sensitive(false); @@ -101,9 +101,9 @@ PortMenu::on_menu_disconnect() void PortMenu::on_menu_set_min() { - const URIs& uris = _app->uris(); - SharedPtr model = PtrCast(_object); - const Raul::Atom& value = model->get_property(uris.ingen_value); + const URIs& uris = _app->uris(); + SPtr model = dynamic_ptr_cast(_object); + const Raul::Atom& value = model->get_property(uris.ingen_value); if (value.is_valid()) _app->interface()->set_property(_object->uri(), uris.lv2_minimum, value); } @@ -111,9 +111,9 @@ PortMenu::on_menu_set_min() void PortMenu::on_menu_set_max() { - const URIs& uris = _app->uris(); - SharedPtr model = PtrCast(_object); - const Raul::Atom& value = model->get_property(uris.ingen_value); + const URIs& uris = _app->uris(); + SPtr model = dynamic_ptr_cast(_object); + const Raul::Atom& value = model->get_property(uris.ingen_value); if (value.is_valid()) _app->interface()->set_property(_object->uri(), uris.lv2_maximum, value); } @@ -121,9 +121,9 @@ PortMenu::on_menu_set_max() void PortMenu::on_menu_reset_range() { - const URIs& uris = _app->uris(); - SharedPtr model = PtrCast(_object); - SharedPtr parent = PtrCast(_object->parent()); + const URIs& uris = _app->uris(); + SPtr model = dynamic_ptr_cast(_object); + SPtr parent = dynamic_ptr_cast(_object->parent()); float min, max; parent->default_port_value_range(model, min, max); @@ -142,9 +142,9 @@ PortMenu::on_menu_reset_range() void PortMenu::on_menu_expose() { - const URIs& uris = _app->uris(); - SharedPtr port = PtrCast(_object); - SharedPtr block = PtrCast(port->parent()); + const URIs& uris = _app->uris(); + SPtr port = dynamic_ptr_cast(_object); + SPtr block = dynamic_ptr_cast(port->parent()); const std::string label = block->label() + " " + block->port_label(port); const Raul::Path path = Raul::Path(block->path() + Raul::Symbol("_" + port->symbol())); diff --git a/src/gui/PortMenu.hpp b/src/gui/PortMenu.hpp index 34f2c315..7e375098 100644 --- a/src/gui/PortMenu.hpp +++ b/src/gui/PortMenu.hpp @@ -22,7 +22,7 @@ #include #include "ingen/client/PortModel.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "ObjectMenu.hpp" @@ -39,9 +39,9 @@ public: PortMenu(BaseObjectType* cobject, const Glib::RefPtr& xml); - void init(App& app, - SharedPtr port, - bool is_graph_port = false); + void init(App& app, + SPtr port, + bool is_graph_port = false); private: void on_menu_disconnect(); diff --git a/src/gui/PortPropertiesWindow.cpp b/src/gui/PortPropertiesWindow.cpp index a0162fba..defe8235 100644 --- a/src/gui/PortPropertiesWindow.cpp +++ b/src/gui/PortPropertiesWindow.cpp @@ -52,7 +52,7 @@ PortPropertiesWindow::PortPropertiesWindow(BaseObjectType* cob * This function MUST be called before using this object in any way. */ void -PortPropertiesWindow::present(SharedPtr pm) +PortPropertiesWindow::present(SPtr pm) { assert(pm); @@ -66,7 +66,7 @@ PortPropertiesWindow::present(SharedPtr pm) set_title(pm->path() + " Properties - Ingen"); float min = 0.0f, max = 1.0f; - boost::shared_ptr parent = PtrCast(_port_model->parent()); + SPtr parent = dynamic_ptr_cast(_port_model->parent()); if (parent) parent->port_value_range(_port_model, min, max, _app->sample_rate()); diff --git a/src/gui/PortPropertiesWindow.hpp b/src/gui/PortPropertiesWindow.hpp index 309f3968..1cf86aa8 100644 --- a/src/gui/PortPropertiesWindow.hpp +++ b/src/gui/PortPropertiesWindow.hpp @@ -22,9 +22,8 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/client/PortModel.hpp" +#include "ingen/types.hpp" #include "Window.hpp" @@ -43,7 +42,7 @@ public: PortPropertiesWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); - void present(SharedPtr port_model); + void present(SPtr port_model); private: void property_changed(const Raul::URI& key, const Raul::Atom& value); @@ -56,12 +55,12 @@ private: float _initial_min; float _initial_max; - SharedPtr _port_model; - Gtk::SpinButton* _min_spinner; - Gtk::SpinButton* _max_spinner; - Gtk::Button* _cancel_button; - Gtk::Button* _ok_button; - std::list _connections; + SPtr _port_model; + Gtk::SpinButton* _min_spinner; + Gtk::SpinButton* _max_spinner; + Gtk::Button* _cancel_button; + Gtk::Button* _ok_button; + std::list _connections; }; } // namespace GUI diff --git a/src/gui/PropertiesWindow.cpp b/src/gui/PropertiesWindow.cpp index 44d84d70..0f21a4fb 100644 --- a/src/gui/PropertiesWindow.cpp +++ b/src/gui/PropertiesWindow.cpp @@ -97,7 +97,7 @@ PropertiesWindow::reset() } void -PropertiesWindow::present(SharedPtr model) +PropertiesWindow::present(SPtr model) { set_object(model); Gtk::Window::present(); @@ -140,7 +140,7 @@ PropertiesWindow::add_property(const Raul::URI& uri, const Raul::Atom& value) * This function MUST be called before using this object in any way. */ void -PropertiesWindow::set_object(SharedPtr model) +PropertiesWindow::set_object(SPtr model) { reset(); _model = model; diff --git a/src/gui/PropertiesWindow.hpp b/src/gui/PropertiesWindow.hpp index 7ba5e5b6..ad4d3d90 100644 --- a/src/gui/PropertiesWindow.hpp +++ b/src/gui/PropertiesWindow.hpp @@ -28,9 +28,8 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/client/BlockModel.hpp" +#include "ingen/types.hpp" #include "Window.hpp" @@ -52,8 +51,8 @@ public: PropertiesWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); - void present(SharedPtr model); - void set_object(SharedPtr model); + void present(SPtr model); + void set_object(SPtr model); private: /** Record of a property (row in the table) */ @@ -96,20 +95,20 @@ private: typedef std::map Records; Records _records; - SharedPtr _model; - ComboColumns _combo_columns; - Glib::RefPtr _key_store; - Glib::RefPtr _value_store; - sigc::connection _property_connection; - Gtk::VBox* _vbox; - Gtk::ScrolledWindow* _scrolledwindow; - Gtk::Table* _table; - Gtk::ComboBox* _key_combo; - Gtk::ComboBox* _value_combo; - Gtk::Button* _add_button; - Gtk::Button* _cancel_button; - Gtk::Button* _apply_button; - Gtk::Button* _ok_button; + SPtr _model; + ComboColumns _combo_columns; + Glib::RefPtr _key_store; + Glib::RefPtr _value_store; + sigc::connection _property_connection; + Gtk::VBox* _vbox; + Gtk::ScrolledWindow* _scrolledwindow; + Gtk::Table* _table; + Gtk::ComboBox* _key_combo; + Gtk::ComboBox* _value_combo; + Gtk::Button* _add_button; + Gtk::Button* _cancel_button; + Gtk::Button* _apply_button; + Gtk::Button* _ok_button; }; } // namespace GUI diff --git a/src/gui/RDFS.cpp b/src/gui/RDFS.cpp index bec69cee..667e51fe 100644 --- a/src/gui/RDFS.cpp +++ b/src/gui/RDFS.cpp @@ -78,7 +78,7 @@ classes(World* world, URISet& types, bool super) } URISet -types(World* world, SharedPtr model) +types(World* world, SPtr model) { typedef Resource::Properties::const_iterator PropIter; typedef std::pair PropRange; @@ -101,7 +101,7 @@ types(World* world, SharedPtr model) } URISet -properties(World* world, SharedPtr model) +properties(World* world, SPtr model) { URISet properties; URISet types = RDFS::types(world, model); diff --git a/src/gui/RDFS.hpp b/src/gui/RDFS.hpp index bdc0a7a1..583f5d90 100644 --- a/src/gui/RDFS.hpp +++ b/src/gui/RDFS.hpp @@ -22,8 +22,8 @@ #include +#include "ingen/types.hpp" #include "raul/URI.hpp" -#include "raul/SharedPtr.hpp" namespace Ingen { @@ -55,10 +55,10 @@ Objects instances(World* world, const URISet& types); /** Get all the types which @p model is an instance of. */ -URISet types(World* world, SharedPtr model); +URISet types(World* world, SPtr model); /** Get all the properties with domains appropriate for @p model. */ -URISet properties(World* world, SharedPtr model); +URISet properties(World* world, SPtr model); } // namespace RDFS } // namespace GUI diff --git a/src/gui/RenameWindow.cpp b/src/gui/RenameWindow.cpp index da9fb2c6..c6815fd7 100644 --- a/src/gui/RenameWindow.cpp +++ b/src/gui/RenameWindow.cpp @@ -59,7 +59,7 @@ RenameWindow::RenameWindow(BaseObjectType* cobject, * This function MUST be called before using this object in any way. */ void -RenameWindow::set_object(SharedPtr object) +RenameWindow::set_object(SPtr object) { _object = object; _symbol_entry->set_text(object->path().symbol()); @@ -69,7 +69,7 @@ RenameWindow::set_object(SharedPtr object) } void -RenameWindow::present(SharedPtr object) +RenameWindow::present(SPtr object) { set_object(object); _symbol_entry->grab_focus(); diff --git a/src/gui/RenameWindow.hpp b/src/gui/RenameWindow.hpp index 03d5e318..718f2863 100644 --- a/src/gui/RenameWindow.hpp +++ b/src/gui/RenameWindow.hpp @@ -22,9 +22,8 @@ #include #include -#include "raul/SharedPtr.hpp" - #include "ingen/client/ObjectModel.hpp" +#include "ingen/types.hpp" #include "Window.hpp" @@ -41,16 +40,16 @@ public: RenameWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); - void present(SharedPtr object); + void present(SPtr object); private: - void set_object(SharedPtr object); + void set_object(SPtr object); void values_changed(); void cancel_clicked(); void ok_clicked(); - SharedPtr _object; + SPtr _object; Gtk::Entry* _symbol_entry; Gtk::Entry* _label_entry; diff --git a/src/gui/Style.hpp b/src/gui/Style.hpp index eb6947f8..e871e3fa 100644 --- a/src/gui/Style.hpp +++ b/src/gui/Style.hpp @@ -21,8 +21,6 @@ #include -#include "raul/SharedPtr.hpp" - namespace Ingen { namespace Client { class PortModel; } } namespace Ingen { diff --git a/src/gui/SubgraphModule.cpp b/src/gui/SubgraphModule.cpp index 88dbc81b..f4e9dc23 100644 --- a/src/gui/SubgraphModule.cpp +++ b/src/gui/SubgraphModule.cpp @@ -36,8 +36,8 @@ using namespace Client; namespace GUI { -SubgraphModule::SubgraphModule(GraphCanvas& canvas, - SharedPtr graph) +SubgraphModule::SubgraphModule(GraphCanvas& canvas, + SPtr graph) : NodeModule(canvas, graph) , _graph(graph) { @@ -49,7 +49,7 @@ SubgraphModule::on_double_click(GdkEventButton* event) { assert(_graph); - SharedPtr parent = PtrCast(_graph->parent()); + SPtr parent = dynamic_ptr_cast(_graph->parent()); GraphWindow* const preferred = ( (parent && (event->state & GDK_SHIFT_MASK)) ? NULL @@ -92,7 +92,7 @@ SubgraphModule::browse_to_graph() { assert(_graph->parent()); - SharedPtr parent = PtrCast(_graph->parent()); + SPtr parent = dynamic_ptr_cast(_graph->parent()); GraphWindow* const preferred = (parent) ? app().window_factory()->graph_window(parent) diff --git a/src/gui/SubgraphModule.hpp b/src/gui/SubgraphModule.hpp index 569e0fd8..a439c324 100644 --- a/src/gui/SubgraphModule.hpp +++ b/src/gui/SubgraphModule.hpp @@ -17,7 +17,7 @@ #ifndef INGEN_GUI_SUBGRAPHMODULE_HPP #define INGEN_GUI_SUBGRAPHMODULE_HPP -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "NodeModule.hpp" #include "GraphPortModule.hpp" @@ -41,7 +41,7 @@ class SubgraphModule : public NodeModule { public: SubgraphModule(GraphCanvas& canvas, - SharedPtr controller); + SPtr controller); virtual ~SubgraphModule() {} @@ -52,10 +52,10 @@ public: void browse_to_graph(); void menu_remove(); - SharedPtr graph() const { return _graph; } + SPtr graph() const { return _graph; } protected: - SharedPtr _graph; + SPtr _graph; }; } // namespace GUI diff --git a/src/gui/ThreadedLoader.cpp b/src/gui/ThreadedLoader.cpp index 9575734b..597a728d 100644 --- a/src/gui/ThreadedLoader.cpp +++ b/src/gui/ThreadedLoader.cpp @@ -30,7 +30,7 @@ using namespace std; namespace Ingen { namespace GUI { -ThreadedLoader::ThreadedLoader(App& app, SharedPtr engine) +ThreadedLoader::ThreadedLoader(App& app, SPtr engine) : Raul::Thread() , _app(app) , _sem(0) @@ -49,7 +49,7 @@ ThreadedLoader::~ThreadedLoader() _sem.post(); } -SharedPtr +SPtr ThreadedLoader::parser() { Ingen::World* world = _app.world(); @@ -108,8 +108,8 @@ ThreadedLoader::load_graph(bool merge, } void -ThreadedLoader::save_graph(SharedPtr model, - const string& filename) +ThreadedLoader::save_graph(SPtr model, + const string& filename) { _mutex.lock(); @@ -122,8 +122,8 @@ ThreadedLoader::save_graph(SharedPtr model, } void -ThreadedLoader::save_graph_event(SharedPtr model, - const string& filename) +ThreadedLoader::save_graph_event(SPtr model, + const string& filename) { if (_app.serialiser()) { if (filename.find(".ingen") != string::npos) diff --git a/src/gui/ThreadedLoader.hpp b/src/gui/ThreadedLoader.hpp index afca29a9..815cfeec 100644 --- a/src/gui/ThreadedLoader.hpp +++ b/src/gui/ThreadedLoader.hpp @@ -47,8 +47,8 @@ namespace GUI { class ThreadedLoader : public Raul::Thread { public: - ThreadedLoader(App& app, - SharedPtr engine); + ThreadedLoader(App& app, + SPtr engine); ~ThreadedLoader(); @@ -58,25 +58,25 @@ public: boost::optional engine_symbol, boost::optional engine_data); - void save_graph(SharedPtr model, - const std::string& filename); + void save_graph(SPtr model, + const std::string& filename); - SharedPtr parser(); + SPtr parser(); private: - void save_graph_event(SharedPtr model, - const std::string& filename); + void save_graph_event(SPtr model, + const std::string& filename); /** Returns nothing and takes no parameters (because they have all been bound) */ typedef sigc::slot Closure; void _run(); - App& _app; - Raul::Semaphore _sem; - SharedPtr _engine; - Glib::Mutex _mutex; - std::list _events; + App& _app; + Raul::Semaphore _sem; + SPtr _engine; + Glib::Mutex _mutex; + std::list _events; }; } // namespace GUI diff --git a/src/gui/WindowFactory.cpp b/src/gui/WindowFactory.cpp index 983e246b..f8738f40 100644 --- a/src/gui/WindowFactory.cpp +++ b/src/gui/WindowFactory.cpp @@ -87,7 +87,7 @@ WindowFactory::num_open_graph_windows() } GraphBox* -WindowFactory::graph_box(SharedPtr graph) +WindowFactory::graph_box(SPtr graph) { GraphWindow* window = graph_window(graph); if (window) { @@ -98,7 +98,7 @@ WindowFactory::graph_box(SharedPtr graph) } GraphWindow* -WindowFactory::graph_window(SharedPtr graph) +WindowFactory::graph_window(SPtr graph) { if (!graph) return NULL; @@ -109,12 +109,12 @@ WindowFactory::graph_window(SharedPtr graph) } GraphWindow* -WindowFactory::parent_graph_window(SharedPtr block) +WindowFactory::parent_graph_window(SPtr block) { if (!block) return NULL; - return graph_window(PtrCast(block->parent())); + return graph_window(dynamic_ptr_cast(block->parent())); } /** Present a GraphWindow for a Graph. @@ -124,9 +124,9 @@ WindowFactory::parent_graph_window(SharedPtr block) * presented and @a preferred left unmodified. */ void -WindowFactory::present_graph(SharedPtr graph, - GraphWindow* preferred, - SharedPtr view) +WindowFactory::present_graph(SPtr graph, + GraphWindow* preferred, + SPtr view) { assert(!view || view->graph() == graph); @@ -150,8 +150,8 @@ WindowFactory::present_graph(SharedPtr graph, } GraphWindow* -WindowFactory::new_graph_window(SharedPtr graph, - SharedPtr view) +WindowFactory::new_graph_window(SPtr graph, + SPtr view) { assert(!view || view->graph() == graph); @@ -185,8 +185,8 @@ WindowFactory::remove_graph_window(GraphWindow* win, GdkEventAny* ignored) } void -WindowFactory::present_load_plugin(SharedPtr graph, - Node::Properties data) +WindowFactory::present_load_plugin(SPtr graph, + Node::Properties data) { _app.request_plugins_if_necessary(); @@ -208,8 +208,8 @@ WindowFactory::present_load_plugin(SharedPtr graph, } void -WindowFactory::present_load_graph(SharedPtr graph, - Node::Properties data) +WindowFactory::present_load_graph(SPtr graph, + Node::Properties data) { GraphWindowMap::iterator w = _graph_windows.find(graph->path()); @@ -220,8 +220,8 @@ WindowFactory::present_load_graph(SharedPtr graph, } void -WindowFactory::present_load_subgraph(SharedPtr graph, - Node::Properties data) +WindowFactory::present_load_subgraph(SPtr graph, + Node::Properties data) { GraphWindowMap::iterator w = _graph_windows.find(graph->path()); @@ -232,8 +232,8 @@ WindowFactory::present_load_subgraph(SharedPtr graph, } void -WindowFactory::present_new_subgraph(SharedPtr graph, - Node::Properties data) +WindowFactory::present_new_subgraph(SPtr graph, + Node::Properties data) { GraphWindowMap::iterator w = _graph_windows.find(graph->path()); @@ -244,7 +244,7 @@ WindowFactory::present_new_subgraph(SharedPtr graph, } void -WindowFactory::present_rename(SharedPtr object) +WindowFactory::present_rename(SPtr object) { GraphWindowMap::iterator w = _graph_windows.find(object->path()); if (w == _graph_windows.end()) @@ -257,7 +257,7 @@ WindowFactory::present_rename(SharedPtr object) } void -WindowFactory::present_properties(SharedPtr object) +WindowFactory::present_properties(SPtr object) { GraphWindowMap::iterator w = _graph_windows.find(object->path()); if (w == _graph_windows.end()) diff --git a/src/gui/WindowFactory.hpp b/src/gui/WindowFactory.hpp index bdeac89d..f68d5847 100644 --- a/src/gui/WindowFactory.hpp +++ b/src/gui/WindowFactory.hpp @@ -20,7 +20,7 @@ #include #include "ingen/Node.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" namespace Ingen { @@ -55,23 +55,23 @@ public: size_t num_open_graph_windows(); - GraphBox* graph_box(SharedPtr graph); - GraphWindow* graph_window(SharedPtr graph); - GraphWindow* parent_graph_window(SharedPtr block); + GraphBox* graph_box(SPtr graph); + GraphWindow* graph_window(SPtr graph); + GraphWindow* parent_graph_window(SPtr block); void present_graph( - SharedPtr model, - GraphWindow* preferred = NULL, - SharedPtr view = SharedPtr()); + SPtr model, + GraphWindow* preferred = NULL, + SPtr view = SPtr()); typedef Node::Properties Properties; - void present_load_plugin(SharedPtr graph, Properties data=Properties()); - void present_load_graph(SharedPtr graph, Properties data=Properties()); - void present_load_subgraph(SharedPtr graph, Properties data=Properties()); - void present_new_subgraph(SharedPtr graph, Properties data=Properties()); - void present_rename(SharedPtr object); - void present_properties(SharedPtr object); + void present_load_plugin(SPtr graph, Properties data=Properties()); + void present_load_graph(SPtr graph, Properties data=Properties()); + void present_load_subgraph(SPtr graph, Properties data=Properties()); + void present_new_subgraph(SPtr graph, Properties data=Properties()); + void present_rename(SPtr object); + void present_properties(SPtr object); bool remove_graph_window(GraphWindow* win, GdkEventAny* ignored = NULL); @@ -82,8 +82,8 @@ public: private: typedef std::map GraphWindowMap; - GraphWindow* new_graph_window(SharedPtr graph, - SharedPtr view); + GraphWindow* new_graph_window(SPtr graph, + SPtr view); App& _app; GraphBox* _main_box; diff --git a/src/gui/ingen_gui.cpp b/src/gui/ingen_gui.cpp index d5c15ca9..999b2431 100644 --- a/src/gui/ingen_gui.cpp +++ b/src/gui/ingen_gui.cpp @@ -25,7 +25,7 @@ struct IngenGUIModule : public Ingen::Module { app->run(); } - SharedPtr app; + Ingen::SPtr app; }; extern "C" { diff --git a/src/gui/ingen_gui_lv2.cpp b/src/gui/ingen_gui_lv2.cpp index b8a4443b..d95ea82f 100644 --- a/src/gui/ingen_gui_lv2.cpp +++ b/src/gui/ingen_gui_lv2.cpp @@ -22,6 +22,7 @@ #include "ingen/client/GraphModel.hpp" #include "ingen/client/SigClientInterface.hpp" #include "ingen/runtime_paths.hpp" +#include "ingen/types.hpp" #include "lv2/lv2plug.in/ns/extensions/ui/ui.h" #include "App.hpp" @@ -62,16 +63,16 @@ struct IngenLV2UI { , sink(NULL) {} - int argc; - char** argv; - Ingen::Forge* forge; - Ingen::World* world; - IngenLV2AtomSink* sink; - SharedPtr app; - SharedPtr view; - SharedPtr engine; - SharedPtr reader; - SharedPtr client; + int argc; + char** argv; + Ingen::Forge* forge; + Ingen::World* world; + IngenLV2AtomSink* sink; + Ingen::SPtr app; + Ingen::SPtr view; + Ingen::SPtr engine; + Ingen::SPtr reader; + Ingen::SPtr client; }; static LV2UI_Handle @@ -113,7 +114,7 @@ instantiate(const LV2UI_Descriptor* descriptor, ui->world->uris(), write_function, controller); // Set up an engine interface that writes LV2 atoms - ui->engine = SharedPtr( + ui->engine = Ingen::SPtr( new Ingen::AtomWriter( ui->world->uri_map(), ui->world->uris(), *ui->sink)); @@ -121,11 +122,11 @@ instantiate(const LV2UI_Descriptor* descriptor, // Create App and client ui->app = Ingen::GUI::App::create(ui->world); - ui->client = SharedPtr( + ui->client = Ingen::SPtr( new Ingen::Client::SigClientInterface()); ui->app->attach(ui->client); - ui->reader = SharedPtr( + ui->reader = Ingen::SPtr( new Ingen::AtomReader(ui->world->uri_map(), ui->world->uris(), ui->world->log(), @@ -140,8 +141,9 @@ instantiate(const LV2UI_Descriptor* descriptor, ui->app->store()->put(Ingen::Node::root_uri(), props); // Create a GraphBox for the root and set as the UI widget - SharedPtr root = PtrCast( - ui->app->store()->object(Raul::Path("/"))); + Ingen::SPtr root = + Ingen::dynamic_ptr_cast( + ui->app->store()->object(Raul::Path("/"))); ui->view = Ingen::GUI::GraphBox::create(*ui->app, root); ui->view->unparent(); *widget = ui->view->gobj(); diff --git a/src/ingen/main.cpp b/src/ingen/main.cpp index 3cd2ccf6..c194dcde 100644 --- a/src/ingen/main.cpp +++ b/src/ingen/main.cpp @@ -24,7 +24,6 @@ #include #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "raul/fmt.hpp" #include "ingen_config.h" @@ -36,6 +35,7 @@ #include "ingen/client/ThreadedSigClientInterface.hpp" #include "ingen/runtime_paths.hpp" #include "ingen/serialisation/Parser.hpp" +#include "ingen/types.hpp" #ifdef WITH_BINDINGS #include "bindings/ingen_bindings.hpp" #endif @@ -97,13 +97,12 @@ main(int argc, char** argv) } // Run engine - SharedPtr engine_interface; + SPtr engine_interface; if (conf.option("engine").get_bool()) { ingen_try(world->load_module("server"), "Unable to load server module"); - ingen_try(world->engine(), - "Unable to create engine"); + ingen_try(bool(world->engine()), "Unable to create engine"); engine_interface = world->interface(); @@ -124,9 +123,10 @@ main(int argc, char** argv) const char* const uri = conf.option("connect").get_string(); ingen_try(Raul::URI::is_valid(uri), (Raul::fmt("Invalid URI <%1%>") % uri).str().c_str()); - SharedPtr client(new Client::ThreadedSigClientInterface(1024)); - ingen_try((engine_interface = world->new_interface(Raul::URI(uri), client)), - (string("Unable to create interface to `") + uri + "'").c_str()); + SPtr client(new Client::ThreadedSigClientInterface(1024)); + engine_interface = world->new_interface(Raul::URI(uri), client); + ingen_try(bool(engine_interface), + (Raul::fmt("Unable to create interface to `%1%'") % uri).str().c_str()); } world->set_interface(engine_interface); @@ -168,8 +168,7 @@ main(int argc, char** argv) } } - ingen_try(world->parser(), - "Unable to create parser"); + ingen_try(bool(world->parser()), "Unable to create parser"); const string path = conf.option("load").is_valid() ? conf.option("load").get_string() : diff --git a/src/serialisation/Serialiser.cpp b/src/serialisation/Serialiser.cpp index 0bd6b49b..41ae45dc 100644 --- a/src/serialisation/Serialiser.cpp +++ b/src/serialisation/Serialiser.cpp @@ -66,12 +66,12 @@ struct Serialiser::Impl { void start_to_filename(const std::string& filename); - void serialise_graph(SharedPtr p, - const Sord::Node& id); + void serialise_graph(SPtr p, + const Sord::Node& id); - void serialise_block(SharedPtr n, - const Sord::Node& class_id, - const Sord::Node& id); + void serialise_block(SPtr n, + const Sord::Node& class_id, + const Sord::Node& id); void serialise_port(const Node* p, Resource::Graph context, @@ -80,17 +80,17 @@ struct Serialiser::Impl { void serialise_properties(Sord::Node id, const Resource::Properties& props); - void write_bundle(SharedPtr graph, - const std::string& uri); + void write_bundle(SPtr graph, + const std::string& uri); Sord::Node path_rdf_node(const Raul::Path& path); - void write_manifest(const std::string& bundle_path, - SharedPtr graph, - const std::string& graph_symbol); + void write_manifest(const std::string& bundle_path, + SPtr graph, + const std::string& graph_symbol); - void serialise_arc(const Sord::Node& parent, - SharedPtr a) + void serialise_arc(const Sord::Node& parent, + SPtr a) throw (std::logic_error); std::string finish(); @@ -113,8 +113,8 @@ Serialiser::~Serialiser() } void -Serialiser::to_file(SharedPtr object, - const std::string& filename) +Serialiser::to_file(SPtr object, + const std::string& filename) { me->_root_path = object->path(); me->start_to_filename(filename); @@ -123,9 +123,9 @@ Serialiser::to_file(SharedPtr object, } void -Serialiser::Impl::write_manifest(const std::string& bundle_path, - SharedPtr graph, - const std::string& graph_symbol) +Serialiser::Impl::write_manifest(const std::string& bundle_path, + SPtr graph, + const std::string& graph_symbol) { const string manifest_path(Glib::build_filename(bundle_path, "manifest.ttl")); const string binary_path(Glib::Module::build_path("", "ingen_lv2")); @@ -158,15 +158,15 @@ Serialiser::Impl::write_manifest(const std::string& bundle_path, } void -Serialiser::write_bundle(SharedPtr graph, - const std::string& path) +Serialiser::write_bundle(SPtr graph, + const std::string& path) { me->write_bundle(graph, path); } void -Serialiser::Impl::write_bundle(SharedPtr graph, - const std::string& a_path) +Serialiser::Impl::write_bundle(SPtr graph, + const std::string& a_path) { std::string path = Glib::filename_from_uri(a_path); if (Glib::file_test(path, Glib::FILE_TEST_EXISTS) @@ -195,8 +195,8 @@ Serialiser::Impl::write_bundle(SharedPtr graph, } string -Serialiser::to_string(SharedPtr object, - const string& base_uri) +Serialiser::to_string(SPtr object, + const string& base_uri) { start_to_string(object->path(), base_uri); serialise(object); @@ -279,7 +279,7 @@ Serialiser::Impl::path_rdf_node(const Raul::Path& path) } void -Serialiser::serialise(SharedPtr object) throw (std::logic_error) +Serialiser::serialise(SPtr object) throw (std::logic_error) { if (!me->_model) throw std::logic_error("serialise called without serialisation in progress"); @@ -300,8 +300,8 @@ Serialiser::serialise(SharedPtr object) throw (std::logic_error) } void -Serialiser::Impl::serialise_graph(SharedPtr graph, - const Sord::Node& graph_id) +Serialiser::Impl::serialise_graph(SPtr graph, + const Sord::Node& graph_id) { Sord::World& world = _model->world(); const URIs& uris = _world.uris(); @@ -354,7 +354,7 @@ Serialiser::Impl::serialise_graph(SharedPtr graph, continue; if (n->second->graph_type() == Node::GraphType::GRAPH) { - SharedPtr subgraph = n->second; + SPtr subgraph = n->second; SerdURI base_uri; serd_uri_parse((const uint8_t*)_base_uri.c_str(), &base_uri); @@ -387,7 +387,7 @@ Serialiser::Impl::serialise_graph(SharedPtr graph, block_id); serialise_block(subgraph, subgraph_id, block_id); } else if (n->second->graph_type() == Node::GraphType::BLOCK) { - SharedPtr block = n->second; + SPtr block = n->second; const Sord::URI class_id(world, block->plugin()->uri()); const Sord::Node block_id(path_rdf_node(n->second->path())); @@ -419,9 +419,9 @@ Serialiser::Impl::serialise_graph(SharedPtr graph, } void -Serialiser::Impl::serialise_block(SharedPtr block, - const Sord::Node& class_id, - const Sord::Node& block_id) +Serialiser::Impl::serialise_block(SPtr block, + const Sord::Node& class_id, + const Sord::Node& block_id) { const URIs& uris = _world.uris(); @@ -480,16 +480,16 @@ Serialiser::Impl::serialise_port(const Node* port, } void -Serialiser::serialise_arc(const Sord::Node& parent, - SharedPtr arc) +Serialiser::serialise_arc(const Sord::Node& parent, + SPtr arc) throw (std::logic_error) { return me->serialise_arc(parent, arc); } void -Serialiser::Impl::serialise_arc(const Sord::Node& parent, - SharedPtr arc) +Serialiser::Impl::serialise_arc(const Sord::Node& parent, + SPtr arc) throw (std::logic_error) { if (!_model) diff --git a/src/serialisation/serialisation.cpp b/src/serialisation/serialisation.cpp index 3c650dc6..65f11090 100644 --- a/src/serialisation/serialisation.cpp +++ b/src/serialisation/serialisation.cpp @@ -24,9 +24,9 @@ using namespace Ingen; struct IngenSerialisationModule : public Ingen::Module { virtual void load(Ingen::World* world) { - world->set_parser(SharedPtr( + world->set_parser(SPtr( new Serialisation::Parser())); - world->set_serialiser(SharedPtr( + world->set_serialiser(SPtr( new Serialisation::Serialiser(*world))); } }; diff --git a/src/server/BlockFactory.cpp b/src/server/BlockFactory.cpp index 61237ee4..a174c270 100644 --- a/src/server/BlockFactory.cpp +++ b/src/server/BlockFactory.cpp @@ -120,13 +120,13 @@ void BlockFactory::load_lv2_plugins() { // Build an array of port type nodes for checking compatibility - typedef std::vector< SharedPtr > Types; + typedef std::vector< SPtr > Types; Types types; for (unsigned t = PortType::ID::AUDIO; t <= PortType::ID::ATOM; ++t) { const Raul::URI& uri(PortType((PortType::ID)t).uri()); - types.push_back(SharedPtr( - lilv_new_uri(_world->lilv_world(), uri.c_str()), - lilv_node_free)); + types.push_back( + SPtr(lilv_new_uri(_world->lilv_world(), uri.c_str()), + lilv_node_free)); } const LilvPlugins* plugins = lilv_world_get_all_plugins(_world->lilv_world()); diff --git a/src/server/BlockFactory.hpp b/src/server/BlockFactory.hpp index a66b7913..877a860b 100644 --- a/src/server/BlockFactory.hpp +++ b/src/server/BlockFactory.hpp @@ -20,8 +20,8 @@ #include #include "ingen/World.hpp" +#include "ingen/types.hpp" #include "raul/Noncopyable.hpp" -#include "raul/SharedPtr.hpp" #include "raul/URI.hpp" namespace Ingen { @@ -51,10 +51,10 @@ private: void load_lv2_plugins(); void load_internal_plugins(); - Plugins _plugins; - Ingen::World* _world; - SharedPtr _lv2_info; - bool _has_loaded; + Plugins _plugins; + Ingen::World* _world; + SPtr _lv2_info; + bool _has_loaded; }; } // namespace Server diff --git a/src/server/Broadcaster.cpp b/src/server/Broadcaster.cpp index 49bc68ae..f3bc96f7 100644 --- a/src/server/Broadcaster.cpp +++ b/src/server/Broadcaster.cpp @@ -35,8 +35,8 @@ Broadcaster::~Broadcaster() /** Register a client to receive messages over the notification band. */ void -Broadcaster::register_client(const Raul::URI& uri, - SharedPtr client) +Broadcaster::register_client(const Raul::URI& uri, + SPtr client) { Glib::Mutex::Lock lock(_clients_mutex); _clients[uri] = client; @@ -57,7 +57,7 @@ Broadcaster::unregister_client(const Raul::URI& uri) /** Looks up the client with the given source @a uri (which is used as the * unique identifier for registered clients). */ -SharedPtr +SPtr Broadcaster::client(const Raul::URI& uri) { Glib::Mutex::Lock lock(_clients_mutex); @@ -65,7 +65,7 @@ Broadcaster::client(const Raul::URI& uri) if (i != _clients.end()) { return (*i).second; } else { - return SharedPtr(); + return SPtr(); } } diff --git a/src/server/Broadcaster.hpp b/src/server/Broadcaster.hpp index 33b438e5..3162742b 100644 --- a/src/server/Broadcaster.hpp +++ b/src/server/Broadcaster.hpp @@ -23,9 +23,8 @@ #include -#include "raul/SharedPtr.hpp" - #include "ingen/Interface.hpp" +#include "ingen/types.hpp" #include "BlockFactory.hpp" @@ -45,7 +44,7 @@ public: Broadcaster() : _bundle_depth(0) {} ~Broadcaster(); - void register_client(const Raul::URI& uri, SharedPtr client); + void register_client(const Raul::URI& uri, SPtr client); bool unregister_client(const Raul::URI& uri); /** A handle that represents a transfer of possibly several changes. @@ -68,7 +67,7 @@ public: Broadcaster& broadcaster; }; - SharedPtr client(const Raul::URI& uri); + SPtr client(const Raul::URI& uri); void send_plugins(const BlockFactory::Plugins& plugin_list); void send_plugins_to(Interface*, const BlockFactory::Plugins& plugin_list); @@ -134,7 +133,7 @@ public: private: friend class Transfer; - typedef std::map< Raul::URI, SharedPtr > Clients; + typedef std::map< Raul::URI, SPtr > Clients; Glib::Mutex _clients_mutex; Clients _clients; diff --git a/src/server/Buffer.hpp b/src/server/Buffer.hpp index 56325f16..14984de4 100644 --- a/src/server/Buffer.hpp +++ b/src/server/Buffer.hpp @@ -22,10 +22,10 @@ #include +#include "ingen/types.hpp" #include "lv2/lv2plug.in/ns/ext/atom/atom.h" #include "lv2/lv2plug.in/ns/ext/urid/urid.h" #include "raul/Deletable.hpp" -#include "raul/SharedPtr.hpp" #include "BufferFactory.hpp" #include "PortType.hpp" diff --git a/src/server/BufferFactory.hpp b/src/server/BufferFactory.hpp index 82180308..8c0f5db9 100644 --- a/src/server/BufferFactory.hpp +++ b/src/server/BufferFactory.hpp @@ -23,11 +23,11 @@ #undef nil #include -#include "raul/Atom.hpp" -#include "raul/RingBuffer.hpp" -#include "raul/SharedPtr.hpp" #include "ingen/Forge.hpp" #include "ingen/URIs.hpp" +#include "ingen/types.hpp" +#include "raul/Atom.hpp" +#include "raul/RingBuffer.hpp" #include "BufferRef.hpp" #include "PortType.hpp" diff --git a/src/server/CompiledGraph.hpp b/src/server/CompiledGraph.hpp index ee02a24e..21b93058 100644 --- a/src/server/CompiledGraph.hpp +++ b/src/server/CompiledGraph.hpp @@ -20,7 +20,7 @@ #include #include -#include "raul/Disposable.hpp" +#include "raul/Maid.hpp" #include "raul/Noncopyable.hpp" namespace Ingen { @@ -63,7 +63,7 @@ private: * before its providers, using this order as well as semaphores. */ class CompiledGraph : public std::vector - , public Raul::Disposable + , public Raul::Maid::Disposable , public Raul::Noncopyable { }; diff --git a/src/server/ControlBindings.cpp b/src/server/ControlBindings.cpp index 25d49265..634c568a 100644 --- a/src/server/ControlBindings.cpp +++ b/src/server/ControlBindings.cpp @@ -350,13 +350,13 @@ ControlBindings::bind(ProcessContext& context, Key key) return true; } -SharedPtr +SPtr ControlBindings::remove(const Raul::Path& path) { ThreadManager::assert_thread(THREAD_PRE_PROCESS); - SharedPtr old_bindings(_bindings); - SharedPtr copy(new Bindings(*_bindings.get())); + SPtr old_bindings(_bindings); + SPtr copy(new Bindings(*_bindings.get())); for (Bindings::iterator i = copy->begin(); i != copy->end();) { Bindings::iterator next = i; @@ -372,13 +372,13 @@ ControlBindings::remove(const Raul::Path& path) return old_bindings; } -SharedPtr +SPtr ControlBindings::remove(PortImpl* port) { ThreadManager::assert_thread(THREAD_PRE_PROCESS); - SharedPtr old_bindings(_bindings); - SharedPtr copy(new Bindings(*_bindings.get())); + SPtr old_bindings(_bindings); + SPtr copy(new Bindings(*_bindings.get())); for (Bindings::iterator i = copy->begin(); i != copy->end();) { Bindings::iterator next = i; @@ -397,8 +397,8 @@ ControlBindings::remove(PortImpl* port) void ControlBindings::pre_process(ProcessContext& context, Buffer* buffer) { - uint16_t value = 0; - SharedPtr bindings = _bindings; + uint16_t value = 0; + SPtr bindings = _bindings; _feedback->clear(); Ingen::World* world = context.engine().world(); diff --git a/src/server/ControlBindings.hpp b/src/server/ControlBindings.hpp index 630ec18a..26e9dd93 100644 --- a/src/server/ControlBindings.hpp +++ b/src/server/ControlBindings.hpp @@ -20,10 +20,10 @@ #include #include +#include "ingen/types.hpp" #include "lv2/lv2plug.in/ns/ext/atom/forge.h" #include "raul/Atom.hpp" #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "BufferFactory.hpp" @@ -82,13 +82,13 @@ public: * The caller must safely drop the returned reference in the * post-processing thread after at least one process thread has run. */ - SharedPtr remove(const Raul::Path& path); + SPtr remove(const Raul::Path& path); /** Remove binding for a particular port. * The caller must safely drop the returned reference in the * post-processing thread after at least one process thread has run. */ - SharedPtr remove(PortImpl* port); + SPtr remove(PortImpl* port); private: Key midi_event_key(uint16_t size, const uint8_t* buf, uint16_t& value); @@ -106,11 +106,11 @@ private: Type type, const Raul::Atom& value) const; - Engine& _engine; - PortImpl* _learn_port; - SharedPtr _bindings; - BufferRef _feedback; - LV2_Atom_Forge _forge; + Engine& _engine; + PortImpl* _learn_port; + SPtr _bindings; + BufferRef _feedback; + LV2_Atom_Forge _forge; }; } // namespace Server diff --git a/src/server/Engine.cpp b/src/server/Engine.cpp index 5002feca..165f6412 100644 --- a/src/server/Engine.cpp +++ b/src/server/Engine.cpp @@ -18,12 +18,12 @@ #include "events/CreatePort.hpp" #include "ingen/Configuration.hpp" +#include "ingen/Log.hpp" #include "ingen/Store.hpp" #include "ingen/URIs.hpp" #include "ingen/World.hpp" -#include "ingen/Log.hpp" +#include "ingen/types.hpp" #include "raul/Maid.hpp" -#include "raul/SharedPtr.hpp" #include "BlockFactory.hpp" #include "Broadcaster.hpp" @@ -68,7 +68,7 @@ Engine::Engine(Ingen::World* world) , _direct_driver(true) { if (!world->store()) { - world->set_store(SharedPtr(new Store())); + world->set_store(SPtr(new Store())); } _control_bindings = new ControlBindings(*this); @@ -82,16 +82,16 @@ Engine::~Engine() _root_graph = NULL; deactivate(); - const SharedPtr store = this->store(); + const SPtr store = this->store(); if (store) { for (auto& s : *store.get()) { - if (!PtrCast(s.second)->parent()) { + if (!dynamic_ptr_cast(s.second)->parent()) { s.second.reset(); } } } - _world->set_store(SharedPtr()); + _world->set_store(SPtr()); delete _maid; delete _pre_processor; @@ -109,7 +109,7 @@ Engine::~Engine() munlockall(); } -SharedPtr +SPtr Engine::store() const { return _world->store(); @@ -136,7 +136,7 @@ Engine::main_iteration() } void -Engine::set_driver(SharedPtr driver) +Engine::set_driver(SPtr driver) { _driver = driver; } @@ -174,7 +174,7 @@ execute_and_delete_event(ProcessContext& context, Event* ev) void Engine::init(double sample_rate, uint32_t block_length) { - set_driver(SharedPtr(new DirectDriver(sample_rate, block_length))); + set_driver(SPtr(new DirectDriver(sample_rate, block_length))); _direct_driver = true; } @@ -240,7 +240,7 @@ Engine::activate() Resource::Property(forge.make(32.0f), Resource::Graph::EXTERNAL))); - SharedPtr respondee; + SPtr respondee; execute_and_delete_event( context, new Events::CreatePort( *this, respondee, -1, 0, Raul::Path("/control_in"), @@ -340,7 +340,7 @@ Engine::process_events() } void -Engine::register_client(const Raul::URI& uri, SharedPtr client) +Engine::register_client(const Raul::URI& uri, SPtr client) { log().info(Raul::fmt("Registering client <%1%>\n") % uri.c_str()); _broadcaster->register_client(uri, client); diff --git a/src/server/Engine.hpp b/src/server/Engine.hpp index 692fbee8..e7327ef4 100644 --- a/src/server/Engine.hpp +++ b/src/server/Engine.hpp @@ -21,7 +21,7 @@ #include "ingen/EngineBase.hpp" #include "ingen/Interface.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "ProcessContext.hpp" @@ -73,10 +73,10 @@ public: virtual void quit(); virtual bool main_iteration(); virtual void register_client(const Raul::URI& uri, - SharedPtr client); + SPtr client); virtual bool unregister_client(const Raul::URI& uri); - void set_driver(SharedPtr driver); + void set_driver(SPtr driver); SampleCount event_time(); @@ -106,25 +106,25 @@ public: ProcessContext& process_context() { return _process_context; } - SharedPtr store() const; + SPtr store() const; size_t event_queue_size() const; private: Ingen::World* _world; - BlockFactory* _block_factory; - Broadcaster* _broadcaster; - BufferFactory* _buffer_factory; - ControlBindings* _control_bindings; - SharedPtr _driver; - EventWriter* _event_writer; - Raul::Maid* _maid; - SharedPtr _options; - PreProcessor* _pre_processor; - PostProcessor* _post_processor; - GraphImpl* _root_graph; - Worker* _worker; + BlockFactory* _block_factory; + Broadcaster* _broadcaster; + BufferFactory* _buffer_factory; + ControlBindings* _control_bindings; + SPtr _driver; + EventWriter* _event_writer; + Raul::Maid* _maid; + SPtr _options; + PreProcessor* _pre_processor; + PostProcessor* _post_processor; + GraphImpl* _root_graph; + Worker* _worker; ProcessContext _process_context; diff --git a/src/server/Event.hpp b/src/server/Event.hpp index e2000d09..21af45c5 100644 --- a/src/server/Event.hpp +++ b/src/server/Event.hpp @@ -22,11 +22,11 @@ #include "raul/Deletable.hpp" #include "raul/Noncopyable.hpp" #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "ingen/Interface.hpp" #include "ingen/Node.hpp" #include "ingen/Status.hpp" +#include "ingen/types.hpp" #include "types.hpp" @@ -81,7 +81,7 @@ public: Status status() const { return _status; } protected: - Event(Engine& engine, SharedPtr client, int32_t id, FrameTime time) + Event(Engine& engine, SPtr client, int32_t id, FrameTime time) : _engine(engine) , _next(NULL) , _request_client(client) @@ -122,13 +122,13 @@ protected: return _status; } - Engine& _engine; - std::atomic _next; - SharedPtr _request_client; - int32_t _request_id; - FrameTime _time; - Status _status; - std::string _err_subject; + Engine& _engine; + std::atomic _next; + SPtr _request_client; + int32_t _request_id; + FrameTime _time; + Status _status; + std::string _err_subject; }; } // namespace Server diff --git a/src/server/EventWriter.hpp b/src/server/EventWriter.hpp index 68f93cbd..6d0fd2d2 100644 --- a/src/server/EventWriter.hpp +++ b/src/server/EventWriter.hpp @@ -23,7 +23,7 @@ #include "ingen/Interface.hpp" #include "ingen/Resource.hpp" -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "types.hpp" @@ -42,11 +42,11 @@ public: Raul::URI uri() const { return Raul::URI("ingen:/clients/event_writer"); } - virtual SharedPtr respondee() const { + virtual SPtr respondee() const { return _respondee; } - virtual void set_respondee(SharedPtr respondee) { + virtual void set_respondee(SPtr respondee) { _respondee = respondee; } @@ -89,9 +89,9 @@ public: virtual void error(const std::string& msg) {} ///< N/A protected: - Engine& _engine; - SharedPtr _respondee; - int32_t _request_id; + Engine& _engine; + SPtr _respondee; + int32_t _request_id; private: SampleCount now() const; diff --git a/src/server/GraphImpl.cpp b/src/server/GraphImpl.cpp index 14af654c..081b5b16 100644 --- a/src/server/GraphImpl.cpp +++ b/src/server/GraphImpl.cpp @@ -198,7 +198,7 @@ GraphImpl::remove_block(BlockImpl& block) } void -GraphImpl::add_arc(SharedPtr a) +GraphImpl::add_arc(SPtr a) { ThreadManager::assert_thread(THREAD_PRE_PROCESS); _arcs.insert(make_pair(make_pair(a->tail(), a->head()), a)); @@ -207,17 +207,17 @@ GraphImpl::add_arc(SharedPtr a) /** Remove an arc. * Preprocessing thread only. */ -SharedPtr +SPtr GraphImpl::remove_arc(const PortImpl* tail, const PortImpl* dst_port) { ThreadManager::assert_thread(THREAD_PRE_PROCESS); Arcs::iterator i = _arcs.find(make_pair(tail, dst_port)); if (i != _arcs.end()) { - SharedPtr arc = PtrCast(i->second); + SPtr arc = dynamic_ptr_cast(i->second); _arcs.erase(i); return arc; } else { - return SharedPtr(); + return SPtr(); } } diff --git a/src/server/GraphImpl.hpp b/src/server/GraphImpl.hpp index 450318ba..b6f3cf73 100644 --- a/src/server/GraphImpl.hpp +++ b/src/server/GraphImpl.hpp @@ -128,10 +128,10 @@ public: void remove_port(DuplexPort& port); void clear_ports(); - void add_arc(SharedPtr arc); + void add_arc(SPtr arc); - SharedPtr remove_arc(const PortImpl* tail, - const PortImpl* head); + SPtr remove_arc(const PortImpl* tail, + const PortImpl* head); bool has_arc(const PortImpl* tail, const PortImpl* head) const; diff --git a/src/server/InputPort.hpp b/src/server/InputPort.hpp index faf323f0..1f82425e 100644 --- a/src/server/InputPort.hpp +++ b/src/server/InputPort.hpp @@ -22,7 +22,7 @@ #include -#include "raul/SharedPtr.hpp" +#include "ingen/types.hpp" #include "ArcImpl.hpp" #include "PortImpl.hpp" diff --git a/src/server/JackDriver.cpp b/src/server/JackDriver.cpp index 33d11e92..20abb787 100644 --- a/src/server/JackDriver.cpp +++ b/src/server/JackDriver.cpp @@ -473,9 +473,9 @@ JackDriver::_session_cb(jack_session_event_t* event) % jack_get_client_name(_client) % event->client_uuid).str(); - SharedPtr serialiser = _engine.world()->serialiser(); + SPtr serialiser = _engine.world()->serialiser(); if (serialiser) { - SharedPtr root(_engine.root_graph(), NullDeleter); + SPtr root(_engine.root_graph(), NullDeleter); serialiser->write_bundle(root, string("file://") + event->session_dir); } diff --git a/src/server/LV2Block.cpp b/src/server/LV2Block.cpp index e334c1f9..1d05137b 100644 --- a/src/server/LV2Block.cpp +++ b/src/server/LV2Block.cpp @@ -69,7 +69,7 @@ LV2Block::~LV2Block() delete _instances; } -SharedPtr +SPtr LV2Block::make_instance(URIs& uris, SampleRate rate, uint32_t voice, @@ -82,7 +82,7 @@ LV2Block::make_instance(URIs& uris, parent_graph()->engine().log().error( Raul::fmt("Failed to instantiate <%1%>\n") % _lv2_plugin->uri().c_str()); - return SharedPtr(); + return SPtr(); } const LV2_Options_Interface* options_iface = (const LV2_Options_Interface*) @@ -134,7 +134,7 @@ LV2Block::make_instance(URIs& uris, parent_graph()->engine().log().error( Raul::fmt("%1% auto-morphed to unknown type %2%\n") % port->path().c_str() % type); - return SharedPtr(); + return SPtr(); } } else { parent_graph()->engine().log().error( @@ -145,7 +145,7 @@ LV2Block::make_instance(URIs& uris, } } - return SharedPtr(inst, lilv_instance_free); + return SPtr(inst, lilv_instance_free); } bool @@ -161,9 +161,9 @@ LV2Block::prepare_poly(BufferFactory& bufs, uint32_t poly) const SampleRate rate = bufs.engine().driver()->sample_rate(); assert(!_prepared_instances); - _prepared_instances = new Instances(poly, *_instances, SharedPtr()); + _prepared_instances = new Instances(poly, *_instances, SPtr()); for (uint32_t i = _polyphony; i < _prepared_instances->size(); ++i) { - SharedPtr inst = make_instance(bufs.uris(), rate, i, true); + SPtr inst = make_instance(bufs.uris(), rate, i, true); if (!inst) { return false; } @@ -206,7 +206,7 @@ bool LV2Block::instantiate(BufferFactory& bufs) { const Ingen::URIs& uris = bufs.uris(); - SharedPtr info = _lv2_plugin->lv2_info(); + SPtr info = _lv2_plugin->lv2_info(); const LilvPlugin* plug = _lv2_plugin->lilv_plugin(); Ingen::Forge& forge = bufs.forge(); const uint32_t num_ports = lilv_plugin_get_num_ports(plug); @@ -401,7 +401,7 @@ LV2Block::instantiate(BufferFactory& bufs) // Actually create plugin instances and port buffers. const SampleRate rate = bufs.engine().driver()->sample_rate(); - _instances = new Instances(_polyphony, SharedPtr()); + _instances = new Instances(_polyphony, SPtr()); for (uint32_t i = 0; i < _polyphony; ++i) { _instances->at(i) = make_instance(bufs.uris(), rate, i, false); if (!_instances->at(i)) { diff --git a/src/server/LV2Block.hpp b/src/server/LV2Block.hpp index 2e45d350..a9cf0afc 100644 --- a/src/server/LV2Block.hpp +++ b/src/server/LV2Block.hpp @@ -19,7 +19,7 @@ #include "lilv/lilv.h" #include "lv2/lv2plug.in/ns/ext/worker/worker.h" -#include "raul/Disposable.hpp" +#include "raul/Maid.hpp" #include "BufferRef.hpp" #include "BlockImpl.hpp" @@ -63,18 +63,18 @@ public: BufferRef buf); protected: - SharedPtr make_instance(URIs& uris, - SampleRate rate, - uint32_t voice, - bool preparing); + SPtr make_instance(URIs& uris, + SampleRate rate, + uint32_t voice, + bool preparing); inline LilvInstance* instance(uint32_t voice) { return (LilvInstance*)(*_instances)[voice].get(); } - typedef Raul::Array< SharedPtr > Instances; + typedef Raul::Array< SPtr > Instances; - struct Response : public Raul::Disposable + struct Response : public Raul::Maid::Disposable , public Raul::Noncopyable , public boost::intrusive::slist_base_hook<> { @@ -101,12 +101,12 @@ protected: static LV2_Worker_Status work_respond( LV2_Worker_Respond_Handle handle, uint32_t size, const void* data); - LV2Plugin* _lv2_plugin; - Instances* _instances; - Instances* _prepared_instances; - const LV2_Worker_Interface* _worker_iface; - Responses _responses; - SharedPtr _features; + LV2Plugin* _lv2_plugin; + Instances* _instances; + Instances* _prepared_instances; + const LV2_Worker_Interface* _worker_iface; + Responses _responses; + SPtr _features; }; } // namespace Server diff --git a/src/server/LV2Info.cpp b/src/server/LV2Info.cpp index 841ee0fd..1e4b2aec 100644 --- a/src/server/LV2Info.cpp +++ b/src/server/LV2Info.cpp @@ -51,7 +51,7 @@ LV2Info::LV2Info(Ingen::World* world) , _world(world) { world->lv2_features().add_feature( - SharedPtr(new ResizeFeature())); + SPtr(new ResizeFeature())); } LV2Info::~LV2Info() diff --git a/src/server/LV2Options.hpp b/src/server/LV2Options.hpp index 19ddfd4b..cc42d68c 100644 --- a/src/server/LV2Options.hpp +++ b/src/server/LV2Options.hpp @@ -51,10 +51,10 @@ struct LV2Options : public Ingen::LV2Features::Feature { const char* uri() const { return LV2_OPTIONS__options; } - SharedPtr feature(World* w, Node* n) { + SPtr feature(World* w, Node* n) { BlockImpl* block = dynamic_cast(n); if (!block) { - return SharedPtr(); + return SPtr(); } Engine& engine = block->parent_graph()->engine(); URIs& uris = engine.world()->uris(); @@ -72,7 +72,7 @@ struct LV2Options : public Ingen::LV2Features::Feature { f->URI = LV2_OPTIONS__options; f->data = malloc(sizeof(options)); memcpy(f->data, options, sizeof(options)); - return SharedPtr(f, &delete_feature); + return SPtr(f, &delete_feature); } private: diff --git a/src/server/LV2Plugin.cpp b/src/server/LV2Plugin.cpp index cc0aee4c..22e7e9c4 100644 --- a/src/server/LV2Plugin.cpp +++ b/src/server/LV2Plugin.cpp @@ -28,7 +28,7 @@ using namespace std; namespace Ingen { namespace Server { -LV2Plugin::LV2Plugin(SharedPtr lv2_info, const Raul::URI& uri) +LV2Plugin::LV2Plugin(SPtr lv2_info, const Raul::URI& uri) : PluginImpl(lv2_info->world().uris(), Plugin::LV2, uri) , _lilv_plugin(NULL) , _lv2_info(lv2_info) diff --git a/src/server/LV2Plugin.hpp b/src/server/LV2Plugin.hpp index bec1b588..1bd4822a 100644 --- a/src/server/LV2Plugin.hpp +++ b/src/server/LV2Plugin.hpp @@ -19,8 +19,8 @@ #include +#include "ingen/types.hpp" #include "lilv/lilv.h" -#include "raul/SharedPtr.hpp" #include "raul/URI.hpp" #include "PluginImpl.hpp" @@ -37,7 +37,7 @@ class BlockImpl; class LV2Plugin : public PluginImpl { public: - LV2Plugin(SharedPtr lv2_info, const Raul::URI& uri); + LV2Plugin(SPtr lv2_info, const Raul::URI& uri); BlockImpl* instantiate(BufferFactory& bufs, const Raul::Symbol& symbol, @@ -47,14 +47,14 @@ public: const Raul::Symbol symbol() const; - SharedPtr lv2_info() const { return _lv2_info; } + SPtr lv2_info() const { return _lv2_info; } const LilvPlugin* lilv_plugin() const { return _lilv_plugin; } void lilv_plugin(const LilvPlugin* p); private: - const LilvPlugin* _lilv_plugin; - SharedPtr _lv2_info; + const LilvPlugin* _lilv_plugin; + SPtr _lv2_info; }; } // namespace Server diff --git a/src/server/LV2ResizeFeature.hpp b/src/server/LV2ResizeFeature.hpp index aeabe47a..6712c74b 100644 --- a/src/server/LV2ResizeFeature.hpp +++ b/src/server/LV2ResizeFeature.hpp @@ -49,10 +49,10 @@ struct ResizeFeature : public Ingen::LV2Features::Feature { const char* uri() const { return LV2_RESIZE_PORT_URI; } - SharedPtr feature(World* w, Node* n) { + SPtr feature(World* w, Node* n) { BlockImpl* block = dynamic_cast(n); if (!block) - return SharedPtr(); + return SPtr(); LV2_Resize_Port_Resize* data = (LV2_Resize_Port_Resize*)malloc(sizeof(LV2_Resize_Port_Resize)); data->data = block; @@ -60,7 +60,7 @@ struct ResizeFeature : public Ingen::LV2Features::Feature { LV2_Feature* f = (LV2_Feature*)malloc(sizeof(LV2_Feature)); f->URI = LV2_RESIZE_PORT_URI; f->data = data; - return SharedPtr(f, &delete_feature); + return SPtr(f, &delete_feature); } }; diff --git a/src/server/NodeImpl.hpp b/src/server/NodeImpl.hpp index 937d4dea..60aa2d3d 100644 --- a/src/server/NodeImpl.hpp +++ b/src/server/NodeImpl.hpp @@ -25,7 +25,6 @@ #include "ingen/Resource.hpp" #include "raul/Deletable.hpp" #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" namespace Raul { class Maid; } diff --git a/src/server/Worker.cpp b/src/server/Worker.cpp index 5bf20609..8afc8a20 100644 --- a/src/server/Worker.cpp +++ b/src/server/Worker.cpp @@ -79,12 +79,12 @@ delete_feature(LV2_Feature* feature) free(feature); } -SharedPtr +SPtr Worker::Schedule::feature(World* world, Node* n) { LV2Block* block = dynamic_cast(n); if (!block) { - return SharedPtr(); + return SPtr(); } LV2_Worker_Schedule* data = (LV2_Worker_Schedule*)malloc( @@ -96,7 +96,7 @@ Worker::Schedule::feature(World* world, Node* n) f->URI = LV2_WORKER__schedule; f->data = data; - return SharedPtr(f, &delete_feature); + return SPtr(f, &delete_feature); } diff --git a/src/server/Worker.hpp b/src/server/Worker.hpp index 69597439..b90e117e 100644 --- a/src/server/Worker.hpp +++ b/src/server/Worker.hpp @@ -40,17 +40,17 @@ public: struct Schedule : public LV2Features::Feature { const char* uri() const { return LV2_WORKER__schedule; } - SharedPtr feature(World* world, Node* n); + SPtr feature(World* world, Node* n); }; LV2_Worker_Status request(LV2Block* block, uint32_t size, const void* data); - SharedPtr schedule_feature() { return _schedule; } + SPtr schedule_feature() { return _schedule; } private: - SharedPtr _schedule; + SPtr _schedule; Log& _log; Raul::Semaphore _sem; diff --git a/src/server/events/Connect.cpp b/src/server/events/Connect.cpp index cbdb67c5..4c4a3974 100644 --- a/src/server/events/Connect.cpp +++ b/src/server/events/Connect.cpp @@ -34,12 +34,12 @@ namespace Ingen { namespace Server { namespace Events { -Connect::Connect(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& tail_path, - const Raul::Path& head_path) +Connect::Connect(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& tail_path, + const Raul::Path& head_path) : Event(engine, client, id, timestamp) , _tail_path(tail_path) , _head_path(head_path) @@ -106,7 +106,7 @@ Connect::pre_process() return Event::pre_process_done(Status::EXISTS, _head_path); } - _arc = SharedPtr(new ArcImpl(tail_output, _head)); + _arc = SPtr(new ArcImpl(tail_output, _head)); rlock.release(); diff --git a/src/server/events/Connect.hpp b/src/server/events/Connect.hpp index a84b9fcf..4b515087 100644 --- a/src/server/events/Connect.hpp +++ b/src/server/events/Connect.hpp @@ -45,12 +45,12 @@ namespace Events { class Connect : public Event { public: - Connect(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& tail, - const Raul::Path& head); + Connect(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& tail, + const Raul::Path& head); bool pre_process(); void execute(ProcessContext& context); @@ -62,7 +62,7 @@ private: GraphImpl* _graph; InputPort* _head; CompiledGraph* _compiled_graph; - SharedPtr _arc; + SPtr _arc; Raul::Array* _buffers; }; diff --git a/src/server/events/CreateBlock.cpp b/src/server/events/CreateBlock.cpp index 90a76c1d..63b05b58 100644 --- a/src/server/events/CreateBlock.cpp +++ b/src/server/events/CreateBlock.cpp @@ -33,7 +33,7 @@ namespace Server { namespace Events { CreateBlock::CreateBlock(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, const Raul::Path& path, diff --git a/src/server/events/CreateBlock.hpp b/src/server/events/CreateBlock.hpp index 4b706e53..36e35775 100644 --- a/src/server/events/CreateBlock.hpp +++ b/src/server/events/CreateBlock.hpp @@ -41,7 +41,7 @@ class CreateBlock : public Event { public: CreateBlock(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, const Raul::Path& block_path, diff --git a/src/server/events/CreateGraph.cpp b/src/server/events/CreateGraph.cpp index f2131246..8ab05a2e 100644 --- a/src/server/events/CreateGraph.cpp +++ b/src/server/events/CreateGraph.cpp @@ -30,7 +30,7 @@ namespace Server { namespace Events { CreateGraph::CreateGraph(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, const Raul::Path& path, diff --git a/src/server/events/CreateGraph.hpp b/src/server/events/CreateGraph.hpp index 0f6a95dd..64fb92bd 100644 --- a/src/server/events/CreateGraph.hpp +++ b/src/server/events/CreateGraph.hpp @@ -36,7 +36,7 @@ class CreateGraph : public Event { public: CreateGraph(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, const Raul::Path& path, diff --git a/src/server/events/CreatePort.cpp b/src/server/events/CreatePort.cpp index 818b0438..2e3e4d42 100644 --- a/src/server/events/CreatePort.cpp +++ b/src/server/events/CreatePort.cpp @@ -37,7 +37,7 @@ namespace Server { namespace Events { CreatePort::CreatePort(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, const Raul::Path& path, diff --git a/src/server/events/CreatePort.hpp b/src/server/events/CreatePort.hpp index d35b58af..d5e2b29c 100644 --- a/src/server/events/CreatePort.hpp +++ b/src/server/events/CreatePort.hpp @@ -43,7 +43,7 @@ class CreatePort : public Event { public: CreatePort(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, const Raul::Path& path, diff --git a/src/server/events/Delete.cpp b/src/server/events/Delete.cpp index bcfb209a..f21e0faf 100644 --- a/src/server/events/Delete.cpp +++ b/src/server/events/Delete.cpp @@ -34,11 +34,11 @@ namespace Ingen { namespace Server { namespace Events { -Delete::Delete(Engine& engine, - SharedPtr client, - int32_t id, - FrameTime time, - const Raul::URI& uri) +Delete::Delete(Engine& engine, + SPtr client, + int32_t id, + FrameTime time, + const Raul::URI& uri) : Event(engine, client, id, time) , _uri(uri) , _engine_port(NULL) @@ -73,8 +73,8 @@ Delete::pre_process() return Event::pre_process_done(Status::NOT_FOUND, _path); } - if (!(_block = PtrCast(iter->second))) { - _port = PtrCast(iter->second); + if (!(_block = dynamic_ptr_cast(iter->second))) { + _port = dynamic_ptr_cast(iter->second); } if (!_block && !_port) { diff --git a/src/server/events/Delete.hpp b/src/server/events/Delete.hpp index 74046f82..3cf9a2dc 100644 --- a/src/server/events/Delete.hpp +++ b/src/server/events/Delete.hpp @@ -57,11 +57,11 @@ class DisconnectAll; class Delete : public Event { public: - Delete(Engine& engine, - SharedPtr client, - int32_t id, - FrameTime timestamp, - const Raul::URI& uri); + Delete(Engine& engine, + SPtr client, + int32_t id, + FrameTime timestamp, + const Raul::URI& uri); ~Delete(); @@ -70,17 +70,17 @@ public: void post_process(); private: - Raul::URI _uri; - Raul::Path _path; - SharedPtr _block; ///< Non-NULL iff a block - SharedPtr _port; ///< Non-NULL iff a port - EnginePort* _engine_port; - Raul::Array* _ports_array; ///< New (external) ports for Graph - CompiledGraph* _compiled_graph; ///< Graph's new process order - DisconnectAll* _disconnect_event; - - SharedPtr _removed_bindings; - Store::Objects _removed_objects; + Raul::URI _uri; + Raul::Path _path; + SPtr _block; ///< Non-NULL iff a block + SPtr _port; ///< Non-NULL iff a port + EnginePort* _engine_port; + Raul::Array* _ports_array; ///< New (external) ports for Graph + CompiledGraph* _compiled_graph; ///< Graph's new process order + DisconnectAll* _disconnect_event; + + SPtr _removed_bindings; + Store::Objects _removed_objects; Glib::RWLock::WriterLock _lock; }; diff --git a/src/server/events/Delta.cpp b/src/server/events/Delta.cpp index 352aa56c..c7836ebd 100644 --- a/src/server/events/Delta.cpp +++ b/src/server/events/Delta.cpp @@ -44,15 +44,15 @@ namespace Events { typedef Resource::Properties Properties; -Delta::Delta(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - bool create, - Resource::Graph context, - const Raul::URI& subject, - const Properties& properties, - const Properties& remove) +Delta::Delta(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + bool create, + Resource::Graph context, + const Raul::URI& subject, + const Properties& properties, + const Properties& remove) : Event(engine, client, id, timestamp) , _create_event(NULL) , _subject(subject) diff --git a/src/server/events/Delta.hpp b/src/server/events/Delta.hpp index 34319591..7e3f5257 100644 --- a/src/server/events/Delta.hpp +++ b/src/server/events/Delta.hpp @@ -70,7 +70,7 @@ class Delta : public Event { public: Delta(Engine& engine, - SharedPtr client, + SPtr client, int32_t id, SampleCount timestamp, bool create, @@ -111,7 +111,7 @@ private: ControlBindings::Key _binding; bool _create; - SharedPtr _old_bindings; + SPtr _old_bindings; }; } // namespace Events diff --git a/src/server/events/Disconnect.cpp b/src/server/events/Disconnect.cpp index 874e0d99..a7f31316 100644 --- a/src/server/events/Disconnect.cpp +++ b/src/server/events/Disconnect.cpp @@ -39,12 +39,12 @@ namespace Ingen { namespace Server { namespace Events { -Disconnect::Disconnect(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& tail_path, - const Raul::Path& head_path) +Disconnect::Disconnect(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& tail_path, + const Raul::Path& head_path) : Event(engine, client, id, timestamp) , _tail_path(tail_path) , _head_path(head_path) diff --git a/src/server/events/Disconnect.hpp b/src/server/events/Disconnect.hpp index b0c9408c..58efba9f 100644 --- a/src/server/events/Disconnect.hpp +++ b/src/server/events/Disconnect.hpp @@ -45,12 +45,12 @@ namespace Events { class Disconnect : public Event { public: - Disconnect(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& tail_path, - const Raul::Path& head_path); + Disconnect(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& tail_path, + const Raul::Path& head_path); bool pre_process(); void execute(ProcessContext& context); @@ -72,7 +72,7 @@ public: OutputPort* _src_output_port; InputPort* _dst_input_port; GraphImpl* _graph; - SharedPtr _arc; + SPtr _arc; Raul::Array* _buffers; }; diff --git a/src/server/events/DisconnectAll.cpp b/src/server/events/DisconnectAll.cpp index a3df4e77..c366508b 100644 --- a/src/server/events/DisconnectAll.cpp +++ b/src/server/events/DisconnectAll.cpp @@ -40,12 +40,12 @@ namespace Ingen { namespace Server { namespace Events { -DisconnectAll::DisconnectAll(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& parent_path, - const Raul::Path& path) +DisconnectAll::DisconnectAll(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& parent_path, + const Raul::Path& path) : Event(engine, client, id, timestamp) , _parent_path(parent_path) , _path(path) diff --git a/src/server/events/DisconnectAll.hpp b/src/server/events/DisconnectAll.hpp index 7db53bfa..43c3ec2b 100644 --- a/src/server/events/DisconnectAll.hpp +++ b/src/server/events/DisconnectAll.hpp @@ -43,12 +43,12 @@ class Disconnect; class DisconnectAll : public Event { public: - DisconnectAll(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& parent, - const Raul::Path& object); + DisconnectAll(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& parent, + const Raul::Path& object); DisconnectAll(Engine& engine, GraphImpl* parent, diff --git a/src/server/events/Get.cpp b/src/server/events/Get.cpp index f16654f7..9a5dd1fa 100644 --- a/src/server/events/Get.cpp +++ b/src/server/events/Get.cpp @@ -37,11 +37,11 @@ namespace Events { static void send_graph(Interface* client, const GraphImpl* graph); -Get::Get(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::URI& uri) +Get::Get(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::URI& uri) : Event(engine, client, id, timestamp) , _uri(uri) , _object(NULL) diff --git a/src/server/events/Get.hpp b/src/server/events/Get.hpp index 12f48b09..7a5830a3 100644 --- a/src/server/events/Get.hpp +++ b/src/server/events/Get.hpp @@ -37,11 +37,11 @@ namespace Events { class Get : public Event { public: - Get(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::URI& uri); + Get(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::URI& uri); bool pre_process(); void execute(ProcessContext& context) {} diff --git a/src/server/events/Move.cpp b/src/server/events/Move.cpp index 700d5814..44939525 100644 --- a/src/server/events/Move.cpp +++ b/src/server/events/Move.cpp @@ -31,12 +31,12 @@ namespace Ingen { namespace Server { namespace Events { -Move::Move(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& path, - const Raul::Path& new_path) +Move::Move(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& path, + const Raul::Path& new_path) : Event(engine, client, id, timestamp) , _old_path(path) , _new_path(new_path) diff --git a/src/server/events/Move.hpp b/src/server/events/Move.hpp index 6e30cba6..666ad7bd 100644 --- a/src/server/events/Move.hpp +++ b/src/server/events/Move.hpp @@ -46,12 +46,12 @@ namespace Events { class Move : public Event { public: - Move(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - const Raul::Path& old_path, - const Raul::Path& new_path); + Move(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + const Raul::Path& old_path, + const Raul::Path& new_path); ~Move(); diff --git a/src/server/events/SetPortValue.cpp b/src/server/events/SetPortValue.cpp index f2399d8e..edef9e8c 100644 --- a/src/server/events/SetPortValue.cpp +++ b/src/server/events/SetPortValue.cpp @@ -34,12 +34,12 @@ namespace Server { namespace Events { /** Internal */ -SetPortValue::SetPortValue(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - PortImpl* port, - const Raul::Atom& value) +SetPortValue::SetPortValue(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + PortImpl* port, + const Raul::Atom& value) : Event(engine, client, id, timestamp) , _port(port) , _value(value) diff --git a/src/server/events/SetPortValue.hpp b/src/server/events/SetPortValue.hpp index a82553f5..32e8f768 100644 --- a/src/server/events/SetPortValue.hpp +++ b/src/server/events/SetPortValue.hpp @@ -37,12 +37,12 @@ namespace Events { class SetPortValue : public Event { public: - SetPortValue(Engine& engine, - SharedPtr client, - int32_t id, - SampleCount timestamp, - PortImpl* port, - const Raul::Atom& value); + SetPortValue(Engine& engine, + SPtr client, + int32_t id, + SampleCount timestamp, + PortImpl* port, + const Raul::Atom& value); ~SetPortValue(); diff --git a/src/server/ingen_engine.cpp b/src/server/ingen_engine.cpp index b020e28b..cd470f44 100644 --- a/src/server/ingen_engine.cpp +++ b/src/server/ingen_engine.cpp @@ -25,10 +25,11 @@ using namespace Ingen; struct IngenEngineModule : public Ingen::Module { virtual void load(Ingen::World* world) { Server::set_denormal_flags(world->log()); - SharedPtr engine(new Server::Engine(world)); + SPtr engine(new Server::Engine(world)); world->set_engine(engine); if (!world->interface()) { - world->set_interface(SharedPtr(engine->interface(), NullDeleter)); + world->set_interface( + SPtr(engine->interface(), NullDeleter)); } } }; diff --git a/src/server/ingen_jack.cpp b/src/server/ingen_jack.cpp index f273a209..9ebb0481 100644 --- a/src/server/ingen_jack.cpp +++ b/src/server/ingen_jack.cpp @@ -44,7 +44,7 @@ struct IngenJackModule : public Ingen::Module { world->conf().option("jack-name").get_string(), NULL); ((Server::Engine*)world->engine().get())->set_driver( - SharedPtr(driver)); + SPtr(driver)); } }; diff --git a/src/server/ingen_lv2.cpp b/src/server/ingen_lv2.cpp index e866ea0e..e6fab92a 100644 --- a/src/server/ingen_lv2.cpp +++ b/src/server/ingen_lv2.cpp @@ -42,8 +42,8 @@ #include "ingen/runtime_paths.hpp" #include "ingen/serialisation/Parser.hpp" #include "ingen/serialisation/Serialiser.hpp" +#include "ingen/types.hpp" #include "raul/Semaphore.hpp" -#include "raul/SharedPtr.hpp" #include "raul/Thread.hpp" #include "Buffer.hpp" @@ -74,7 +74,7 @@ class Lib { public: explicit Lib(const char* bundle_path); - typedef std::vector< SharedPtr > Graphs; + typedef std::vector< Ingen::SPtr > Graphs; Graphs graphs; }; @@ -401,8 +401,8 @@ using namespace Ingen::Server; class MainThread : public Raul::Thread { public: - explicit MainThread(SharedPtr engine, - LV2Driver* driver) + explicit MainThread(SPtr engine, + LV2Driver* driver) : Raul::Thread() , _engine(engine) , _driver(driver) @@ -424,8 +424,8 @@ private: } } - SharedPtr _engine; - LV2Driver* _driver; + SPtr _engine; + LV2Driver* _driver; }; struct IngenPlugin { @@ -466,8 +466,9 @@ find_graphs(const Glib::ustring& manifest_uri) if (!f.end()) { const uint8_t* file_uri = f.get_object().to_u_string(); uint8_t* file_path = serd_file_uri_parse(file_uri, NULL); - graphs.push_back(boost::shared_ptr( - new LV2Graph(graph_uri, (const char*)file_path))); + graphs.push_back( + SPtr( + new LV2Graph(graph_uri, (const char*)file_path))); free(file_path); } } @@ -568,11 +569,11 @@ ingen_instantiate(const LV2_Descriptor* descriptor, "queue-size", plugin->world->forge().make(std::max(block_length, seq_size) * 4)); - SharedPtr engine(new Server::Engine(plugin->world)); + SPtr engine(new Server::Engine(plugin->world)); plugin->world->set_engine(engine); - SharedPtr interface = - SharedPtr(engine->interface(), NullDeleter); + SPtr interface = SPtr(engine->interface(), + NullDeleter); plugin->world->set_interface(interface); @@ -580,7 +581,7 @@ ingen_instantiate(const LV2_Descriptor* descriptor, Server::ThreadManager::single_threaded = true; LV2Driver* driver = new LV2Driver(*engine.get(), block_length, rate); - engine->set_driver(SharedPtr(driver)); + engine->set_driver(SPtr(driver)); plugin->main = new MainThread(engine, driver); @@ -604,7 +605,7 @@ ingen_instantiate(const LV2_Descriptor* descriptor, /* Register client after loading graph so the to-ui ring does not overflow. Since we are not yet rolling, it won't be drained, causing a deadlock. */ - SharedPtr client(&driver->writer(), NullDeleter); + SPtr client(&driver->writer(), NullDeleter); interface->set_respondee(client); engine->register_client(Raul::URI("ingen:/clients/lv2"), client); @@ -660,8 +661,8 @@ static void ingen_cleanup(LV2_Handle instance) { IngenPlugin* me = (IngenPlugin*)instance; - me->world->set_engine(SharedPtr()); - me->world->set_interface(SharedPtr()); + me->world->set_engine(SPtr()); + me->world->set_interface(SPtr()); delete me->world; delete me; } diff --git a/src/socket/Socket.cpp b/src/socket/Socket.cpp index 2de88226..689e7eb6 100644 --- a/src/socket/Socket.cpp +++ b/src/socket/Socket.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include @@ -142,7 +143,7 @@ Socket::listen() } } -SharedPtr +SPtr Socket::accept() { socklen_t client_addr_len = _addr_len; @@ -151,7 +152,7 @@ Socket::accept() int conn = ::accept(_sock, client_addr, &client_addr_len); if (conn == -1) { - return SharedPtr(); + return SPtr(); } Raul::URI client_uri = _uri; @@ -161,7 +162,7 @@ Socket::accept() client_uri = Raul::URI(_uri.scheme() + "://" + host); } - return SharedPtr( + return SPtr( new Socket(_type, client_uri, client_addr, client_addr_len, conn)); } diff --git a/src/socket/Socket.hpp b/src/socket/Socket.hpp index ed2ddb74..ebe9f68f 100644 --- a/src/socket/Socket.hpp +++ b/src/socket/Socket.hpp @@ -21,9 +21,10 @@ #include #include "raul/Noncopyable.hpp" -#include "raul/SharedPtr.hpp" #include "raul/URI.hpp" +#include "ingen/types.hpp" + namespace Ingen { namespace Socket { @@ -71,7 +72,7 @@ public: /** Accept a connection. * @return An new open socket for the connection. */ - SharedPtr accept(); + SPtr accept(); /** Return the file descriptor for the socket. */ int fd() { return _sock; } diff --git a/src/socket/SocketClient.hpp b/src/socket/SocketClient.hpp index 14227c90..b05cb343 100644 --- a/src/socket/SocketClient.hpp +++ b/src/socket/SocketClient.hpp @@ -27,10 +27,10 @@ namespace Socket { class SocketClient : public SocketWriter { public: - SocketClient(World& world, - const Raul::URI& uri, - SharedPtr sock, - SharedPtr respondee) + SocketClient(World& world, + const Raul::URI& uri, + SPtr sock, + SPtr respondee) : SocketWriter(world.uri_map(), world.uris(), uri, sock) , _respondee(respondee) , _reader(world, *respondee.get(), sock) @@ -38,17 +38,17 @@ public: _reader.start(); } - virtual SharedPtr respondee() const { + virtual SPtr respondee() const { return _respondee; } - virtual void set_respondee(SharedPtr respondee) { + virtual void set_respondee(SPtr respondee) { _respondee = respondee; } private: - SharedPtr _respondee; - SocketReader _reader; + SPtr _respondee; + SocketReader _reader; }; } // namespace Socket diff --git a/src/socket/SocketListener.cpp b/src/socket/SocketListener.cpp index 0628b7a5..4e1f9512 100644 --- a/src/socket/SocketListener.cpp +++ b/src/socket/SocketListener.cpp @@ -109,14 +109,14 @@ SocketListener::_run() } if (pfds[0].revents & POLLIN) { - SharedPtr conn = _unix_sock.accept(); + SPtr conn = _unix_sock.accept(); if (conn) { new SocketServer(_world, *engine, conn); } } if (pfds[1].revents & POLLIN) { - SharedPtr conn = _net_sock.accept(); + SPtr conn = _net_sock.accept(); if (conn) { new SocketServer(_world, *engine, conn); } diff --git a/src/socket/SocketListener.hpp b/src/socket/SocketListener.hpp index c4700ed4..bea55da2 100644 --- a/src/socket/SocketListener.hpp +++ b/src/socket/SocketListener.hpp @@ -16,7 +16,6 @@ #include -#include "raul/SharedPtr.hpp" #include "raul/Thread.hpp" #include "Socket.hpp" diff --git a/src/socket/SocketReader.cpp b/src/socket/SocketReader.cpp index cc5da947..4ff65b3b 100644 --- a/src/socket/SocketReader.cpp +++ b/src/socket/SocketReader.cpp @@ -30,9 +30,9 @@ namespace Ingen { namespace Socket { -SocketReader::SocketReader(Ingen::World& world, - Interface& iface, - SharedPtr sock) +SocketReader::SocketReader(Ingen::World& world, + Interface& iface, + SPtr sock) : Raul::Thread() , _world(world) , _iface(iface) diff --git a/src/socket/SocketReader.hpp b/src/socket/SocketReader.hpp index 51435368..ea2bcd8e 100644 --- a/src/socket/SocketReader.hpp +++ b/src/socket/SocketReader.hpp @@ -33,9 +33,9 @@ namespace Socket { class SocketReader : public Raul::Thread { public: - SocketReader(World& world, - Interface& iface, - SharedPtr sock); + SocketReader(World& world, + Interface& iface, + SPtr sock); ~SocketReader(); @@ -58,12 +58,12 @@ private: const SerdNode* object_datatype, const SerdNode* object_lang); - World& _world; - Interface& _iface; - SerdEnv* _env; - SordInserter* _inserter; - SordNode* _msg_node; - SharedPtr _socket; + World& _world; + Interface& _iface; + SerdEnv* _env; + SordInserter* _inserter; + SordNode* _msg_node; + SPtr _socket; }; } // namespace Ingen diff --git a/src/socket/SocketServer.hpp b/src/socket/SocketServer.hpp index 6bbd792d..371bd1e0 100644 --- a/src/socket/SocketServer.hpp +++ b/src/socket/SocketServer.hpp @@ -29,9 +29,9 @@ namespace Socket { class SocketServer : public Server::EventWriter, public SocketReader { public: - SocketServer(World& world, - Server::Engine& engine, - SharedPtr sock) + SocketServer(World& world, + Server::Engine& engine, + SPtr sock) : Server::EventWriter(engine) , SocketReader(world, *this, sock) , _engine(engine) @@ -49,8 +49,8 @@ public: } private: - Server::Engine& _engine; - SharedPtr _writer; + Server::Engine& _engine; + SPtr _writer; }; } // namespace Ingen diff --git a/src/socket/SocketWriter.cpp b/src/socket/SocketWriter.cpp index d2652dec..fd099e30 100644 --- a/src/socket/SocketWriter.cpp +++ b/src/socket/SocketWriter.cpp @@ -40,10 +40,10 @@ socket_sink(const void* buf, size_t len, void* stream) return ret; } -SocketWriter::SocketWriter(URIMap& map, - URIs& uris, - const Raul::URI& uri, - SharedPtr sock) +SocketWriter::SocketWriter(URIMap& map, + URIs& uris, + const Raul::URI& uri, + SPtr sock) : AtomWriter(map, uris, *this) , _map(map) , _sratom(sratom_new(&map.urid_map_feature()->urid_map)) diff --git a/src/socket/SocketWriter.hpp b/src/socket/SocketWriter.hpp index d6ba5dd3..141b0ca5 100644 --- a/src/socket/SocketWriter.hpp +++ b/src/socket/SocketWriter.hpp @@ -19,11 +19,11 @@ #include -#include "ingen/Interface.hpp" #include "ingen/AtomSink.hpp" #include "ingen/AtomWriter.hpp" +#include "ingen/Interface.hpp" +#include "ingen/types.hpp" #include "raul/URI.hpp" -#include "raul/SharedPtr.hpp" #include "sratom/sratom.h" #include "Socket.hpp" @@ -36,10 +36,10 @@ namespace Socket { class SocketWriter : public AtomWriter, public AtomSink { public: - SocketWriter(URIMap& map, - URIs& uris, - const Raul::URI& uri, - SharedPtr sock); + SocketWriter(URIMap& map, + URIs& uris, + const Raul::URI& uri, + SPtr sock); ~SocketWriter(); @@ -51,14 +51,14 @@ public: Raul::URI uri() const { return _uri; } protected: - URIMap& _map; - Sratom* _sratom; - SerdNode _base; - SerdURI _base_uri; - SerdEnv* _env; - SerdWriter* _writer; - Raul::URI _uri; - SharedPtr _socket; + URIMap& _map; + Sratom* _sratom; + SerdNode _base; + SerdURI _base_uri; + SerdEnv* _env; + SerdWriter* _writer; + Raul::URI _uri; + SPtr _socket; }; } // namespace Socket diff --git a/src/socket/ingen_socket_client.cpp b/src/socket/ingen_socket_client.cpp index e835adc8..88842dde 100644 --- a/src/socket/ingen_socket_client.cpp +++ b/src/socket/ingen_socket_client.cpp @@ -23,21 +23,21 @@ #include "Socket.hpp" #include "SocketClient.hpp" -static SharedPtr -new_socket_interface(Ingen::World* world, - const Raul::URI& uri, - SharedPtr respondee) +static Ingen::SPtr +new_socket_interface(Ingen::World* world, + const Raul::URI& uri, + Ingen::SPtr respondee) { - SharedPtr sock( + Ingen::SPtr sock( new Ingen::Socket::Socket(Ingen::Socket::Socket::type_from_uri(uri))); if (!sock->connect(uri)) { world->log().error(Raul::fmt("Failed to connect <%1%> (%2%)\n") % sock->uri() % strerror(errno)); - return SharedPtr(); + return Ingen::SPtr(); } Ingen::Socket::SocketClient* client = new Ingen::Socket::SocketClient( *world, uri, sock, respondee); - return SharedPtr(client); + return Ingen::SPtr(client); } struct IngenSocketClientModule : public Ingen::Module { diff --git a/src/socket/ingen_socket_server.cpp b/src/socket/ingen_socket_server.cpp index 45c587ce..37b05bae 100644 --- a/src/socket/ingen_socket_server.cpp +++ b/src/socket/ingen_socket_server.cpp @@ -26,11 +26,11 @@ using namespace Ingen; struct IngenSocketServerModule : public Ingen::Module { void load(Ingen::World* world) { - listener = SharedPtr( + listener = SPtr( new Ingen::Socket::SocketListener(*world)); } - SharedPtr listener; + SPtr listener; }; extern "C" { diff --git a/tests/ingen_test.cpp b/tests/ingen_test.cpp index 8608b447..7bba3289 100644 --- a/tests/ingen_test.cpp +++ b/tests/ingen_test.cpp @@ -28,7 +28,6 @@ #include #include "raul/Path.hpp" -#include "raul/SharedPtr.hpp" #include "raul/Thread.hpp" #include "serd/serd.h" @@ -48,6 +47,7 @@ #include "ingen/client/ThreadedSigClientInterface.hpp" #include "ingen/runtime_paths.hpp" #include "ingen/serialisation/Parser.hpp" +#include "ingen/types.hpp" #ifdef WITH_BINDINGS #include "bindings/ingen_bindings.hpp" #endif @@ -197,10 +197,10 @@ main(int argc, char** argv) // AtomWriter to serialise responses from the engine /* TestClient client; - SharedPtr atom_writer( + SPtr atom_writer( new AtomWriter(world->uri_map(), world->uris(), client)); */ - SharedPtr client(new TestClient(world->log())); + SPtr client(new TestClient(world->log())); world->interface()->set_respondee(client); world->engine()->register_client(Raul::URI("ingen:/clients/test"), -- cgit v1.2.1