Improvements on lazy decoding of Asn1Codec. (#1880)

* Added const qualifier to data buffer parameter in decodeValue.

* Changed GenericRecord to utilize smart pointer.
- This change also fixes single value delete being used to delete an array.

* Added Lazy class.

* Added LazyEvaluationMixin for classes that need lazy evaluation.

* Changed implementation of lazy decoding of Asn1Record.

- The lazy decoding is implemented through the new LazyFieldEvaluationMixin class.
- Marked most methods as `const` and the record value fields are marked as mutable to allow decode operation when the object is counted as const.
-

* Removed orignal Lazy implementation. Updated LazyMixin documentation.

* Improved documentation.

* Moved decodeValueIfNeeded to header as its a forward that can be inlined.

* Merged decodeInternal in decode as it was just a forward to the method.

* Method renames.

* Lint

* Removed ability to eagerly evaluate in base constructor due to dependency on virtual dispatch.

* Added const to encode and toString.

* Inlined decoding to Asn1Record for now.

* Updated decode exception to std::runtime_error.

* Added docstrings.

* Updated enum names.

* Reverted decoding to use encoded value as state.

* Fix if condition.

* Reverted decodeIfNeeded call in Asn1StringRecord.

* Removed extra calls to decode value if needed in toStringList.
The decode check is to be set as prerequesite in toString().

Author: Dimi1010

Packet++/header/Asn1Codec.h

@@ -109,6 +109,20 @@ namespace pcpp
 		NotApplicable = 255
 	};
 
+	namespace internal
+	{
+		/// @enum Asn1LoadPolicy
+		/// @brief Policy for when to evaluate (decode) ASN.1 record values.
+		/// Determines whether the value is decoded immediately (eager) or on first access (lazy).
+		enum class Asn1LoadPolicy
+		{
+			/// The value is evaluated on first access (lazy decoding).
+			Lazy,
+			/// The value is evaluated immediately on construction (eager decoding).
+			Eager
+		};
+	}  // namespace internal
+
 	/// @class Asn1Record
 	/// Represents an ASN.1 record, as described in ITU-T Recommendation X.680:
 	/// <https://www.itu.int/rec/T-REC-X.680/en>
@@ -127,7 +141,7 @@ namespace pcpp
 
 		/// Encode this record and convert it to a byte stream
 		/// @return A vector of bytes representing the record
-		std::vector<uint8_t> encode();
+		std::vector<uint8_t> encode() const;
 
 		/// @return The ASN.1 tag class
 		Asn1TagClass getTagClass() const
@@ -164,7 +178,7 @@ namespace pcpp
 		}
 
 		/// @return A string representation of the record
-		std::string toString();
+		std::string toString() const;
 
 		/// A templated method that accepts a class derived from Asn1Record as its template argument and attempts
 		/// to cast the current instance to that type
@@ -190,26 +204,41 @@ namespace pcpp
 		size_t m_ValueLength = 0;
 		size_t m_TotalLength = 0;
 
-		uint8_t const* m_EncodedValue = nullptr;
-
 		Asn1Record() = default;
 
-		static std::unique_ptr<Asn1Record> decodeInternal(const uint8_t* data, size_t dataLen, bool lazy);
+		/// @brief Decodes the record value from a byte array into the mutable cache variables.
+		/// This method is marked as const as it can be called on a const instance of the record for lazy decoding.
+		virtual void decodeValue(uint8_t const* data) const = 0;
 
-		virtual void decodeValue(uint8_t const* data, bool lazy) = 0;
+		/// @brief Encodes the record value into a byte array
+		/// Prefer using encodeValueSafe() to ensure the value is decoded first if needed
 		virtual std::vector<uint8_t> encodeValue() const = 0;
 
+		/// @brief Encodes the record value into a byte array, ensuring that the value is decoded first if needed
+		std::vector<uint8_t> encodeValueSafe() const
+		{
+			decodeValueIfNeeded();
+			return encodeValue();
+		}
+
 		static std::unique_ptr<Asn1Record> decodeTagAndCreateRecord(const uint8_t* data, size_t dataLen,
 		                                                            uint8_t& tagLen);
 		uint8_t decodeLength(const uint8_t* data, size_t dataLen);
-		void decodeValueIfNeeded();
+		void decodeValueIfNeeded() const;
 
-		uint8_t encodeTag();
+		uint8_t encodeTag() const;
 		std::vector<uint8_t> encodeLength() const;
 
-		virtual std::vector<std::string> toStringList();
+		// note: Requires the value to be decoded first if lazy decoding is used
+		virtual std::vector<std::string> toStringList() const;
 
 		friend class Asn1ConstructedRecord;
+
+	private:
+		void setEncodedValue(uint8_t const* dataSource,
+		                     internal::Asn1LoadPolicy loadPolicy = internal::Asn1LoadPolicy::Lazy);
+
+		mutable uint8_t const* m_EncodedValue = nullptr;
 	};
 
 	/// @class Asn1GenericRecord
@@ -248,11 +277,11 @@ namespace pcpp
 	protected:
 		Asn1GenericRecord() = default;
 
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
 	private:
-		std::unique_ptr<uint8_t[]> m_Value = nullptr;
+		mutable std::unique_ptr<uint8_t[]> m_Value = nullptr;
 
 		void init(Asn1TagClass tagClass, bool isConstructed, uint8_t tagType, const uint8_t* value, size_t valueLen);
 	};
@@ -289,10 +318,10 @@ namespace pcpp
 	protected:
 		Asn1ConstructedRecord() = default;
 
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
-		std::vector<std::string> toStringList() override;
+		std::vector<std::string> toStringList() const override;
 
 		template <typename Iterator> void init(Asn1TagClass tagClass, uint8_t tagType, Iterator begin, Iterator end)
 		{
@@ -304,7 +333,7 @@ namespace pcpp
 			for (Iterator recordIter = begin; recordIter != end; ++recordIter)
 			{
 				auto encodedRecord = (*recordIter)->encode();
-				auto copyRecord = Asn1Record::decode(encodedRecord.data(), encodedRecord.size(), false);
+				auto copyRecord = Asn1Record::decode(encodedRecord.data(), encodedRecord.size(), LazySubRecordDecoding);
 				m_SubRecords.pushBack(std::move(copyRecord));
 				recordValueLength += encodedRecord.size();
 			}
@@ -314,7 +343,10 @@ namespace pcpp
 		}
 
 	private:
-		PointerVector<Asn1Record> m_SubRecords;
+		// Set to false as there are issues with lazy decoding of sub-records in some cases.
+		static constexpr bool LazySubRecordDecoding = false;
+
+		mutable PointerVector<Asn1Record> m_SubRecords;
 	};
 
 	/// @class Asn1SequenceRecord
@@ -389,7 +421,7 @@ namespace pcpp
 
 		/// @return The integer value of this record
 		/// @throw std::invalid_argument if the value doesn't fit the requested integer size
-		template <typename T, EnableIfUnsignedIntegral<T> = 0> T getIntValue()
+		template <typename T, EnableIfUnsignedIntegral<T> = 0> T getIntValue() const
 		{
 			decodeValueIfNeeded();
 			return m_Value.getInt<T>();
@@ -403,7 +435,7 @@ namespace pcpp
 		}
 
 		/// @return A hex string representation of the record value
-		std::string getValueAsString()
+		std::string getValueAsString() const
 		{
 			decodeValueIfNeeded();
 			return m_Value.toString();
@@ -412,10 +444,10 @@ namespace pcpp
 	protected:
 		Asn1IntegerRecord() = default;
 
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
-		std::vector<std::string> toStringList() override;
+		std::vector<std::string> toStringList() const override;
 
 	private:
 		class BigInt
@@ -475,7 +507,7 @@ namespace pcpp
 			}
 		};
 
-		BigInt m_Value;
+		mutable BigInt m_Value;
 	};
 
 	/// @class Asn1EnumeratedRecord
@@ -500,7 +532,7 @@ namespace pcpp
 	{
 	public:
 		/// @return The string value of this record
-		std::string getValue()
+		std::string getValue() const
 		{
 			decodeValueIfNeeded();
 			return m_Value;
@@ -516,7 +548,7 @@ namespace pcpp
 			m_TotalLength = m_ValueLength + 2;
 		}
 
-		void decodeValue(uint8_t const* data, bool lazy) override
+		void decodeValue(uint8_t const* data) const override
 		{
 			m_Value = std::string(reinterpret_cast<char const*>(data), m_ValueLength);
 		}
@@ -525,12 +557,12 @@ namespace pcpp
 			return { m_Value.begin(), m_Value.end() };
 		}
 
-		std::vector<std::string> toStringList() override
+		std::vector<std::string> toStringList() const override
 		{
 			return { Asn1Record::toStringList().front() + ", Value: " + getValue() };
 		}
 
-		std::string m_Value;
+		mutable std::string m_Value;
 	};
 
 	/// @class Asn1OctetStringRecord
@@ -553,13 +585,13 @@ namespace pcpp
 		{}
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
 	private:
 		Asn1OctetStringRecord() = default;
 
-		bool m_IsPrintable = true;
+		mutable bool m_IsPrintable = true;
 	};
 
 	/// @class Asn1UTF8StringRecord
@@ -622,22 +654,22 @@ namespace pcpp
 		explicit Asn1BooleanRecord(bool value);
 
 		/// @return The boolean value of this record
-		bool getValue()
+		bool getValue() const
 		{
 			decodeValueIfNeeded();
 			return m_Value;
 		};
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
-		std::vector<std::string> toStringList() override;
+		std::vector<std::string> toStringList() const override;
 
 	private:
 		Asn1BooleanRecord() = default;
 
-		bool m_Value = false;
+		mutable bool m_Value = false;
 	};
 
 	/// @class Asn1NullRecord
@@ -651,7 +683,7 @@ namespace pcpp
 		Asn1NullRecord();
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override
+		void decodeValue(uint8_t const* data) const override
 		{}
 		std::vector<uint8_t> encodeValue() const override
 		{
@@ -728,20 +760,20 @@ namespace pcpp
 		explicit Asn1ObjectIdentifierRecord(const Asn1ObjectIdentifier& value);
 
 		/// @return The OID value of this record
-		const Asn1ObjectIdentifier& getValue()
+		const Asn1ObjectIdentifier& getValue() const
 		{
 			decodeValueIfNeeded();
 			return m_Value;
 		}
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
-		std::vector<std::string> toStringList() override;
+		std::vector<std::string> toStringList() const override;
 
 	private:
-		Asn1ObjectIdentifier m_Value;
+		mutable Asn1ObjectIdentifier m_Value;
 
 		Asn1ObjectIdentifierRecord() = default;
 	};
@@ -756,7 +788,7 @@ namespace pcpp
 		/// timezones. The default value is UTC
 		/// @return The time-point value of this record
 		/// @throws std::invalid_argument if timezone is not in the correct format
-		std::chrono::system_clock::time_point getValue(const std::string& timezone = "Z")
+		std::chrono::system_clock::time_point getValue(const std::string& timezone = "Z") const
 		{
 			decodeValueIfNeeded();
 			return adjustTimezones(m_Value, "Z", timezone);
@@ -769,16 +801,16 @@ namespace pcpp
 		/// @return The value as string
 		/// @throws std::invalid_argument if timezone is not in the correct format
 		std::string getValueAsString(const std::string& format = "%Y-%m-%d %H:%M:%S", const std::string& timezone = "Z",
-		                             bool includeMilliseconds = false);
+		                             bool includeMilliseconds = false) const;
 
 	protected:
 		Asn1TimeRecord() = default;
 		explicit Asn1TimeRecord(Asn1UniversalTagType tagType, const std::chrono::system_clock::time_point& value,
 		                        const std::string& timezone);
 
-		std::chrono::system_clock::time_point m_Value;
+		mutable std::chrono::system_clock::time_point m_Value;
 
-		std::vector<std::string> toStringList() override;
+		std::vector<std::string> toStringList() const override;
 
 		static void validateTimezone(const std::string& timezone);
 		static std::chrono::system_clock::time_point adjustTimezones(const std::chrono::system_clock::time_point& value,
@@ -799,12 +831,12 @@ namespace pcpp
 		explicit Asn1UtcTimeRecord(const std::chrono::system_clock::time_point& value, bool withSeconds = true);
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
 	private:
 		Asn1UtcTimeRecord() = default;
-		bool m_WithSeconds = true;
+		mutable bool m_WithSeconds = true;
 	};
 
 	/// @class Asn1GeneralizedTimeRecord
@@ -823,12 +855,12 @@ namespace pcpp
 		                                   const std::string& timezone = "Z");
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
 	private:
 		Asn1GeneralizedTimeRecord() = default;
-		std::string m_Timezone;
+		mutable std::string m_Timezone;
 	};
 
 	/// @class Asn1BitStringRecord
@@ -858,10 +890,10 @@ namespace pcpp
 		}
 
 	protected:
-		void decodeValue(uint8_t const* data, bool lazy) override;
+		void decodeValue(uint8_t const* data) const override;
 		std::vector<uint8_t> encodeValue() const override;
 
-		std::vector<std::string> toStringList() override;
+		std::vector<std::string> toStringList() const override;
 
 	private:
 		class BitSet
@@ -890,6 +922,6 @@ namespace pcpp
 
 		Asn1BitStringRecord() = default;
 
-		BitSet m_Value;
+		mutable BitSet m_Value;
 	};
 }  // namespace pcpp