better comment change

[ardour.git] / libs / pbd / convert.cc

diff --git a/libs/pbd/convert.cc b/libs/pbd/convert.cc
index 3b709d8e422da644bbf156e172e6e0e19d3189bc..bda0683910661f6f9e352fbe86e7fd8ff85c7795 100644 (file)
--- a/libs/pbd/convert.cc
+++ b/libs/pbd/convert.cc
@@ -19,6 +19,13 @@
 
 #include <cmath>
 #include <stdint.h>
+#include <stdlib.h>
+#include <cstdio>
+#include <ctype.h>
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS
+#endif
+#include <inttypes.h>
 
 #include "pbd/convert.h"
 
@@ -26,9 +33,21 @@
 
 using std::string;
 using std::vector;
+using Glib::ustring;
 
 namespace PBD {
 
+string
+capitalize (const string& str)
+{
+        string ret = str;
+        if (!str.empty()) {
+                /* XXX not unicode safe */
+                ret[0] = toupper (str[0]);
+        }
+        return ret;
+}
+
 string
 short_version (string orig, string::size_type target_length)
 {
@@ -96,13 +115,25 @@ short_version (string orig, string::size_type target_length)
 int
 atoi (const string& s)
 {
-       return std::atoi (s.c_str());
+       return ::atoi (s.c_str());
+}
+
+int32_t
+atol (const string& s)
+{
+       return (int32_t) ::atol (s.c_str());
+}
+
+int64_t
+atoll (const string& s)
+{
+       return (int64_t) ::atoll (s.c_str());
 }
 
 double
 atof (const string& s)
 {
-       return std::atof (s.c_str());
+       return ::atof (s.c_str());
 }
 
 vector<string>
@@ -190,23 +221,109 @@ url_decode (string& url)
        }
 }
 
+void
+url_decode (ustring& url)
+{
+       ustring::iterator last;
+       ustring::iterator next;
+
+       for (ustring::iterator i = url.begin(); i != url.end(); ++i) {
+               if ((*i) == '+') {
+                       next = i;
+                       ++next;
+                       url.replace (i, next, 1, ' ');
+               }
+       }
+
+       if (url.length() <= 3) {
+               return;
+       }
+
+       last = url.end();
+
+       --last; /* points at last char */
+       --last; /* points at last char - 1 */
+
+       for (ustring::iterator i = url.begin(); i != last; ) {
+
+               if (*i == '%') {
+
+                       next = i;
+
+                       url.erase (i);
+                       
+                       i = next;
+                       ++next;
+                       
+                       if (isxdigit (*i) && isxdigit (*next)) {
+                               /* replace first digit with char */
+                               url.replace (i, next, 1, (gunichar) int_from_hex (*i,*next));
+                               ++i; /* points at 2nd of 2 digits */
+                               url.erase (i);
+                       }
+               } else {
+                       ++i;
+               }
+       }
+}
+
+#if 0
 string
 length2string (const int32_t frames, const float sample_rate)
 {
-    int secs = (int) (frames / sample_rate);
-    int hrs =  secs / 3600;
+    int32_t secs = (int32_t) (frames / sample_rate);
+    int32_t hrs =  secs / 3600;
     secs -= (hrs * 3600);
-    int mins = secs / 60;
+    int32_t mins = secs / 60;
     secs -= (mins * 60);
 
-    int total_secs = (hrs * 3600) + (mins * 60) + secs;
-    int frames_remaining = (int) floor (frames - (total_secs * sample_rate));
+    int32_t total_secs = (hrs * 3600) + (mins * 60) + secs;
+    int32_t frames_remaining = (int) floor (frames - (total_secs * sample_rate));
     float fractional_secs = (float) frames_remaining / sample_rate;
 
     char duration_str[32];
-    sprintf (duration_str, "%02d:%02d:%05.2f", hrs, mins, (float) secs + fractional_secs);
+    sprintf (duration_str, "%02" PRIi32 ":%02" PRIi32 ":%05.2f", hrs, mins, (float) secs + fractional_secs);
 
     return duration_str;
 }
+#endif
+
+string
+length2string (const int64_t frames, const double sample_rate)
+{
+       int64_t secs = (int64_t) floor (frames / sample_rate);
+       int64_t hrs =  secs / 3600LL;
+       secs -= (hrs * 3600LL);
+       int64_t mins = secs / 60LL;
+       secs -= (mins * 60LL);
+       
+       int64_t total_secs = (hrs * 3600LL) + (mins * 60LL) + secs;
+       int64_t frames_remaining = (int64_t) floor (frames - (total_secs * sample_rate));
+       float fractional_secs = (float) frames_remaining / sample_rate;
+       
+       char duration_str[64];
+       sprintf (duration_str, "%02" PRIi64 ":%02" PRIi64 ":%05.2f", hrs, mins, (float) secs + fractional_secs);
+       
+       return duration_str;
+}
+
+static bool 
+chars_equal_ignore_case(char x, char y)
+{
+       /* app should have called setlocale() if its wants this comparison to be
+          locale sensitive.
+       */
+       return toupper (x) == toupper (y);
+}
+
+bool 
+strings_equal_ignore_case (const string& a, const string& b)
+{
+       if (a.length() == b.length()) {
+               return std::equal (a.begin(), a.end(), b.begin(), chars_equal_ignore_case);
+       }
+       return false;
+}
+
 
 } // namespace PBD