++

Author: Damir Zainullin

process-plugin-api/directionalField.hpp

@@ -8,6 +8,6 @@ template<typename T>
 struct DirectionalField {
 	T values[2]{};
 
-	T& operator[](Direction d) { return values[static_cast<std::size_t>(d)]; }
-	const T& operator[](Direction d) const { return values[static_cast<std::size_t>(d)]; }
+	constexpr T& operator[](Direction d) { return values[static_cast<std::size_t>(d)]; }
+	constexpr const T& operator[](Direction d) const { return values[static_cast<std::size_t>(d)]; }
 };

process-plugin-api/ipAddress.hpp

@@ -28,9 +28,10 @@ union IPAddress {
 		u32[2] = u32[3] = std::numeric_limits<uint32_t>::max();
 	}
 
-	constexpr IPAddress(const std::array<uint8_t, 16>& ipv6) noexcept
+	constexpr IPAddress(const std::span<const std::byte, 16>& ipv6) noexcept
 	{
-		u8 = ipv6;
+		std::copy(
+			ipv6.begin(), ipv6.end(), reinterpret_cast<std::byte*>(u8.data()));
 	}
 
 	constexpr bool isIPv4() const noexcept

process-plugin-api/main.o

@@ -48,9 +48,10 @@ parseSection(
     std::size_t sectionSize{0};
     const auto sectionBegin = payload.begin();
 
-    DNSSectionReader reader(recordCount, payload, fullDNSPayload);
+    DNSSectionReader reader;
 
-    std::ranges::for_each(reader, 
+    std::ranges::for_each(
+        reader.getRange(recordCount, payload, fullDNSPayload), 
         [&, needToCallCallback = true]
         (const DNSRecord& record) mutable {
             sectionSize = static_cast<std::size_t>(

process-plugin-api/process/basicPlus/src/basicPlus.o

@@ -19,8 +19,8 @@ DNSSection::parseSection(
     const std::size_t recordsCount) noexcept
 {
     auto res = std::make_optional<DNSSection>();
-    DNSSectionReader reader(recordsCount, section, fullDNSPayload);
-    std::ranges::copy(reader | 
+    DNSSectionReader reader;
+    std::ranges::copy(reader.getRange(recordsCount, section, fullDNSPayload) | 
         std::views::take(res->records.capacity()), 
         std::back_inserter(res->records));
 

process-plugin-api/process/bstats/src/burstStats.o

@@ -14,22 +14,21 @@
 namespace ipxp
 {
 
-class DNSSectionReader;
-
-struct DNSSectionReaderFactory
+class DNSSectionReader : public RangeReader
 {
-    static auto makeReader(
+public:
+
+    auto getRange(
         std::size_t itemCount, 
         std::span<const std::byte> fullDNSPayload,
-        std::span<const std::byte> section,
-        ParsingState& parsingState
+        std::span<const std::byte> section
     ) noexcept
     {
-        return Generator::generate([section, itemCount, fullDNSPayload, parsingState]() mutable
+        return Generator::generate([this, section, itemCount, fullDNSPayload]() mutable
         -> std::optional<DNSRecord> {
             auto res = std::make_optional<DNSRecord>();
             if (itemCount == 0) {
-                parsingState.state = ParsingState::State::SUCCESS;
+                setSuccess();
                 return std::nullopt;
             }
             itemCount--;
@@ -76,7 +75,6 @@ struct DNSSectionReaderFactory
             return *v;
         });
     }
-
 };
 
 /*
@@ -87,27 +85,22 @@ class DNSSectionReader : public RangeReader<DNSSectionReaderFactory> {
         : RangeReader(section, DNSSectionReaderFactory{this, itemCount, fullDNSPayload.data()}) {}
 };*/
 
-using Args = FunctionTraits<decltype(
-            &DNSSectionReaderFactory::makeReader
-        )>::ArgumentTypes;
-
-using Ret = 
-    ReturnType<DNSSectionReaderFactory::makeReader, Args>::Type;
-
-class DNSSectionReader : 
-    public RangeReader<Ret> {
+/*
+class DNSSectionReaderX : public RangeReader {
 
 public:
     DNSSectionReader(
         const std::size_t itemCount, 
         std::span<const std::byte> fullDNSPayload,
         std::span<const std::byte> section)
-        : RangeReader(
-            DNSSectionReaderFactory::makeReader(
-                itemCount, fullDNSPayload, section, m_state))
+        : m_callback(DNSSectionReaderFactory::makeReader(
+            itemCount, fullDNSPayload, section))
     {
     }
+
+    auto m_callback{DNSSectionReaderFactory::makeReader({}, {}, {})};
     
+};*/
 /*public:
 
     DNSSectionReader(
@@ -124,7 +117,6 @@ class DNSSectionReader :
     std::span<const std::byte> m_fullDNSPayload;
     std::span<const std::byte> section;
     CallbackType m_callback;*/
-};