Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-05 03:21:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

SCRIPT namespace replacements

Browse Source
This commit is contained in:
PJ Reiniger
2025-11-07 20:00:05 -05:00
committed by Peter Johnson
parent ae6c043632
commit 9aca8e0fd6
2622 changed files with 22275 additions and 22275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
datalog/src/main/native/cpp/DataLog.cpp
View File

@@ -25,14 +25,14 @@ static constexpr size_t kRecordMaxHeaderSize = 17;
static void DefaultLog(unsigned int level, const char* file, unsigned int line,
const char* msg) {
if (level > wpi::WPI_LOG_INFO) {
wpi::print(stderr, "DataLog: {}\n", msg);
} else if (level == wpi::WPI_LOG_INFO) {
wpi::print("DataLog: {}\n", msg);
if (level > wpi::util::WPI_LOG_INFO) {
wpi::util::print(stderr, "DataLog: {}\n", msg);
} else if (level == wpi::util::WPI_LOG_INFO) {
wpi::util::print("DataLog: {}\n", msg);
}
}
wpi::Logger DataLog::s_defaultMessageLog{DefaultLog};
wpi::util::Logger DataLog::s_defaultMessageLog{DefaultLog};
template <typename T>
static unsigned int WriteVarInt(uint8_t* buf, T val) {
@@ -56,7 +56,7 @@ static unsigned int WriteRecordHeader(uint8_t* buf, uint32_t entry,
unsigned int payloadLen = WriteVarInt(buf, payloadSize);
buf += payloadLen;
unsigned int timestampLen =
WriteVarInt(buf, timestamp == 0 ? wpi::Now() : timestamp);
WriteVarInt(buf, timestamp == 0 ? wpi::util::Now() : timestamp);
buf += timestampLen;
*origbuf =
((timestampLen - 1) << 4) | ((payloadLen - 1) << 2) | (entryLen - 1);
@@ -78,7 +78,7 @@ void DataLog::StartFile() {
uint8_t* buf = Reserve(m_extraHeader.size() + 12);
static const uint8_t header[] = {'W', 'P', 'I', 'L', 'O', 'G', 0, 1};
std::memcpy(buf, header, 8);
support::endian::write32le(buf + 8, m_extraHeader.size());
wpi::util::support::endian::write32le(buf + 8, m_extraHeader.size());
std::memcpy(buf + 12, m_extraHeader.data(), m_extraHeader.size());
// Existing start and schema data records
@@ -145,7 +145,7 @@ void DataLog::AddSchema(std::string_view name, std::string_view type,
return; // don't add duplicates
}
schemaInfo.data.assign(schema.begin(), schema.end());
wpi::SmallString<128> fullName{"/.schema/"};
wpi::util::SmallString<128> fullName{"/.schema/"};
fullName += name;
int entry = StartImpl(fullName, type, {}, timestamp);
@@ -206,7 +206,7 @@ void DataLog::AppendStartRecord(int id, std::string_view name,
size_t strsize = name.size() + type.size() + metadata.size();
uint8_t* buf = StartRecord(0, timestamp, 5 + 12 + strsize, 5);
*buf++ = impl::kControlStart;
wpi::support::endian::write32le(buf, id);
wpi::util::support::endian::write32le(buf, id);
AppendStringImpl(name);
AppendStringImpl(type);
AppendStringImpl(metadata);
@@ -241,7 +241,7 @@ void DataLog::Finish(int entry, int64_t timestamp) {
}
uint8_t* buf = StartRecord(0, timestamp, 5, 5);
*buf++ = impl::kControlFinish;
wpi::support::endian::write32le(buf, entry);
wpi::util::support::endian::write32le(buf, entry);
}
void DataLog::SetMetadata(int entry, std::string_view metadata,
@@ -256,7 +256,7 @@ void DataLog::SetMetadata(int entry, std::string_view metadata,
}
uint8_t* buf = StartRecord(0, timestamp, 5 + 4 + metadata.size(), 5);
*buf++ = impl::kControlSetMetadata;
wpi::support::endian::write32le(buf, entry);
wpi::util::support::endian::write32le(buf, entry);
AppendStringImpl(metadata);
}
@@ -305,7 +305,7 @@ void DataLog::AppendImpl(std::span<const uint8_t> data) {
void DataLog::AppendStringImpl(std::string_view str) {
uint8_t* buf = Reserve(4);
wpi::support::endian::write32le(buf, str.size());
wpi::util::support::endian::write32le(buf, str.size());
AppendImpl({reinterpret_cast<const uint8_t*>(str.data()), str.size()});
}
@@ -363,7 +363,7 @@ void DataLog::AppendInteger(int entry, int64_t value, int64_t timestamp) {
[[unlikely]] return;
}
uint8_t* buf = StartRecord(entry, timestamp, 8, 8);
wpi::support::endian::write64le(buf, value);
wpi::util::support::endian::write64le(buf, value);
}
void DataLog::AppendFloat(int entry, float value, int64_t timestamp) {
@@ -378,7 +378,7 @@ void DataLog::AppendFloat(int entry, float value, int64_t timestamp) {
if constexpr (std::endian::native == std::endian::little) {
std::memcpy(buf, &value, 4);
} else {
wpi::support::endian::write32le(buf, std::bit_cast<uint32_t>(value));
wpi::util::support::endian::write32le(buf, std::bit_cast<uint32_t>(value));
}
}
@@ -394,7 +394,7 @@ void DataLog::AppendDouble(int entry, double value, int64_t timestamp) {
if constexpr (std::endian::native == std::endian::little) {
std::memcpy(buf, &value, 8);
} else {
wpi::support::endian::write64le(buf, std::bit_cast<uint64_t>(value));
wpi::util::support::endian::write64le(buf, std::bit_cast<uint64_t>(value));
}
}
@@ -477,14 +477,14 @@ void DataLog::AppendIntegerArray(int entry, std::span<const int64_t> arr,
while ((arr.size() * 8) > kBlockSize) {
buf = Reserve(kBlockSize);
for (auto val : arr.subspan(0, kBlockSize / 8)) {
wpi::support::endian::write64le(buf, val);
wpi::util::support::endian::write64le(buf, val);
buf += 8;
}
arr = arr.subspan(kBlockSize / 8);
}
buf = Reserve(arr.size() * 8);
for (auto val : arr) {
wpi::support::endian::write64le(buf, val);
wpi::util::support::endian::write64le(buf, val);
buf += 8;
}
}
@@ -509,14 +509,14 @@ void DataLog::AppendFloatArray(int entry, std::span<const float> arr,
while ((arr.size() * 4) > kBlockSize) {
buf = Reserve(kBlockSize);
for (auto val : arr.subspan(0, kBlockSize / 4)) {
wpi::support::endian::write32le(buf, std::bit_cast<uint32_t>(val));
wpi::util::support::endian::write32le(buf, std::bit_cast<uint32_t>(val));
buf += 4;
}
arr = arr.subspan(kBlockSize / 4);
}
buf = Reserve(arr.size() * 4);
for (auto val : arr) {
wpi::support::endian::write32le(buf, std::bit_cast<uint32_t>(val));
wpi::util::support::endian::write32le(buf, std::bit_cast<uint32_t>(val));
buf += 4;
}
}
@@ -541,14 +541,14 @@ void DataLog::AppendDoubleArray(int entry, std::span<const double> arr,
while ((arr.size() * 8) > kBlockSize) {
buf = Reserve(kBlockSize);
for (auto val : arr.subspan(0, kBlockSize / 8)) {
wpi::support::endian::write64le(buf, std::bit_cast<uint64_t>(val));
wpi::util::support::endian::write64le(buf, std::bit_cast<uint64_t>(val));
buf += 8;
}
arr = arr.subspan(kBlockSize / 8);
}
buf = Reserve(arr.size() * 8);
for (auto val : arr) {
wpi::support::endian::write64le(buf, std::bit_cast<uint64_t>(val));
wpi::util::support::endian::write64le(buf, std::bit_cast<uint64_t>(val));
buf += 8;
}
}
@@ -570,7 +570,7 @@ void DataLog::AppendStringArray(int entry, std::span<const std::string> arr,
[[unlikely]] return;
}
uint8_t* buf = StartRecord(entry, timestamp, size, 4);
wpi::support::endian::write32le(buf, arr.size());
wpi::util::support::endian::write32le(buf, arr.size());
for (auto&& str : arr) {
AppendStringImpl(str);
}
@@ -593,7 +593,7 @@ void DataLog::AppendStringArray(int entry,
[[unlikely]] return;
}
uint8_t* buf = StartRecord(entry, timestamp, size, 4);
wpi::support::endian::write32le(buf, arr.size());
wpi::util::support::endian::write32le(buf, arr.size());
for (auto&& sv : arr) {
AppendStringImpl(sv);
}
@@ -616,7 +616,7 @@ void DataLog::AppendStringArray(int entry,
[[unlikely]] return;
}
uint8_t* buf = StartRecord(entry, timestamp, size, 4);
wpi::support::endian::write32le(buf, arr.size());
wpi::util::support::endian::write32le(buf, arr.size());
for (auto&& sv : arr) {
AppendStringImpl(sv.str);
}
@@ -750,8 +750,8 @@ int WPI_DataLog_Start(struct WPI_DataLog* datalog,
const struct WPI_String* type,
const struct WPI_String* metadata, int64_t timestamp) {
return reinterpret_cast<DataLog*>(datalog)->Start(
wpi::to_string_view(name), wpi::to_string_view(type),
wpi::to_string_view(metadata), timestamp);
wpi::util::to_string_view(name), wpi::util::to_string_view(type),
wpi::util::to_string_view(metadata), timestamp);
}
void WPI_DataLog_Finish(struct WPI_DataLog* datalog, int entry,
@@ -763,7 +763,7 @@ void WPI_DataLog_SetMetadata(struct WPI_DataLog* datalog, int entry,
const struct WPI_String* metadata,
int64_t timestamp) {
reinterpret_cast<DataLog*>(datalog)->SetMetadata(
entry, wpi::to_string_view(metadata), timestamp);
entry, wpi::util::to_string_view(metadata), timestamp);
}
void WPI_DataLog_AppendRaw(struct WPI_DataLog* datalog, int entry,
@@ -846,8 +846,8 @@ void WPI_DataLog_AddSchemaString(struct WPI_DataLog* datalog,
const struct WPI_String* schema,
int64_t timestamp) {
reinterpret_cast<DataLog*>(datalog)->AddSchema(
wpi::to_string_view(name), wpi::to_string_view(type),
wpi::to_string_view(schema), timestamp);
wpi::util::to_string_view(name), wpi::util::to_string_view(type),
wpi::util::to_string_view(schema), timestamp);
}
void WPI_DataLog_AddSchema(struct WPI_DataLog* datalog,
@@ -855,7 +855,7 @@ void WPI_DataLog_AddSchema(struct WPI_DataLog* datalog,
const struct WPI_String* type, const uint8_t* schema,
size_t schema_len, int64_t timestamp) {
reinterpret_cast<DataLog*>(datalog)->AddSchema(
wpi::to_string_view(name), wpi::to_string_view(type),
wpi::util::to_string_view(name), wpi::util::to_string_view(type),
std::span<const uint8_t>{schema, schema_len}, timestamp);
}

14
datalog/src/main/native/cpp/DataLogBackgroundWriter.cpp
View File

@@ -53,7 +53,7 @@ DataLogBackgroundWriter::DataLogBackgroundWriter(std::string_view dir,
: DataLogBackgroundWriter{s_defaultMessageLog, dir, filename, period,
extraHeader} {}
DataLogBackgroundWriter::DataLogBackgroundWriter(wpi::Logger& msglog,
DataLogBackgroundWriter::DataLogBackgroundWriter(wpi::util::Logger& msglog,
std::string_view dir,
std::string_view filename,
double period,
@@ -70,7 +70,7 @@ DataLogBackgroundWriter::DataLogBackgroundWriter(
extraHeader} {}
DataLogBackgroundWriter::DataLogBackgroundWriter(
wpi::Logger& msglog,
wpi::util::Logger& msglog,
std::function<void(std::span<const uint8_t> data)> write, double period,
std::string_view extraHeader)
: DataLog{msglog, extraHeader},
@@ -132,7 +132,7 @@ void DataLogBackgroundWriter::Stop() {
}
static void WriteToFile(fs::file_t f, std::span<const uint8_t> data,
std::string_view filename, wpi::Logger& msglog) {
std::string_view filename, wpi::util::Logger& msglog) {
do {
#ifdef _WIN32
DWORD ret;
@@ -469,8 +469,8 @@ struct WPI_DataLog* WPI_DataLog_CreateBackgroundWriter(
const struct WPI_String* dir, const struct WPI_String* filename,
double period, const struct WPI_String* extraHeader) {
return reinterpret_cast<WPI_DataLog*>(new DataLogBackgroundWriter{
wpi::to_string_view(dir), wpi::to_string_view(filename), period,
wpi::to_string_view(extraHeader)});
wpi::util::to_string_view(dir), wpi::util::to_string_view(filename), period,
wpi::util::to_string_view(extraHeader)});
}
struct WPI_DataLog* WPI_DataLog_CreateBackgroundWriter_Func(
@@ -478,13 +478,13 @@ struct WPI_DataLog* WPI_DataLog_CreateBackgroundWriter_Func(
double period, const struct WPI_String* extraHeader) {
return reinterpret_cast<WPI_DataLog*>(new DataLogBackgroundWriter{
[=](auto data) { write(ptr, data.data(), data.size()); }, period,
wpi::to_string_view(extraHeader)});
wpi::util::to_string_view(extraHeader)});
}
void WPI_DataLog_SetBackgroundWriterFilename(
struct WPI_DataLog* datalog, const struct WPI_String* filename) {
reinterpret_cast<DataLogBackgroundWriter*>(datalog)->SetFilename(
wpi::to_string_view(filename));
wpi::util::to_string_view(filename));
}
} // extern "C"

30
datalog/src/main/native/cpp/DataLogReader.cpp
View File

@@ -17,7 +17,7 @@ static bool ReadString(std::span<const uint8_t>* buf, std::string_view* str) {
*str = {};
return false;
}
uint32_t len = wpi::support::endian::read32le(buf->data());
uint32_t len = wpi::util::support::endian::read32le(buf->data());
if (len > (buf->size() - 4)) {
*str = {};
return false;
@@ -46,7 +46,7 @@ bool DataLogRecord::GetStartData(StartRecordData* out) const {
if (!IsStart()) {
return false;
}
out->entry = wpi::support::endian::read32le(&m_data[1]);
out->entry = wpi::util::support::endian::read32le(&m_data[1]);
auto buf = m_data.subspan(5);
if (!ReadString(&buf, &out->name)) {
return false;
@@ -64,7 +64,7 @@ bool DataLogRecord::GetFinishEntry(int* out) const {
if (!IsFinish()) {
return false;
}
*out = wpi::support::endian::read32le(&m_data[1]);
*out = wpi::util::support::endian::read32le(&m_data[1]);
return true;
}
@@ -72,7 +72,7 @@ bool DataLogRecord::GetSetMetadataData(MetadataRecordData* out) const {
if (!IsSetMetadata()) {
return false;
}
out->entry = wpi::support::endian::read32le(&m_data[1]);
out->entry = wpi::util::support::endian::read32le(&m_data[1]);
auto buf = m_data.subspan(5);
return ReadString(&buf, &out->metadata);
}
@@ -89,7 +89,7 @@ bool DataLogRecord::GetInteger(int64_t* value) const {
if (m_data.size() != 8) {
return false;
}
*value = wpi::support::endian::read64le(m_data.data());
*value = wpi::util::support::endian::read64le(m_data.data());
return true;
}
@@ -97,7 +97,7 @@ bool DataLogRecord::GetFloat(float* value) const {
if (m_data.size() != 4) {
return false;
}
*value = std::bit_cast<float>(wpi::support::endian::read32le(m_data.data()));
*value = std::bit_cast<float>(wpi::util::support::endian::read32le(m_data.data()));
return true;
}
@@ -105,7 +105,7 @@ bool DataLogRecord::GetDouble(double* value) const {
if (m_data.size() != 8) {
return false;
}
*value = std::bit_cast<double>(wpi::support::endian::read64le(m_data.data()));
*value = std::bit_cast<double>(wpi::util::support::endian::read64le(m_data.data()));
return true;
}
@@ -130,7 +130,7 @@ bool DataLogRecord::GetIntegerArray(std::vector<int64_t>* arr) const {
}
arr->reserve(m_data.size() / 8);
for (size_t pos = 0; pos < m_data.size(); pos += 8) {
arr->push_back(wpi::support::endian::read64le(&m_data[pos]));
arr->push_back(wpi::util::support::endian::read64le(&m_data[pos]));
}
return true;
}
@@ -143,7 +143,7 @@ bool DataLogRecord::GetFloatArray(std::vector<float>* arr) const {
arr->reserve(m_data.size() / 4);
for (size_t pos = 0; pos < m_data.size(); pos += 4) {
arr->push_back(
std::bit_cast<float>(wpi::support::endian::read32le(&m_data[pos])));
std::bit_cast<float>(wpi::util::support::endian::read32le(&m_data[pos])));
}
return true;
}
@@ -156,7 +156,7 @@ bool DataLogRecord::GetDoubleArray(std::vector<double>* arr) const {
arr->reserve(m_data.size() / 8);
for (size_t pos = 0; pos < m_data.size(); pos += 8) {
arr->push_back(
std::bit_cast<double>(wpi::support::endian::read64le(&m_data[pos])));
std::bit_cast<double>(wpi::util::support::endian::read64le(&m_data[pos])));
}
return true;
}
@@ -166,7 +166,7 @@ bool DataLogRecord::GetStringArray(std::vector<std::string_view>* arr) const {
if (m_data.size() < 4) {
return false;
}
uint32_t size = wpi::support::endian::read32le(m_data.data());
uint32_t size = wpi::util::support::endian::read32le(m_data.data());
// sanity check size
if (size > ((m_data.size() - 4) / 4)) {
return false;
@@ -189,7 +189,7 @@ bool DataLogRecord::GetStringArray(std::vector<std::string_view>* arr) const {
return true;
}
DataLogReader::DataLogReader(std::unique_ptr<MemoryBuffer> buffer)
DataLogReader::DataLogReader(std::unique_ptr<wpi::util::MemoryBuffer> buffer)
: m_buf{std::move(buffer)} {}
bool DataLogReader::IsValid() const {
@@ -200,7 +200,7 @@ bool DataLogReader::IsValid() const {
return buf.size() >= 12 &&
std::string_view{reinterpret_cast<const char*>(buf.data()), 6} ==
"WPILOG" &&
wpi::support::endian::read16le(&buf[6]) >= 0x0100;
wpi::util::support::endian::read16le(&buf[6]) >= 0x0100;
}
uint16_t DataLogReader::GetVersion() const {
@@ -211,7 +211,7 @@ uint16_t DataLogReader::GetVersion() const {
if (buf.size() < 12) {
return 0;
}
return wpi::support::endian::read16le(&buf[6]);
return wpi::util::support::endian::read16le(&buf[6]);
}
std::string_view DataLogReader::GetExtraHeader() const {
@@ -236,7 +236,7 @@ DataLogReader::iterator DataLogReader::begin() const {
if (buf.size() < 12) {
return end();
}
uint32_t size = wpi::support::endian::read32le(&buf[8]);
uint32_t size = wpi::util::support::endian::read32le(&buf[8]);
if (buf.size() < (12 + size)) {
return end();
}

26
datalog/src/main/native/cpp/DataLogReaderThread.cpp
View File

@@ -20,7 +20,7 @@ DataLogReaderThread::~DataLogReaderThread() {
}
void DataLogReaderThread::ReadMain() {
wpi::SmallDenseMap<
wpi::util::SmallDenseMap<
int, std::pair<DataLogReaderEntry*, std::span<const uint8_t>>, 8>
schemaEntries;
@@ -37,7 +37,7 @@ void DataLogReaderThread::ReadMain() {
std::scoped_lock lock{m_mutex};
auto& entryPtr = m_entriesById[data.entry];
if (entryPtr) {
wpi::print("...DUPLICATE entry ID, overriding\n");
wpi::util::print("...DUPLICATE entry ID, overriding\n");
}
auto [it, isNew] = m_entriesByName.emplace(data.name, data);
if (isNew) {
@@ -51,7 +51,7 @@ void DataLogReaderThread::ReadMain() {
}
sigEntryAdded(data);
} else {
wpi::print("Start(INVALID)\n");
wpi::util::print("Start(INVALID)\n");
}
} else if (record.IsFinish()) {
int entry;
@@ -59,13 +59,13 @@ void DataLogReaderThread::ReadMain() {
std::scoped_lock lock{m_mutex};
auto it = m_entriesById.find(entry);
if (it == m_entriesById.end()) {
wpi::print("...ID not found\n");
wpi::util::print("...ID not found\n");
} else {
it->second->ranges.back().m_end = recordIt;
m_entriesById.erase(it);
}
} else {
wpi::print("Finish(INVALID)\n");
wpi::util::print("Finish(INVALID)\n");
}
} else if (record.IsSetMetadata()) {
wpi::log::MetadataRecordData data;
@@ -73,15 +73,15 @@ void DataLogReaderThread::ReadMain() {
std::scoped_lock lock{m_mutex};
auto it = m_entriesById.find(data.entry);
if (it == m_entriesById.end()) {
wpi::print("...ID not found\n");
wpi::util::print("...ID not found\n");
} else {
it->second->metadata = data.metadata;
}
} else {
wpi::print("SetMetadata(INVALID)\n");
wpi::util::print("SetMetadata(INVALID)\n");
}
} else if (record.IsControl()) {
wpi::print("Unrecognized control record\n");
wpi::util::print("Unrecognized control record\n");
} else {
auto it = schemaEntries.find(record.GetEntry());
if (it != schemaEntries.end()) {
@@ -97,19 +97,19 @@ void DataLogReaderThread::ReadMain() {
if (data.empty()) {
continue;
}
if (auto strippedName = wpi::remove_prefix(name, "NT:")) {
if (auto strippedName = wpi::util::remove_prefix(name, "NT:")) {
name = *strippedName;
}
if (auto typeStr = wpi::remove_prefix(name, "/.schema/struct:")) {
if (auto typeStr = wpi::util::remove_prefix(name, "/.schema/struct:")) {
std::string_view schema{reinterpret_cast<const char*>(data.data()),
data.size()};
std::string err;
auto desc = m_structDb.Add(*typeStr, schema, &err);
if (!desc) {
wpi::print("could not decode struct '{}' schema '{}': {}\n", name,
wpi::util::print("could not decode struct '{}' schema '{}': {}\n", name,
schema, err);
}
} else if (auto filename = wpi::remove_prefix(name, "/.schema/proto:")) {
} else if (auto filename = wpi::util::remove_prefix(name, "/.schema/proto:")) {
// protobuf descriptor handling
upb_Status status;
status.ok = true;
@@ -119,7 +119,7 @@ void DataLogReaderThread::ReadMain() {
reinterpret_cast<const char*>(data.data()), data.size(), m_arena),
&status);
if (!status.ok) {
wpi::print("could not decode protobuf '{}' filename '{}'\n", name,
wpi::util::print("could not decode protobuf '{}' filename '{}'\n", name,
*filename);
}
}

14
datalog/src/main/native/cpp/DataLogWriter.cpp
View File

@@ -12,9 +12,9 @@
using namespace wpi::log;
static std::unique_ptr<wpi::raw_ostream> CheckOpen(std::string_view filename,
static std::unique_ptr<wpi::util::raw_ostream> CheckOpen(std::string_view filename,
std::error_code& ec) {
auto rv = std::make_unique<wpi::raw_fd_ostream>(filename, ec);
auto rv = std::make_unique<wpi::util::raw_fd_ostream>(filename, ec);
if (ec) {
return nullptr;
}
@@ -25,7 +25,7 @@ DataLogWriter::DataLogWriter(std::string_view filename, std::error_code& ec,
std::string_view extraHeader)
: DataLogWriter{s_defaultMessageLog, filename, ec, extraHeader} {}
DataLogWriter::DataLogWriter(wpi::Logger& msglog, std::string_view filename,
DataLogWriter::DataLogWriter(wpi::util::Logger& msglog, std::string_view filename,
std::error_code& ec, std::string_view extraHeader)
: DataLogWriter{msglog, CheckOpen(filename, ec), extraHeader} {
if (ec) {
@@ -33,12 +33,12 @@ DataLogWriter::DataLogWriter(wpi::Logger& msglog, std::string_view filename,
}
}
DataLogWriter::DataLogWriter(std::unique_ptr<wpi::raw_ostream> os,
DataLogWriter::DataLogWriter(std::unique_ptr<wpi::util::raw_ostream> os,
std::string_view extraHeader)
: DataLogWriter{s_defaultMessageLog, std::move(os), extraHeader} {}
DataLogWriter::DataLogWriter(wpi::Logger& msglog,
std::unique_ptr<wpi::raw_ostream> os,
DataLogWriter::DataLogWriter(wpi::util::Logger& msglog,
std::unique_ptr<wpi::util::raw_ostream> os,
std::string_view extraHeader)
: DataLog{msglog, extraHeader}, m_os{std::move(os)} {
StartFile();
@@ -80,7 +80,7 @@ struct WPI_DataLog* WPI_DataLog_CreateWriter(
const struct WPI_String* extraHeader) {
std::error_code ec;
auto rv = reinterpret_cast<WPI_DataLog*>(new DataLogWriter{
wpi::to_string_view(filename), ec, wpi::to_string_view(extraHeader)});
wpi::util::to_string_view(filename), ec, wpi::util::to_string_view(extraHeader)});
*errorCode = ec.value();
return rv;
}

6
datalog/src/main/native/cpp/FileLogger.cpp
View File

@@ -88,12 +88,12 @@ FileLogger::~FileLogger() {
std::function<void(std::string_view)> FileLogger::Buffer(
std::function<void(std::string_view)> callback) {
return [callback,
buf = wpi::SmallVector<char, 64>{}](std::string_view data) mutable {
buf = wpi::util::SmallVector<char, 64>{}](std::string_view data) mutable {
buf.append(data.begin(), data.end());
if (!wpi::contains({data.data(), data.size()}, "\n")) {
if (!wpi::util::contains({data.data(), data.size()}, "\n")) {
return;
}
auto [wholeData, extra] = wpi::rsplit({buf.data(), buf.size()}, "\n");
auto [wholeData, extra] = wpi::util::rsplit({buf.data(), buf.size()}, "\n");
std::string leftover{extra};
callback(wholeData);

10
datalog/src/main/native/cpp/jni/DataLogJNI.cpp
View File

@@ -19,7 +19,7 @@
#include "wpi/datalog/FileLogger.hpp"
#include "wpi/util/jni_util.hpp"
using namespace wpi::java;
using namespace wpi::util::java;
using namespace wpi::log;
static bool mockTimeEnabled = false;
@@ -53,12 +53,12 @@ void wpi::ThrowNullPointerException(JNIEnv* env, std::string_view msg) {
}
namespace {
class buf_ostream : public wpi::raw_uvector_ostream {
class buf_ostream : public wpi::util::raw_uvector_ostream {
private:
std::vector<uint8_t> data;
public:
buf_ostream() : raw_uvector_ostream{data} {}
buf_ostream() : wpi::util::raw_uvector_ostream{data} {}
void clear() { data.clear(); }
};
@@ -181,7 +181,7 @@ Java_org_wpilib_util_WPIUtilJNI_now
if (mockTimeEnabled) {
return mockNow;
} else {
return wpi::Now();
return wpi::util::Now();
}
}
@@ -599,7 +599,7 @@ Java_org_wpilib_datalog_DataLogJNI_appendIntegerArray
entry, {reinterpret_cast<const int64_t*>(jarr.data()), jarr.size()},
timestamp);
} else {
wpi::SmallVector<int64_t, 16> arr;
wpi::util::SmallVector<int64_t, 16> arr;
arr.reserve(jarr.size());
for (auto v : jarr) {
arr.push_back(v);