OpenSystemsDevelopment / qpdf

- Standardize error handling by replacing repetitive throw statements with helper functions.
- Add test coverage for new helper functions in error handling.
- Enhance maintainability and readability with concise utilities.

…ntation, and update references in `FormField` methods.

Simplify integer value retrieval by introducing a templated `value` method in the `Integer` class. Replace redundant exception handling logic across multiple functions with this unified approach. Streamline type conversions and improve readability.

Introduce new methods: `data()` to access buffer content, `empty()` to check buffer state, and `size()` to retrieve buffer size. Update unit tests to validate the behavior of these methods alongside existing functionality.

Implement `Buffer::view()` to provide a read-only view of the buffer content. Update unit tests to validate `view()` behavior alongside `move()`. Include necessary `#include <string_view>` for functionality.

Refactor `Buffer`: implement `move()` method to enable efficient transfer of content to a string, leaving the buffer empty. Include unit tests for `move()` functionality to ensure correctness. Remove redundant `#include <cstring>` for cleanup.

…y, modify bounds checks, and adjust affected tests.

… to use subscript operators, and simplify object access logic.

Refactor array handling in `QPDFObjectHandle`: replace `int` with `size_t` for size and index operations, introduce utility functions for type conversions, and simplify sparse array logic.

Replaced raw key pointer and length parameters with a `std::string` in `Pl_AES_PDF` and `Pl_RC4` constructors for improved safety and clarity. Updated all usage sites accordingly, reducing reliance on manual memory management and redundant conversions.

Replaced raw pointer defaults (e.g., `0`) with `nullptr` for better readability and type-safety. Simplified object initializer syntax using uniform initialization `{}`. These changes enhance code maintainability and ensure modern C++ standards compliance.

This change updates all occurrences of `std::endl` to `\n` across various files for improved efficiency and consistency. It reduces unnecessary flushing of output buffers associated with `std::endl` while maintaining the same output format.

Thanks to github user @cdosborn for the basic enhancement.

Move all array-specific methods to new class qpdf::Array.

If duplicate keys are encountered, overwrite earlier values with the latest
value.

Also, move Buffer::Members definition to Buffer.cc

This improves indentation of long strings. This commit also fixes some
trailing whitespace in ChangeLog.

Change the return type to a std::pair<bool, QPDFObjectHandle> in order to
allow a default constructed object handle (which is currently returned to
indicate failure) to become a valid object.

Create unresolved objects only for objects in the xref table (except during
parsing of the xref table). Do not add indirect nulls into the the object
cache as the result of a cache miss during a call to getObject except
during parsing or creation/updating from JSON. To support this behaviour,
add new private methods getObjectForParser and getObjectForJSON.

As a result of this change, dangling references are treated as direct nulls
rather than indirect nulls.

Fix writing reals with trailing '.' as JSON (fixes #1261)

GCC 15 starts to no longer include this by default, requiring it to be
explicitly included.

Error message:
libtests/cxx11.cc:75:16: error: ‘uint8_t’ was not declared in this scope
   75 |     check_size<uint8_t>(1, false);
      |                ^~~~~~~
libtests/cxx11.cc:10:1: note: ‘uint8_t’ is defined in header ‘<cstdint>’; this is probably fixable by adding ‘#include <cstdint>’
    9 | #include <regex>
  +++ |+#include <cstdint>
   10 | #include <type_traits>

Signed-off-by: Christopher Fore <csfore@posteo.net>

As a rule, we should avoid conditional compilation is it always causes
code paths that are sometimes not even seen lexically by the compiler.
Also, we want the actual code being fuzzed to be as close as possible
to the real code. Conditional compilation is suitable to handle
underlying system differences.

Instead, favor configuration using callbacks or other methods that can
be triggered in the places where they need to be exercised.