Use std::string_view and fmtlib across all libraries (#3402)

- Twine, StringRef, Format, and NativeFormatting have been removed
- Logging now uses fmtlib style formatting
- Nearly all uses of wpi::outs/errs have been replaced with fmt::print() or
std::puts()/std::fputs() (for unformatted strings).
- A wpi/fmt/raw_ostream.h header has been added to enable
fmt::print() with wpi::raw_ostream

wpilibc/src/main/native/cpp/smartdashboard/SmartDashboard.cpp

@@ -44,7 +44,7 @@ void SmartDashboard::init() {
   Singleton::GetInstance();
 }
 
-bool SmartDashboard::ContainsKey(wpi::StringRef key) {
+bool SmartDashboard::ContainsKey(std::string_view key) {
   return Singleton::GetInstance().table->ContainsKey(key);
 }
 
@@ -52,39 +52,39 @@ std::vector<std::string> SmartDashboard::GetKeys(int types) {
   return Singleton::GetInstance().table->GetKeys(types);
 }
 
-void SmartDashboard::SetPersistent(wpi::StringRef key) {
+void SmartDashboard::SetPersistent(std::string_view key) {
   Singleton::GetInstance().table->GetEntry(key).SetPersistent();
 }
 
-void SmartDashboard::ClearPersistent(wpi::StringRef key) {
+void SmartDashboard::ClearPersistent(std::string_view key) {
   Singleton::GetInstance().table->GetEntry(key).ClearPersistent();
 }
 
-bool SmartDashboard::IsPersistent(wpi::StringRef key) {
+bool SmartDashboard::IsPersistent(std::string_view key) {
   return Singleton::GetInstance().table->GetEntry(key).IsPersistent();
 }
 
-void SmartDashboard::SetFlags(wpi::StringRef key, unsigned int flags) {
+void SmartDashboard::SetFlags(std::string_view key, unsigned int flags) {
   Singleton::GetInstance().table->GetEntry(key).SetFlags(flags);
 }
 
-void SmartDashboard::ClearFlags(wpi::StringRef key, unsigned int flags) {
+void SmartDashboard::ClearFlags(std::string_view key, unsigned int flags) {
   Singleton::GetInstance().table->GetEntry(key).ClearFlags(flags);
 }
 
-unsigned int SmartDashboard::GetFlags(wpi::StringRef key) {
+unsigned int SmartDashboard::GetFlags(std::string_view key) {
   return Singleton::GetInstance().table->GetEntry(key).GetFlags();
 }
 
-void SmartDashboard::Delete(wpi::StringRef key) {
+void SmartDashboard::Delete(std::string_view key) {
   Singleton::GetInstance().table->Delete(key);
 }
 
-nt::NetworkTableEntry SmartDashboard::GetEntry(wpi::StringRef key) {
+nt::NetworkTableEntry SmartDashboard::GetEntry(std::string_view key) {
   return Singleton::GetInstance().table->GetEntry(key);
 }
 
-void SmartDashboard::PutData(wpi::StringRef key, Sendable* data) {
+void SmartDashboard::PutData(std::string_view key, Sendable* data) {
   if (!data) {
     throw FRC_MakeError(err::NullParameter, "{}", "value");
   }
@@ -111,7 +111,7 @@ void SmartDashboard::PutData(Sendable* value) {
   }
 }
 
-Sendable* SmartDashboard::GetData(wpi::StringRef key) {
+Sendable* SmartDashboard::GetData(std::string_view key) {
   auto& inst = Singleton::GetInstance();
   std::scoped_lock lock(inst.tablesToDataMutex);
   auto it = inst.tablesToData.find(key);
@@ -121,128 +121,132 @@ Sendable* SmartDashboard::GetData(wpi::StringRef key) {
   return SendableRegistry::GetInstance().GetSendable(it->getValue());
 }
 
-bool SmartDashboard::PutBoolean(wpi::StringRef keyName, bool value) {
+bool SmartDashboard::PutBoolean(std::string_view keyName, bool value) {
   return Singleton::GetInstance().table->GetEntry(keyName).SetBoolean(value);
 }
 
-bool SmartDashboard::SetDefaultBoolean(wpi::StringRef key, bool defaultValue) {
+bool SmartDashboard::SetDefaultBoolean(std::string_view key,
+                                       bool defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultBoolean(
       defaultValue);
 }
 
-bool SmartDashboard::GetBoolean(wpi::StringRef keyName, bool defaultValue) {
+bool SmartDashboard::GetBoolean(std::string_view keyName, bool defaultValue) {
   return Singleton::GetInstance().table->GetEntry(keyName).GetBoolean(
       defaultValue);
 }
 
-bool SmartDashboard::PutNumber(wpi::StringRef keyName, double value) {
+bool SmartDashboard::PutNumber(std::string_view keyName, double value) {
   return Singleton::GetInstance().table->GetEntry(keyName).SetDouble(value);
 }
 
-bool SmartDashboard::SetDefaultNumber(wpi::StringRef key, double defaultValue) {
+bool SmartDashboard::SetDefaultNumber(std::string_view key,
+                                      double defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultDouble(
       defaultValue);
 }
 
-double SmartDashboard::GetNumber(wpi::StringRef keyName, double defaultValue) {
+double SmartDashboard::GetNumber(std::string_view keyName,
+                                 double defaultValue) {
   return Singleton::GetInstance().table->GetEntry(keyName).GetDouble(
       defaultValue);
 }
 
-bool SmartDashboard::PutString(wpi::StringRef keyName, wpi::StringRef value) {
+bool SmartDashboard::PutString(std::string_view keyName,
+                               std::string_view value) {
   return Singleton::GetInstance().table->GetEntry(keyName).SetString(value);
 }
 
-bool SmartDashboard::SetDefaultString(wpi::StringRef key,
-                                      wpi::StringRef defaultValue) {
+bool SmartDashboard::SetDefaultString(std::string_view key,
+                                      std::string_view defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultString(
       defaultValue);
 }
 
-std::string SmartDashboard::GetString(wpi::StringRef keyName,
-                                      wpi::StringRef defaultValue) {
+std::string SmartDashboard::GetString(std::string_view keyName,
+                                      std::string_view defaultValue) {
   return Singleton::GetInstance().table->GetEntry(keyName).GetString(
       defaultValue);
 }
 
-bool SmartDashboard::PutBooleanArray(wpi::StringRef key,
+bool SmartDashboard::PutBooleanArray(std::string_view key,
                                      wpi::ArrayRef<int> value) {
   return Singleton::GetInstance().table->GetEntry(key).SetBooleanArray(value);
 }
 
-bool SmartDashboard::SetDefaultBooleanArray(wpi::StringRef key,
+bool SmartDashboard::SetDefaultBooleanArray(std::string_view key,
                                             wpi::ArrayRef<int> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultBooleanArray(
       defaultValue);
 }
 
 std::vector<int> SmartDashboard::GetBooleanArray(
-    wpi::StringRef key, wpi::ArrayRef<int> defaultValue) {
+    std::string_view key, wpi::ArrayRef<int> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).GetBooleanArray(
       defaultValue);
 }
 
-bool SmartDashboard::PutNumberArray(wpi::StringRef key,
+bool SmartDashboard::PutNumberArray(std::string_view key,
                                     wpi::ArrayRef<double> value) {
   return Singleton::GetInstance().table->GetEntry(key).SetDoubleArray(value);
 }
 
-bool SmartDashboard::SetDefaultNumberArray(wpi::StringRef key,
+bool SmartDashboard::SetDefaultNumberArray(std::string_view key,
                                            wpi::ArrayRef<double> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultDoubleArray(
       defaultValue);
 }
 
 std::vector<double> SmartDashboard::GetNumberArray(
-    wpi::StringRef key, wpi::ArrayRef<double> defaultValue) {
+    std::string_view key, wpi::ArrayRef<double> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).GetDoubleArray(
       defaultValue);
 }
 
-bool SmartDashboard::PutStringArray(wpi::StringRef key,
+bool SmartDashboard::PutStringArray(std::string_view key,
                                     wpi::ArrayRef<std::string> value) {
   return Singleton::GetInstance().table->GetEntry(key).SetStringArray(value);
 }
 
 bool SmartDashboard::SetDefaultStringArray(
-    wpi::StringRef key, wpi::ArrayRef<std::string> defaultValue) {
+    std::string_view key, wpi::ArrayRef<std::string> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultStringArray(
       defaultValue);
 }
 
 std::vector<std::string> SmartDashboard::GetStringArray(
-    wpi::StringRef key, wpi::ArrayRef<std::string> defaultValue) {
+    std::string_view key, wpi::ArrayRef<std::string> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).GetStringArray(
       defaultValue);
 }
 
-bool SmartDashboard::PutRaw(wpi::StringRef key, wpi::StringRef value) {
+bool SmartDashboard::PutRaw(std::string_view key, std::string_view value) {
   return Singleton::GetInstance().table->GetEntry(key).SetRaw(value);
 }
 
-bool SmartDashboard::SetDefaultRaw(wpi::StringRef key,
-                                   wpi::StringRef defaultValue) {
+bool SmartDashboard::SetDefaultRaw(std::string_view key,
+                                   std::string_view defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultRaw(
       defaultValue);
 }
 
-std::string SmartDashboard::GetRaw(wpi::StringRef key,
-                                   wpi::StringRef defaultValue) {
+std::string SmartDashboard::GetRaw(std::string_view key,
+                                   std::string_view defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).GetRaw(defaultValue);
 }
 
-bool SmartDashboard::PutValue(wpi::StringRef keyName,
+bool SmartDashboard::PutValue(std::string_view keyName,
                               std::shared_ptr<nt::Value> value) {
   return Singleton::GetInstance().table->GetEntry(keyName).SetValue(value);
 }
 
-bool SmartDashboard::SetDefaultValue(wpi::StringRef key,
+bool SmartDashboard::SetDefaultValue(std::string_view key,
                                      std::shared_ptr<nt::Value> defaultValue) {
   return Singleton::GetInstance().table->GetEntry(key).SetDefaultValue(
       defaultValue);
 }
 
-std::shared_ptr<nt::Value> SmartDashboard::GetValue(wpi::StringRef keyName) {
+std::shared_ptr<nt::Value> SmartDashboard::GetValue(std::string_view keyName) {
   return Singleton::GetInstance().table->GetEntry(keyName).GetValue();
 }