str::format changes from CODA-OSS

Dan Smith · Dan Smith · commit 02e1917799c7 · 2023-08-28T14:39:22.000-04:00
diff --git a/externals/coda-oss/modules/c++/cli/include/cli/Value.h b/externals/coda-oss/modules/c++/cli/include/cli/Value.h
@@ -106,10 +106,7 @@ class CODA_OSS_API Value
     {
         if (index >= mValues.size())
             throw except::IndexOutOfRangeException(
-                                                   Ctxt(
-                                                        FmtX(
-                                                             "Invalid index: %d",
-                                                             index)));
+                                                   Ctxt(FmtX("Invalid index: %d", index)));
         return str::toType<T>(mValues[index]);
     }
 
diff --git a/externals/coda-oss/modules/c++/cli/source/ArgumentParser.cpp b/externals/coda-oss/modules/c++/cli/source/ArgumentParser.cpp
@@ -317,8 +317,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog
                 std::map<std::string, Argument*>& flagMap =
                         (subOption ? shortOptionsFlags : shortFlags);
                 if (flagMap.find(op) != flagMap.end())
-                    parseError(FmtX("Conflicting option: %c%s", mPrefixChar,
-                                    op.c_str()));
+                    parseError(FmtX("Conflicting option: %c%s", mPrefixChar, op));
                 flagMap[op] = arg;
             }
             for (std::vector<std::string>::const_iterator it =
@@ -328,8 +327,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog
                 std::map<std::string, Argument*>& flagMap =
                         (subOption ? longOptionsFlags : longFlags);
                 if (flagMap.find(op) != flagMap.end())
-                    parseError(FmtX("Conflicting option: %c%c%s", mPrefixChar,
-                                    mPrefixChar, op.c_str()));
+                    parseError(FmtX("Conflicting option: %c%c%s", mPrefixChar, mPrefixChar, op));
                 flagMap[op] = arg;
             }
         }
@@ -458,8 +456,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog
                     }
                     else
                     {
-                        throw except::Exception(Ctxt(
-                                FmtX("Invalid option: [%s]", argStr.c_str())));
+                        throw except::Exception(Ctxt(FmtX("Invalid option: [%s]", argStr)));
                     }
                 }
             }
@@ -500,8 +497,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog
                     }
                     else
                     {
-                        throw except::Exception(Ctxt(
-                                FmtX("Invalid option: [%s]", argStr.c_str())));
+                        throw except::Exception(Ctxt(FmtX("Invalid option: [%s]", argStr)));
                     }
 
                 }
@@ -549,10 +545,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog
                 }
 
                 if (!added)
-                    parseError(
-                               FmtX(
-                                    "option requires value or has exceeded its max: [%s]",
-                                    argVar.c_str()));
+                    parseError(FmtX("option requires value or has exceeded its max: [%s]", argVar));
 
                 currentResults->put(argVar, v);
                 break;
@@ -677,11 +670,9 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog
         if (arg->isRequired() || numGiven > 0)
         {
             if (minArgs > 0 && numGiven < static_cast<size_t>(minArgs))
-                parseError(FmtX("not enough arguments, %d required: [%s]",
-                                minArgs, argId.c_str()));
+                parseError(FmtX("not enough arguments, %d required: [%s]", minArgs, argId));
             if (maxArgs >= 0 && numGiven > static_cast<size_t>(maxArgs))
-                parseError(FmtX("too many arguments, %d supported: [%s]",
-                                maxArgs, argId.c_str()));
+                parseError(FmtX("too many arguments, %d supported: [%s]", maxArgs, argId));
         }
 
 
diff --git a/externals/coda-oss/modules/c++/pch.h b/externals/coda-oss/modules/c++/pch.h
@@ -103,10 +103,10 @@ CODA_OSS_disable_warning_pop
 // change we want to rebuild everything anyway.
 #include "gsl/gsl.h"
 #include "config/Exports.h"
+#include "mem/SharedPtr.h"
+#include "sys/filesystem.h"
 #include "except/Throwable.h"
 #include "sys/Conf.h"
-#include "sys/filesystem.h"
-#include "mem/SharedPtr.h"
 
 #include "xml/lite/xerces_.h"
 #pragma comment(lib, "xerces-c")
diff --git a/externals/coda-oss/modules/c++/plugin/include/plugin/BasicPluginManager.h b/externals/coda-oss/modules/c++/plugin/include/plugin/BasicPluginManager.h
@@ -279,7 +279,7 @@ template<typename T> class BasicPluginManager
                 for (unsigned int i = 0; ops[i] != nullptr; i++)
                     oss << ops[i] << ":";
                 eh->onPluginVersionUnsupported(
-                    FmtX("For plugin supporting ops %s version [%d.%d] not supported (%d.%d)",
+                    str::Format("For plugin supporting ops %s version [%d.%d] not supported (%d.%d)",
                          oss.str().c_str(), majorVersion, minorVersion,
                          mMajorVersion, mMinorVersion
                         )
diff --git a/externals/coda-oss/modules/c++/str/include/str/Format.h b/externals/coda-oss/modules/c++/str/include/str/Format.h
@@ -21,23 +21,20 @@
  */
 
 
-#ifndef __STR_FORMAT_H__
-#define __STR_FORMAT_H__
+#pragma once
+#ifndef CODA_OSS_str_Format_h_INCLUDED_
+#define CODA_OSS_str_Format_h_INCLUDED_
 
 #include <stdarg.h>
+#include<stdint.h>
+#include<stddef.h>
+
 #include <string>
 
 #include "config/Exports.h"
 
 namespace str
 {
-
-/*!
- *  \param format  The format
- *  \param ... Any printf like thing
- */
-CODA_OSS_API std::string format(const char* format, ...);
-
 struct CODA_OSS_API Format final
 {
     Format(const char* format, ...);
@@ -47,14 +44,95 @@ struct CODA_OSS_API Format final
         return mString;
     }
 
-    operator std::string& () noexcept
-    {
-        return mString;
-    }
-
-protected:
+private:
     std::string mString;
 };
 
+/*!
+ *  \param format  The format
+ *  \param ... Any printf like thing
+ */
+//CODA_OSS_API std::string format(const char* format, ...);
+
+inline std::string format(const char* format)
+{
+    return Format(format);
+}
+
+inline std::string format(const char* format, const char* pStr)
+{
+    return Format(format, pStr);
+}
+inline std::string format(const char* format, const std::string& s)
+{
+    return Format(format, s.c_str());
+}
+inline std::string format(const char* format, int i)
+{
+    return Format(format, i);
+}
+inline std::string format(const char* format, uint32_t i)
+{
+    return Format(format, i);
+}
+inline std::string format(const char* format, ptrdiff_t l)
+{
+    return Format(format, l);
+}
+inline std::string format(const char* format, size_t ul)
+{
+    return Format(format, ul);
+}
+inline std::string format(const char* format, float f)
+{
+    return Format(format, f);
+}
+
+inline std::string format(const char* format, char ch, const char* pStr)
+{
+    return Format(format, ch, pStr);
+}
+inline std::string format(const char* format, char ch, const std::string& s)
+{
+    return Format(format, ch, s.c_str());
+}
+inline std::string format(const char* format, const std::string& s1, const std::string& s2)
+{
+    return Format(format, s1.c_str(), s2.c_str());
+}
+inline std::string format(const char* format, const std::string& s, size_t ul)
+{
+    return Format(format, s.c_str(), ul);
+}
+inline std::string format(const char* format, char ch1, char ch2)
+{
+    return Format(format, ch1, ch2);
+}
+inline std::string format(const char* format, size_t ul1, size_t ul2)
+{
+    return Format(format, ul1, ul2);
+}
+inline std::string format(const char* format, int i, const std::string& s)
+{
+    return Format(format, i, s.c_str());
+}
+inline std::string format(const char* format, int i, const char* pStr)
+{
+    return Format(format, i, pStr);
+}
+
+inline std::string format(const char* format, char ch1, char ch2, const std::string& s)
+{
+    return Format(format, ch1, ch2, s.c_str());
+}
+inline std::string format(const char* format, int i1, int i2, unsigned long ul)
+{
+    return Format(format, i1, i2, ul);
+}
+inline std::string format(const char* format, const std::string& s1, const std::string& s2, uint32_t ui)
+{
+    return Format(format, s1.c_str(), s2.c_str(), ui);
+}
+
 }
-#endif
+#endif  // CODA_OSS_str_Format_h_INCLUDED_
diff --git a/externals/coda-oss/modules/c++/str/source/Format.cpp b/externals/coda-oss/modules/c++/str/source/Format.cpp
@@ -51,14 +51,14 @@ inline void va_end_(va_list& args)
     CODA_OSS_disable_warning_pop
 }
 
-std::string str::format(const char *format, ...)
-{
-    va_list args;
-    va_start(args, format);
-    auto retval = vformat(format, args);
-    va_end_(args);
-    return retval;
-}
+//std::string str::format(const char *format, ...)
+//{
+//    va_list args;
+//    va_start(args, format);
+//    auto retval = vformat(format, args);
+//    va_end_(args);
+//    return retval;
+//}
 
 str::Format::Format(const char* format, ...)
 {
diff --git a/externals/coda-oss/modules/c++/sys/source/OSUnix.cpp b/externals/coda-oss/modules/c++/sys/source/OSUnix.cpp
@@ -143,7 +143,7 @@ std::string sys::OSUnix::getPlatformName() const
     if (uname(&name) == -1)
         throw sys::SystemException("Uname failed");
 
-    return FmtX("%s (%s): %s [build: %s]", name.sysname, name.machine,
+    return str::Format("%s (%s): %s [build: %s]", name.sysname, name.machine,
                 name.release, name.version);
 }
 
diff --git a/externals/coda-oss/modules/c++/sys/source/OSWin32.cpp b/externals/coda-oss/modules/c++/sys/source/OSWin32.cpp
@@ -58,7 +58,7 @@ std::string sys::OSWin32::getPlatformName() const
     {
         platform = "Unknown Windows OS";
     }
-    return FmtX("%s: %d.%d [build: %d], %s", platform.c_str(),
+    return str::Format("%s: %d.%d [build: %d], %s", platform.c_str(),
                 info.dwMajorVersion, info.dwMinorVersion, info.dwBuildNumber,
                 info.szCSDVersion);
 }
diff --git a/externals/coda-oss/modules/c++/xml.lite/source/Attributes.cpp b/externals/coda-oss/modules/c++/xml.lite/source/Attributes.cpp
@@ -152,8 +152,7 @@ std::string xml::lite::Attributes::getValue(const QName& qname) const
     {
         const auto uri = qname.getUri().value;
         const auto localName = qname.getName();
-        throw except::NoSuchKeyException(Ctxt(FmtX("(uri: %s, localName: %s",
-                                                   uri.c_str(), localName.c_str())));
+        throw except::NoSuchKeyException(Ctxt(FmtX("(uri: %s, localName: %s", uri, localName)));
     }
     return retval;
 }
diff --git a/externals/nitro/modules/c++/nitf/include/nitf/Enum.hpp b/externals/nitro/modules/c++/nitf/include/nitf/Enum.hpp
@@ -32,6 +32,7 @@
 #include <new> // std::nothrow
 
 #include "str/Manip.h"
+#include "str/Encoding.h"
 
 namespace nitf
 {
diff --git a/externals/nitro/modules/c++/nitf/tests/test_extract.cpp b/externals/nitro/modules/c++/nitf/tests/test_extract.cpp
@@ -44,7 +44,7 @@ static  std::vector<std::string> extract_image(const nitf::ImageSubheader& subhe
     size_t band = 0;
     for (const auto& data : bandData) // for band, data in enumerate(bandData):
     {
-        auto outName = str::format("%s_%d__%d_x_%d_%d_band_%d.out",
+        std::string outName = str::Format("%s_%d__%d_x_%d_%d_band_%d.out",
             baseName.c_str(), index, window.getNumRows(), window.getNumCols(), static_cast<int>(nbpp), static_cast<int>(band));
         outName = sys::Path::joinPaths(outDir, outName);
         auto f = fopen(outName.c_str(), "wb"); // f = open(outName, "wb");
diff --git a/externals/nitro/modules/c++/nitf/tests/test_j2k_nitf_read_region.cpp b/externals/nitro/modules/c++/nitf/tests/test_j2k_nitf_read_region.cpp
@@ -47,7 +47,7 @@
 void writeFile(uint32_t x0, uint32_t y0,
     uint32_t x1, uint32_t y1, std::span<const uint8_t> buf, const std::string& prefix)
 {
-    const auto filename = str::format("%s-raw-%d_%d__%d_%d.out", prefix.c_str(), x0, y0, x1, y1);
+    const std::string filename = str::Format("%s-raw-%d_%d__%d_%d.out", prefix.c_str(), x0, y0, x1, y1);
     nitf::IOHandle outHandle(filename, NRT_ACCESS_WRITEONLY, NRT_CREATE);
     outHandle.write(buf.data(), buf.size());
     printf("Wrote file: %s\n", filename.c_str());
@@ -57,7 +57,7 @@ void writeJ2K(uint32_t x0, uint32_t y0,
     uint32_t x1, uint32_t y1, std::span<const uint8_t> buf,
     const j2k::Container& inContainer, const std::string& prefix)
 {
-    const auto outName = str::format("%s-raw-%d_%d__%d_%d.j2k", prefix.c_str(), x0, y0, x1, y1);
+    const std::string outName = str::Format("%s-raw-%d_%d__%d_%d.j2k", prefix.c_str(), x0, y0, x1, y1);
 
     const auto num_x_tiles = inContainer.getTilesX();
     const auto num_y_tiles = inContainer.getTilesY();
diff --git a/externals/nitro/modules/c++/nitf/unittests/test_j2k_loading++.cpp b/externals/nitro/modules/c++/nitf/unittests/test_j2k_loading++.cpp
@@ -168,7 +168,7 @@ TEST_CASE(test_j2k_nitf)
 void writeFile(uint32_t x0, uint32_t y0,
     uint32_t x1, uint32_t y1, std::span<const uint8_t> buf, const std::string& prefix)
 {
-    const auto filename = str::format("%s-raw-%d_%d__%d_%d.out", prefix.c_str(), x0, y0, x1, y1);
+    const std::string filename = str::Format("%s-raw-%d_%d__%d_%d.out", prefix.c_str(), x0, y0, x1, y1);
     nitf::IOHandle outHandle(filename, NRT_ACCESS_WRITEONLY, NRT_CREATE);
     outHandle.write(buf.data(), buf.size());
     //printf("Wrote file: %s\n", filename.c_str());
@@ -177,7 +177,7 @@ void writeJ2K(uint32_t x0, uint32_t y0,
     uint32_t x1, uint32_t y1, std::span<const uint8_t> buf,
     const j2k::Container& inContainer, const std::string& prefix)
 {
-    const auto outName = str::format("%s-raw-%d_%d__%d_%d.j2k", prefix.c_str(), x0, y0, x1, y1);
+    const std::string outName = str::Format("%s-raw-%d_%d__%d_%d.j2k", prefix.c_str(), x0, y0, x1, y1);
 
     const auto num_x_tiles = inContainer.getTilesX();
     const auto num_y_tiles = inContainer.getTilesY();
diff --git a/six/modules/c++/samples/test_dump_images.cpp b/six/modules/c++/samples/test_dump_images.cpp
@@ -161,7 +161,7 @@ int main(int argc, char** argv)
         for (size_t i = 0, total = container->size(); i < total; ++i)
         {
             const six::Data* data = container->getData(i);
-            std::string filename = FmtX("%s_DES_%d.xml", base.c_str(), i);
+            std::string filename = FmtX("%s_DES_%d.xml", base.string(), i);
             const auto xmlFile = fs::path(outputDir) / filename;
             io::FileOutputStream xmlStream(xmlFile.string());
 
diff --git a/six/modules/c++/samples/test_parse_xml.cpp b/six/modules/c++/samples/test_parse_xml.cpp
@@ -95,7 +95,7 @@ std::vector<std::string> extractXML(std::string inputFile,
         nitf::Off size = deReader.getSize();
 
         const auto typeID = subheader.typeID();
-        const std::string outputFile = FmtX("%s-%s%d.xml", prefix.c_str(), typeID.c_str(), i);
+        const std::string outputFile = FmtX("%s-%s%d.xml", prefix, typeID, i);
         const auto fileName = outputDir / outputFile;
         {
             std::vector<char> xml(size);

Original file line number	Diff line number	Diff line change
`@@ -106,10 +106,7 @@ class CODA_OSS_API Value`
`106`	`106`	`{`
`107`	`107`	`if (index >= mValues.size())`
`108`	`108`	`throw except::IndexOutOfRangeException(`
`109`		`- Ctxt(`
`110`		`- FmtX(`
`111`		`- "Invalid index: %d",`
`112`		`- index)));`
	`109`	`+ Ctxt(FmtX("Invalid index: %d", index)));`
`113`	`110`	`return str::toType<T>(mValues[index]);`
`114`	`111`	`}`
`115`	`112`
Original file line number	Diff line number	Diff line change
`@@ -317,8 +317,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog`
`317`	`317`	`std::map<std::string, Argument*>& flagMap =`
`318`	`318`	`(subOption ? shortOptionsFlags : shortFlags);`
`319`	`319`	`if (flagMap.find(op) != flagMap.end())`
`320`		`- parseError(FmtX("Conflicting option: %c%s", mPrefixChar,`
`321`		`- op.c_str()));`
	`320`	`+ parseError(FmtX("Conflicting option: %c%s", mPrefixChar, op));`
`322`	`321`	`flagMap[op] = arg;`
`323`	`322`	`}`
`324`	`323`	`for (std::vector<std::string>::const_iterator it =`
`@@ -328,8 +327,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog`
`328`	`327`	`std::map<std::string, Argument*>& flagMap =`
`329`	`328`	`(subOption ? longOptionsFlags : longFlags);`
`330`	`329`	`if (flagMap.find(op) != flagMap.end())`
`331`		`- parseError(FmtX("Conflicting option: %c%c%s", mPrefixChar,`
`332`		`- mPrefixChar, op.c_str()));`
	`330`	`+ parseError(FmtX("Conflicting option: %c%c%s", mPrefixChar, mPrefixChar, op));`
`333`	`331`	`flagMap[op] = arg;`
`334`	`332`	`}`
`335`	`333`	`}`
`@@ -458,8 +456,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog`
`458`	`456`	`}`
`459`	`457`	`else`
`460`	`458`	`{`
`461`		`- throw except::Exception(Ctxt(`
`462`		`- FmtX("Invalid option: [%s]", argStr.c_str())));`
	`459`	`+ throw except::Exception(Ctxt(FmtX("Invalid option: [%s]", argStr)));`
`463`	`460`	`}`
`464`	`461`	`}`
`465`	`462`	`}`
`@@ -500,8 +497,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog`
`500`	`497`	`}`
`501`	`498`	`else`
`502`	`499`	`{`
`503`		`- throw except::Exception(Ctxt(`
`504`		`- FmtX("Invalid option: [%s]", argStr.c_str())));`
	`500`	`+ throw except::Exception(Ctxt(FmtX("Invalid option: [%s]", argStr)));`
`505`	`501`	`}`
`506`	`502`
`507`	`503`	`}`
`@@ -549,10 +545,7 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog`
`549`	`545`	`}`
`550`	`546`
`551`	`547`	`if (!added)`
`552`		`- parseError(`
`553`		`- FmtX(`
`554`		`- "option requires value or has exceeded its max: [%s]",`
`555`		`- argVar.c_str()));`
	`548`	`+ parseError(FmtX("option requires value or has exceeded its max: [%s]", argVar));`
`556`	`549`
`557`	`550`	`currentResults->put(argVar, v);`
`558`	`551`	`break;`
`@@ -677,11 +670,9 @@ std::unique_ptr<cli::Results> cli::ArgumentParser::parse(const std::string& prog`
`677`	`670`	`if (arg->isRequired() \|\| numGiven > 0)`
`678`	`671`	`{`
`679`	`672`	`if (minArgs > 0 && numGiven < static_cast<size_t>(minArgs))`
`680`		`- parseError(FmtX("not enough arguments, %d required: [%s]",`
`681`		`- minArgs, argId.c_str()));`
	`673`	`+ parseError(FmtX("not enough arguments, %d required: [%s]", minArgs, argId));`
`682`	`674`	`if (maxArgs >= 0 && numGiven > static_cast<size_t>(maxArgs))`
`683`		`- parseError(FmtX("too many arguments, %d supported: [%s]",`
`684`		`- maxArgs, argId.c_str()));`
	`675`	`+ parseError(FmtX("too many arguments, %d supported: [%s]", maxArgs, argId));`
`685`	`676`	`}`
`686`	`677`
`687`	`678`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ template<typename T> class BasicPluginManager`
`279`	`279`	`for (unsigned int i = 0; ops[i] != nullptr; i++)`
`280`	`280`	`oss << ops[i] << ":";`
`281`	`281`	`eh->onPluginVersionUnsupported(`
`282`		`- FmtX("For plugin supporting ops %s version [%d.%d] not supported (%d.%d)",`
	`282`	`+ str::Format("For plugin supporting ops %s version [%d.%d] not supported (%d.%d)",`
`283`	`283`	`oss.str().c_str(), majorVersion, minorVersion,`
`284`	`284`	`mMajorVersion, mMinorVersion`
`285`	`285`	`)`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ std::string sys::OSUnix::getPlatformName() const`
`143`	`143`	`if (uname(&name) == -1)`
`144`	`144`	`throw sys::SystemException("Uname failed");`
`145`	`145`
`146`		`- return FmtX("%s (%s): %s [build: %s]", name.sysname, name.machine,`
	`146`	`+ return str::Format("%s (%s): %s [build: %s]", name.sysname, name.machine,`
`147`	`147`	`name.release, name.version);`
`148`	`148`	`}`
`149`	`149`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ std::string sys::OSWin32::getPlatformName() const`
`58`	`58`	`{`
`59`	`59`	`platform = "Unknown Windows OS";`
`60`	`60`	`}`
`61`		`- return FmtX("%s: %d.%d [build: %d], %s", platform.c_str(),`
	`61`	`+ return str::Format("%s: %d.%d [build: %d], %s", platform.c_str(),`
`62`	`62`	`info.dwMajorVersion, info.dwMinorVersion, info.dwBuildNumber,`
`63`	`63`	`info.szCSDVersion);`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,8 +152,7 @@ std::string xml::lite::Attributes::getValue(const QName& qname) const`
`152`	`152`	`{`
`153`	`153`	`const auto uri = qname.getUri().value;`
`154`	`154`	`const auto localName = qname.getName();`
`155`		`- throw except::NoSuchKeyException(Ctxt(FmtX("(uri: %s, localName: %s",`
`156`		`- uri.c_str(), localName.c_str())));`
	`155`	`+ throw except::NoSuchKeyException(Ctxt(FmtX("(uri: %s, localName: %s", uri, localName)));`
`157`	`156`	`}`
`158`	`157`	`return retval;`
`159`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@`
`32`	`32`	`#include <new> // std::nothrow`
`33`	`33`
`34`	`34`	`#include "str/Manip.h"`
	`35`	`+#include "str/Encoding.h"`
`35`	`36`
`36`	`37`	`namespace nitf`
`37`	`38`	`{`