Reduce SmallVector and SmallString usage

cameraserver/src/main/native/cpp/cameraserver/CameraServer.cpp

@@ -18,13 +18,11 @@
 #include <networktables/StringArrayTopic.h>
 #include <networktables/StringTopic.h>
 #include <wpi/DenseMap.h>
-#include <wpi/SmallString.h>
 #include <wpi/StringExtras.h>
 #include <wpi/StringMap.h>
 #include <wpi/mutex.h>
 
 #include "cameraserver/CameraServerShared.h"
-#include "ntcore_cpp.h"
 
 using namespace frc;
 
@@ -93,26 +91,14 @@ static Instance& GetInstance() {
   return instance;
 }
 
-static std::string_view MakeSourceValue(CS_Source source,
-                                        wpi::SmallVectorImpl<char>& buf) {
+static std::string MakeSourceValue(CS_Source source) {
   CS_Status status = 0;
-  buf.clear();
   switch (cs::GetSourceKind(source, &status)) {
-    case CS_SOURCE_USB: {
-      std::string_view prefix{"usb:"};
-      buf.append(prefix.begin(), prefix.end());
-      auto path = cs::GetUsbCameraPath(source, &status);
-      buf.append(path.begin(), path.end());
-      break;
-    }
+    case CS_SOURCE_USB:
+      return fmt::format("usb:{}", cs::GetUsbCameraPath(source, &status));
     case CS_SOURCE_HTTP: {
-      std::string_view prefix{"ip:"};
-      buf.append(prefix.begin(), prefix.end());
       auto urls = cs::GetHttpCameraUrls(source, &status);
-      if (!urls.empty()) {
-        buf.append(urls[0].begin(), urls[0].end());
-      }
-      break;
+      return fmt::format("ip:{}", urls.empty() ? "" : urls.front());
     }
     case CS_SOURCE_CV:
       return "cv:";
@@ -121,8 +107,6 @@ static std::string_view MakeSourceValue(CS_Source source,
     default:
       return "unknown:";
   }
-
-  return {buf.begin(), buf.size()};
 }
 
 static std::string MakeStreamValue(std::string_view address, int port) {
@@ -361,10 +345,8 @@ SourcePublisher::SourcePublisher(Instance& inst,
       modeEntry{table->GetStringTopic("mode").GetEntry("")},
       modesPublisher{table->GetStringArrayTopic("modes").Publish()} {
   CS_Status status = 0;
-  wpi::SmallString<64> buf;
-  sourcePublisher.Set(MakeSourceValue(source, buf));
-  wpi::SmallString<64> descBuf;
-  descriptionPublisher.Set(cs::GetSourceDescription(source, descBuf, &status));
+  sourcePublisher.Set(MakeSourceValue(source));
+  descriptionPublisher.Set(cs::GetSourceDescription(source, &status));
   connectedPublisher.Set(cs::IsSourceConnected(source, &status));
   streamsPublisher.Set(inst.GetSourceStreamValues(source));
   auto mode = cs::GetSourceVideoMode(source, &status);
@@ -404,9 +386,8 @@ Instance::Instance() {
           case cs::VideoEvent::kSourceConnected:
             if (auto publisher = GetPublisher(event.sourceHandle)) {
               // update the description too (as it may have changed)
-              wpi::SmallString<64> descBuf;
-              publisher->descriptionPublisher.Set(cs::GetSourceDescription(
-                  event.sourceHandle, descBuf, &status));
+              publisher->descriptionPublisher.Set(
+                  cs::GetSourceDescription(event.sourceHandle, &status));
               publisher->connectedPublisher.Set(true);
             }
             break;
@@ -604,8 +585,7 @@ cs::CvSink CameraServer::GetVideo() {
 
 cs::CvSink CameraServer::GetVideo(const cs::VideoSource& camera) {
   auto& inst = ::GetInstance();
-  wpi::SmallString<64> name{"opencv_"};
-  name += camera.GetName();
+  auto name = fmt::format("opencv_{}", camera.GetName());
 
   {
     std::scoped_lock lock(inst.m_mutex);
@@ -622,7 +602,7 @@ cs::CvSink CameraServer::GetVideo(const cs::VideoSource& camera) {
     }
   }
 
-  cs::CvSink newsink{name.str()};
+  cs::CvSink newsink{name};
   newsink.SetSource(camera);
   AddServer(newsink);
   return newsink;
@@ -631,8 +611,7 @@ cs::CvSink CameraServer::GetVideo(const cs::VideoSource& camera) {
 cs::CvSink CameraServer::GetVideo(const cs::VideoSource& camera,
                                   cs::VideoMode::PixelFormat pixelFormat) {
   auto& inst = ::GetInstance();
-  wpi::SmallString<64> name{"opencv_"};
-  name += camera.GetName();
+  auto name = fmt::format("opencv_{}", camera.GetName());
 
   {
     std::scoped_lock lock(inst.m_mutex);
@@ -649,7 +628,7 @@ cs::CvSink CameraServer::GetVideo(const cs::VideoSource& camera,
     }
   }
 
-  cs::CvSink newsink{name.str(), pixelFormat};
+  cs::CvSink newsink{name, pixelFormat};
   newsink.SetSource(camera);
   AddServer(newsink);
   return newsink;

cscore/src/main/native/cpp/ConfigurableSourceImpl.cpp

@@ -6,6 +6,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include <wpi/timestamp.h>
 
@@ -238,7 +239,7 @@ CS_Property CS_CreateSourcePropertyCallback(
 void CS_SetSourceEnumPropertyChoices(CS_Source source, CS_Property property,
                                      const struct WPI_String* choices,
                                      int count, CS_Status* status) {
-  wpi::SmallVector<std::string, 8> vec;
+  std::vector<std::string> vec;
   vec.reserve(count);
   for (int i = 0; i < count; ++i) {
     vec.emplace_back(wpi::to_string_view(&choices[i]));

cscore/src/main/native/cpp/HttpCameraImpl.cpp

@@ -123,8 +123,7 @@ void HttpCameraImpl::StreamThreadMain() {
     }
 
     // connect
-    wpi::SmallString<64> boundary;
-    wpi::HttpConnection* conn = DeviceStreamConnect(boundary);
+    auto [conn, boundary] = DeviceStreamConnect();
 
     if (!m_active) {
       break;
@@ -139,7 +138,7 @@ void HttpCameraImpl::StreamThreadMain() {
     SetConnected(true);
 
     // stream
-    DeviceStream(conn->is, boundary.str());
+    DeviceStream(conn->is, boundary);
     {
       std::unique_lock lock(m_mutex);
       m_streamConn = nullptr;
@@ -150,16 +149,16 @@ void HttpCameraImpl::StreamThreadMain() {
   SetConnected(false);
 }
 
-wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
-    wpi::SmallVectorImpl<char>& boundary) {
+std::pair<wpi::HttpConnection*, std::string>
+HttpCameraImpl::DeviceStreamConnect() {
   // Build the request
   wpi::HttpRequest req;
   {
     std::scoped_lock lock(m_mutex);
     if (m_locations.empty()) {
       SERROR("locations array is empty!?");
       std::this_thread::sleep_for(std::chrono::seconds(1));
-      return nullptr;
+      return {};
     }
     if (m_nextLocation >= m_locations.size()) {
       m_nextLocation = 0;
@@ -173,7 +172,7 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
       wpi::TCPConnector::connect(req.host.c_str(), req.port, m_logger, 1);
 
   if (!m_active || !stream) {
-    return nullptr;
+    return {};
   }
 
   auto connPtr = std::make_unique<wpi::HttpConnection>(std::move(stream), 1);
@@ -191,22 +190,21 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
     SWARNING("{}", warn);
     std::scoped_lock lock(m_mutex);
     m_streamConn = nullptr;
-    return nullptr;
+    return {};
   }
 
   // Parse Content-Type header to get the boundary
-  auto [mediaType, contentType] = wpi::split(conn->contentType.str(), ';');
+  auto [mediaType, contentType] = wpi::split(conn->contentType, ';');
   mediaType = wpi::trim(mediaType);
   if (mediaType != "multipart/x-mixed-replace") {
-    SWARNING("\"{}\": unrecognized Content-Type \"{}\"", req.host.str(),
-             mediaType);
+    SWARNING("\"{}\": unrecognized Content-Type \"{}\"", req.host, mediaType);
     std::scoped_lock lock(m_mutex);
     m_streamConn = nullptr;
-    return nullptr;
+    return {};
   }
 
   // media parameters
-  boundary.clear();
+  std::string boundary;
   while (!contentType.empty()) {
     std::string_view keyvalue;
     std::tie(keyvalue, contentType) = wpi::split(contentType, ';');
@@ -222,14 +220,13 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
   }
 
   if (boundary.empty()) {
-    SWARNING("\"{}\": empty multi-part boundary or no Content-Type",
-             req.host.str());
+    SWARNING("\"{}\": empty multi-part boundary or no Content-Type", req.host);
     std::scoped_lock lock(m_mutex);
     m_streamConn = nullptr;
-    return nullptr;
+    return {};
   }
 
-  return conn;
+  return {conn, boundary};
 }
 
 void HttpCameraImpl::DeviceStream(wpi::raw_istream& is,
@@ -277,26 +274,25 @@ void HttpCameraImpl::DeviceStream(wpi::raw_istream& is,
 bool HttpCameraImpl::DeviceStreamFrame(wpi::raw_istream& is,
                                        std::string& imageBuf) {
   // Read the headers
-  wpi::SmallString<64> contentTypeBuf;
-  wpi::SmallString<64> contentLengthBuf;
-  if (!ParseHttpHeaders(is, &contentTypeBuf, &contentLengthBuf)) {
+  std::string contentType;
+  std::string contentLength;
+  if (!ParseHttpHeaders(is, &contentType, &contentLength)) {
     SWARNING("disconnected during headers");
     PutError("disconnected during headers", wpi::Now());
     return false;
   }
 
   // Check the content type (if present)
-  if (!contentTypeBuf.str().empty() &&
-      !wpi::starts_with(contentTypeBuf, "image/jpeg")) {
-    auto errMsg = fmt::format("received unknown Content-Type \"{}\"",
-                              contentTypeBuf.str());
+  if (!contentType.empty() && !wpi::starts_with(contentType, "image/jpeg")) {
+    auto errMsg =
+        fmt::format("received unknown Content-Type \"{}\"", contentType);
     SWARNING("{}", errMsg);
     PutError(errMsg, wpi::Now());
     return false;
   }
 
   int width, height;
-  if (auto v = wpi::parse_integer<unsigned int>(contentLengthBuf, 10)) {
+  if (auto v = wpi::parse_integer<unsigned int>(contentLength, 10)) {
     // We know how big it is!  Just get a frame of the right size and read
     // the data directly into it.
     unsigned int contentLength = v.value();
@@ -659,7 +655,7 @@ CS_Source CS_CreateHttpCamera(const struct WPI_String* name,
 CS_Source CS_CreateHttpCameraMulti(const struct WPI_String* name,
                                    const struct WPI_String* urls, int count,
                                    CS_HttpCameraKind kind, CS_Status* status) {
-  wpi::SmallVector<std::string, 4> vec;
+  std::vector<std::string> vec;
   vec.reserve(count);
   for (int i = 0; i < count; ++i) {
     vec.emplace_back(wpi::to_string_view(&urls[i]));
@@ -673,7 +669,7 @@ CS_HttpCameraKind CS_GetHttpCameraKind(CS_Source source, CS_Status* status) {
 
 void CS_SetHttpCameraUrls(CS_Source source, const struct WPI_String* urls,
                           int count, CS_Status* status) {
-  wpi::SmallVector<std::string, 4> vec;
+  std::vector<std::string> vec;
   vec.reserve(count);
   for (int i = 0; i < count; ++i) {
     vec.emplace_back(wpi::to_string_view(&urls[i]));

cscore/src/main/native/cpp/HttpCameraImpl.h

@@ -13,6 +13,7 @@
 #include <string>
 #include <string_view>
 #include <thread>
+#include <utility>
 #include <vector>
 
 #include <wpi/StringMap.h>
@@ -99,8 +100,7 @@ class HttpCameraImpl : public SourceImpl {
   void StreamThreadMain();
 
   // Functions used by StreamThreadMain()
-  wpi::HttpConnection* DeviceStreamConnect(
-      wpi::SmallVectorImpl<char>& boundary);
+  std::pair<wpi::HttpConnection*, std::string> DeviceStreamConnect();
   void DeviceStream(wpi::raw_istream& is, std::string_view boundary);
   bool DeviceStreamFrame(wpi::raw_istream& is, std::string& imageBuf);
 

cscore/src/main/native/cpp/Instance.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include <wpi/Logger.h>
 #include <wpinet/EventLoopRunner.h>
@@ -86,18 +87,16 @@ class Instance {
   void DestroySource(CS_Source handle);
   void DestroySink(CS_Sink handle);
 
-  std::span<CS_Source> EnumerateSourceHandles(
-      wpi::SmallVectorImpl<CS_Source>& vec) {
-    return m_sources.GetAll(vec);
+  std::vector<CS_Source> EnumerateSourceHandles() {
+    return m_sources.GetAll<CS_Source>();
   }
 
-  std::span<CS_Sink> EnumerateSinkHandles(wpi::SmallVectorImpl<CS_Sink>& vec) {
-    return m_sinks.GetAll(vec);
+  std::vector<CS_Sink> EnumerateSinkHandles() {
+    return m_sinks.GetAll<CS_Sink>();
   }
 
-  std::span<CS_Sink> EnumerateSourceSinks(CS_Source source,
-                                          wpi::SmallVectorImpl<CS_Sink>& vec) {
-    vec.clear();
+  std::vector<CS_Sink> EnumerateSourceSinks(CS_Source source) {
+    std::vector<CS_Sink> vec;
     m_sinks.ForEach([&](CS_Sink sinkHandle, const SinkData& data) {
       if (source == data.sourceHandle.load()) {
         vec.push_back(sinkHandle);