GNOME.org
 

[beast: 44/57] BSE: use more Bse namespace elements instead of Rapicorn

commit a5ba7a1ef1d7509d21a236ecc935c0366c5167e5
Author: Tim Janik <timj gnu org>
Date:   Tue Jul 18 00:39:51 2017 +0200

    BSE: use more Bse namespace elements instead of Rapicorn
    
    Signed-off-by: Tim Janik <timj gnu org>

 bse/bsecategories.cc        |    6 +++---
 bse/bseengine.cc            |    4 ++--
 bse/bseenginemaster.cc      |   10 +++++-----
 bse/bseitem.cc              |    2 +-
 bse/bseitem.hh              |    2 +-
 bse/bsemain.cc              |   12 ++++++------
 bse/bsemath.cc              |    4 ++--
 bse/bsemididevice-oss.cc    |    2 +-
 bse/bseobject.hh            |    4 ++--
 bse/bsepcmdevice-oss.cc     |    2 +-
 bse/bseplugin.cc            |    2 +-
 bse/bsesequencer.cc         |    6 ++----
 bse/bseserver.cc            |    4 ++--
 bse/bseserverinsert.hh      |    4 ++--
 bse/bsesoundfont.cc         |    2 +-
 bse/bsestandardsynths.cc    |    4 ++--
 bse/bsestartup.cc           |    2 +-
 bse/bsestartup.hh           |    2 +-
 bse/bsestorage.cc           |    4 ++--
 bse/bsestorage.hh           |    8 ++++----
 bse/bsewave.cc              |    2 +-
 bse/gslcommon.cc            |    2 +-
 bse/pybse/pysupport.hh      |    4 ++--
 bse/tests/blocktests.cc     |    4 ++--
 bse/tests/resamplehandle.cc |    6 +++---
 25 files changed, 51 insertions(+), 53 deletions(-)
---
diff --git a/bse/bsecategories.cc b/bse/bsecategories.cc
index 37a5d52..5101c52 100644
--- a/bse/bsecategories.cc
+++ b/bse/bsecategories.cc
@@ -153,11 +153,11 @@ bse_categories_register (const std::string &category, const char *i18n_category,
       title = title ? title + 1 : name;
       while (end > name && end[-1] == '/')
         --end;
-      Rapicorn::StringVector tags;
+      Bse::StringVector tags;
       if (name < end)
-        tags = Rapicorn::string_split (std::string (name, end - name), "/");
+        tags = Bse::string_split (std::string (name, end - name), "/");
       Bse::ServerImpl::register_source_module (centry->otype, title,
-                                               Rapicorn::string_join (";", tags),
+                                               Bse::string_join (";", tags),
                                                pixstream);
     }
 }
diff --git a/bse/bseengine.cc b/bse/bseengine.cc
index cc5127b..3d68ffe 100644
--- a/bse/bseengine.cc
+++ b/bse/bseengine.cc
@@ -1175,7 +1175,7 @@ bse_module_new_virtual (guint       n_iostreams,
 static void
 slave (gpointer data)
 {
-  Bse::TaskRegistry::add ("DSP Slave", Rapicorn::ThisThread::process_pid(), 
Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::add ("DSP Slave", Bse::ThisThread::process_pid(), Bse::ThisThread::thread_pid());
   gboolean run = TRUE;
   while (run)
     {
@@ -1190,7 +1190,7 @@ slave (gpointer data)
       bse_trans_commit (trans);
       g_usleep (1000*500);
     }
-  Bse::TaskRegistry::remove (Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::remove (Bse::ThisThread::thread_pid());
 }
 /* --- setup & trigger --- */
 static bool     bse_engine_initialized = false;
diff --git a/bse/bseenginemaster.cc b/bse/bseenginemaster.cc
index 1b22d4f..021f1a5 100644
--- a/bse/bseenginemaster.cc
+++ b/bse/bseenginemaster.cc
@@ -912,7 +912,7 @@ engine_start_slaves ()
 {
   assert_return (slaves_running == false);
   slaves_running = true;
-  const uint n_cpus = Rapicorn::ThisThread::online_cpus();
+  const uint n_cpus = Bse::ThisThread::online_cpus();
   const uint n_slaves = std::max (1u, n_cpus) - 1;
   for (uint i = 0; i < n_slaves; i++)
     slave_threads.push_back (new std::thread (engine_run_slave));
@@ -945,7 +945,7 @@ void
 engine_run_slave ()
 {
   std::string myid = Bse::string_format ("DSP #%u", ++slave_counter);
-  Bse::TaskRegistry::add (myid, Rapicorn::ThisThread::process_pid(), Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::add (myid, Bse::ThisThread::process_pid(), Bse::ThisThread::thread_pid());
   while (slaves_running)
     {
       thread_process_nodes (bse_engine_block_size(), NULL); // FIXME: merge profile data
@@ -954,7 +954,7 @@ engine_run_slave ()
         break;
       slave_condition.wait (slave_lock);
     }
-  Bse::TaskRegistry::remove (Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::remove (Bse::ThisThread::thread_pid());
 }
 
 } // BseInternal
@@ -1208,7 +1208,7 @@ static std::atomic<bool> master_thread_running { false };
 void
 MasterThread::master_thread()
 {
-  Bse::TaskRegistry::add ("DSP #1", Rapicorn::ThisThread::process_pid(), Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::add ("DSP #1", Bse::ThisThread::process_pid(), Bse::ThisThread::thread_pid());
 
   /* assert pollfd equality, since we're simply casting structures */
   static_assert (sizeof (struct pollfd) == sizeof (GPollFD), "");
@@ -1251,7 +1251,7 @@ MasterThread::master_thread()
       if (bse_engine_has_garbage ())
        caller_wakeup_();
     }
-  Bse::TaskRegistry::remove (Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::remove (Bse::ThisThread::thread_pid());
 }
 
 static std::atomic<MasterThread*> master_thread_singleton { NULL };
diff --git a/bse/bseitem.cc b/bse/bseitem.cc
index f1ad65b..40165e5 100644
--- a/bse/bseitem.cc
+++ b/bse/bseitem.cc
@@ -1164,7 +1164,7 @@ bse_item_undo_open_str (void *item, const std::string &string)
   else
     {
       ustack = bse_undo_stack_dummy ();
-      bse_undo_group_open (ustack, Rapicorn::string_format ("DUMMY-GROUP(%s)", string).c_str());
+      bse_undo_group_open (ustack, Bse::string_format ("DUMMY-GROUP(%s)", string).c_str());
     }
   return ustack;
 }
diff --git a/bse/bseitem.hh b/bse/bseitem.hh
index 8ca2145..822619a 100644
--- a/bse/bseitem.hh
+++ b/bse/bseitem.hh
@@ -124,7 +124,7 @@ void          bse_item_set_property_undoable (BseItem         *self,
                                               const GValue    *value);
 /* undo admin functions */
 BseUndoStack* bse_item_undo_open_str         (void *item, const std::string &string);
-#define       bse_item_undo_open(item,...)   bse_item_undo_open_str (item, Rapicorn::string_format 
(__VA_ARGS__).c_str())
+#define       bse_item_undo_open(item,...)   bse_item_undo_open_str (item, Bse::string_format 
(__VA_ARGS__).c_str())
 void          bse_item_undo_close            (BseUndoStack    *ustack);
 /* undo helper functions */
 void          bse_item_push_undo_proc        (gpointer         item,
diff --git a/bse/bsemain.cc b/bse/bsemain.cc
index b9a8d90..54bb0a1 100644
--- a/bse/bsemain.cc
+++ b/bse/bsemain.cc
@@ -167,7 +167,7 @@ bse_init_intern()
   // unit testing message
   if (initialized_for_unit_testing > 0)
     {
-      StringVector sv = Rapicorn::string_split (Rapicorn::cpu_info(), " ");
+      StringVector sv = Bse::string_split (Bse::cpu_info(), " ");
       String machine = sv.size() >= 2 ? sv[1] : "Unknown";
       Test::tprintout ("  NOTE   Running on: %s+%s", machine.c_str(), bse_block_impl_name());
     }
@@ -217,9 +217,9 @@ bse_init_inprocess (int *argc, char **argv, const char *app_name, const Bse::Str
 static std::atomic<bool> main_loop_thread_running { true };
 
 static void
-bse_main_loop_thread (Rapicorn::AsyncBlockingQueue<int> *init_queue)
+bse_main_loop_thread (Bse::AsyncBlockingQueue<int> *init_queue)
 {
-  Bse::TaskRegistry::add ("BSE Core", Rapicorn::ThisThread::process_pid(), 
Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::add ("BSE Core", Bse::ThisThread::process_pid(), Bse::ThisThread::thread_pid());
 
   bse_init_intern ();
 
@@ -235,7 +235,7 @@ bse_main_loop_thread (Rapicorn::AsyncBlockingQueue<int> *init_queue)
       g_main_context_iteration (bse_main_context, TRUE);
     }
 
-  Bse::TaskRegistry::remove (Rapicorn::ThisThread::thread_pid()); // see bse_init_intern
+  Bse::TaskRegistry::remove (Bse::ThisThread::thread_pid()); // see bse_init_intern
 }
 
 static void
@@ -255,7 +255,7 @@ _bse_init_async (int *argc, char **argv, const char *app_name, const Bse::String
   // start main BSE thread
   if (std::atexit (reap_main_loop_thread) != 0)
     Bse::warning ("BSE: failed to install main thread reaper");
-  auto *init_queue = new Rapicorn::AsyncBlockingQueue<int>();
+  auto *init_queue = new Bse::AsyncBlockingQueue<int>();
   async_bse_thread = std::thread (bse_main_loop_thread, init_queue); // calls bse_init_intern
   // wait for initialization completion of the core thread
   int msg = init_queue->pop();
@@ -266,7 +266,7 @@ _bse_init_async (int *argc, char **argv, const char *app_name, const Bse::String
 struct AsyncData {
   const gchar *client;
   const std::function<void()> &caller_wakeup;
-  Rapicorn::AsyncBlockingQueue<SfiGlueContext*> result_queue;
+  Bse::AsyncBlockingQueue<SfiGlueContext*> result_queue;
 };
 
 static gboolean
diff --git a/bse/bsemath.cc b/bse/bsemath.cc
index e88ba8b..e623e5e 100644
--- a/bse/bsemath.cc
+++ b/bse/bsemath.cc
@@ -8,7 +8,7 @@
 std::string
 bse_string_from_double (long double value)
 {
-  std::string str = Rapicorn::string_format ("%.1270f", value);
+  std::string str = Bse::string_format ("%.1270f", value);
   const char *s = &str[str.size()];
   while (s > &str[0] && s[-1] == '0' && s[-2] != '.')
     s--;
@@ -88,7 +88,7 @@ bse_poly_str1 (uint degree, double *a, const std::string &uvar)
        }
       s += var;
       if (i > 1)
-        s += Rapicorn::string_format ("**%u", i);
+        s += Bse::string_format ("**%u", i);
       need_plus = true;
     }
   s += ')';
diff --git a/bse/bsemididevice-oss.cc b/bse/bsemididevice-oss.cc
index e9a5c01..fd32604 100644
--- a/bse/bsemididevice-oss.cc
+++ b/bse/bsemididevice-oss.cc
@@ -74,7 +74,7 @@ bse_midi_device_oss_list_devices (BseDevice *device)
   for (i = 0; i < G_N_ELEMENTS (postfixes); i++)
     {
       char *dname = g_strconcat (BSE_MIDI_DEVICE_OSS (device)->device_name, postfixes[i], NULL);
-      if (!Rapicorn::Path::equals (last, dname))
+      if (!Bse::Path::equals (last, dname))
         {
           if (check_device_usage (dname, "crw") == Bse::Error::NONE)
             ring = sfi_ring_append (ring,
diff --git a/bse/bseobject.hh b/bse/bseobject.hh
index 4b81ab9..25f0953 100644
--- a/bse/bseobject.hh
+++ b/bse/bseobject.hh
@@ -63,7 +63,7 @@ struct BseObject : GObject {
   operator               Bse::ObjectImpl* ()          { return cxxobject_; }
   // DERIVES_shared_ptr (uses void_t to prevent errors for T without shared_ptr's typedefs)
   template<class T, typename = void> struct DERIVES_shared_ptr : std::false_type {};
-  template<class T> struct DERIVES_shared_ptr<T, Rapicorn::void_t< typename T::element_type > > :
+  template<class T> struct DERIVES_shared_ptr<T, Bse::void_t< typename T::element_type > > :
   std::is_base_of< std::shared_ptr<typename T::element_type>, T > {};
   // as<T*>()
   template<class ObjectImplPtr, typename ::std::enable_if<std::is_pointer<ObjectImplPtr>::value, bool>::type 
= true>
@@ -81,7 +81,7 @@ struct BseObject : GObject {
     typedef typename ObjectImplP::element_type ObjectImplT;
     static_assert (std::is_base_of<Aida::ImplicitBase, ObjectImplT>::value, "");
     ObjectImplT *impl = this && cxxobject_ ? as<ObjectImplT*>() : NULL;
-    return impl ? Rapicorn::shared_ptr_cast<ObjectImplT> (impl) : NULL;
+    return impl ? Bse::shared_ptr_cast<ObjectImplT> (impl) : NULL;
   }
 };
 
diff --git a/bse/bsepcmdevice-oss.cc b/bse/bsepcmdevice-oss.cc
index 01aa890..a471ccd 100644
--- a/bse/bsepcmdevice-oss.cc
+++ b/bse/bsepcmdevice-oss.cc
@@ -103,7 +103,7 @@ bse_pcm_device_oss_list_devices (BseDevice    *device)
   for (i = 0; i < G_N_ELEMENTS (postfixes); i++)
     {
       gchar *dname = g_strconcat (BSE_PCM_DEVICE_OSS (device)->device_name, postfixes[i], NULL);
-      if (!Rapicorn::Path::equals (last, dname))
+      if (!Bse::Path::equals (last, dname))
         {
           if (check_device_usage (dname, "crw") == Bse::Error::NONE)
             ring = sfi_ring_append (ring,
diff --git a/bse/bseplugin.cc b/bse/bseplugin.cc
index 8280a6d..8126bf2 100644
--- a/bse/bseplugin.cc
+++ b/bse/bseplugin.cc
@@ -164,7 +164,7 @@ bse_plugin_init_builtins (void)
 static guint64
 runtime_export_config (void)
 {
-  const std::string cinfo = Rapicorn::cpu_info();
+  const std::string cinfo = Bse::cpu_info();
   guint64 emask = 0;
   if (cinfo.find (" MMX ") != cinfo.npos)
     emask |= BSE_EXPORT_FLAG_MMX;
diff --git a/bse/bsesequencer.cc b/bse/bsesequencer.cc
index 36f36e8..afe812a 100644
--- a/bse/bsesequencer.cc
+++ b/bse/bsesequencer.cc
@@ -23,8 +23,6 @@
 
 namespace Bse {
 
-using Rapicorn::ThreadInfo; // FIXME
-
 Sequencer              *Sequencer::singleton_ = NULL;
 std::mutex              Sequencer::sequencer_mutex_;
 static ThreadInfo      *sequencer_thread_self = NULL;
@@ -333,7 +331,7 @@ static std::atomic<bool> sequencer_thread_running { false };
 void
 Sequencer::sequencer_thread ()
 {
-  Bse::TaskRegistry::add ("Sequencer", Rapicorn::ThisThread::process_pid(), 
Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::add ("Sequencer", Bse::ThisThread::process_pid(), Bse::ThisThread::thread_pid());
   sequencer_thread_self = &ThreadInfo::self();
   SDEBUG ("thrdstrt: now=%llu", Bse::TickStamp::current());
   Bse::TickStampWakeupP wakeup = Bse::TickStamp::create_wakeup ([&]() { this->wakeup(); });
@@ -390,7 +388,7 @@ Sequencer::sequencer_thread ()
   while (pool_poll_Lm (-1) && sequencer_thread_running);
   BSE_SEQUENCER_UNLOCK();
   SDEBUG ("thrdstop: now=%llu", Bse::TickStamp::current());
-  Bse::TaskRegistry::remove (Rapicorn::ThisThread::thread_pid());
+  Bse::TaskRegistry::remove (Bse::ThisThread::thread_pid());
 }
 
 bool
diff --git a/bse/bseserver.cc b/bse/bseserver.cc
index f9c7e8a..c2e7775 100644
--- a/bse/bseserver.cc
+++ b/bse/bseserver.cc
@@ -1080,7 +1080,7 @@ engine_init (BseServer *server,
       engine_is_initialized = true;
       bse_engine_init();
       // lower priority compared to engine if our priority range permits
-      const int mypid = Rapicorn::ThisThread::thread_pid();
+      const int mypid = Bse::ThisThread::thread_pid();
       int current_priority = getpriority (PRIO_PROCESS, mypid);
       if (current_priority <= -2 && mypid)
         setpriority (PRIO_PROCESS, mypid, current_priority + 1);
@@ -1414,7 +1414,7 @@ ServerImpl::register_source_module (const String &type, const String &title, con
     printerr ("%s\n  %s\n  tags=%s\n  icon=...%s\n",
               type,
               title,
-              Rapicorn::string_join (", ", Rapicorn::string_split_any (tags, ":;")),
+              Bse::string_join (", ", Bse::string_split_any (tags, ":;")),
               ad.icon.width && ad.icon.height ? string_format ("%ux%u", ad.icon.width, ad.icon.height) : 
"0");
 }
 
diff --git a/bse/bseserverinsert.hh b/bse/bseserverinsert.hh
index e7f1941..3408391 100644
--- a/bse/bseserverinsert.hh
+++ b/bse/bseserverinsert.hh
@@ -16,7 +16,7 @@ class_scope:Object:
   }
   // DERIVES_shared_ptr (uses void_t to prevent errors for T without shared_ptr's typedefs)
   template<class T, typename = void> struct DERIVES_shared_ptr : std::false_type {};
-  template<class T> struct DERIVES_shared_ptr<T, Rapicorn::void_t< typename T::element_type > > :
+  template<class T> struct DERIVES_shared_ptr<T, Bse::void_t< typename T::element_type > > :
   std::is_base_of< std::shared_ptr<typename T::element_type>, T > {};
   // as<shared_ptr<T>>()
   template<class ObjectImplP, typename ::std::enable_if<DERIVES_shared_ptr<ObjectImplP>::value, bool>::type 
= true>
@@ -25,7 +25,7 @@ class_scope:Object:
     typedef typename ObjectImplP::element_type ObjectImplT;
     static_assert (std::is_base_of<Aida::ImplicitBase, ObjectImplT>::value, "");
     ObjectImplT *impl = this ? dynamic_cast<ObjectImplT*> (this) : NULL;
-    return impl ? Rapicorn::shared_ptr_cast<ObjectImplT> (impl) : NULL;
+    return impl ? Bse::shared_ptr_cast<ObjectImplT> (impl) : NULL;
   }
 protected:
   virtual BseObject* as_bse_object() = 0;
diff --git a/bse/bsesoundfont.cc b/bse/bsesoundfont.cc
index 50695de..cfa1930 100644
--- a/bse/bsesoundfont.cc
+++ b/bse/bsesoundfont.cc
@@ -96,7 +96,7 @@ use_searchpath (std::string file_name)
   if (bse_main_args->override_sample_path)
     sample_path = bse_main_args->override_sample_path;
   else
-    sample_path = Rapicorn::Path::searchpath_join (Bse::installpath (Bse::INSTALLPATH_DATADIR_SAMPLES), 
BSE_GCONFIG (sample_path));
+    sample_path = Bse::Path::searchpath_join (Bse::installpath (Bse::INSTALLPATH_DATADIR_SAMPLES), 
BSE_GCONFIG (sample_path));
   files = sfi_file_crawler_list_files (sample_path.c_str(), file_name.c_str(), G_FILE_TEST_IS_REGULAR);
 
   for (walk = files; walk; walk = sfi_ring_walk (files, walk))
diff --git a/bse/bsestandardsynths.cc b/bse/bsestandardsynths.cc
index cb4192a..0e82715 100644
--- a/bse/bsestandardsynths.cc
+++ b/bse/bsestandardsynths.cc
@@ -13,8 +13,8 @@ bse_standard_synth_inflate (const gchar *synth_name,
 {
   assert_return (synth_name != NULL, NULL);
 
-  const Rapicorn::String synth_res = Rapicorn::String ("@res ") + synth_name + ".bse";
-  Rapicorn::Blob blob = Rapicorn::Res (synth_res);
+  const Bse::String synth_res = Bse::String ("@res ") + synth_name + ".bse";
+  Bse::Blob blob = Bse::Res (synth_res);
   if (blob.size())
     {
       gchar *result = (gchar*) g_malloc (blob.size() + 1);
diff --git a/bse/bsestartup.cc b/bse/bsestartup.cc
index fd2c7e0..b64fd23 100644
--- a/bse/bsestartup.cc
+++ b/bse/bsestartup.cc
@@ -43,7 +43,7 @@ static TaskRegistry::List task_registry_tasks_;
 void
 TaskRegistry::add (const std::string &name, int pid, int tid)
 {
-  Rapicorn::TaskStatus task (pid, tid);
+  Bse::TaskStatus task (pid, tid);
   task.name = name;
   task.update();
   std::lock_guard<std::mutex> locker (task_registry_mutex_);
diff --git a/bse/bsestartup.hh b/bse/bsestartup.hh
index c2d1899..a0a5b24 100644
--- a/bse/bsestartup.hh
+++ b/bse/bsestartup.hh
@@ -11,7 +11,7 @@ namespace Bse {
 /// The task registry keeps track of runtime threads for profiling and statistical purposes.
 class TaskRegistry {            // FIXME: move this to IDL
 public:
-  typedef std::vector<Rapicorn::TaskStatus> List;
+  typedef std::vector<Bse::TaskStatus> List;
   static void  add     (const std::string &name, int pid,
                         int tid = -1);  ///< Add process/thread to registry for runtime profiling.
   static bool  remove  (int tid);       ///< Remove process/thread based on thread_id.
diff --git a/bse/bsestorage.cc b/bse/bsestorage.cc
index dd5c900..a99ffef 100644
--- a/bse/bsestorage.cc
+++ b/bse/bsestorage.cc
@@ -1817,8 +1817,8 @@ BseStorage::Blob::~Blob()
 static std::string
 bse_storage_blob_tmp_dir()
 {
-  std::string dirname = Rapicorn::Path::join (Rapicorn::Path::cache_home(), "libbse");
-  if (!Rapicorn::Path::check (dirname, "d"))
+  std::string dirname = Bse::Path::join (Bse::Path::cache_home(), "libbse");
+  if (!Bse::Path::check (dirname, "d"))
     g_mkdir_with_parents (dirname.c_str(), 0755);
   return dirname;
 }
diff --git a/bse/bsestorage.hh b/bse/bsestorage.hh
index 05efde9..a636900 100644
--- a/bse/bsestorage.hh
+++ b/bse/bsestorage.hh
@@ -147,11 +147,11 @@ Bse::Error bse_storage_flush_fd               (BseStorage             *self,
 
 
 /* --- reading --- */
-#define      bse_storage_error(s, ...)          bse_storage_error_str (s, Rapicorn::string_format 
(__VA_ARGS__).c_str())
+#define      bse_storage_error(s, ...)          bse_storage_error_str (s, Bse::string_format 
(__VA_ARGS__).c_str())
 void         bse_storage_error_str              (BseStorage *self, const std::string &string);
-#define      bse_storage_warn(s, ...)           bse_storage_warn_str (s, Rapicorn::string_format 
(__VA_ARGS__).c_str())
+#define      bse_storage_warn(s, ...)           bse_storage_warn_str (s, Bse::string_format 
(__VA_ARGS__).c_str())
 void         bse_storage_warn_str               (BseStorage *self, const std::string &string);
-#define      bse_storage_warn_skip(s, ...)      bse_storage_skip (s, Rapicorn::string_format 
(__VA_ARGS__).c_str())
+#define      bse_storage_warn_skip(s, ...)      bse_storage_skip (s, Bse::string_format 
(__VA_ARGS__).c_str())
 GTokenType   bse_storage_skip                   (BseStorage *self, const std::string &string);
 GTokenType   bse_storage_parse_param_value      (BseStorage             *self,
                                                  GValue                 *value,
@@ -197,6 +197,6 @@ void              bse_storage_blob_clean_files       (void);
 #define bse_storage_break(s)            sfi_wstore_break ((s)->wstore)
 #define bse_storage_putc(s,c)           sfi_wstore_putc ((s)->wstore, c)
 #define bse_storage_puts(s,b)           sfi_wstore_puts ((s)->wstore, b)
-#define bse_storage_printf(s, ...)      bse_storage_puts (s, Rapicorn::string_format (__VA_ARGS__).c_str())
+#define bse_storage_printf(s, ...)      bse_storage_puts (s, Bse::string_format (__VA_ARGS__).c_str())
 
 #endif /* __BSE_STORAGE_H__ */
diff --git a/bse/bsewave.cc b/bse/bsewave.cc
index 9e635cc..5289a43 100644
--- a/bse/bsewave.cc
+++ b/bse/bsewave.cc
@@ -268,7 +268,7 @@ bse_wave_load_wave_file (BseWave      *self,
       if (bse_main_args->override_sample_path)
        sample_path = bse_main_args->override_sample_path;
       else
-       sample_path = Rapicorn::Path::searchpath_join (Bse::installpath (Bse::INSTALLPATH_DATADIR_SAMPLES), 
BSE_GCONFIG (sample_path));
+       sample_path = Bse::Path::searchpath_join (Bse::installpath (Bse::INSTALLPATH_DATADIR_SAMPLES), 
BSE_GCONFIG (sample_path));
       files = sfi_file_crawler_list_files (sample_path.c_str(), file_name, G_FILE_TEST_IS_REGULAR);
 
       for (walk = files; walk; walk = sfi_ring_walk (files, walk))
diff --git a/bse/gslcommon.cc b/bse/gslcommon.cc
index dc50ba4..f4bbcea 100644
--- a/bse/gslcommon.cc
+++ b/bse/gslcommon.cc
@@ -197,7 +197,7 @@ gsl_byte_order_from_string (const gchar *string)
 Bse::Error
 gsl_file_check (const std::string &file_name, const std::string &mode)
 {
-  if (Rapicorn::Path::check (file_name, mode))
+  if (Bse::Path::check (file_name, mode))
     return Bse::Error::NONE;
   return gsl_error_from_errno (errno, Bse::Error::FILE_OPEN_FAILED);
 }
diff --git a/bse/pybse/pysupport.hh b/bse/pybse/pysupport.hh
index 4027790..248e767 100644
--- a/bse/pybse/pysupport.hh
+++ b/bse/pybse/pysupport.hh
@@ -25,7 +25,7 @@ py_init_async (const StringVector &args)
         break;
       }
   if (pyargc && !pyargv)
-    PyErr_Warn (PyExc_Warning, Rapicorn::string_format ("%s: failed to readout sys.argv", __func__).c_str());
+    PyErr_Warn (PyExc_Warning, Bse::string_format ("%s: failed to readout sys.argv", __func__).c_str());
   if (PyErr_Occurred())
     return false; // indicate exception
   std::vector<String> sargv;
@@ -34,7 +34,7 @@ py_init_async (const StringVector &args)
   for (size_t i = pyargv ? 0 : pyargc; i < pyargc; i++)
     sargv.push_back (PyString_AsString (PyList_GetItem (pyargv, i)));
   if (sargv.size() == 0)
-    sargv.push_back (Rapicorn::program_name());
+    sargv.push_back (Bse::executable_name());
   char *cargv[sargv.size() + 1];
   for (size_t i = 0; i < sargv.size(); i++)
     cargv[i] = const_cast<char*> (sargv[i].c_str());
diff --git a/bse/tests/blocktests.cc b/bse/tests/blocktests.cc
index c00c82a..7ca118d 100644
--- a/bse/tests/blocktests.cc
+++ b/bse/tests/blocktests.cc
@@ -408,8 +408,8 @@ main (int   argc,
 {
   // usually we'd call bse_init_test() here, but we have tests to run before plugins are loaded
   Rapicorn::init_core_test (RAPICORN_PRETTY_FILE, &argc, argv);
-  Rapicorn::StringVector sv = Rapicorn::string_split (Rapicorn::cpu_info(), " ");
-  Rapicorn::String machine = sv.size() >= 2 ? sv[1] : "Unknown";
+  Bse::StringVector sv = Bse::string_split (Bse::cpu_info(), " ");
+  Bse::String machine = sv.size() >= 2 ? sv[1] : "Unknown";
   printout ("  NOTE     Running on: %s+%s\n", machine.c_str(), bse_block_impl_name()); // usually done by 
bse_init_test
 
   TSTART ("Running Default Block Ops");
diff --git a/bse/tests/resamplehandle.cc b/bse/tests/resamplehandle.cc
index 3413418..fcdd211 100644
--- a/bse/tests/resamplehandle.cc
+++ b/bse/tests/resamplehandle.cc
@@ -165,7 +165,7 @@ generate_test_signal (vector<Sample> &signal,
           cached_window[i] = bse_window_blackman (wpos);
         }
     }
-  string signal_cache_key = Rapicorn::string_format ("%d/%.1f/%.1f/%.1f", signal_length, sample_rate, 
frequency1, frequency2);
+  string signal_cache_key = Bse::string_format ("%d/%.1f/%.1f/%.1f", signal_length, sample_rate, frequency1, 
frequency2);
   static map<string, vector<Sample> > signal_cache;
   vector<Sample>& cached_signal = signal_cache[signal_cache_key];
   if (cached_signal.empty())
@@ -458,8 +458,8 @@ main (int   argc,
 {
   // usually we'd call bse_init_test() here, but we have tests to rnu before plugins are loaded
   Rapicorn::init_core_test (RAPICORN_PRETTY_FILE, &argc, argv);
-  Rapicorn::StringVector sv = Rapicorn::string_split (Rapicorn::cpu_info(), " ");
-  Rapicorn::String machine = sv.size() >= 2 ? sv[1] : "Unknown";
+  Bse::StringVector sv = Bse::string_split (Bse::cpu_info(), " ");
+  Bse::String machine = sv.size() >= 2 ? sv[1] : "Unknown";
   printout ("  NOTE     Running on: %s+%s", machine.c_str(), bse_block_impl_name()); // usually done by 
bse_init_test
 
   test_c_api ("FPU");
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]