Added proper new loading interface to Serializer, updated everything that uses it (no actual implementation yet).

git-svn-id: http://svn.drobilla.net/lad/ingen@194 a436a847-0d15-0410-975c-d299462d15a1

8 files changed, 85 insertions, 72 deletions

diff --git a/configure.ac b/configure.ac
index 018d9f3b..d87e97a4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -358,7 +358,6 @@ AC_CONFIG_FILES([Makefile])
 AC_CONFIG_FILES([src/Makefile])
 AC_CONFIG_FILES([src/common/Makefile])
 AC_CONFIG_FILES([src/common/interface/Makefile])
-AC_CONFIG_FILES([src/common/Makefile])
 AC_CONFIG_FILES([src/libs/Makefile])
 AC_CONFIG_FILES([src/libs/engine/Makefile])
 AC_CONFIG_FILES([src/libs/engine/tests/Makefile])
diff --git a/src/libs/client/Serializer.cpp b/src/libs/client/Serializer.cpp
index 9ebf66e4..3557c011 100644
--- a/src/libs/client/Serializer.cpp
+++ b/src/libs/client/Serializer.cpp
@@ -24,6 +24,7 @@
 #include <cassert>
 #include <cmath>
 #include <cstdlib> // atof
+#include <boost/optional/optional.hpp>
 #include <cstring>
 #include <raptor.h>
 #include "Serializer.h"
@@ -42,6 +43,7 @@
 
 using std::string; using std::vector; using std::pair;
 using std::cerr; using std::cout; using std::endl;
+using boost::optional;
 
 namespace Ingen {
 namespace Client {
@@ -453,39 +455,41 @@ Serializer::serialize_connection(SharedPtr<ConnectionModel> connection) throw (s
 }
 
 
-/** Load a patch in to the engine (and client) from a patch file.
+/** Load a patch into the engine (e.g. from a patch file).
  *
- * The name and poly from the passed PatchModel are used.  If the name is
- * the empty string, the name will be loaded from the file.  If the poly
- * is 0, it will be loaded from file.  Otherwise the given values will
- * be used.
+ * @param base_uri Base URI (e.g. URI of the file to load from).
  *
- * @param wait If true the patch will be checked for existence before
- * loading everything in to it (to prevent messing up existing patches
- * that exist at the path this one should load as).
- *
- * @param existing If true, the patch will be loaded into a currently
- * existing patch (ie a merging will take place).  Errors will result
- * if Nodes of conflicting names exist.
- *
- * @param parent_path Patch to load this patch as a child of (empty string to load
- * to the root patch)
+ * @param data_path Path of the patch relative to base_uri
+ * (e.g. relative to file root patch).
+ * 
+ * @param engine_path Path in the engine for the newly created patch
+ * (i.e. 'destination' of the load).
+ * 
+ * @param initial_data will be set last, so values passed there will override
+ * any values loaded from the patch file (or values in the existing patch).
  *
- * @param name Name of this patch (loaded/generated if the empty string)
+ * @param merge If true, the loaded patch's contents will be loaded into a
+ * currently existing patch.  Errors may result if Nodes of conflicting names
+ * (etc) exist - the loaded patch will take precendence (ie overwriting
+ * existing values).  If false and the patch at @a load_path already exists,
+ * load is aborted and false is returned.
  *
- * @param initial_data will be set last, so values passed there will override
- * any values loaded from the patch file.
+ * @param poly Polyphony of new loaded patch if given, otherwise polyphony
+ * will be loaded (unless saved polyphony isn't found, in which case it's 1).
  *
- * Returns the path of the newly created patch.
+ * Returns whether or not patch was loaded.
  */
-string
-Serializer::load_patch(const string& filename,
-	                   const string& parent_path,
-	                   const string& name,
-	                   size_t        poly,
-	                   MetadataMap   initial_data,
-	                   bool          existing)
+bool
+Serializer::load_patch(bool                    merge,
+                       const string&           data_base_uri,
+                       const Path&             data_path,
+                       MetadataMap             engine_data,
+                       optional<const Path&>   engine_parent,
+                       optional<const string&> engine_name,
+                       optional<size_t>        engine_poly)
+
 {
+	cerr << "LOAD: " << data_base_uri << ", " << data_path << ", " << engine_parent << endl;
 #if 0
 	cerr << "[Serializer] Loading patch " << filename << "" << endl;
 
diff --git a/src/libs/client/Serializer.h b/src/libs/client/Serializer.h
index 15c49101..a6b89315 100644
--- a/src/libs/client/Serializer.h
+++ b/src/libs/client/Serializer.h
@@ -21,14 +21,16 @@
 #include <utility>
 #include <string>
 #include <stdexcept>
-#include <raptor.h>
 #include <cassert>
+#include <boost/optional/optional.hpp>
+#include <raptor.h>
 #include "raul/SharedPtr.h"
 #include "raul/Path.h"
 #include "raul/Atom.h"
 #include "ObjectModel.h"
 
 using std::string;
+using boost::optional;
 
 namespace Ingen {
 namespace Client {
@@ -61,17 +63,19 @@ public:
 	
 	string find_file(const string& filename, const string& additional_path = "");
 	
-	string load_patch(const string& filename,
-	                  const string& parent_path,
-	                  const string& name,
-	                  size_t        poly,
-	                  MetadataMap   initial_data,
-	                  bool          existing = false);
+	bool load_patch(bool                    merge,
+	                const string&           data_base_uri,
+	                const Path&             data_path,
+	                MetadataMap             engine_data,
+	                optional<const Path&>   engine_parent = optional<const Path&>(),
+	                optional<const string&> engine_name = optional<const string&>(),
+	                optional<size_t>        engine_poly = optional<size_t>());
+
 	
 	void   start_to_filename(const string& filename)            throw (std::logic_error);
 	void   start_to_string()                                    throw (std::logic_error);
-	void   serialize(SharedPtr<ObjectModel> object)            throw (std::logic_error);
-	void   serialize_connection(SharedPtr<ConnectionModel> c)  throw (std::logic_error);
+	void   serialize(SharedPtr<ObjectModel> object)             throw (std::logic_error);
+	void   serialize_connection(SharedPtr<ConnectionModel> c)   throw (std::logic_error);
 	string finish()                                             throw (std::logic_error);
 
 private:
diff --git a/src/progs/ingenuity/LoadPatchWindow.cpp b/src/progs/ingenuity/LoadPatchWindow.cpp
index 7605f0f0..b3e3068b 100644
--- a/src/progs/ingenuity/LoadPatchWindow.cpp
+++ b/src/progs/ingenuity/LoadPatchWindow.cpp
@@ -17,12 +17,15 @@
 #include "LoadPatchWindow.h"
 #include <sys/types.h>
 #include <dirent.h>
+#include <boost/optional/optional.hpp>
 #include "App.h"
 #include "Configuration.h"
 #include "PatchModel.h"
 #include "ModelEngineInterface.h"
 #include "Loader.h"
 
+using boost::optional;
+
 namespace Ingenuity {
 
 
@@ -108,9 +111,9 @@ LoadPatchWindow::poly_from_user_selected()
 void
 LoadPatchWindow::ok_clicked()
 {
-	// These values are interpreted by load_patch() as "not defined", ie load from file
-	string name = "";
-	int    poly = 0;
+	// If unset load_patch will load values
+	optional<const string&> name;
+	optional<size_t> poly;
 	
 	if (m_poly_from_user_radio->get_active())
 		poly = m_poly_spinbutton->get_value_as_int();
@@ -118,14 +121,8 @@ LoadPatchWindow::ok_clicked()
 	if (m_replace)
 		App::instance().engine()->clear_patch(m_patch->path());
 
-	cerr << "FIXME: load patch" << endl;
-	//SharedPtr<PatchModel> pm(new PatchModel(m_patch->path(), poly));
-	//pm->filename(get_filename());
-	//pm->set_metadata("filename", Atom(get_filename().c_str()));
-	// FIXME: necessary?
-	//pm->set_parent(m_patch->parent());
-	//App::instance().engine()->push_added_patch(pm);
-	//App::instance().loader()->load_patch(pm, true, true);
+	App::instance().loader()->load_patch(true, get_filename(), "/",
+		m_initial_data, m_patch->parent()->path(), name, poly);
 	
 	hide();
 }			
diff --git a/src/progs/ingenuity/LoadPatchWindow.h b/src/progs/ingenuity/LoadPatchWindow.h
index b70552b1..a1bc228f 100644
--- a/src/progs/ingenuity/LoadPatchWindow.h
+++ b/src/progs/ingenuity/LoadPatchWindow.h
@@ -31,9 +31,9 @@ namespace Ingenuity {
 
 /** 'Load Patch' window.
  *
- * Loaded by glade as a derived object.  Used for both "Load" and "Load Into"
- * operations (the radio button state should be changed with the provided
- * methods prior to presenting this window).
+ * Loaded by glade as a derived object.  Used for both "Import" and "Load"
+ * (e.g. Replace, clear-then-import) operations (the radio button state
+ * should be changed with the provided methods before presenting).
  *
  * This is not for loading subpatches.  See @a LoadSubpatchWindow for that.
  *
diff --git a/src/progs/ingenuity/LoadSubpatchWindow.cpp b/src/progs/ingenuity/LoadSubpatchWindow.cpp
index 9aea1bd6..6a8aa24d 100644
--- a/src/progs/ingenuity/LoadSubpatchWindow.cpp
+++ b/src/progs/ingenuity/LoadSubpatchWindow.cpp
@@ -136,20 +136,23 @@ LoadSubpatchWindow::ok_clicked()
 {
 	assert(m_patch);
 	
-	const string filename = get_filename();
-
-	string name = "";
-	int    poly = 1;
+	// If unset load_patch will load values
+	optional<const string&> name;
+	optional<size_t> poly;
+	string name_str = "";
 	
-	if (m_name_from_user_radio->get_active())
-		name = m_name_entry->get_text();
+	if (m_name_from_user_radio->get_active()) {
+		name_str = m_name_entry->get_text();
+		name = name_str;
+	}
 
 	if (m_poly_from_user_radio->get_active())
 		poly = m_poly_spinbutton->get_value_as_int();
 	else if (m_poly_from_parent_radio->get_active())
 		poly = m_patch->poly();
 
-	App::instance().loader()->load_patch(filename, m_patch->path(), name, poly, m_initial_data);
+	App::instance().loader()->load_patch(false, get_filename(), "/",
+		m_initial_data, m_patch->parent()->path(), name, poly);
 
 	hide();
 }			
diff --git a/src/progs/ingenuity/Loader.cpp b/src/progs/ingenuity/Loader.cpp
index 98f88e55..89245dff 100644
--- a/src/progs/ingenuity/Loader.cpp
+++ b/src/progs/ingenuity/Loader.cpp
@@ -54,20 +54,21 @@ Loader::_whipped()
 	_mutex.unlock();
 }
 
-
 void
-Loader::load_patch(const string&      filename,
-	               const string&      parent_path,
-	               const string&      name,
-	               size_t             poly,
-                   const MetadataMap& initial_data,
-	               bool               existing)
+Loader::load_patch(bool                    merge,
+                   const string&           data_base_uri,
+                   const Path&             data_path,
+                   MetadataMap             engine_data,
+                   optional<const Path&>   engine_parent,
+                   optional<const string&> engine_name,
+                   optional<size_t>        engine_poly)
 {
 	_mutex.lock();
 
 	_events.push_back(sigc::hide_return(sigc::bind(
 		sigc::mem_fun(_serializer, &Serializer::load_patch),
-		filename, parent_path, name, poly, initial_data, existing)));
+		merge, data_base_uri, data_path,
+		engine_data, engine_parent, engine_name, engine_poly)));
 	
 	_mutex.unlock();
 
diff --git a/src/progs/ingenuity/Loader.h b/src/progs/ingenuity/Loader.h
index 65d1fcfe..05f97dbb 100644
--- a/src/progs/ingenuity/Loader.h
+++ b/src/progs/ingenuity/Loader.h
@@ -20,6 +20,7 @@
 #include <string>
 #include <list>
 #include <cassert>
+#include <boost/optional/optional.hpp>
 #include "raul/Thread.h"
 #include "raul/Slave.h"
 #include "raul/Mutex.h"
@@ -28,6 +29,7 @@
 #include "ObjectModel.h"
 using std::string;
 using std::list;
+using boost::optional;
 
 namespace Ingen { namespace Client {
 	class Serializer;
@@ -57,16 +59,19 @@ public:
 
 	Serializer& serializer() const { return *_serializer; }
 
-	void load_patch(const string&      filename,
-	                const string&      parent_path,
-	                const string&      name,
-	                size_t             poly,
-	                const MetadataMap& initial_data,
-	                bool               merge = false);
+	// FIXME: there's a pattern here....
+	// (same core interface as Serializer)
+	
+	void load_patch(bool                    merge,
+	                const string&           data_base_uri,
+	                const Path&             data_path,
+	                MetadataMap             engine_data,
+	                optional<const Path&>   engine_parent = optional<const Path&>(),
+	                optional<const string&> engine_name = optional<const string&>(),
+	                optional<size_t>        engine_poly = optional<size_t>());
 	
 	void save_patch(SharedPtr<PatchModel> model, const string& filename, bool recursive);
 
-
 private:	
 
 	void save_patch_event(SharedPtr<PatchModel> model, const string& filename, bool recursive);