Log message:
revbump for boost-libs

Log message:
(converters/orcus) Update buildlink3.mk for API update, tks Marc Baudoin

Log message:
(converters/orcus) Remove redundent lines (Re: libtool)

Log message:
(converters/orcus) Updated to 0.21.0, with asking at least gcc12

(previous commit was missing following log, sorry)
* When importing an XML document via orcus_xml, import_factory's
  finalize() method was previously not called which violates the
  interface contract.  This version fixes it.

* added static method has_range(std::string_view stream) to both
  orcus_xml and orcus_json to detect whether a given XML and JSON
  document has at least one linkable range, respectively.

* added a variant of orcus::detect() function that takes a document
  content and the format type to check against.  This variant only
  checks whether the document is of the specified type, and returns the
  result as a boolean value.

* The following functions now take a binary stream containing file
  content as std::string_view as opposed to the previous const char* and
  size_t pair:

  * orcus_ods::detect(std::string_view strm)

  * orcus_xlsx::detect(std::string_view strm)

  * orcus_gnumeric::detect(std::string_view strm)

  * orcus_xls_xml::detect(std::string_view strm)

  * orcus_parquet::detect(std::string_view strm)

  * orcus_json::detect(std::string_view strm)

  * orcus_xml::detect(std::string_view strm)

Log message:
(converters/orcus) +USE_CXX_FEATURES = c++20, implying for gcc12

NetBSD/amd64 9.x fails with following line, later releases are OK.

In file included from /usr/include/g++/memory:80:0,
                 from ../../include/orcus/stream.hpp:13,
                 from stream.cpp:8:
/usr/include/g++/bits/unique_ptr.h: In instantiation of 'typename \ 
std::_MakeUniq<_Tp>::__single_object std::make_unique(_Args&& ...) \ 
[with _Tp = orcus::file_content::impl; _Args = \ 
{std::basic_string_view<char16_t, std::char_traits<char16_t> \ 
>&}; typename std::_MakeUniq<_Tp>::__single_object = \ 
std::unique_ptr<orcus::file_content::impl>]':
stream.cpp:191:44:   required from here
/usr/include/g++/bits/unique_ptr.h:821:30: error: no matching function for call \ 
to \ 
'orcus::file_content::impl::impl(std::basic_string_view<char16_t>&)'
     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Log message:
orcus: remove outdated branch information

Unneeded now that we only have one copy of this in-tree

Log message:
*: recursive bump for boost 1.89

Log message:
converters/orcus: Update to 0.20.2

Changelog:
orcus 0.20.2

* The base JSON parser class (orcus::json_parser) now allows primitive string,
  numeric and boolean values to be document root as it should per JSON
  specification.

* added to the command-line programs proper support for Unicode filepath
  handling on Windows which still uses UTF-16 with code pages.  Relevant
  public API has been updated to add support for Unicode filepaths on Windows.

* added to the import_sheet interface a variant of set_string() that takes a
  non-indexed string value.  This is used to handle cells with inline strings
  in the xlsx import filter.  However, orcus's own document store backend does
  not yet handle cells with non-indexed strings, so when importing xlsx
  documents containing cells with inline strings, those cells will be ignored
  for now.

* added to the orcus::format_t enum type json and xml as its members.  With
  that change, you can now instantiate import filter adapters for these two
  new format types to import generic JSON and XML documents.  These two
  adapter filters will auto-detect tabular structures and map them to sheets
  if they exist.

* orcus::detect() can now detect generic JSON and XML documents.

* fixed a bug where orcus-xml generated incorrect map file in map-gen mode
  when the source document contained multiple tabular structures.

orcus 0.20.1

* fixed an assertion failure when importing a document in Excel 2003 XML
  format containing an autofilter with no filtering applied to it.

* added a set of new interfaces to support importing pivot table definitions
  from xlsx documents.

* added support for dumping the internal state of pivot caches and pivot table
  definitions as part of the debug state output.

* added clarification on the return value of import_sheet::get_sheet_size()
  interface method in the documentation.

* C++ API reference has been restructured to show each symbol in a separate
  page, and have their header information also included.

* added test cases for testing expected string labels for enum types.

* fixed orcus-json's map mode which would previously fail when built with
  CMake.

orcus 0.20.0

* import filters

  * added support for more format types in formatted strings in xlsx, xls-xml
    and gnumeric filters.  The following format types are now supported:

    * superscript

    * subscript

    * strikethrough

    * underline

  * strikethrough format applied to cells are now supported in xlsx and
    xls-xml.

  * importing of underline format applied to cells in gnumeric have been
    revised to fix issues.

  * interface for autofilter import has been revamped to properly import
    autofilter properties from xlsx, xls-xml, gnumeric and ods.

  * import_sheet_properties::set_row_height() now takes a row span as opposed
    to a single row position.

  * fixed a bug in the ods filter to properly separate styles in different
    style families.  Previously, all styles were stored without style-family
    segregation which resulted in collision of styles with the same name.

* document model

  * format run storage in orcus::spreadsheet::format_run now correctly
    differentiates a format not being applied from a negative format being
    applied.  For instance, the previous storage could not differentiate the
    state of a bold format not being specified from a non-bold state being
    intentionally applied.

* json

  * added support for custom indent when formatting JSON document.
    orcus::json::document_tree::dump() now takes an additional indent
    parameter to control the amount of indentation in the output.

  * orcus::json::subtree class has been added to allow referencing of subtree
    in an existing document_tree instance.

  * parser has been revised to properly handle escaped unicode characters.
    The parser now propertly converts escaped unicode characters to proper
    UTF-8 characters.

* tools

  * orcus-json now has a new subtree mode to allow extraction of subtree from
    an existing JSON document.  The root of a subtree is to be specified as a
    subset of JSONPath expression.  Both bracket notation and dot notation are
    supported.  Wildcard selector is also supported.

  * orcus-json now has a lint mode to allow reformatting of a JSON document
    with custom indent length via --indent option.