comparison vamp-stubber/stubber.cpp @ 238:0664784566d8

Generate plausible metadata names; emit empty type URIs for outputs that
don't have any (to make the structure clearer)

 
 static void usage(bool successful = false)
 {
     cerr << "\n" << myname <<
         ": Emit stub version of main code\nfor a Piper Adapter implementation of a Vamp plugin library\n\n"
-        "    Usage: " << myname << " [-d] <soname>\n"
+        "    Usage: " << myname << " [-d] <libname>\n"
         "           " << myname << " -v\n"
         "           " << myname << " -h\n\n"
         "    where\n"
-        "       <soname>: the Vamp plugin library name to emit stub conversion code for\n"
-        "       -d: also print debug information to stderr\n"
+        "       <libname>: the Vamp plugin library name to emit stub conversion code for\n"
         "       -v: print version number to stdout and exit\n"
         "       -h: print this text to stderr and exit\n\n";
     if (successful) exit(0);
     else exit(2);
 }

     dup2(normalFd, 1);
 #endif
 }
 
 ListResponse
-makeRequest(string soname, bool debug)
+makeRequest(string libname)
 {
     ListRequest req;
-    req.from.push_back(soname);
+    req.from.push_back(libname);
     return LoaderRequests().listPluginData(req);
 }
 
 struct PlausibleMetadata
 {

 };
 
 PlausibleMetadata
 inventPlausibleMetadata(string key)
 {
+    string className, adapterName;
+    bool initial = true, interCap = false;
+
+    int idIdx = 0;
+    for (int i = 0; i < int(key.size()); ++i) {
+        char c = key[i];
+        if (c == ':') {
+            idIdx = i + 1;
+            break;
+        }
+    }
+    
+    for (int i = idIdx; i < int(key.size()); ++i) {
+        char c = key[i];
+        if (isalpha(c)) {
+            if (initial || interCap) {
+                className += toupper(c);
+            } else {
+                className += c;
+            }
+            if (interCap) {
+                adapterName += toupper(c);
+            } else {
+                adapterName += c;
+            }
+            interCap = false;
+        } else {
+            interCap = true;
+        }
+        initial = false;
+    }
+    adapterName += "Adapter";
+    
     PlausibleMetadata pm;
-    pm.className = "MyPlugin";//!!!
-    pm.adapterName = "myPluginAdapter";//!!!
+    pm.className = className;
+    pm.adapterName = adapterName;
     return pm;
 }
 
 void
-emitFor(string soname, const ListResponse &resp, bool debug)
+emitFor(string libname, const ListResponse &resp)
 {
     cout <<
         "\n#include \"PiperExport.h\"\n"
         "\n"
         "// #include your own plugin headers here\n"
         "\n"
         "using piper_vamp_js::PiperAdapter;\n"
         "using piper_vamp_js::PiperPluginLibrary;\n"
         "\n"
-        "static std::string soname(\"" << soname << "\");\n"
+        "static std::string libname(\"" << libname << "\");\n"
         "\n";
 
     // The same plugin key may appear more than once in the available
     // list, if the same plugin is installed in more than one location
     // on the Vamp path. To avoid emitting its wrapper definition

         PlausibleMetadata pm = inventPlausibleMetadata(key);
         cout << "static PiperAdapter<"
              << pm.className
              << "> // replace with the actual Vamp plugin class name for \""
              << plugin.basic.identifier << "\" plugin\n" << pm.adapterName
-             << "(\n    soname,\n    ";
+             << "(\n    libname,\n    ";
         
         string catString = "{ ";
         bool first = true;
         for (auto c: plugin.category) {
             if (!first) catString += ", ";

         catString += " }";
         cout << catString << ",\n    ";
 
         cout << "{\n    ";
         first = true;
-        for (auto o: plugin.staticOutputInfo) {
+        for (auto o: plugin.basicOutputInfo) {
             if (!first) {
                 cout << ",\n    ";
             }
             cout << "    ";
-            string outputId = o.first;
-            const StaticOutputDescriptor &desc = o.second;
-            cout << "{ \"" << outputId << "\",\n            { \""
-                 << desc.typeURI << "\" }\n        }";
+            string outputId = o.identifier;
+            cout << "{ \"" << outputId << "\",\n            { \"";
+            if (plugin.staticOutputInfo.find(outputId) !=
+                plugin.staticOutputInfo.end()) {
+                cout << plugin.staticOutputInfo.at(outputId).typeURI;
+            }
+            cout << "\" }\n        }";
             first = false;
         }
         cout << "\n    }\n";
         cout << "    );\n\n";
         emitted.insert(key);

 {
     if (argc != 2 && argc != 3) {
         usage();
     }
 
-    bool debug = false;
-    
     string arg = argv[1];
     if (arg == "-h") {
         if (argc == 2) {
             usage(true);
         } else {

         if (argc == 2) {
             version();
         } else {
             usage();
         }
-    } else if (arg == "-d") {
-        if (argc == 2) {
-            usage();
-        } else {
-            debug = true;
-            arg = argv[2];
-        }
-    }
-    
-    string soname = arg;
+    }
+    
+    string libname = arg;
 
     try {            
         initFds(false);
     } catch (exception &e) {
         cerr << "ERROR: " << e.what() << endl;
         exit(1);
     }
 
     suspendOutput();
 
-    ListResponse resp = makeRequest(soname, debug);
+    ListResponse resp = makeRequest(libname);
 
     resumeOutput();
 
-    emitFor(soname, resp, debug);
+    emitFor(libname, resp);
     
     exit(0);
 }