diff -Nru pbbam-2.1.0+dfsg/CHANGELOG.md pbbam-2.3.0+dfsg/CHANGELOG.md --- pbbam-2.1.0+dfsg/CHANGELOG.md 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/CHANGELOG.md 2023-01-03 21:57:00.000000000 +0000 @@ -5,6 +5,19 @@ ## Active +## [2.3.0] - 2022-01-03 + +### Removed + - Deprecated APIs (now part of pbcopper) + +### Fixed + - Read group lookup for "legacy" barcoded IDs (different syntax) + +## [2.2.0] - 2022-07-26 + +### Fixed + - Use tabix 1-based indexing + ## [2.1.0] - 2022-04-19 ### Added diff -Nru pbbam-2.1.0+dfsg/debian/changelog pbbam-2.3.0+dfsg/debian/changelog --- pbbam-2.1.0+dfsg/debian/changelog 2022-10-06 09:27:28.000000000 +0000 +++ pbbam-2.3.0+dfsg/debian/changelog 2023-08-13 12:08:17.000000000 +0000 @@ -1,3 +1,15 @@ +pbbam (2.3.0+dfsg-1) unstable; urgency=medium + + * Team upload. + * New upstream version + * Standards-Version: 4.6.2 (routine-update) + * refreshed patches + * d/control: use ${devlibs:Depends} on the -dev package + * d/patches/spelling: fix a typo + * d/control: build-dep on the newer pbcopper (2.2.0) + + -- Michael R. Crusoe Sun, 13 Aug 2023 14:08:17 +0200 + pbbam (2.1.0+dfsg-2) unstable; urgency=medium * Fix watch file diff -Nru pbbam-2.1.0+dfsg/debian/control pbbam-2.3.0+dfsg/debian/control --- pbbam-2.1.0+dfsg/debian/control 2022-10-06 09:27:28.000000000 +0000 +++ pbbam-2.3.0+dfsg/debian/control 2023-08-13 12:08:17.000000000 +0000 @@ -13,11 +13,11 @@ zlib1g-dev, libssl-dev, libhts-dev, - libpbcopper-dev (>= 1.8.0), + libpbcopper-dev (>> 2.2.0), python3-cram, libgtest-dev , samtools -Standards-Version: 4.6.1 +Standards-Version: 4.6.2 Vcs-Browser: https://salsa.debian.org/med-team/pbbam Vcs-Git: https://salsa.debian.org/med-team/pbbam.git Homepage: https://pbbam.readthedocs.org/en/latest/index.html @@ -27,7 +27,7 @@ Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, - libpbbam2.1.0 (= ${binary:Version}) + libpbbam2.3.0 (= ${binary:Version}) Recommends: samtools Description: processing Pacific Biosciences binary alignment/map files The BAM format is a binary, compressed, record-oriented container format @@ -42,7 +42,7 @@ This package provides command-line utilities for working with PacBio BAM files. -Package: libpbbam2.1.0 +Package: libpbbam2.3.0 Architecture: any Multi-Arch: same Section: libs @@ -65,8 +65,8 @@ Architecture: any Multi-Arch: same Section: libdevel -Depends: libpbbam2.1.0 (= ${binary:Version}), - libhts-dev, +Depends: libpbbam2.3.0 (= ${binary:Version}), + ${devlibs:Depends}, libssl-dev, ${misc:Depends} Description: Pacific Biosciences binary alignment/map (BAM) library (headers) diff -Nru pbbam-2.1.0+dfsg/debian/patches/series pbbam-2.3.0+dfsg/debian/patches/series --- pbbam-2.1.0+dfsg/debian/patches/series 2022-10-06 09:27:28.000000000 +0000 +++ pbbam-2.3.0+dfsg/debian/patches/series 2023-08-13 12:08:17.000000000 +0000 @@ -2,3 +2,4 @@ python3.patch results_with_latest_samtools.patch # boost_optional.patch +spelling diff -Nru pbbam-2.1.0+dfsg/debian/patches/spelling pbbam-2.3.0+dfsg/debian/patches/spelling --- pbbam-2.1.0+dfsg/debian/patches/spelling 1970-01-01 00:00:00.000000000 +0000 +++ pbbam-2.3.0+dfsg/debian/patches/spelling 2023-08-13 12:08:17.000000000 +0000 @@ -0,0 +1,23 @@ +From: Michael R. Crusoe +Subject: fix typo, arbitray → arbitrary + +--- pbbam.orig/tests/src/cram/pbbamify.t.in ++++ pbbam/tests/src/cram/pbbamify.t.in +@@ -143,5 +143,5 @@ + + No-args: + +- $ $PBBAMIFY | grep -c "pbbamify - pbbamify converts an arbitray aligned BAM file" ++ $ $PBBAMIFY | grep -c "pbbamify - pbbamify converts an arbitrary aligned BAM file" + 1 +--- pbbam.orig/tools/pbbamify/src/PbBamifySettings.cpp ++++ pbbam/tools/pbbamify/src/PbBamifySettings.cpp +@@ -62,7 +62,7 @@ + { + // clang-format off + const std::string description{ +- "pbbamify converts an arbitray aligned BAM file to a PacBio-compatible BAM file." ++ "pbbamify converts an arbitrary aligned BAM file to a PacBio-compatible BAM file." + "Input BAM file is read from a file or stdin, the raw-reads PacBio BAM is given" + "as a parameter, and BAM output is written to stdout." + }; diff -Nru pbbam-2.1.0+dfsg/debian/patches/use_debian_packaged_python3-cram.patch pbbam-2.3.0+dfsg/debian/patches/use_debian_packaged_python3-cram.patch --- pbbam-2.1.0+dfsg/debian/patches/use_debian_packaged_python3-cram.patch 2022-10-06 09:27:28.000000000 +0000 +++ pbbam-2.3.0+dfsg/debian/patches/use_debian_packaged_python3-cram.patch 2023-08-13 12:07:19.000000000 +0000 @@ -2,14 +2,13 @@ Last-Update: Sun, 04 Aug 2019 09:15:35 +0200 Description: Use python3-cram instead of cram code copy ---- a/tests/meson.build -+++ b/tests/meson.build +--- pbbam.orig/tests/meson.build ++++ pbbam/tests/meson.build @@ -1,7 +1,7 @@ subdir('src') --pbbam_python = find_program('python') + pbbam_python = import('python').find_installation('python3') -pbbam_cram_script = find_program('cram', required : false) -+pbbam_python = find_program('python3') +pbbam_cram_script = find_program('cram3', required : false) if not pbbam_cram_script.found() warning('Using bundled cram script') diff -Nru pbbam-2.1.0+dfsg/debian/rules pbbam-2.3.0+dfsg/debian/rules --- pbbam-2.1.0+dfsg/debian/rules 2022-10-06 09:27:28.000000000 +0000 +++ pbbam-2.3.0+dfsg/debian/rules 2023-08-13 12:08:17.000000000 +0000 @@ -10,7 +10,7 @@ generated_data_dir = $(CURDIR)/gendata %: - dh $@ --buildsystem=meson + dh $@ --buildsystem=meson override_dh_auto_test: $(subst .t.in,.deb.t,$(wildcard tests/src/cram/pb*.t.in)) ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS))) diff -Nru pbbam-2.1.0+dfsg/include/meson.build pbbam-2.3.0+dfsg/include/meson.build --- pbbam-2.1.0+dfsg/include/meson.build 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/meson.build 2023-01-03 21:57:00.000000000 +0000 @@ -5,7 +5,6 @@ if not meson.is_subproject() install_headers( files([ - 'pbbam/Accuracy.h', 'pbbam/AlignmentPrinter.h', 'pbbam/BaiIndexCache.h', 'pbbam/BaiIndexedBamReader.h', @@ -22,8 +21,6 @@ 'pbbam/BgzipFastaWriter.h', 'pbbam/BgzipFastqWriter.h', 'pbbam/BgzipWriter.h', - 'pbbam/Cigar.h', - 'pbbam/CigarOperation.h', 'pbbam/ClipType.h', 'pbbam/CollectionMetadata.h', 'pbbam/Compare.h', @@ -46,21 +43,16 @@ 'pbbam/FastqWriter.h', 'pbbam/FormatUtils.h', 'pbbam/FrameEncodingType.h', - 'pbbam/Frames.h', - 'pbbam/GenomicInterval.h', 'pbbam/GenomicIntervalQuery.h', 'pbbam/IFastaWriter.h', 'pbbam/IFastqWriter.h', 'pbbam/IndexedBamWriter.h', 'pbbam/IndexedFastaReader.h', 'pbbam/IndexedFastqReader.h', - 'pbbam/Interval.h', 'pbbam/IRecordWriter.h', 'pbbam/LibraryInfo.h', - 'pbbam/LocalContextFlags.h', 'pbbam/MD5.h', 'pbbam/MoveAppend.h', - 'pbbam/Orientation.h', 'pbbam/PbbamVersion.h', 'pbbam/PbiBasicTypes.h', 'pbbam/PbiBuilder.h', @@ -70,12 +62,9 @@ 'pbbam/PbiFilterTypes.h', 'pbbam/PbiIndexedBamReader.h', 'pbbam/PbiRawData.h', - 'pbbam/Position.h', 'pbbam/ProgramInfo.h', 'pbbam/PulseBehavior.h', 'pbbam/PulseExclusionReason.h', - 'pbbam/QualityValue.h', - 'pbbam/QualityValues.h', 'pbbam/ReadGroupInfo.h', 'pbbam/RecordType.h', 'pbbam/RunMetadata.h', @@ -83,8 +72,6 @@ 'pbbam/SamTagCodec.h', 'pbbam/SamWriter.h', 'pbbam/SequenceInfo.h', - 'pbbam/SNR.h', - 'pbbam/Strand.h', 'pbbam/StringUtilities.h', 'pbbam/Tag.h', 'pbbam/TagCollection.h', diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Accuracy.h pbbam-2.3.0+dfsg/include/pbbam/Accuracy.h --- pbbam-2.1.0+dfsg/include/pbbam/Accuracy.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Accuracy.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_ACCURACY_H -#define PBBAM_ACCURACY_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using Accuracy PBBAM_DEPRECATED = Data::Accuracy; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_ACCURACY_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/BaiIndexedBamReader.h pbbam-2.3.0+dfsg/include/pbbam/BaiIndexedBamReader.h --- pbbam-2.1.0+dfsg/include/pbbam/BaiIndexedBamReader.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/BaiIndexedBamReader.h 2023-01-03 21:57:00.000000000 +0000 @@ -6,7 +6,8 @@ #include #include #include -#include + +#include #include @@ -56,8 +57,8 @@ /// \throws std::runtime_error if either file (*.bam or *.bai) fails to open /// for reading, or if the interval is invalid /// - BaiIndexedBamReader(const GenomicInterval& interval, std::string filename); - BaiIndexedBamReader(const GenomicInterval& interval, std::string filename, + BaiIndexedBamReader(const Data::GenomicInterval& interval, std::string filename); + BaiIndexedBamReader(const Data::GenomicInterval& interval, std::string filename, const std::shared_ptr& index); /// \brief Constructs %BAM reader, bounded by a genomic interval. @@ -70,8 +71,8 @@ /// \throws std::runtime_error if either file (*.bam or *.bai) fails to open /// for reading, or if the interval is invalid /// - BaiIndexedBamReader(const GenomicInterval& interval, BamFile bamFile); - BaiIndexedBamReader(const GenomicInterval& interval, BamFile bamFile, + BaiIndexedBamReader(const Data::GenomicInterval& interval, BamFile bamFile); + BaiIndexedBamReader(const Data::GenomicInterval& interval, BamFile bamFile, const std::shared_ptr& index); /// \} @@ -84,14 +85,14 @@ const BamFile& File() const; /// \returns the current GenomicInterval in use by this reader - const GenomicInterval& Interval() const; + const Data::GenomicInterval& Interval() const; /// \brief Sets a new genomic interval on the reader. /// /// \param[in] interval /// \returns reference to this reader /// - BaiIndexedBamReader& Interval(const GenomicInterval& interval); + BaiIndexedBamReader& Interval(const Data::GenomicInterval& interval); /// \} diff -Nru pbbam-2.1.0+dfsg/include/pbbam/BamRecord.h pbbam-2.3.0+dfsg/include/pbbam/BamRecord.h --- pbbam-2.1.0+dfsg/include/pbbam/BamRecord.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/BamRecord.h 2023-01-03 21:57:00.000000000 +0000 @@ -3,25 +3,25 @@ #include -#include #include #include #include #include -#include -#include -#include #include #include -#include #include #include -#include #include #include +#include +#include +#include #include +#include +#include #include +#include #include #include @@ -262,7 +262,7 @@ /// std::string ReferenceName() const; - /// \returns the record's reference end position, or UnmappedPosition if + /// \returns the record's reference end position, or UNMAPPED_POSITION if /// unmapped /// /// \note ReferenceEnd is in reference coordinates, NOT polymerase read @@ -270,7 +270,7 @@ /// Data::Position ReferenceEnd() const; - /// \returns the record's reference start position, or UnmappedPosition if + /// \returns the record's reference start position, or UNMAPPED_POSITION if /// unmapped /// /// \note ReferenceStart is in reference coordinates, NOT polymerase read @@ -846,8 +846,8 @@ /// \param[in] orientation Orientation of output. /// \returns PulseWidth as Frames object /// - Frames PulseWidthRaw(Orientation orientation = Orientation::NATIVE, bool aligned = false, - bool exciseSoftClips = false) const; + Data::Frames PulseWidthRaw(Data::Orientation orientation = Data::Orientation::NATIVE, + bool aligned = false, bool exciseSoftClips = false) const; /// \brief Fetches this record's reverse IPD values ("ri" tag). /// @@ -1143,7 +1143,7 @@ /// \param[in] labelQVs /// \returns reference to this record /// - BamRecord& LabelQV(const QualityValues& labelQVs); + BamRecord& LabelQV(const Data::QualityValues& labelQVs); /// \brief Sets this record's MergeQV values ("mq" tag). /// @@ -1522,8 +1522,8 @@ private: /// \internal /// cached positions (mutable to allow lazy-calc in const methods) - mutable Data::Position alignedStart_ = Data::UnmappedPosition; - mutable Data::Position alignedEnd_ = Data::UnmappedPosition; + mutable Data::Position alignedStart_ = Data::UNMAPPED_POSITION; + mutable Data::Position alignedEnd_ = Data::UNMAPPED_POSITION; private: /// \internal @@ -1550,7 +1550,8 @@ // sequence tags std::string FetchBasesRaw(BamRecordTag tag) const; - std::string FetchBases(BamRecordTag tag, Orientation orientation = Orientation::NATIVE, + std::string FetchBases(BamRecordTag tag, + Data::Orientation orientation = Data::Orientation::NATIVE, bool aligned = false, bool exciseSoftClips = false, PulseBehavior pulseBehavior = PulseBehavior::ALL) const; diff -Nru pbbam-2.1.0+dfsg/include/pbbam/BamRecordImpl.h pbbam-2.3.0+dfsg/include/pbbam/BamRecordImpl.h --- pbbam-2.1.0+dfsg/include/pbbam/BamRecordImpl.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/BamRecordImpl.h 2023-01-03 21:57:00.000000000 +0000 @@ -4,12 +4,13 @@ #include #include -#include #include -#include -#include #include +#include +#include +#include + #include #include @@ -242,7 +243,7 @@ /// Sets the record's CIGAR data using a Cigar object /// - /// \param[in] cigar PacBio::BAM::Cigar object + /// \param[in] cigar PacBio::Data::Cigar object /// \returns reference to this record /// BamRecordImpl& CigarData(const Data::Cigar& cigar); diff -Nru pbbam-2.1.0+dfsg/include/pbbam/BamRecordView.h pbbam-2.3.0+dfsg/include/pbbam/BamRecordView.h --- pbbam-2.1.0+dfsg/include/pbbam/BamRecordView.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/BamRecordView.h 2023-01-03 21:57:00.000000000 +0000 @@ -67,7 +67,7 @@ Data::QualityValues MergeQVs() const; /// \returns BamRecord::PulseMergeQV with this view's parameters applied - QualityValues PulseMergeQVs() const; + Data::QualityValues PulseMergeQVs() const; /// \returns BamRecord::Pkmean with this view's parameters applied std::vector Pkmean() const; diff -Nru pbbam-2.1.0+dfsg/include/pbbam/bed/BedReader.h pbbam-2.3.0+dfsg/include/pbbam/bed/BedReader.h --- pbbam-2.1.0+dfsg/include/pbbam/bed/BedReader.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/bed/BedReader.h 2023-01-03 21:57:00.000000000 +0000 @@ -3,9 +3,10 @@ #include -#include #include +#include + #include #include #include diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Cigar.h pbbam-2.3.0+dfsg/include/pbbam/Cigar.h --- pbbam-2.1.0+dfsg/include/pbbam/Cigar.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Cigar.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,20 +0,0 @@ -#ifndef PBBAM_CIGAR_H -#define PBBAM_CIGAR_H - -#include - -#include - -#include - -namespace PacBio { -namespace BAM { - -using Cigar PBBAM_DEPRECATED = PacBio::Data::Cigar; - -PBBAM_DEPRECATED constexpr auto ReferenceLength = PacBio::Data::ReferenceLength; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_CIGAR_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/CigarOperation.h pbbam-2.3.0+dfsg/include/pbbam/CigarOperation.h --- pbbam-2.1.0+dfsg/include/pbbam/CigarOperation.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/CigarOperation.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,20 +0,0 @@ -#ifndef PBBAM_CIGAROPERATION_H -#define PBBAM_CIGAROPERATION_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using CigarOperation PBBAM_DEPRECATED = PacBio::Data::CigarOperation; -using CigarOperationType PBBAM_DEPRECATED = PacBio::Data::CigarOperationType; - -PBBAM_DEPRECATED constexpr auto ConsumesQuery = PacBio::Data::ConsumesQuery; -PBBAM_DEPRECATED constexpr auto ConsumesReference = PacBio::Data::ConsumesReference; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_CIGAROPERATION_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/CompositeBamReader.h pbbam-2.3.0+dfsg/include/pbbam/CompositeBamReader.h --- pbbam-2.1.0+dfsg/include/pbbam/CompositeBamReader.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/CompositeBamReader.h 2023-01-03 21:57:00.000000000 +0000 @@ -10,9 +10,10 @@ #include #include #include -#include #include +#include + #include #include #include @@ -153,9 +154,9 @@ /// \throws std::runtime_error on failure to open/read underlying %BAM or /// BAI files. /// - GenomicIntervalCompositeBamReader(const GenomicInterval& interval, + GenomicIntervalCompositeBamReader(const Data::GenomicInterval& interval, const std::vector& bamFiles); - GenomicIntervalCompositeBamReader(const GenomicInterval& interval, + GenomicIntervalCompositeBamReader(const Data::GenomicInterval& interval, const std::vector& bamFiles, const BaiIndexCache& cache); @@ -168,8 +169,9 @@ /// \throws std::runtime_error on failure to open/read underlying %BAM or /// BAI files. /// - GenomicIntervalCompositeBamReader(const GenomicInterval& interval, const DataSet& dataset); - GenomicIntervalCompositeBamReader(const GenomicInterval& interval, const DataSet& dataset, + GenomicIntervalCompositeBamReader(const Data::GenomicInterval& interval, + const DataSet& dataset); + GenomicIntervalCompositeBamReader(const Data::GenomicInterval& interval, const DataSet& dataset, const BaiIndexCache& cache); /// \} @@ -182,17 +184,17 @@ /// /// \returns reference to this reader /// - GenomicIntervalCompositeBamReader& Interval(const GenomicInterval& interval); + GenomicIntervalCompositeBamReader& Interval(const Data::GenomicInterval& interval); /// \returns the current specified interval /// - const GenomicInterval& Interval() const; + const Data::GenomicInterval& Interval() const; /// \} private: BaiIndexCache indexCache_; - GenomicInterval interval_; + Data::GenomicInterval interval_; }; /// \brief Provides read access to multipe %BAM files, limiting results to those diff -Nru pbbam-2.1.0+dfsg/include/pbbam/DataSet.h pbbam-2.3.0+dfsg/include/pbbam/DataSet.h --- pbbam-2.1.0+dfsg/include/pbbam/DataSet.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/DataSet.h 2023-01-03 21:57:00.000000000 +0000 @@ -6,7 +6,8 @@ #include #include #include -#include + +#include #include #include @@ -444,7 +445,7 @@ /// \throws std::runtime_error if DataSet contains invalid or non-sensical /// filters, such as rname appearing twice, etc. /// - std::vector GenomicIntervals() const; + std::vector GenomicIntervals() const; /// \} diff -Nru pbbam-2.1.0+dfsg/include/pbbam/FastqSequence.h pbbam-2.3.0+dfsg/include/pbbam/FastqSequence.h --- pbbam-2.1.0+dfsg/include/pbbam/FastqSequence.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/FastqSequence.h 2023-01-03 21:57:00.000000000 +0000 @@ -4,7 +4,8 @@ #include #include -#include + +#include #include diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Frames.h pbbam-2.3.0+dfsg/include/pbbam/Frames.h --- pbbam-2.1.0+dfsg/include/pbbam/Frames.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Frames.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_FRAMES_H -#define PBBAM_FRAMES_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using Frames PBBAM_DEPRECATED = PacBio::Data::Frames; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_FRAMES_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/GenomicInterval.h pbbam-2.3.0+dfsg/include/pbbam/GenomicInterval.h --- pbbam-2.1.0+dfsg/include/pbbam/GenomicInterval.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/GenomicInterval.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_GENOMICINTERVAL_H -#define PBBAM_GENOMICINTERVAL_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using GenomicInterval PBBAM_DEPRECATED = Data::GenomicInterval; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_GENOMICINTERVAL_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/IndexedFastaReader.h pbbam-2.3.0+dfsg/include/pbbam/IndexedFastaReader.h --- pbbam-2.1.0+dfsg/include/pbbam/IndexedFastaReader.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/IndexedFastaReader.h 2023-01-03 21:57:00.000000000 +0000 @@ -4,10 +4,10 @@ #include #include -#include -#include #include +#include +#include #include #include diff -Nru pbbam-2.1.0+dfsg/include/pbbam/IndexedFastqReader.h pbbam-2.3.0+dfsg/include/pbbam/IndexedFastqReader.h --- pbbam-2.1.0+dfsg/include/pbbam/IndexedFastqReader.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/IndexedFastqReader.h 2023-01-03 21:57:00.000000000 +0000 @@ -5,12 +5,12 @@ #include #include -#include -#include -#include #include #include +#include +#include +#include #include #include diff -Nru pbbam-2.1.0+dfsg/include/pbbam/internal/PbiFilterTypes.inl pbbam-2.3.0+dfsg/include/pbbam/internal/PbiFilterTypes.inl --- pbbam-2.1.0+dfsg/include/pbbam/internal/PbiFilterTypes.inl 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/internal/PbiFilterTypes.inl 2023-01-03 21:57:00.000000000 +0000 @@ -83,7 +83,7 @@ } template <> -inline bool FilterBase::CompareSingleHelper(const LocalContextFlags& lhs) const +inline bool FilterBase::CompareSingleHelper(const Data::LocalContextFlags& lhs) const { switch (cmp_) { case Compare::EQUAL: @@ -182,16 +182,16 @@ } // this typedef exists purely so that the next method signature isn't 2 screen widths long -using LocalContextFilter__ = - BasicDataFilterBase; +using LocalContextFilterInternal = + BasicDataFilterBase; template <> -inline bool LocalContextFilter__::BasicDataFilterBase::Accepts(const PbiRawData& idx, +inline bool LocalContextFilterInternal::BasicDataFilterBase::Accepts(const PbiRawData& idx, const size_t row) const { const auto& basicData = idx.BasicData(); - const auto rowFlags = static_cast(basicData.ctxtFlag_.at(row)); - return FilterBase::CompareHelper(rowFlags); + const auto rowFlags = static_cast(basicData.ctxtFlag_.at(row)); + return FilterBase::CompareHelper(rowFlags); } // BasicDataFilterBase @@ -210,12 +210,12 @@ template <> inline bool -MappedDataFilterBase::MappedDataFilterBase::Accepts( +MappedDataFilterBase::MappedDataFilterBase::Accepts( const PbiRawData& idx, const size_t row) const { const PbiRawMappedData& mappedData = idx.MappedData(); - const Strand strand = (mappedData.revStrand_.at(row) == 1 ? Strand::REVERSE : Strand::FORWARD); - return FilterBase::CompareHelper(strand); + const Data::Strand strand = (mappedData.revStrand_.at(row) == 1 ? Data::Strand::REVERSE : Data::Strand::FORWARD); + return FilterBase::CompareHelper(strand); } template @@ -278,8 +278,8 @@ // PbiAlignedStrandFilter -inline PbiAlignedStrandFilter::PbiAlignedStrandFilter(const Strand strand, const Compare::Type cmp) - : internal::MappedDataFilterBase{strand, cmp} +inline PbiAlignedStrandFilter::PbiAlignedStrandFilter(const Data::Strand strand, const Compare::Type cmp) + : internal::MappedDataFilterBase{strand, cmp} { if (cmp != Compare::EQUAL && cmp != Compare::NOT_EQUAL) { throw std::runtime_error{ @@ -374,9 +374,9 @@ // PbiLocalContextFilter -inline PbiLocalContextFilter::PbiLocalContextFilter(const LocalContextFlags& flags, +inline PbiLocalContextFilter::PbiLocalContextFilter(const Data::LocalContextFlags& flags, const Compare::Type cmp) - : internal::BasicDataFilterBase{flags, + : internal::BasicDataFilterBase{flags, cmp} { } @@ -443,9 +443,9 @@ // PbiReadAccuracyFilter -inline PbiReadAccuracyFilter::PbiReadAccuracyFilter(const Accuracy accuracy, +inline PbiReadAccuracyFilter::PbiReadAccuracyFilter(const Data::Accuracy accuracy, const Compare::Type cmp) - : internal::BasicDataFilterBase{accuracy, cmp} + : internal::BasicDataFilterBase{accuracy, cmp} { } @@ -489,10 +489,10 @@ inline uint32_t BoostHashCombine(const int32_t zm) { - constexpr static const uint16_t mask = 0xFFFF; + constexpr uint16_t MASK = 0xFFFF; - const uint16_t upper = (zm >> 16) & mask; - const uint16_t lower = zm & mask; + const uint16_t upper = (zm >> 16) & MASK; + const uint16_t lower = zm & MASK; // FIXME: discrepancies with Python API. Will return to nail down. diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Interval.h pbbam-2.3.0+dfsg/include/pbbam/Interval.h --- pbbam-2.1.0+dfsg/include/pbbam/Interval.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Interval.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_INTERVAL_H -#define PBBAM_INTERVAL_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using Interval PBBAM_DEPRECATED = Data::Interval; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_INTERVAL_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/LocalContextFlags.h pbbam-2.3.0+dfsg/include/pbbam/LocalContextFlags.h --- pbbam-2.1.0+dfsg/include/pbbam/LocalContextFlags.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/LocalContextFlags.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,26 +0,0 @@ -#ifndef PBBAM_LOCALCONTEXTFLAGS_H -#define PBBAM_LOCALCONTEXTFLAGS_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using LocalContextFlags PBBAM_DEPRECATED = PacBio::Data::LocalContextFlags; - -using PacBio::Data::ADAPTER_AFTER; -using PacBio::Data::ADAPTER_AFTER_BAD; -using PacBio::Data::ADAPTER_BEFORE; -using PacBio::Data::ADAPTER_BEFORE_BAD; -using PacBio::Data::BARCODE_AFTER; -using PacBio::Data::BARCODE_BEFORE; -using PacBio::Data::FORWARD_PASS; -using PacBio::Data::NO_LOCAL_CONTEXT; -using PacBio::Data::REVERSE_PASS; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_LOCALCONTEXTFLAGS_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Orientation.h pbbam-2.3.0+dfsg/include/pbbam/Orientation.h --- pbbam-2.1.0+dfsg/include/pbbam/Orientation.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Orientation.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_ORIENTATION_H -#define PBBAM_ORIENTATION_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using Orientation PBBAM_DEPRECATED = PacBio::Data::Orientation; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_ORIENTATION_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/PbiFilterTypes.h pbbam-2.3.0+dfsg/include/pbbam/PbiFilterTypes.h --- pbbam-2.1.0+dfsg/include/pbbam/PbiFilterTypes.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/PbiFilterTypes.h 2023-01-03 21:57:00.000000000 +0000 @@ -170,7 +170,7 @@ /// \param[in] strand strand value to compare on /// \param[in] cmp compare type /// - PbiAlignedStrandFilter(Strand strand, Compare::Type cmp = Compare::EQUAL); + PbiAlignedStrandFilter(Data::Strand strand, Compare::Type cmp = Compare::EQUAL); }; /// \brief The PbiBarcodeFilter class provides a PbiFilter-compatible filter on diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Position.h pbbam-2.3.0+dfsg/include/pbbam/Position.h --- pbbam-2.1.0+dfsg/include/pbbam/Position.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Position.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,29 +0,0 @@ -#ifndef PBBAM_POSITION_H -#define PBBAM_POSITION_H - -#include - -#include - -#include - -namespace PacBio { -namespace BAM { - -/// \brief This type is used to refer to genomic positions. -/// \typedef typedef int32_t PacBio::BAM::Position -/// -/// We use a signed integer because SAM/BAM uses the -1 value to indicate -/// unknown or unmapped positions. -/// -using Position PBBAM_DEPRECATED = PacBio::Data::Position; - -/// \brief This constant is widely used as a "missing" or "invalid" position -/// marker. -/// -PBBAM_DEPRECATED constexpr Position UnmappedPosition{-1}; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_POSITION_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/QualityValue.h pbbam-2.3.0+dfsg/include/pbbam/QualityValue.h --- pbbam-2.1.0+dfsg/include/pbbam/QualityValue.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/QualityValue.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_QUALITYVALUE_H -#define PBBAM_QUALITYVALUE_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using QualityValue PBBAM_DEPRECATED = PacBio::Data::QualityValue; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_QUALITYVALUE_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/QualityValues.h pbbam-2.3.0+dfsg/include/pbbam/QualityValues.h --- pbbam-2.1.0+dfsg/include/pbbam/QualityValues.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/QualityValues.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,18 +0,0 @@ -#ifndef PBBAM_QUALITYVALUES_H -#define PBBAM_QUALITYVALUES_H - -#include - -#include - -#include - -namespace PacBio { -namespace BAM { - -using QualityValues PBBAM_DEPRECATED = PacBio::Data::QualityValues; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_QUALITYVALUES_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/ReadGroupInfo.h pbbam-2.3.0+dfsg/include/pbbam/ReadGroupInfo.h --- pbbam-2.1.0+dfsg/include/pbbam/ReadGroupInfo.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/ReadGroupInfo.h 2023-01-03 21:57:00.000000000 +0000 @@ -88,7 +88,8 @@ ASTRO, RS, SEQUEL, - SEQUELII + SEQUELII, + REVIO, }; /// \brief Aggregate to simplify ReadGroupInfo constructor. diff -Nru pbbam-2.1.0+dfsg/include/pbbam/SNR.h pbbam-2.3.0+dfsg/include/pbbam/SNR.h --- pbbam-2.1.0+dfsg/include/pbbam/SNR.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/SNR.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,18 +0,0 @@ -#ifndef PBBAM_SNR_H -#define PBBAM_SNR_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using SNR PBBAM_DEPRECATED = PacBio::Data::SNR; - -PBBAM_DEPRECATED constexpr auto ClampSNR = PacBio::Data::ClampSNR; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_SNR_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Strand.h pbbam-2.3.0+dfsg/include/pbbam/Strand.h --- pbbam-2.1.0+dfsg/include/pbbam/Strand.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Strand.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,16 +0,0 @@ -#ifndef PBBAM_STRAND_H -#define PBBAM_STRAND_H - -#include - -#include - -namespace PacBio { -namespace BAM { - -using Strand PBBAM_DEPRECATED = PacBio::Data::Strand; - -} // namespace BAM -} // namespace PacBio - -#endif // PBBAM_STRAND_H diff -Nru pbbam-2.1.0+dfsg/include/pbbam/Tag.h pbbam-2.3.0+dfsg/include/pbbam/Tag.h --- pbbam-2.1.0+dfsg/include/pbbam/Tag.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/Tag.h 2023-01-03 21:57:00.000000000 +0000 @@ -3,10 +3,9 @@ #include -#include - #include #include +#include #include #include @@ -19,7 +18,7 @@ /// enum class TagDataType { - INVALID = 0, ///< boost::blank + INVALID = 0, ///< std::monostate INT8, ///< int8_t UINT8, ///< uint8_t INT16, ///< int16_t @@ -165,7 +164,7 @@ Tag() = default; - Tag& operator=(boost::blank value); + Tag& operator=(std::monostate value); Tag& operator=(int8_t value); Tag& operator=(uint8_t value); Tag& operator=(int16_t value); @@ -394,22 +393,22 @@ // clang-format off // NOTE - keep this synced with TagDataType enum ordering - using var_t = boost::variant, - std::vector, - std::vector, - std::vector, - std::vector, - std::vector, - std::vector >; + using var_t = std::variant, + std::vector, + std::vector, + std::vector, + std::vector, + std::vector, + std::vector >; // clang-format on private: diff -Nru pbbam-2.1.0+dfsg/include/pbbam/vcf/VcfFormat.h pbbam-2.3.0+dfsg/include/pbbam/vcf/VcfFormat.h --- pbbam-2.1.0+dfsg/include/pbbam/vcf/VcfFormat.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/vcf/VcfFormat.h 2023-01-03 21:57:00.000000000 +0000 @@ -8,6 +8,7 @@ #include #include +#include namespace PacBio { namespace VCF { @@ -18,7 +19,7 @@ /// \name General format info /// \{ - static const char* CurrentVersion(); + static std::string_view CurrentVersion(); /// \} diff -Nru pbbam-2.1.0+dfsg/include/pbbam/vcf/VcfVariant.h pbbam-2.3.0+dfsg/include/pbbam/vcf/VcfVariant.h --- pbbam-2.1.0+dfsg/include/pbbam/vcf/VcfVariant.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/vcf/VcfVariant.h 2023-01-03 21:57:00.000000000 +0000 @@ -3,9 +3,10 @@ #include -#include #include +#include + #include #include #include diff -Nru pbbam-2.1.0+dfsg/include/pbbam/virtual/VirtualRegion.h pbbam-2.3.0+dfsg/include/pbbam/virtual/VirtualRegion.h --- pbbam-2.1.0+dfsg/include/pbbam/virtual/VirtualRegion.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/include/pbbam/virtual/VirtualRegion.h 2023-01-03 21:57:00.000000000 +0000 @@ -3,9 +3,10 @@ #include -#include #include +#include + namespace PacBio { namespace BAM { diff -Nru pbbam-2.1.0+dfsg/meson.build pbbam-2.3.0+dfsg/meson.build --- pbbam-2.1.0+dfsg/meson.build 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/meson.build 2023-01-03 21:57:00.000000000 +0000 @@ -1,7 +1,7 @@ project( 'PacBioBAM', - 'cpp', - version : '2.1.0', + ['cpp', 'c'], + version : '2.3.0', default_options : [ 'buildtype=release', 'warning_level=3', diff -Nru pbbam-2.1.0+dfsg/src/BamHeader.cpp pbbam-2.3.0+dfsg/src/BamHeader.cpp --- pbbam-2.1.0+dfsg/src/BamHeader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/BamHeader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -375,11 +375,24 @@ ReadGroupInfo BamHeader::ReadGroup(const std::string& id) const { - const auto iter = d_->readGroups_.find(id); - if (iter == d_->readGroups_.cend()) { - throw std::runtime_error{"[pbbam] BAM header ERROR: read group ID not found: " + id}; + // standard ID lookup + auto found = d_->readGroups_.find(id); + if (found != std::cend(d_->readGroups_)) { + return found->second; } - return iter->second; + + // verbatim ID not found, see if we are mixing correct & legacy IDs + const size_t slashFound = id.find('/'); + if (slashFound != std::string::npos) { + const std::string trimmedId = id.substr(0, slashFound); + found = d_->readGroups_.find(trimmedId); + if (found != std::cend(d_->readGroups_)) { + return found->second; + } + } + + // no match found + throw std::runtime_error{"[pbbam] BAM header ERROR: read group ID not found: " + id}; } std::vector BamHeader::ReadGroupIds() const diff -Nru pbbam-2.1.0+dfsg/src/BamRecord.cpp pbbam-2.3.0+dfsg/src/BamRecord.cpp --- pbbam-2.1.0+dfsg/src/BamRecord.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/BamRecord.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -392,7 +392,7 @@ Data::Position BamRecord::AlignedEnd() const { - if (alignedEnd_ == Data::UnmappedPosition) { + if (alignedEnd_ == Data::UNMAPPED_POSITION) { CalculateAlignedPositions(); } return alignedEnd_; @@ -400,7 +400,7 @@ Data::Position BamRecord::AlignedStart() const { - if (alignedStart_ == Data::UnmappedPosition) { + if (alignedStart_ == Data::UNMAPPED_POSITION) { CalculateAlignedPositions(); } return alignedStart_; @@ -508,7 +508,7 @@ const Data::Position qStart = isCcsOrTranscript ? 0 : QueryStart(); const Data::Position qEnd = isCcsOrTranscript ? seqLength : QueryEnd(); - if (qStart == Data::UnmappedPosition || qEnd == Data::UnmappedPosition) { + if (qStart == Data::UNMAPPED_POSITION || qEnd == Data::UNMAPPED_POSITION) { return; } @@ -1667,8 +1667,8 @@ } // reset any cached aligned start/end - alignedStart_ = Data::UnmappedPosition; - alignedEnd_ = Data::UnmappedPosition; + alignedStart_ = Data::UNMAPPED_POSITION; + alignedEnd_ = Data::UNMAPPED_POSITION; return *this; } @@ -1758,10 +1758,11 @@ assert(boost::algorithm::starts_with(str, "C+m")); assert(boost::algorithm::ends_with(str, ";")); - const char* strView = str.c_str() + 3; // skip the "C+m" prefix - const int32_t strLen = str.size() - 3; + const int32_t skipPrefix = 3 + boost::algorithm::starts_with(str, "C+m?"); + const char* strView = str.c_str() + skipPrefix; // skip the "C+m?" or "C+m" prefix + const int32_t strLen = str.size() - skipPrefix; - // convert "C+m,3,1,4;" to std::vector{3, 1, 4} + // convert "C+m?,3,1,4;" to std::vector{3, 1, 4} std::vector result; int32_t currentNumber = 0; assert((strView[0] == ',') || @@ -1786,7 +1787,7 @@ std::string BamRecord::SplitBasemods::SeparatingCToString(const std::vector& vec) { std::ostringstream newBasemodsString; - newBasemodsString << "C+m"; + newBasemodsString << "C+m?"; for (const auto val : vec) { newBasemodsString << ',' << val; } @@ -2328,11 +2329,11 @@ Data::Position BamRecord::ReferenceEnd() const { if (!impl_.IsMapped()) { - return Data::UnmappedPosition; + return Data::UNMAPPED_POSITION; } const auto& htsData = BamRecordMemory::GetRawData(impl_); if (!htsData) { - return Data::UnmappedPosition; + return Data::UNMAPPED_POSITION; } return bam_endpos(htsData.get()); } @@ -2389,14 +2390,14 @@ void BamRecord::ResetCachedPositions() const { - alignedEnd_ = Data::UnmappedPosition; - alignedStart_ = Data::UnmappedPosition; + alignedEnd_ = Data::UNMAPPED_POSITION; + alignedStart_ = Data::UNMAPPED_POSITION; } void BamRecord::ResetCachedPositions() { - alignedEnd_ = Data::UnmappedPosition; - alignedStart_ = Data::UnmappedPosition; + alignedEnd_ = Data::UNMAPPED_POSITION; + alignedStart_ = Data::UNMAPPED_POSITION; } VirtualRegionType BamRecord::ScrapRegionType() const @@ -2469,8 +2470,8 @@ return *this; } -QualityValues BamRecord::SubstitutionQV(Data::Orientation orientation, bool aligned, - bool exciseSoftClips) const +Data::QualityValues BamRecord::SubstitutionQV(Data::Orientation orientation, bool aligned, + bool exciseSoftClips) const { return FetchQualities(BamRecordTag::SUBSTITUTION_QV, orientation, aligned, exciseSoftClips); } diff -Nru pbbam-2.1.0+dfsg/src/BamRecordImpl.cpp pbbam-2.3.0+dfsg/src/BamRecordImpl.cpp --- pbbam-2.1.0+dfsg/src/BamRecordImpl.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/BamRecordImpl.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -191,7 +191,7 @@ std::vector cigarData(cigar.size()); cigarData.reserve(cigar.size()); for (size_t i = 0; i < cigar.size(); ++i) { - const CigarOperation& op = cigar.at(i); + const Data::CigarOperation& op = cigar.at(i); cigarData[i] = bam_cigar_gen(op.Length(), static_cast(op.Type())); } if (HasTag("CG")) { @@ -214,7 +214,7 @@ BamRecordImpl& BamRecordImpl::CigarData(const std::string& cigarString) { - return CigarData(Cigar::FromStdString(cigarString)); + return CigarData(Data::Cigar::FromStdString(cigarString)); } bool BamRecordImpl::EditTag(const std::string& tagName, const Tag& newValue) @@ -303,8 +303,8 @@ d_.reset(bam_init1()); // init unmapped - Position(Data::UnmappedPosition); - MatePosition(Data::UnmappedPosition); + Position(Data::UNMAPPED_POSITION); + MatePosition(Data::UNMAPPED_POSITION); ReferenceId(-1); MateReferenceId(-1); SetMapped(false); @@ -512,11 +512,11 @@ std::string BamRecordImpl::Sequence() const { std::string result(d_->core.l_qseq, '\0'); - static const constexpr std::array DnaLookup{ + constexpr std::array DNA_LOOKUP{ {'=', 'A', 'C', 'M', 'G', 'R', 'S', 'V', 'T', 'W', 'Y', 'H', 'K', 'D', 'B', 'N'}}; const uint8_t* seqData = bam_get_seq(d_); for (int i = 0; i < d_->core.l_qseq; ++i) { - result[i] = DnaLookup[bam_seqi(seqData, i)]; + result[i] = DNA_LOOKUP[bam_seqi(seqData, i)]; } return result; } diff -Nru pbbam-2.1.0+dfsg/src/BamTagCodec.cpp pbbam-2.3.0+dfsg/src/BamTagCodec.cpp --- pbbam-2.1.0+dfsg/src/BamTagCodec.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/BamTagCodec.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -8,6 +8,8 @@ #include #include +#include + namespace PacBio { namespace BAM { namespace { diff -Nru pbbam-2.1.0+dfsg/src/bed/BedWriter.cpp pbbam-2.3.0+dfsg/src/bed/BedWriter.cpp --- pbbam-2.1.0+dfsg/src/bed/BedWriter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/bed/BedWriter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -2,9 +2,10 @@ #include -#include #include +#include + #include #include diff -Nru pbbam-2.1.0+dfsg/src/ChemistryTable.cpp pbbam-2.3.0+dfsg/src/ChemistryTable.cpp --- pbbam-2.1.0+dfsg/src/ChemistryTable.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/ChemistryTable.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -175,8 +175,9 @@ {{"101-894-200", "102-186-000", "5.0", "S/P5-C2/5.0-8M"}}, // Sequel® II Binding Kit 2.2; Sequel II Sequencing Plate 3.0 (1 rxn), QC {{"101-894-200", "102-186-100", "5.0", "S/P5-C2/5.0-8M"}}, - // Future PN placeholder; SequencingChemistry and SoftwareVersion need to be reviewed/updated prior to integration/release - {{"101-894-200", "102-118-800", "5.0", "S/P5-C2/5.0-8M"}}, + + // Deprecated engineering tuple, remove prior to release, update product name prior to release + {{"101-894-200", "102-118-800", "5.0", "R/P1-C1/5.0-25M"}}, // Sequel® II Binding Kit 3.1; Sequel® II Sequencing Plate 2.0EA (4 Rxn) {{"102-194-200", "101-789-300", "5.0", "S/P5-C2/5.0-8M", "TAGT-5381"}}, @@ -199,6 +200,15 @@ {{"102-194-100", "102-186-100", "5.0", "S/P5-C2/5.0-8M", "TAGT-5381"}}, // Sequel® II Binding Kit 3.2; Sequel® II Sequencing Plate 2.0 (4 Rxn) - QC {{"102-194-100", "101-820-300", "5.0", "S/P5-C2/5.0-8M", "TAGT-5381"}}, + + // Revio® Kit; Revio® Sequencing Plate 1.0 (4 rxn) + {{"102-739-100", "102-118-800", "5.0", "R/P1-C1/5.0-25M"}}, + // Revio® Kit; Revio® Sequencing Plate 1.0 (1 rxn) + {{"102-739-100", "102-412-400", "5.0", "R/P1-C1/5.0-25M"}}, + // Revio® Kit; Revio® Sequencing Plate QC + {{"102-739-100", "102-118-900", "5.0", "R/P1-C1/5.0-25M"}}, + // Revio® Kit; Revio® Sequencing Plate Internal + {{"102-739-100", "102-171-000", "5.0", "R/P1-C1/5.0-25M"}}, }; return builtin; diff -Nru pbbam-2.1.0+dfsg/src/CollectionMetadata.cpp pbbam-2.3.0+dfsg/src/CollectionMetadata.cpp --- pbbam-2.1.0+dfsg/src/CollectionMetadata.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/CollectionMetadata.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -121,7 +121,10 @@ AutomationParameters() = params; return *this; } -bool Automation::HasAutomationParameters() const { return HasChild(Element::AutomationParameters); } +bool Automation::HasAutomationParameters() const +{ + return HasChild(Element::AUTOMATION_PARAMETERS); +} // ---------------------- // AutomationParameter @@ -215,201 +218,207 @@ int32_t AutomationParameters::CellNFCIndex() const { - return std::stoi(GetParameter(Element::CellNFCIndex)); + return std::stoi(GetParameter(Element::CELL_NFC_INDEX)); } AutomationParameters& AutomationParameters::CellNFCIndex(int32_t i) { - return SetParameter(Element::CellNFCIndex, "Int32", std::to_string(i)); + return SetParameter(Element::CELL_NFC_INDEX, "Int32", std::to_string(i)); } -bool AutomationParameters::HasCellNFCIndex() const { return HasParameter(Element::CellNFCIndex); } +bool AutomationParameters::HasCellNFCIndex() const { return HasParameter(Element::CELL_NFC_INDEX); } int32_t AutomationParameters::CollectionNumber() const { - return std::stoi(GetParameter(Element::CollectionNumber)); + return std::stoi(GetParameter(Element::COLLECTION_NUMBER)); } AutomationParameters& AutomationParameters::CollectionNumber(int32_t i) { - return SetParameter(Element::CollectionNumber, "Int32", std::to_string(i)); + return SetParameter(Element::COLLECTION_NUMBER, "Int32", std::to_string(i)); } bool AutomationParameters::HasCollectionNumber() const { - return HasParameter(Element::CellNFCIndex); + return HasParameter(Element::CELL_NFC_INDEX); } -double AutomationParameters::Exposure() const { return std::stod(GetParameter(Element::Exposure)); } +double AutomationParameters::Exposure() const { return std::stod(GetParameter(Element::EXPOSURE)); } AutomationParameters& AutomationParameters::Exposure(double d) { - return SetParameter(Element::Exposure, "Double", std::to_string(d)); + return SetParameter(Element::EXPOSURE, "Double", std::to_string(d)); } -bool AutomationParameters::HasExposure() const { return HasParameter(Element::Exposure); } +bool AutomationParameters::HasExposure() const { return HasParameter(Element::EXPOSURE); } bool AutomationParameters::ExtendFirst() const { - return boost::iequals(GetParameter(Element::ExtendFirst), "True"); + return boost::iequals(GetParameter(Element::EXTEND_FIRST), "True"); } AutomationParameters& AutomationParameters::ExtendFirst(bool ok) { - return SetParameter(Element::ExtendFirst, "Boolean", (ok ? "True" : "False")); + return SetParameter(Element::EXTEND_FIRST, "Boolean", (ok ? "True" : "False")); } -bool AutomationParameters::HasExtendFirst() const { return HasParameter(Element::ExtendFirst); } +bool AutomationParameters::HasExtendFirst() const { return HasParameter(Element::EXTEND_FIRST); } double AutomationParameters::ExtensionTime() const { - return std::stod(GetParameter(Element::ExtensionTime)); + return std::stod(GetParameter(Element::EXTENSION_TIME)); } AutomationParameters& AutomationParameters::ExtensionTime(double d) { - return SetParameter(Element::ExtensionTime, "Double", std::to_string(d)); + return SetParameter(Element::EXTENSION_TIME, "Double", std::to_string(d)); } -bool AutomationParameters::HasExtensionTime() const { return HasParameter(Element::ExtensionTime); } +bool AutomationParameters::HasExtensionTime() const +{ + return HasParameter(Element::EXTENSION_TIME); +} int32_t AutomationParameters::ExtraIMWashes() const { - return std::stoi(GetParameter(Element::ExtraIMWashes)); + return std::stoi(GetParameter(Element::EXTRA_IM_WASHES)); } AutomationParameters& AutomationParameters::ExtraIMWashes(int32_t i) { - return SetParameter(Element::ExtraIMWashes, "Int32", std::to_string(i)); + return SetParameter(Element::EXTRA_IM_WASHES, "Int32", std::to_string(i)); } -bool AutomationParameters::HasExtraIMWashes() const { return HasParameter(Element::ExtraIMWashes); } +bool AutomationParameters::HasExtraIMWashes() const +{ + return HasParameter(Element::EXTRA_IM_WASHES); +} bool AutomationParameters::HasN2Switch() const { - return boost::iequals(GetParameter(Element::HasN2Switch), "True"); + return boost::iequals(GetParameter(Element::HAS_N2_SWITCH), "True"); } AutomationParameters& AutomationParameters::HasN2Switch(bool ok) { - return SetParameter(Element::HasN2Switch, "Boolean", (ok ? "True" : "False")); + return SetParameter(Element::HAS_N2_SWITCH, "Boolean", (ok ? "True" : "False")); } -bool AutomationParameters::HasHasN2Switch() const { return HasParameter(Element::HasN2Switch); } +bool AutomationParameters::HasHasN2Switch() const { return HasParameter(Element::HAS_N2_SWITCH); } -std::string AutomationParameters::HQRFMethod() const { return GetParameter(Element::HQRFMethod); } +std::string AutomationParameters::HQRFMethod() const { return GetParameter(Element::HQRF_METHOD); } AutomationParameters& AutomationParameters::HQRFMethod(std::string s) { - return SetParameter(Element::HQRFMethod, "String", s); + return SetParameter(Element::HQRF_METHOD, "String", s); } -bool AutomationParameters::HasHQRFMethod() const { return HasParameter(Element::HQRFMethod); } +bool AutomationParameters::HasHQRFMethod() const { return HasParameter(Element::HQRF_METHOD); } double AutomationParameters::ImmobilizationTime() const { - return std::stod(GetParameter(Element::ImmobilizationTime)); + return std::stod(GetParameter(Element::IMMOBILIZATION_TIME)); } AutomationParameters& AutomationParameters::ImmobilizationTime(double d) { - return SetParameter(Element::ImmobilizationTime, "Double", std::to_string(d)); + return SetParameter(Element::IMMOBILIZATION_TIME, "Double", std::to_string(d)); } bool AutomationParameters::HasImmobilizationTime() const { - return HasParameter(Element::ImmobilizationTime); + return HasParameter(Element::IMMOBILIZATION_TIME); } int32_t AutomationParameters::InsertSize() const { - return std::stoi(GetParameter(Element::InsertSize)); + return std::stoi(GetParameter(Element::INSERT_SIZE)); } AutomationParameters& AutomationParameters::InsertSize(int32_t i) { - return SetParameter(Element::InsertSize, "Int32", std::to_string(i)); + return SetParameter(Element::INSERT_SIZE, "Int32", std::to_string(i)); } -bool AutomationParameters::HasInsertSize() const { return HasParameter(Element::InsertSize); } +bool AutomationParameters::HasInsertSize() const { return HasParameter(Element::INSERT_SIZE); } double AutomationParameters::MovieLength() const { - return std::stod(GetParameter(Element::MovieLength)); + return std::stod(GetParameter(Element::MOVIE_LENGTH)); } AutomationParameters& AutomationParameters::MovieLength(double d) { - return SetParameter(Element::ImmobilizationTime, "Double", std::to_string(d)); + return SetParameter(Element::IMMOBILIZATION_TIME, "Double", std::to_string(d)); } -bool AutomationParameters::HasMovieLength() const { return HasParameter(Element::MovieLength); } +bool AutomationParameters::HasMovieLength() const { return HasParameter(Element::MOVIE_LENGTH); } bool AutomationParameters::PCDinPlate() const { - return boost::iequals(GetParameter(Element::PCDinPlate), "True"); + return boost::iequals(GetParameter(Element::PCD_IN_PLATE), "True"); } AutomationParameters& AutomationParameters::PCDinPlate(bool ok) { - return SetParameter(Element::PCDinPlate, "Boolean", (ok ? "True" : "False")); + return SetParameter(Element::PCD_IN_PLATE, "Boolean", (ok ? "True" : "False")); } -bool AutomationParameters::HasPCDinPlate() const { return HasParameter(Element::PCDinPlate); } +bool AutomationParameters::HasPCDinPlate() const { return HasParameter(Element::PCD_IN_PLATE); } bool AutomationParameters::PreExtensionWorkflow() const { - return boost::iequals(GetParameter(Element::PreExtensionWorkflow), "True"); + return boost::iequals(GetParameter(Element::PRE_EXTENSION_WORKFLOW), "True"); } AutomationParameters& AutomationParameters::PreExtensionWorkflow(bool ok) { - return SetParameter(Element::PreExtensionWorkflow, "Boolean", (ok ? "True" : "False")); + return SetParameter(Element::PRE_EXTENSION_WORKFLOW, "Boolean", (ok ? "True" : "False")); } bool AutomationParameters::HasPreExtensionWorkflow() const { - return HasParameter(Element::PreExtensionWorkflow); + return HasParameter(Element::PRE_EXTENSION_WORKFLOW); } -double AutomationParameters::SNRCut() const { return std::stod(GetParameter(Element::SNRCut)); } +double AutomationParameters::SNRCut() const { return std::stod(GetParameter(Element::SNR_CUT)); } AutomationParameters& AutomationParameters::SNRCut(double d) { - return SetParameter(Element::SNRCut, "Double", std::to_string(d)); + return SetParameter(Element::SNR_CUT, "Double", std::to_string(d)); } -bool AutomationParameters::HasSNRCut() const { return HasParameter(Element::SNRCut); } +bool AutomationParameters::HasSNRCut() const { return HasParameter(Element::SNR_CUT); } int32_t AutomationParameters::TipSearchMaxDuration() const { - return std::stoi(GetParameter(Element::TipSearchMaxDuration)); + return std::stoi(GetParameter(Element::TIP_SEARCH_MAX_DURATION)); } AutomationParameters& AutomationParameters::TipSearchMaxDuration(int32_t i) { - return SetParameter(Element::TipSearchMaxDuration, "Int32", std::to_string(i)); + return SetParameter(Element::TIP_SEARCH_MAX_DURATION, "Int32", std::to_string(i)); } bool AutomationParameters::HasTipSearchMaxDuration() const { - return HasParameter(Element::TipSearchMaxDuration); + return HasParameter(Element::TIP_SEARCH_MAX_DURATION); } bool AutomationParameters::UseStageHotStart() const { - return boost::iequals(GetParameter(Element::UseStageHotStart), "True"); + return boost::iequals(GetParameter(Element::USE_STAGE_HOT_START), "True"); } AutomationParameters& AutomationParameters::UseStageHotStart(bool ok) { - return SetParameter(Element::UseStageHotStart, "Boolean", (ok ? "True" : "False")); + return SetParameter(Element::USE_STAGE_HOT_START, "Boolean", (ok ? "True" : "False")); return *this; } bool AutomationParameters::HasUseStageHotStart() const { - return HasParameter(Element::UseStageHotStart); + return HasParameter(Element::USE_STAGE_HOT_START); } std::string AutomationParameters::GetParameter(const std::string& param) const @@ -467,17 +476,17 @@ : internal::DataSetElement{"", fromInputXml, XsdType::COLLECTION_METADATA} {} -const std::string& BindingKit::PartNumber() const { return Attribute(Element::PartNumber); } +const std::string& BindingKit::PartNumber() const { return Attribute(Element::PART_NUMBER); } -std::string& BindingKit::PartNumber() { return Attribute(Element::PartNumber); } +std::string& BindingKit::PartNumber() { return Attribute(Element::PART_NUMBER); } BindingKit& BindingKit::PartNumber(std::string s) { - Attribute(Element::PartNumber, s); + Attribute(Element::PART_NUMBER, s); return *this; } -bool BindingKit::HasPartNumber() { return HasAttribute(Element::PartNumber); } +bool BindingKit::HasPartNumber() { return HasAttribute(Element::PART_NUMBER); } // ---------------------- // Collections @@ -504,16 +513,16 @@ : internal::DataSetElement{"", fromInputXml, XsdType::COLLECTION_METADATA} {} -const std::string& ControlKit::PartNumber() const { return Attribute(Element::PartNumber); } +const std::string& ControlKit::PartNumber() const { return Attribute(Element::PART_NUMBER); } -std::string& ControlKit::PartNumber() { return Attribute(Element::PartNumber); } +std::string& ControlKit::PartNumber() { return Attribute(Element::PART_NUMBER); } ControlKit& ControlKit::PartNumber(std::string s) { - Attribute(Element::PartNumber, s); + Attribute(Element::PART_NUMBER, s); return *this; } -bool ControlKit::HasPartNumber() const { return HasAttribute(Element::PartNumber); } +bool ControlKit::HasPartNumber() const { return HasAttribute(Element::PART_NUMBER); } const std::string& ControlKit::LeftAdapter() const { @@ -607,17 +616,20 @@ : internal::DataSetElement{"", fromInputXml, XsdType::COLLECTION_METADATA} {} -const std::string& SequencingKitPlate::PartNumber() const { return Attribute(Element::PartNumber); } +const std::string& SequencingKitPlate::PartNumber() const +{ + return Attribute(Element::PART_NUMBER); +} -std::string& SequencingKitPlate::PartNumber() { return Attribute(Element::PartNumber); } +std::string& SequencingKitPlate::PartNumber() { return Attribute(Element::PART_NUMBER); } SequencingKitPlate& SequencingKitPlate::PartNumber(std::string s) { - Attribute(Element::PartNumber, s); + Attribute(Element::PART_NUMBER, s); return *this; } -bool SequencingKitPlate::HasPartNumber() const { return HasAttribute(Element::PartNumber); } +bool SequencingKitPlate::HasPartNumber() const { return HasAttribute(Element::PART_NUMBER); } // ---------------------- // TemplatePrepKit @@ -631,83 +643,83 @@ : internal::DataSetElement{"", fromInputXml, XsdType::COLLECTION_METADATA} {} -const std::string& TemplatePrepKit::PartNumber() const { return Attribute(Element::PartNumber); } +const std::string& TemplatePrepKit::PartNumber() const { return Attribute(Element::PART_NUMBER); } -std::string& TemplatePrepKit::PartNumber() { return Attribute(Element::PartNumber); } +std::string& TemplatePrepKit::PartNumber() { return Attribute(Element::PART_NUMBER); } TemplatePrepKit& TemplatePrepKit::PartNumber(std::string s) { - Attribute(Element::PartNumber, s); + Attribute(Element::PART_NUMBER, s); return *this; } bool TemplatePrepKit::TemplatePrepKit::HasPartNumber() const { - return HasAttribute(Element::PartNumber); + return HasAttribute(Element::PART_NUMBER); } std::string TemplatePrepKit::LeftAdaptorSequence() const { - return ChildText(Element::LeftAdaptorSequence); + return ChildText(Element::LEFT_ADAPTOR_SEQUENCE); } TemplatePrepKit& TemplatePrepKit::LeftAdaptorSequence(std::string s) { - ChildText(Element::LeftAdaptorSequence, s); + ChildText(Element::LEFT_ADAPTOR_SEQUENCE, s); return *this; } bool TemplatePrepKit::HasLeftAdaptorSequence() const { - return HasChild(Element::LeftAdaptorSequence); + return HasChild(Element::LEFT_ADAPTOR_SEQUENCE); } std::string TemplatePrepKit::LeftPrimerSequence() const { - return ChildText(Element::LeftPrimerSequence); + return ChildText(Element::LEFT_PRIMER_SEQUENCE); } TemplatePrepKit& TemplatePrepKit::LeftPrimerSequence(std::string s) { - ChildText(Element::LeftPrimerSequence, s); + ChildText(Element::LEFT_PRIMER_SEQUENCE, s); return *this; } bool TemplatePrepKit::HasLeftPrimerSequence() const { - return HasChild(Element::LeftPrimerSequence); + return HasChild(Element::LEFT_PRIMER_SEQUENCE); } std::string TemplatePrepKit::RightAdaptorSequence() const { - return ChildText(Element::RightAdaptorSequence); + return ChildText(Element::RIGHT_ADAPTOR_SEQUENCE); } TemplatePrepKit& TemplatePrepKit::RightAdaptorSequence(std::string s) { - ChildText(Element::RightAdaptorSequence, s); + ChildText(Element::RIGHT_ADAPTOR_SEQUENCE, s); return *this; } bool TemplatePrepKit::HasRightAdaptorSequence() const { - return HasChild(Element::RightAdaptorSequence); + return HasChild(Element::RIGHT_ADAPTOR_SEQUENCE); } std::string TemplatePrepKit::RightPrimerSequence() const { - return ChildText(Element::RightPrimerSequence); + return ChildText(Element::RIGHT_PRIMER_SEQUENCE); } TemplatePrepKit& TemplatePrepKit::RightPrimerSequence(std::string s) { - ChildText(Element::RightPrimerSequence, s); + ChildText(Element::RIGHT_PRIMER_SEQUENCE, s); return *this; } bool TemplatePrepKit::HasRightPrimerSequence() const { - return HasChild(Element::RightPrimerSequence); + return HasChild(Element::RIGHT_PRIMER_SEQUENCE); } // ---------------------- @@ -747,7 +759,7 @@ return *this; } -bool CollectionMetadata::HasAutomation() const { return HasChild(Element::Automation); } +bool CollectionMetadata::HasAutomation() const { return HasChild(Element::AUTOMATION); } const BAM::AutomationParameters& CollectionMetadata::AutomationParameters() const { diff -Nru pbbam-2.1.0+dfsg/src/CompositeBamReader.cpp pbbam-2.3.0+dfsg/src/CompositeBamReader.cpp --- pbbam-2.1.0+dfsg/src/CompositeBamReader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/CompositeBamReader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -37,12 +37,12 @@ {} GenomicIntervalCompositeBamReader::GenomicIntervalCompositeBamReader( - const GenomicInterval& interval, const std::vector& bamFiles) + const Data::GenomicInterval& interval, const std::vector& bamFiles) : GenomicIntervalCompositeBamReader{interval, bamFiles, MakeBaiIndexCache(bamFiles)} {} GenomicIntervalCompositeBamReader::GenomicIntervalCompositeBamReader( - const GenomicInterval& interval, const std::vector& bamFiles, + const Data::GenomicInterval& interval, const std::vector& bamFiles, const BaiIndexCache& cache) : GenomicIntervalCompositeBamReader{bamFiles, cache} { @@ -50,19 +50,22 @@ } GenomicIntervalCompositeBamReader::GenomicIntervalCompositeBamReader( - const GenomicInterval& interval, const DataSet& dataset) + const Data::GenomicInterval& interval, const DataSet& dataset) : GenomicIntervalCompositeBamReader{interval, dataset.BamFiles()} {} GenomicIntervalCompositeBamReader::GenomicIntervalCompositeBamReader( - const GenomicInterval& interval, const DataSet& dataset, const BaiIndexCache& cache) + const Data::GenomicInterval& interval, const DataSet& dataset, const BaiIndexCache& cache) : GenomicIntervalCompositeBamReader{interval, dataset.BamFiles(), cache} {} -const GenomicInterval& GenomicIntervalCompositeBamReader::Interval() const { return interval_; } +const Data::GenomicInterval& GenomicIntervalCompositeBamReader::Interval() const +{ + return interval_; +} GenomicIntervalCompositeBamReader& GenomicIntervalCompositeBamReader::Interval( - const GenomicInterval& interval) + const Data::GenomicInterval& interval) { // reset readers mergeItems_.clear(); diff -Nru pbbam-2.1.0+dfsg/src/Config.cpp pbbam-2.3.0+dfsg/src/Config.cpp --- pbbam-2.1.0+dfsg/src/Config.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/Config.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -43,9 +43,9 @@ // check against v1.7 const int versionMajor = std::stoi(versionParts[0]); const int versionMinor = std::stoi(versionParts[1]); - static constexpr const int v17_major = 1; - static constexpr const int v17_minor = 7; - return std::tie(versionMajor, versionMinor) >= std::tie(v17_major, v17_minor); + constexpr int V17_MAJOR = 1; + constexpr int V17_MINOR = 7; + return std::tie(versionMajor, versionMinor) >= std::tie(V17_MAJOR, V17_MINOR); } #ifdef PBBAM_PERMISSIVE_CIGAR diff -Nru pbbam-2.1.0+dfsg/src/DataSet.cpp pbbam-2.3.0+dfsg/src/DataSet.cpp --- pbbam-2.1.0+dfsg/src/DataSet.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/DataSet.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -282,7 +282,7 @@ return result; } -std::vector DataSet::GenomicIntervals() const +std::vector DataSet::GenomicIntervals() const { // need to gather the contig lengths std::map contigLengths; @@ -372,7 +372,7 @@ } // extract all GenomicIntervals - std::vector result; + std::vector result; if (numFilters) { // have some filters, only return regions passing filters for (const auto& contigs : contigIntervals) { diff -Nru pbbam-2.1.0+dfsg/src/FastqWriter.cpp pbbam-2.3.0+dfsg/src/FastqWriter.cpp --- pbbam-2.1.0+dfsg/src/FastqWriter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/FastqWriter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -5,9 +5,10 @@ #include #include #include -#include #include "ErrnoReason.h" +#include + #include #include diff -Nru pbbam-2.1.0+dfsg/src/FileUtils.cpp pbbam-2.3.0+dfsg/src/FileUtils.cpp --- pbbam-2.1.0+dfsg/src/FileUtils.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/FileUtils.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -52,7 +52,7 @@ return filePath; } -static const char native_pathSeparator = '\\'; +constexpr char NATIVE_PATH_SEPARATOR = '\\'; static bool native_pathIsAbsolute(const std::string& filePath) { @@ -98,14 +98,14 @@ const bool thisDirAtStart = (schemeLess.find(".") == 0); if (thisDirAtStart) { - if (schemeLess.find(native_pathSeparator) == 1) schemeLess = schemeLess.substr(2); + if (schemeLess.find(NATIVE_PATH_SEPARATOR) == 1) schemeLess = schemeLess.substr(2); } - return from + native_pathSeparator + schemeLess; + return from + NATIVE_PATH_SEPARATOR + schemeLess; } #else // else for non-Windows systems -static const char native_pathSeparator = '/'; +constexpr char NATIVE_PATH_SEPARATOR = '/'; static bool native_pathIsAbsolute(const std::string& filePath) { return filePath.at(0) == '/'; } @@ -129,11 +129,11 @@ // const bool thisDirAtStart = (schemeLess.find(".") == 0); if (thisDirAtStart) { - if (schemeLess.find(native_pathSeparator) == 1) { + if (schemeLess.find(NATIVE_PATH_SEPARATOR) == 1) { schemeLess = schemeLess.substr(2); } } - return from + native_pathSeparator + schemeLess; + return from + NATIVE_PATH_SEPARATOR + schemeLess; } #endif // PBBAM_WIN_FILEPATHS @@ -160,7 +160,7 @@ // long path - use heap, trying progressively longer buffers for (size_t chunks = 2; chunks < maxNumChunks; ++chunks) { - std::unique_ptr cwd(new char[chunkSize * chunks]); + auto cwd = std::make_unique(chunkSize * chunks); if (getcwd(cwd.get(), chunkSize * chunks) != nullptr) { return std::string(cwd.get()); } @@ -210,7 +210,7 @@ return native_resolvedFilePath(filePath, from); } -constexpr char FileUtils::Separator() { return native_pathSeparator; } +char FileUtils::Separator() { return NATIVE_PATH_SEPARATOR; } off_t FileUtils::Size(const char* fn) { diff -Nru pbbam-2.1.0+dfsg/src/FileUtils.h pbbam-2.3.0+dfsg/src/FileUtils.h --- pbbam-2.1.0+dfsg/src/FileUtils.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/FileUtils.h 2023-01-03 21:57:00.000000000 +0000 @@ -72,7 +72,7 @@ static std::string ResolvedFilePath(const std::string& filePath, const std::string& from = "."); /// \returns native path separator - constexpr static char Separator(); + static char Separator(); /// Check size of file. /// diff -Nru pbbam-2.1.0+dfsg/src/GenomicIntervalQuery.cpp pbbam-2.3.0+dfsg/src/GenomicIntervalQuery.cpp --- pbbam-2.1.0+dfsg/src/GenomicIntervalQuery.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/GenomicIntervalQuery.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -4,7 +4,8 @@ #include #include -#include + +#include namespace PacBio { namespace BAM { diff -Nru pbbam-2.1.0+dfsg/src/IndexedBamWriter.cpp pbbam-2.3.0+dfsg/src/IndexedBamWriter.cpp --- pbbam-2.1.0+dfsg/src/IndexedBamWriter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/IndexedBamWriter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -289,7 +289,7 @@ auto recordLength = [](bam1_t* b) { auto* c = &b->core; - static constexpr size_t fixedLength = 36; + constexpr size_t FIXED_LENGTH = 36; const size_t qnameLength = (c->l_qname - c->l_extranul); // TODO: long CIGAR handling... sigh... @@ -302,7 +302,7 @@ remainingLength = 8 + (b->l_data - cigarEnd) + 4 + (4 * c->n_cigar); } - return fixedLength + qnameLength + remainingLength; + return FIXED_LENGTH + qnameLength + remainingLength; }; uncompressedFilePos_ += recordLength(rawRecord.get()); } @@ -562,7 +562,7 @@ auto recordLength = [](bam1_t* b) { auto* c = &b->core; - static constexpr size_t fixedLength = 36; + constexpr size_t FIXED_LENGTH = 36; const size_t qnameLength = (c->l_qname - c->l_extranul); // TODO: long CIGAR handling... sigh... @@ -575,7 +575,7 @@ remainingLength = 8 + (b->l_data - cigarEnd) + 4 + (4 * c->n_cigar); } - return fixedLength + qnameLength + remainingLength; + return FIXED_LENGTH + qnameLength + remainingLength; }; uncompressedFilePos_ += recordLength(rawRecord.get()); diff -Nru pbbam-2.1.0+dfsg/src/IndexedFastaReader.cpp pbbam-2.3.0+dfsg/src/IndexedFastaReader.cpp --- pbbam-2.1.0+dfsg/src/IndexedFastaReader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/IndexedFastaReader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -4,12 +4,12 @@ #include #include -#include -#include #include #include "ErrnoReason.h" #include "SequenceUtils.h" +#include +#include #include #include diff -Nru pbbam-2.1.0+dfsg/src/IndexedFastqReader.cpp pbbam-2.3.0+dfsg/src/IndexedFastqReader.cpp --- pbbam-2.1.0+dfsg/src/IndexedFastqReader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/IndexedFastqReader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -5,12 +5,13 @@ #include #include #include -#include #include "IndexedFastqBgzfReader.h" #include "IndexedFastqReaderImpl.h" #include "IndexedFastqTextReader.h" #include "SequenceUtils.h" +#include + #include #include #include @@ -191,7 +192,7 @@ return d_->Subsequence(id, start, end); } -std::pair IndexedFastqReader::Subsequence( +std::pair IndexedFastqReader::Subsequence( const Data::GenomicInterval& interval) { return Subsequence(interval.Name(), interval.Start(), interval.Stop()); diff -Nru pbbam-2.1.0+dfsg/src/LibraryGitHash.h.in pbbam-2.3.0+dfsg/src/LibraryGitHash.h.in --- pbbam-2.1.0+dfsg/src/LibraryGitHash.h.in 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/LibraryGitHash.h.in 2023-01-03 21:57:00.000000000 +0000 @@ -1,10 +1,12 @@ #ifndef PBBAM_LIBRARY_GITHASH_H #define PBBAM_LIBRARY_GITHASH_H +#include + namespace PacBio { namespace Pbbam { -constexpr const char LibraryGitSha1[] = "@PBBAM_GIT_SHA1@"; +constexpr std::string_view LIBRARY_GIT_SHA1{"@PBBAM_GIT_SHA1@"}; } // namespace Pbbam } // namespace PacBio diff -Nru pbbam-2.1.0+dfsg/src/LibraryInfo.cpp pbbam-2.3.0+dfsg/src/LibraryInfo.cpp --- pbbam-2.1.0+dfsg/src/LibraryInfo.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/LibraryInfo.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -26,7 +26,10 @@ return bundle; } -Library::Info LibraryInfo() { return {"pbbam", Pbbam::ReleaseVersion, Pbbam::LibraryGitSha1}; } +Library::Info LibraryInfo() +{ + return {"pbbam", std::string{Pbbam::RELEASE_VERSION}, std::string{Pbbam::LIBRARY_GIT_SHA1}}; +} } // namespace Pbbam } // namespace PacBio diff -Nru pbbam-2.1.0+dfsg/src/LibraryVersion.h.in pbbam-2.3.0+dfsg/src/LibraryVersion.h.in --- pbbam-2.1.0+dfsg/src/LibraryVersion.h.in 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/LibraryVersion.h.in 2023-01-03 21:57:00.000000000 +0000 @@ -1,10 +1,12 @@ #ifndef PBBAM_LIBRARY_VERION_H #define PBBAM_LIBRARY_VERION_H +#include + namespace PacBio { namespace Pbbam { -constexpr const char ReleaseVersion[] = "@PBBAM_VERSION@"; +constexpr std::string_view RELEASE_VERSION{"@PBBAM_VERSION@"}; } // namespace Pbbam } // namespace PacBio diff -Nru pbbam-2.1.0+dfsg/src/PbbamGitHash.cpp.in pbbam-2.3.0+dfsg/src/PbbamGitHash.cpp.in --- pbbam-2.1.0+dfsg/src/PbbamGitHash.cpp.in 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbbamGitHash.cpp.in 2023-01-03 21:57:00.000000000 +0000 @@ -2,16 +2,14 @@ #include +#include + namespace PacBio { namespace BAM { -namespace { - -static constexpr const char LibraryGitSha1[] = "@PBBAM_GIT_SHA1@"; -} // namespace +constexpr std::string_view LIBRARY_GIT_SHA1{"@PBBAM_GIT_SHA1@"}; -std::string LibraryGitSha1String() -{ return LibraryGitSha1; } +std::string LibraryGitSha1String() { return std::string{LIBRARY_GIT_SHA1}; } } // namespace BAM -} // namespace PacBio \ No newline at end of file +} // namespace PacBio diff -Nru pbbam-2.1.0+dfsg/src/PbbamVersion.cpp.in pbbam-2.3.0+dfsg/src/PbbamVersion.cpp.in --- pbbam-2.1.0+dfsg/src/PbbamVersion.cpp.in 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbbamVersion.cpp.in 2023-01-03 21:57:00.000000000 +0000 @@ -2,22 +2,22 @@ #include +#include + namespace PacBio { namespace BAM { -namespace { - -static constexpr const char LibraryVersion[] = "@PBBAM_VERSION@"; -static constexpr const int LibraryMajor = @PBBAM_VERSION_MAJOR@; -static constexpr const int LibraryMinor = @PBBAM_VERSION_MINOR@; -static constexpr const int LibraryPatch = @PBBAM_VERSION_PATCH@; -} // namespace +constexpr std::string_view LIBRARY_VERSION{"@PBBAM_VERSION@"}; +constexpr int LIBRARY_MAJOR = @PBBAM_VERSION_MAJOR@; +constexpr int LIBRARY_MINOR = @PBBAM_VERSION_MINOR@; +constexpr int LIBRARY_PATCH = @PBBAM_VERSION_PATCH@; -std::string LibraryVersionString() -{ return LibraryVersion; } +std::string LibraryVersionString() { return std::string{LIBRARY_VERSION}; } std::tuple LibraryVersionTriple() -{ return std::make_tuple(LibraryMajor, LibraryMinor, LibraryPatch); } +{ + return {LIBRARY_MAJOR, LIBRARY_MINOR, LIBRARY_PATCH}; +} } // namespace BAM -} // namespace PacBio \ No newline at end of file +} // namespace PacBio diff -Nru pbbam-2.1.0+dfsg/src/PbiBuilderBase.cpp pbbam-2.3.0+dfsg/src/PbiBuilderBase.cpp --- pbbam-2.1.0+dfsg/src/PbiBuilderBase.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbiBuilderBase.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -304,8 +304,8 @@ BGZF* bgzf = pbiFile_.get(); // 'magic' string - static constexpr const std::array magic{{'P', 'B', 'I', '\1'}}; - bgzf_write_safe(bgzf, magic.data(), 4); + static constexpr std::array MAGIC{{'P', 'B', 'I', '\1'}}; + bgzf_write_safe(bgzf, MAGIC.data(), 4); PbiFile::Sections sections = PbiFile::BASIC; if (hasMappedData_) { diff -Nru pbbam-2.1.0+dfsg/src/PbiBuilderBase.h pbbam-2.3.0+dfsg/src/PbiBuilderBase.h --- pbbam-2.1.0+dfsg/src/PbiBuilderBase.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbiBuilderBase.h 2023-01-03 21:57:00.000000000 +0000 @@ -130,11 +130,11 @@ template class PbiField { - constexpr static const size_t ElementSize = sizeof(T); - static_assert(ElementSize > 0, ""); + static constexpr size_t ELEMENT_SIZE = sizeof(T); + static_assert(ELEMENT_SIZE > 0); public: - PbiField(size_t maxBufferSize = 0) : maxElementCount_{maxBufferSize / ElementSize} + PbiField(size_t maxBufferSize = 0) : maxElementCount_{maxBufferSize / ELEMENT_SIZE} { buffer_.reserve(maxElementCount_); } diff -Nru pbbam-2.1.0+dfsg/src/PbiBuilder.cpp pbbam-2.3.0+dfsg/src/PbiBuilder.cpp --- pbbam-2.1.0+dfsg/src/PbiBuilder.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbiBuilder.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -35,13 +35,13 @@ class PbiBuilderPrivate : public PacBio::BAM::PbiBuilderBase { // TODO: Make this tweak-able, a la IndexedBamWriter's buffers - constexpr static const size_t MaxBufferSize = 0x10000; + static constexpr size_t MAX_BUFFER_SIZE = 0x10000; public: PbiBuilderPrivate(const std::string& pbiFilename, const size_t numReferenceSequences, const bool isCoordinateSorted, const PbiBuilder::CompressionLevel compressionLevel, const size_t numThreads) - : PacBio::BAM::PbiBuilderBase{pbiFilename, compressionLevel, numThreads, MaxBufferSize} + : PacBio::BAM::PbiBuilderBase{pbiFilename, compressionLevel, numThreads, MAX_BUFFER_SIZE} { if (isCoordinateSorted && numReferenceSequences > 0) { diff -Nru pbbam-2.1.0+dfsg/src/PbiFilter.cpp pbbam-2.3.0+dfsg/src/PbiFilter.cpp --- pbbam-2.1.0+dfsg/src/PbiFilter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbiFilter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -100,17 +100,17 @@ { "zmw", BuiltIn::ZmwFilter } }; -static const std::unordered_map contextFlagNames = +static const std::unordered_map contextFlagNames = { - { "NO_LOCAL_CONTEXT", LocalContextFlags::NO_LOCAL_CONTEXT }, - { "ADAPTER_BEFORE", LocalContextFlags::ADAPTER_BEFORE }, - { "ADAPTER_AFTER", LocalContextFlags::ADAPTER_AFTER }, - { "BARCODE_BEFORE", LocalContextFlags::BARCODE_BEFORE }, - { "BARCODE_AFTER", LocalContextFlags::BARCODE_AFTER }, - { "FORWARD_PASS", LocalContextFlags::FORWARD_PASS }, - { "REVERSE_PASS", LocalContextFlags::REVERSE_PASS }, - { "ADAPTER_BEFORE_BAD", LocalContextFlags::ADAPTER_BEFORE_BAD}, - { "ADAPTER_AFTER_BAD", LocalContextFlags::ADAPTER_AFTER_BAD} + { "NO_LOCAL_CONTEXT", Data::LocalContextFlags::NO_LOCAL_CONTEXT }, + { "ADAPTER_BEFORE", Data::LocalContextFlags::ADAPTER_BEFORE }, + { "ADAPTER_AFTER", Data::LocalContextFlags::ADAPTER_AFTER }, + { "BARCODE_BEFORE", Data::LocalContextFlags::BARCODE_BEFORE }, + { "BARCODE_AFTER", Data::LocalContextFlags::BARCODE_AFTER }, + { "FORWARD_PASS", Data::LocalContextFlags::FORWARD_PASS }, + { "REVERSE_PASS", Data::LocalContextFlags::REVERSE_PASS }, + { "ADAPTER_BEFORE_BAD", Data::LocalContextFlags::ADAPTER_BEFORE_BAD}, + { "ADAPTER_AFTER_BAD", Data::LocalContextFlags::ADAPTER_AFTER_BAD} }; // clang-format on diff -Nru pbbam-2.1.0+dfsg/src/PbiIndexIO.cpp pbbam-2.3.0+dfsg/src/PbiIndexIO.cpp --- pbbam-2.1.0+dfsg/src/PbiIndexIO.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbiIndexIO.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -200,13 +200,13 @@ } else { Utility::MoveAppend(std::vector(currentPbiCount, -1), aggregateMappedData.tId_); - Utility::MoveAppend(std::vector(currentPbiCount, UnmappedPosition), + Utility::MoveAppend(std::vector(currentPbiCount, Data::UNMAPPED_POSITION), aggregateMappedData.tStart_); - Utility::MoveAppend(std::vector(currentPbiCount, UnmappedPosition), + Utility::MoveAppend(std::vector(currentPbiCount, Data::UNMAPPED_POSITION), aggregateMappedData.tEnd_); - Utility::MoveAppend(std::vector(currentPbiCount, UnmappedPosition), + Utility::MoveAppend(std::vector(currentPbiCount, Data::UNMAPPED_POSITION), aggregateMappedData.aStart_); - Utility::MoveAppend(std::vector(currentPbiCount, UnmappedPosition), + Utility::MoveAppend(std::vector(currentPbiCount, Data::UNMAPPED_POSITION), aggregateMappedData.aEnd_); Utility::MoveAppend(std::vector(currentPbiCount, 0), aggregateMappedData.revStrand_); @@ -387,8 +387,8 @@ void PbiIndexIO::WriteHeader(const PbiRawData& index, BGZF* fp) { // 'magic' string - constexpr static const std::array magic{{'P', 'B', 'I', '\1'}}; - auto ret = bgzf_write(fp, magic.data(), 4); + static constexpr std::array MAGIC{'P', 'B', 'I', '\1'}; + auto ret = bgzf_write(fp, MAGIC.data(), 4); // version, pbi_flags, & n_reads auto version = static_cast(index.Version()); diff -Nru pbbam-2.1.0+dfsg/src/PbiRawData.cpp pbbam-2.3.0+dfsg/src/PbiRawData.cpp --- pbbam-2.1.0+dfsg/src/PbiRawData.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/PbiRawData.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -83,7 +83,7 @@ tEnd_.push_back(b.ReferenceEnd()); aStart_.push_back(b.AlignedStart()); aEnd_.push_back(b.AlignedEnd()); - revStrand_.push_back((b.AlignedStrand() == Strand::REVERSE ? 1 : 0)); + revStrand_.push_back((b.AlignedStrand() == Data::Strand::REVERSE ? 1 : 0)); mapQV_.push_back(b.MapQuality()); const auto matchesAndMismatches = b.NumMatchesAndMismatches(); diff -Nru pbbam-2.1.0+dfsg/src/pugixml/pugixml.cpp pbbam-2.3.0+dfsg/src/pugixml/pugixml.cpp --- pbbam-2.1.0+dfsg/src/pugixml/pugixml.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/pugixml/pugixml.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -93,28 +93,28 @@ // Inlining controls #if defined(_MSC_VER) && _MSC_VER >= 1300 -# define PUGI__NO_INLINE __declspec(noinline) +# define PUGI_NO_INLINE __declspec(noinline) #elif defined(__GNUC__) -# define PUGI__NO_INLINE __attribute__((noinline)) +# define PUGI_NO_INLINE __attribute__((noinline)) #else -# define PUGI__NO_INLINE +# define PUGI_NO_INLINE #endif // Branch weight controls #if defined(__GNUC__) -# define PUGI__UNLIKELY(cond) __builtin_expect(cond, 0) +# define PUGI_UNLIKELY(cond) __builtin_expect(cond, 0) #else -# define PUGI__UNLIKELY(cond) (cond) +# define PUGI_UNLIKELY(cond) (cond) #endif // Simple static assertion -#define PUGI__STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; } +#define PUGI_STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; } // Digital Mars C++ bug workaround for passing char loaded from memory via stack #ifdef __DMC__ -# define PUGI__DMC_VOLATILE volatile +# define PUGI_DMC_VOLATILE volatile #else -# define PUGI__DMC_VOLATILE +# define PUGI_DMC_VOLATILE #endif // Borland C++ bug workaround for not defining ::memcpy depending on header include order (can't always use std::memcpy because some compilers don't have it at all) @@ -125,24 +125,24 @@ // In some environments MSVC is a compiler but the CRT lacks certain MSVC-specific features #if defined(_MSC_VER) && !defined(__S3E__) -# define PUGI__MSVC_CRT_VERSION _MSC_VER +# define PUGI_MSVC_CRT_VERSION _MSC_VER #endif #ifdef PUGIXML_HEADER_ONLY -# define PUGI__NS_BEGIN namespace pugi { namespace impl { -# define PUGI__NS_END } } -# define PUGI__FN inline -# define PUGI__FN_NO_INLINE inline +# define PUGI_NS_BEGIN namespace pugi { namespace impl { +# define PUGI_NS_END } } +# define PUGI_FN inline +# define PUGI_FN_NO_INLINE inline #else # if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces -# define PUGI__NS_BEGIN namespace pugi { namespace impl { -# define PUGI__NS_END } } +# define PUGI_NS_BEGIN namespace pugi { namespace impl { +# define PUGI_NS_END } } # else -# define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace { -# define PUGI__NS_END } } } +# define PUGI_NS_BEGIN namespace pugi { namespace impl { namespace { +# define PUGI_NS_END } } } # endif -# define PUGI__FN -# define PUGI__FN_NO_INLINE PUGI__NO_INLINE +# define PUGI_FN +# define PUGI_FN_NO_INLINE PUGI_NO_INLINE #endif // uintptr_t @@ -154,21 +154,21 @@ typedef size_t uintptr_t; #define _UINTPTR_T_DEFINED # endif -PUGI__NS_BEGIN +PUGI_NS_BEGIN typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; -PUGI__NS_END +PUGI_NS_END #endif // Memory allocation -PUGI__NS_BEGIN - PUGI__FN void* default_allocate(size_t size) +PUGI_NS_BEGIN + PUGI_FN void* default_allocate(size_t size) { return malloc(size); } - PUGI__FN void default_deallocate(void* ptr) + PUGI_FN void default_deallocate(void* ptr) { free(ptr); } @@ -186,12 +186,12 @@ template deallocation_function xml_memory_management_function_storage::deallocate = default_deallocate; typedef xml_memory_management_function_storage xml_memory; -PUGI__NS_END +PUGI_NS_END // String utilities -PUGI__NS_BEGIN +PUGI_NS_BEGIN // Get string length - PUGI__FN size_t strlength(const char_t* s) + PUGI_FN size_t strlength(const char_t* s) { assert(s); @@ -203,7 +203,7 @@ } // Compare two strings - PUGI__FN bool strequal(const char_t* src, const char_t* dst) + PUGI_FN bool strequal(const char_t* src, const char_t* dst) { assert(src && dst); @@ -215,7 +215,7 @@ } // Compare lhs with [rhs_begin, rhs_end) - PUGI__FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count) + PUGI_FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count) { for (size_t i = 0; i < count; ++i) if (lhs[i] != rhs[i]) @@ -225,7 +225,7 @@ } // Get length of wide string, even if CRT lacks wide character support - PUGI__FN size_t strlength_wide(const wchar_t* s) + PUGI_FN size_t strlength_wide(const wchar_t* s) { assert(s); @@ -240,17 +240,17 @@ #ifdef PUGIXML_WCHAR_MODE // Convert string to wide string, assuming all symbols are ASCII - PUGI__FN void widen_ascii(wchar_t* dest, const char* source) + PUGI_FN void widen_ascii(wchar_t* dest, const char* source) { for (const char* i = source; *i; ++i) *dest++ = *i; *dest = 0; } #endif -PUGI__NS_END +PUGI_NS_END #if !defined(PUGIXML_NO_STL) || !defined(PUGIXML_NO_XPATH) // auto_ptr-like buffer holder for exception recovery -PUGI__NS_BEGIN +PUGI_NS_BEGIN struct buffer_holder { void* data; @@ -272,10 +272,10 @@ return result; } }; -PUGI__NS_END +PUGI_NS_END #endif -PUGI__NS_BEGIN +PUGI_NS_BEGIN static const size_t xml_memory_page_size = #ifdef PUGIXML_MEMORY_PAGE_SIZE PUGIXML_MEMORY_PAGE_SIZE @@ -293,7 +293,7 @@ static const uintptr_t xml_memory_page_name_allocated_or_shared_mask = xml_memory_page_name_allocated_mask | xml_memory_page_contents_shared_mask; static const uintptr_t xml_memory_page_value_allocated_or_shared_mask = xml_memory_page_value_allocated_mask | xml_memory_page_contents_shared_mask; - #define PUGI__NODETYPE(n) static_cast(((n)->header & impl::xml_memory_page_type_mask) + 1) + #define PUGI_NODETYPE(n) static_cast(((n)->header & impl::xml_memory_page_type_mask) + 1) struct xml_allocator; @@ -416,7 +416,7 @@ char_t* allocate_string(size_t length) { - PUGI__STATIC_ASSERT(xml_memory_page_size <= (1 << 16)); + PUGI_STATIC_ASSERT(xml_memory_page_size <= (1 << 16)); // allocate memory for string and header block size_t size = sizeof(xml_memory_string_header) + length * sizeof(char_t); @@ -467,7 +467,7 @@ size_t _busy_size; }; - PUGI__FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page) + PUGI_FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page) { const size_t large_allocation_threshold = xml_memory_page_size / 4; @@ -505,7 +505,7 @@ return reinterpret_cast(page) + sizeof(xml_memory_page); } -PUGI__NS_END +PUGI_NS_END namespace pugi { @@ -551,7 +551,7 @@ }; } -PUGI__NS_BEGIN +PUGI_NS_BEGIN struct xml_extra_buffer { char_t* buffer; @@ -582,10 +582,10 @@ return *static_cast(reinterpret_cast(object->header & xml_memory_page_pointer_mask)->allocator); } -PUGI__NS_END +PUGI_NS_END // Low-level DOM operations -PUGI__NS_BEGIN +PUGI_NS_BEGIN inline xml_attribute_struct* allocate_attribute(xml_allocator& alloc) { xml_memory_page* page; @@ -807,7 +807,7 @@ attr->next_attribute = 0; } - PUGI__FN_NO_INLINE xml_node_struct* append_new_node(xml_node_struct* node, xml_allocator& alloc, xml_node_type type = node_element) + PUGI_FN_NO_INLINE xml_node_struct* append_new_node(xml_node_struct* node, xml_allocator& alloc, xml_node_type type = node_element) { xml_node_struct* child = allocate_node(alloc, type); if (!child) return 0; @@ -817,7 +817,7 @@ return child; } - PUGI__FN_NO_INLINE xml_attribute_struct* append_new_attribute(xml_node_struct* node, xml_allocator& alloc) + PUGI_FN_NO_INLINE xml_attribute_struct* append_new_attribute(xml_node_struct* node, xml_allocator& alloc) { xml_attribute_struct* attr = allocate_attribute(alloc); if (!attr) return 0; @@ -826,10 +826,10 @@ return attr; } -PUGI__NS_END +PUGI_NS_END // Helper classes for code generation -PUGI__NS_BEGIN +PUGI_NS_BEGIN struct opt_false { enum { value = 0 }; @@ -839,10 +839,10 @@ { enum { value = 1 }; }; -PUGI__NS_END +PUGI_NS_END // Unicode utilities -PUGI__NS_BEGIN +PUGI_NS_BEGIN inline uint16_t endian_swap(uint16_t value) { return static_cast(((value & 0xff) << 8) | (value >> 8)); @@ -1202,20 +1202,20 @@ } }; - template PUGI__FN void convert_utf_endian_swap(T* result, const T* data, size_t length) + template PUGI_FN void convert_utf_endian_swap(T* result, const T* data, size_t length) { for (size_t i = 0; i < length; ++i) result[i] = endian_swap(data[i]); } #ifdef PUGIXML_WCHAR_MODE - PUGI__FN void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length) + PUGI_FN void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length) { for (size_t i = 0; i < length; ++i) result[i] = static_cast(endian_swap(static_cast::type>(data[i]))); } #endif -PUGI__NS_END +PUGI_NS_END -PUGI__NS_BEGIN +PUGI_NS_BEGIN enum chartype_t { ct_parse_pcdata = 1, // \0, &, \r, < @@ -1281,24 +1281,24 @@ }; #ifdef PUGIXML_WCHAR_MODE - #define PUGI__IS_CHARTYPE_IMPL(c, ct, table) ((static_cast(c) < 128 ? table[static_cast(c)] : table[128]) & (ct)) + #define PUGI_IS_CHARTYPE_IMPL(c, ct, table) ((static_cast(c) < 128 ? table[static_cast(c)] : table[128]) & (ct)) #else - #define PUGI__IS_CHARTYPE_IMPL(c, ct, table) (table[static_cast(c)] & (ct)) + #define PUGI_IS_CHARTYPE_IMPL(c, ct, table) (table[static_cast(c)] & (ct)) #endif - #define PUGI__IS_CHARTYPE(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartype_table) - #define PUGI__IS_CHARTYPEX(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartypex_table) + #define PUGI_IS_CHARTYPE(c, ct) PUGI_IS_CHARTYPE_IMPL(c, ct, chartype_table) + #define PUGI_IS_CHARTYPEX(c, ct) PUGI_IS_CHARTYPE_IMPL(c, ct, chartypex_table) - PUGI__FN bool is_little_endian() + PUGI_FN bool is_little_endian() { unsigned int ui = 1; return *reinterpret_cast(&ui) == 1; } - PUGI__FN xml_encoding get_wchar_encoding() + PUGI_FN xml_encoding get_wchar_encoding() { - PUGI__STATIC_ASSERT(sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4); + PUGI_STATIC_ASSERT(sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4); if (sizeof(wchar_t) == 2) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be; @@ -1306,7 +1306,7 @@ return is_little_endian() ? encoding_utf32_le : encoding_utf32_be; } - PUGI__FN xml_encoding guess_buffer_encoding(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3) + PUGI_FN xml_encoding guess_buffer_encoding(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3) { // look for BOM in first few bytes if (d0 == 0 && d1 == 0 && d2 == 0xfe && d3 == 0xff) return encoding_utf32_be; @@ -1330,7 +1330,7 @@ return encoding_utf8; } - PUGI__FN xml_encoding get_buffer_encoding(xml_encoding encoding, const void* contents, size_t size) + PUGI_FN xml_encoding get_buffer_encoding(xml_encoding encoding, const void* contents, size_t size) { // replace wchar encoding with utf implementation if (encoding == encoding_wchar) return get_wchar_encoding(); @@ -1350,12 +1350,12 @@ // try to guess encoding (based on XML specification, Appendix F.1) const uint8_t* data = static_cast(contents); - PUGI__DMC_VOLATILE uint8_t d0 = data[0], d1 = data[1], d2 = data[2], d3 = data[3]; + PUGI_DMC_VOLATILE uint8_t d0 = data[0], d1 = data[1], d2 = data[2], d3 = data[3]; return guess_buffer_encoding(d0, d1, d2, d3); } - PUGI__FN bool get_mutable_buffer(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable) + PUGI_FN bool get_mutable_buffer(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable) { size_t length = size / sizeof(char_t); @@ -1384,13 +1384,13 @@ } #ifdef PUGIXML_WCHAR_MODE - PUGI__FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re) + PUGI_FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re) { return (le == encoding_utf16_be && re == encoding_utf16_le) || (le == encoding_utf16_le && re == encoding_utf16_be) || (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be); } - PUGI__FN bool convert_buffer_endian_swap(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable) + PUGI_FN bool convert_buffer_endian_swap(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable) { const char_t* data = static_cast(contents); size_t length = size / sizeof(char_t); @@ -1419,7 +1419,7 @@ return true; } - PUGI__FN bool convert_buffer_utf8(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size) + PUGI_FN bool convert_buffer_utf8(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size) { const uint8_t* data = static_cast(contents); size_t data_length = size; @@ -1444,7 +1444,7 @@ return true; } - template PUGI__FN bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) + template PUGI_FN bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint16_t* data = static_cast(contents); size_t data_length = size / sizeof(uint16_t); @@ -1469,7 +1469,7 @@ return true; } - template PUGI__FN bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) + template PUGI_FN bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint32_t* data = static_cast(contents); size_t data_length = size / sizeof(uint32_t); @@ -1494,7 +1494,7 @@ return true; } - PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size) + PUGI_FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size) { const uint8_t* data = static_cast(contents); size_t data_length = size; @@ -1519,7 +1519,7 @@ return true; } - PUGI__FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable) + PUGI_FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable) { // get native encoding xml_encoding wchar_encoding = get_wchar_encoding(); @@ -1560,7 +1560,7 @@ return false; } #else - template PUGI__FN bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) + template PUGI_FN bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint16_t* data = static_cast(contents); size_t data_length = size / sizeof(uint16_t); @@ -1585,7 +1585,7 @@ return true; } - template PUGI__FN bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) + template PUGI_FN bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint32_t* data = static_cast(contents); size_t data_length = size / sizeof(uint32_t); @@ -1610,7 +1610,7 @@ return true; } - PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size) + PUGI_FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size) { for (size_t i = 0; i < size; ++i) if (data[i] > 127) @@ -1619,7 +1619,7 @@ return size; } - PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable) + PUGI_FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable) { const uint8_t* data = static_cast(contents); size_t data_length = size; @@ -1656,7 +1656,7 @@ return true; } - PUGI__FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable) + PUGI_FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable) { // fast path: no conversion required if (encoding == encoding_utf8) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable); @@ -1689,13 +1689,13 @@ } #endif - PUGI__FN size_t as_utf8_begin(const wchar_t* str, size_t length) + PUGI_FN size_t as_utf8_begin(const wchar_t* str, size_t length) { // get length in utf8 characters return utf_decoder::decode_wchar_block(str, length, 0); } - PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length) + PUGI_FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length) { // convert to utf8 uint8_t* begin = reinterpret_cast(buffer); @@ -1709,7 +1709,7 @@ } #ifndef PUGIXML_NO_STL - PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length) + PUGI_FN std::string as_utf8_impl(const wchar_t* str, size_t length) { // first pass: get length in utf8 characters size_t size = as_utf8_begin(str, length); @@ -1724,7 +1724,7 @@ return result; } - PUGI__FN std::basic_string as_wide_impl(const char* str, size_t size) + PUGI_FN std::basic_string as_wide_impl(const char* str, size_t size) { const uint8_t* data = reinterpret_cast(str); @@ -1765,7 +1765,7 @@ return target_length >= length && (target_length < reuse_threshold || target_length - length < target_length / 2); } - PUGI__FN bool strcpy_insitu(char_t*& dest, uintptr_t& header, uintptr_t header_mask, const char_t* source) + PUGI_FN bool strcpy_insitu(char_t*& dest, uintptr_t& header, uintptr_t header_mask, const char_t* source) { assert(header); @@ -1855,7 +1855,7 @@ } }; - PUGI__FN char_t* strconv_escape(char_t* s, gap& g) + PUGI_FN char_t* strconv_escape(char_t* s, gap& g) { char_t* stre = s + 1; @@ -1996,25 +1996,25 @@ } // Parser utilities - #define PUGI__ENDSWITH(c, e) ((c) == (e) || ((c) == 0 && endch == (e))) - #define PUGI__SKIPWS() { while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; } - #define PUGI__OPTSET(OPT) ( optmsk & (OPT) ) - #define PUGI__PUSHNODE(TYPE) { cursor = append_new_node(cursor, alloc, TYPE); if (!cursor) PUGI__THROW_ERROR(status_out_of_memory, s); } - #define PUGI__POPNODE() { cursor = cursor->parent; } - #define PUGI__SCANFOR(X) { while (*s != 0 && !(X)) ++s; } - #define PUGI__SCANWHILE(X) { while (X) ++s; } - #define PUGI__SCANWHILE_UNROLL(X) { for (;;) { char_t ss = s[0]; if (PUGI__UNLIKELY(!(X))) { break; } ss = s[1]; if (PUGI__UNLIKELY(!(X))) { s += 1; break; } ss = s[2]; if (PUGI__UNLIKELY(!(X))) { s += 2; break; } ss = s[3]; if (PUGI__UNLIKELY(!(X))) { s += 3; break; } s += 4; } } - #define PUGI__ENDSEG() { ch = *s; *s = 0; ++s; } - #define PUGI__THROW_ERROR(err, m) return error_offset = m, error_status = err, static_cast(0) - #define PUGI__CHECK_ERROR(err, m) { if (*s == 0) PUGI__THROW_ERROR(err, m); } + #define PUGI_ENDSWITH(c, e) ((c) == (e) || ((c) == 0 && endch == (e))) + #define PUGI_SKIPWS() { while (PUGI_IS_CHARTYPE(*s, ct_space)) ++s; } + #define PUGI_OPTSET(OPT) ( optmsk & (OPT) ) + #define PUGI_PUSHNODE(TYPE) { cursor = append_new_node(cursor, alloc, TYPE); if (!cursor) PUGI_THROW_ERROR(status_out_of_memory, s); } + #define PUGI_POPNODE() { cursor = cursor->parent; } + #define PUGI_SCANFOR(X) { while (*s != 0 && !(X)) ++s; } + #define PUGI_SCANWHILE(X) { while (X) ++s; } + #define PUGI_SCANWHILE_UNROLL(X) { for (;;) { char_t ss = s[0]; if (PUGI_UNLIKELY(!(X))) { break; } ss = s[1]; if (PUGI_UNLIKELY(!(X))) { s += 1; break; } ss = s[2]; if (PUGI_UNLIKELY(!(X))) { s += 2; break; } ss = s[3]; if (PUGI_UNLIKELY(!(X))) { s += 3; break; } s += 4; } } + #define PUGI_ENDSEG() { ch = *s; *s = 0; ++s; } + #define PUGI_THROW_ERROR(err, m) return error_offset = m, error_status = err, static_cast(0) + #define PUGI_CHECK_ERROR(err, m) { if (*s == 0) PUGI_THROW_ERROR(err, m); } - PUGI__FN char_t* strconv_comment(char_t* s, char_t endch) + PUGI_FN char_t* strconv_comment(char_t* s, char_t endch) { gap g; while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_comment)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_comment)); if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair { @@ -2022,7 +2022,7 @@ if (*s == '\n') g.push(s, 1); } - else if (s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>')) // comment ends here + else if (s[0] == '-' && s[1] == '-' && PUGI_ENDSWITH(s[2], '>')) // comment ends here { *g.flush(s) = 0; @@ -2036,13 +2036,13 @@ } } - PUGI__FN char_t* strconv_cdata(char_t* s, char_t endch) + PUGI_FN char_t* strconv_cdata(char_t* s, char_t endch) { gap g; while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_cdata)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_cdata)); if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair { @@ -2050,7 +2050,7 @@ if (*s == '\n') g.push(s, 1); } - else if (s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>')) // CDATA ends here + else if (s[0] == ']' && s[1] == ']' && PUGI_ENDSWITH(s[2], '>')) // CDATA ends here { *g.flush(s) = 0; @@ -2076,14 +2076,14 @@ while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_pcdata)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_pcdata)); if (*s == '<') // PCDATA ends here { char_t* end = g.flush(s); if (opt_trim::value) - while (end > begin && PUGI__IS_CHARTYPE(end[-1], ct_space)) + while (end > begin && PUGI_IS_CHARTYPE(end[-1], ct_space)) --end; *end = 0; @@ -2105,7 +2105,7 @@ char_t* end = g.flush(s); if (opt_trim::value) - while (end > begin && PUGI__IS_CHARTYPE(end[-1], ct_space)) + while (end > begin && PUGI_IS_CHARTYPE(end[-1], ct_space)) --end; *end = 0; @@ -2117,9 +2117,9 @@ } }; - PUGI__FN strconv_pcdata_t get_strconv_pcdata(unsigned int optmask) + PUGI_FN strconv_pcdata_t get_strconv_pcdata(unsigned int optmask) { - PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_trim_pcdata == 0x0800); + PUGI_STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_trim_pcdata == 0x0800); switch (((optmask >> 4) & 3) | ((optmask >> 9) & 4)) // get bitmask for flags (eol escapes trim) { @@ -2144,37 +2144,37 @@ gap g; // trim leading whitespaces - if (PUGI__IS_CHARTYPE(*s, ct_space)) + if (PUGI_IS_CHARTYPE(*s, ct_space)) { char_t* str = s; do ++str; - while (PUGI__IS_CHARTYPE(*str, ct_space)); + while (PUGI_IS_CHARTYPE(*str, ct_space)); g.push(s, str - s); } while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr_ws | ct_space)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_attr_ws | ct_space)); if (*s == end_quote) { char_t* str = g.flush(s); do *str-- = 0; - while (PUGI__IS_CHARTYPE(*str, ct_space)); + while (PUGI_IS_CHARTYPE(*str, ct_space)); return s + 1; } - else if (PUGI__IS_CHARTYPE(*s, ct_space)) + else if (PUGI_IS_CHARTYPE(*s, ct_space)) { *s++ = ' '; - if (PUGI__IS_CHARTYPE(*s, ct_space)) + if (PUGI_IS_CHARTYPE(*s, ct_space)) { char_t* str = s + 1; - while (PUGI__IS_CHARTYPE(*str, ct_space)) ++str; + while (PUGI_IS_CHARTYPE(*str, ct_space)) ++str; g.push(s, str - s); } @@ -2197,7 +2197,7 @@ while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr_ws)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_attr_ws)); if (*s == end_quote) { @@ -2205,7 +2205,7 @@ return s + 1; } - else if (PUGI__IS_CHARTYPE(*s, ct_space)) + else if (PUGI_IS_CHARTYPE(*s, ct_space)) { if (*s == '\r') { @@ -2233,7 +2233,7 @@ while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_attr)); if (*s == end_quote) { @@ -2265,7 +2265,7 @@ while (true) { - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPE(ss, ct_parse_attr)); if (*s == end_quote) { @@ -2286,9 +2286,9 @@ } }; - PUGI__FN strconv_attribute_t get_strconv_attribute(unsigned int optmask) + PUGI_FN strconv_attribute_t get_strconv_attribute(unsigned int optmask) { - PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wconv_attribute == 0x40 && parse_wnorm_attribute == 0x80); + PUGI_STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wconv_attribute == 0x40 && parse_wnorm_attribute == 0x80); switch ((optmask >> 4) & 15) // get bitmask for flags (wconv wnorm eol escapes) { @@ -2344,8 +2344,8 @@ { // quoted string char_t ch = *s++; - PUGI__SCANFOR(*s == ch); - if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s); + PUGI_SCANFOR(*s == ch); + if (!*s) PUGI_THROW_ERROR(status_bad_doctype, s); s++; } @@ -2353,20 +2353,20 @@ { // s += 2; - PUGI__SCANFOR(s[0] == '?' && s[1] == '>'); // no need for ENDSWITH because ?> can't terminate proper doctype - if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s); + PUGI_SCANFOR(s[0] == '?' && s[1] == '>'); // no need for ENDSWITH because ?> can't terminate proper doctype + if (!*s) PUGI_THROW_ERROR(status_bad_doctype, s); s += 2; } else if (s[0] == '<' && s[1] == '!' && s[2] == '-' && s[3] == '-') { s += 4; - PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && s[2] == '>'); // no need for ENDSWITH because --> can't terminate proper doctype - if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s); + PUGI_SCANFOR(s[0] == '-' && s[1] == '-' && s[2] == '>'); // no need for ENDSWITH because --> can't terminate proper doctype + if (!*s) PUGI_THROW_ERROR(status_bad_doctype, s); s += 4; } - else PUGI__THROW_ERROR(status_bad_doctype, s); + else PUGI_THROW_ERROR(status_bad_doctype, s); return s; } @@ -2399,7 +2399,7 @@ else s++; } - PUGI__THROW_ERROR(status_bad_doctype, s); + PUGI_THROW_ERROR(status_bad_doctype, s); } char_t* parse_doctype_group(char_t* s, char_t endch) @@ -2443,7 +2443,7 @@ else s++; } - if (depth != 0 || endch != '>') PUGI__THROW_ERROR(status_bad_doctype, s); + if (depth != 0 || endch != '>') PUGI_THROW_ERROR(status_bad_doctype, s); return s; } @@ -2461,31 +2461,31 @@ { ++s; - if (PUGI__OPTSET(parse_comments)) + if (PUGI_OPTSET(parse_comments)) { - PUGI__PUSHNODE(node_comment); // Append a new node on the tree. + PUGI_PUSHNODE(node_comment); // Append a new node on the tree. cursor->value = s; // Save the offset. } - if (PUGI__OPTSET(parse_eol) && PUGI__OPTSET(parse_comments)) + if (PUGI_OPTSET(parse_eol) && PUGI_OPTSET(parse_comments)) { s = strconv_comment(s, endch); - if (!s) PUGI__THROW_ERROR(status_bad_comment, cursor->value); + if (!s) PUGI_THROW_ERROR(status_bad_comment, cursor->value); } else { // Scan for terminating '-->'. - PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>')); - PUGI__CHECK_ERROR(status_bad_comment, s); + PUGI_SCANFOR(s[0] == '-' && s[1] == '-' && PUGI_ENDSWITH(s[2], '>')); + PUGI_CHECK_ERROR(status_bad_comment, s); - if (PUGI__OPTSET(parse_comments)) + if (PUGI_OPTSET(parse_comments)) *s = 0; // Zero-terminate this segment at the first terminating '-'. s += (s[2] == '>' ? 3 : 2); // Step over the '\0->'. } } - else PUGI__THROW_ERROR(status_bad_comment, s); + else PUGI_THROW_ERROR(status_bad_comment, s); } else if (*s == '[') { @@ -2494,22 +2494,22 @@ { ++s; - if (PUGI__OPTSET(parse_cdata)) + if (PUGI_OPTSET(parse_cdata)) { - PUGI__PUSHNODE(node_cdata); // Append a new node on the tree. + PUGI_PUSHNODE(node_cdata); // Append a new node on the tree. cursor->value = s; // Save the offset. - if (PUGI__OPTSET(parse_eol)) + if (PUGI_OPTSET(parse_eol)) { s = strconv_cdata(s, endch); - if (!s) PUGI__THROW_ERROR(status_bad_cdata, cursor->value); + if (!s) PUGI_THROW_ERROR(status_bad_cdata, cursor->value); } else { // Scan for terminating ']]>'. - PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>')); - PUGI__CHECK_ERROR(status_bad_cdata, s); + PUGI_SCANFOR(s[0] == ']' && s[1] == ']' && PUGI_ENDSWITH(s[2], '>')); + PUGI_CHECK_ERROR(status_bad_cdata, s); *s++ = 0; // Zero-terminate this segment. } @@ -2517,21 +2517,21 @@ else // Flagged for discard, but we still have to scan for the terminator. { // Scan for terminating ']]>'. - PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>')); - PUGI__CHECK_ERROR(status_bad_cdata, s); + PUGI_SCANFOR(s[0] == ']' && s[1] == ']' && PUGI_ENDSWITH(s[2], '>')); + PUGI_CHECK_ERROR(status_bad_cdata, s); ++s; } s += (s[1] == '>' ? 2 : 1); // Step over the last ']>'. } - else PUGI__THROW_ERROR(status_bad_cdata, s); + else PUGI_THROW_ERROR(status_bad_cdata, s); } - else if (s[0] == 'D' && s[1] == 'O' && s[2] == 'C' && s[3] == 'T' && s[4] == 'Y' && s[5] == 'P' && PUGI__ENDSWITH(s[6], 'E')) + else if (s[0] == 'D' && s[1] == 'O' && s[2] == 'C' && s[3] == 'T' && s[4] == 'Y' && s[5] == 'P' && PUGI_ENDSWITH(s[6], 'E')) { s -= 2; - if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s); + if (cursor->parent) PUGI_THROW_ERROR(status_bad_doctype, s); char_t* mark = s + 9; @@ -2541,18 +2541,18 @@ assert((*s == 0 && endch == '>') || *s == '>'); if (*s) *s++ = 0; - if (PUGI__OPTSET(parse_doctype)) + if (PUGI_OPTSET(parse_doctype)) { - while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark; + while (PUGI_IS_CHARTYPE(*mark, ct_space)) ++mark; - PUGI__PUSHNODE(node_doctype); + PUGI_PUSHNODE(node_doctype); cursor->value = mark; } } - else if (*s == 0 && endch == '-') PUGI__THROW_ERROR(status_bad_comment, s); - else if (*s == 0 && endch == '[') PUGI__THROW_ERROR(status_bad_cdata, s); - else PUGI__THROW_ERROR(status_unrecognized_tag, s); + else if (*s == 0 && endch == '-') PUGI_THROW_ERROR(status_bad_comment, s); + else if (*s == 0 && endch == '[') PUGI_THROW_ERROR(status_bad_cdata, s); + else PUGI_THROW_ERROR(status_unrecognized_tag, s); return s; } @@ -2569,50 +2569,50 @@ // read PI target char_t* target = s; - if (!PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_pi, s); + if (!PUGI_IS_CHARTYPE(*s, ct_start_symbol)) PUGI_THROW_ERROR(status_bad_pi, s); - PUGI__SCANWHILE(PUGI__IS_CHARTYPE(*s, ct_symbol)); - PUGI__CHECK_ERROR(status_bad_pi, s); + PUGI_SCANWHILE(PUGI_IS_CHARTYPE(*s, ct_symbol)); + PUGI_CHECK_ERROR(status_bad_pi, s); // determine node type; stricmp / strcasecmp is not portable bool declaration = (target[0] | ' ') == 'x' && (target[1] | ' ') == 'm' && (target[2] | ' ') == 'l' && target + 3 == s; - if (declaration ? PUGI__OPTSET(parse_declaration) : PUGI__OPTSET(parse_pi)) + if (declaration ? PUGI_OPTSET(parse_declaration) : PUGI_OPTSET(parse_pi)) { if (declaration) { // disallow non top-level declarations - if (cursor->parent) PUGI__THROW_ERROR(status_bad_pi, s); + if (cursor->parent) PUGI_THROW_ERROR(status_bad_pi, s); - PUGI__PUSHNODE(node_declaration); + PUGI_PUSHNODE(node_declaration); } else { - PUGI__PUSHNODE(node_pi); + PUGI_PUSHNODE(node_pi); } cursor->name = target; - PUGI__ENDSEG(); + PUGI_ENDSEG(); // parse value/attributes if (ch == '?') { // empty node - if (!PUGI__ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_pi, s); + if (!PUGI_ENDSWITH(*s, '>')) PUGI_THROW_ERROR(status_bad_pi, s); s += (*s == '>'); - PUGI__POPNODE(); + PUGI_POPNODE(); } - else if (PUGI__IS_CHARTYPE(ch, ct_space)) + else if (PUGI_IS_CHARTYPE(ch, ct_space)) { - PUGI__SKIPWS(); + PUGI_SKIPWS(); // scan for tag end char_t* value = s; - PUGI__SCANFOR(s[0] == '?' && PUGI__ENDSWITH(s[1], '>')); - PUGI__CHECK_ERROR(status_bad_pi, s); + PUGI_SCANFOR(s[0] == '?' && PUGI_ENDSWITH(s[1], '>')); + PUGI_CHECK_ERROR(status_bad_pi, s); if (declaration) { @@ -2626,20 +2626,20 @@ { // store value and step over > cursor->value = value; - PUGI__POPNODE(); + PUGI_POPNODE(); - PUGI__ENDSEG(); + PUGI_ENDSEG(); s += (*s == '>'); } } - else PUGI__THROW_ERROR(status_bad_pi, s); + else PUGI_THROW_ERROR(status_bad_pi, s); } else { // scan for tag end - PUGI__SCANFOR(s[0] == '?' && PUGI__ENDSWITH(s[1], '>')); - PUGI__CHECK_ERROR(status_bad_pi, s); + PUGI_SCANFOR(s[0] == '?' && PUGI_ENDSWITH(s[1], '>')); + PUGI_CHECK_ERROR(status_bad_pi, s); s += (s[1] == '>' ? 2 : 1); } @@ -2666,39 +2666,39 @@ ++s; LOC_TAG: - if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // '<#...' + if (PUGI_IS_CHARTYPE(*s, ct_start_symbol)) // '<#...' { - PUGI__PUSHNODE(node_element); // Append a new node to the tree. + PUGI_PUSHNODE(node_element); // Append a new node to the tree. cursor->name = s; - PUGI__SCANWHILE_UNROLL(PUGI__IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator. - PUGI__ENDSEG(); // Save char in 'ch', terminate & step over. + PUGI_SCANWHILE_UNROLL(PUGI_IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator. + PUGI_ENDSEG(); // Save char in 'ch', terminate & step over. if (ch == '>') { // end of tag } - else if (PUGI__IS_CHARTYPE(ch, ct_space)) + else if (PUGI_IS_CHARTYPE(ch, ct_space)) { LOC_ATTRIBUTES: while (true) { - PUGI__SKIPWS(); // Eat any whitespace. + PUGI_SKIPWS(); // Eat any whitespace. - if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // <... #... + if (PUGI_IS_CHARTYPE(*s, ct_start_symbol)) // <... #... { xml_attribute_struct* a = append_new_attribute(cursor, alloc); // Make space for this attribute. - if (!a) PUGI__THROW_ERROR(status_out_of_memory, s); + if (!a) PUGI_THROW_ERROR(status_out_of_memory, s); a->name = s; // Save the offset. - PUGI__SCANWHILE_UNROLL(PUGI__IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator. - PUGI__ENDSEG(); // Save char in 'ch', terminate & step over. + PUGI_SCANWHILE_UNROLL(PUGI_IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator. + PUGI_ENDSEG(); // Save char in 'ch', terminate & step over. - if (PUGI__IS_CHARTYPE(ch, ct_space)) + if (PUGI_IS_CHARTYPE(ch, ct_space)) { - PUGI__SKIPWS(); // Eat any whitespace. + PUGI_SKIPWS(); // Eat any whitespace. ch = *s; ++s; @@ -2706,7 +2706,7 @@ if (ch == '=') // '<... #=...' { - PUGI__SKIPWS(); // Eat any whitespace. + PUGI_SKIPWS(); // Eat any whitespace. if (*s == '"' || *s == '\'') // '<... #="...' { @@ -2716,16 +2716,16 @@ s = strconv_attribute(s, ch); - if (!s) PUGI__THROW_ERROR(status_bad_attribute, a->value); + if (!s) PUGI_THROW_ERROR(status_bad_attribute, a->value); // After this line the loop continues from the start; // Whitespaces, / and > are ok, symbols and EOF are wrong, // everything else will be detected - if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_attribute, s); + if (PUGI_IS_CHARTYPE(*s, ct_start_symbol)) PUGI_THROW_ERROR(status_bad_attribute, s); } - else PUGI__THROW_ERROR(status_bad_attribute, s); + else PUGI_THROW_ERROR(status_bad_attribute, s); } - else PUGI__THROW_ERROR(status_bad_attribute, s); + else PUGI_THROW_ERROR(status_bad_attribute, s); } else if (*s == '/') { @@ -2733,16 +2733,16 @@ if (*s == '>') { - PUGI__POPNODE(); + PUGI_POPNODE(); s++; break; } else if (*s == 0 && endch == '>') { - PUGI__POPNODE(); + PUGI_POPNODE(); break; } - else PUGI__THROW_ERROR(status_bad_start_element, s); + else PUGI_THROW_ERROR(status_bad_start_element, s); } else if (*s == '>') { @@ -2754,16 +2754,16 @@ { break; } - else PUGI__THROW_ERROR(status_bad_start_element, s); + else PUGI_THROW_ERROR(status_bad_start_element, s); } // !!! } else if (ch == '/') // '<#.../' { - if (!PUGI__ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_start_element, s); + if (!PUGI_ENDSWITH(*s, '>')) PUGI_THROW_ERROR(status_bad_start_element, s); - PUGI__POPNODE(); // Pop. + PUGI_POPNODE(); // Pop. s += (*s == '>'); } @@ -2772,39 +2772,39 @@ // we stepped over null terminator, backtrack & handle closing tag --s; - if (endch != '>') PUGI__THROW_ERROR(status_bad_start_element, s); + if (endch != '>') PUGI_THROW_ERROR(status_bad_start_element, s); } - else PUGI__THROW_ERROR(status_bad_start_element, s); + else PUGI_THROW_ERROR(status_bad_start_element, s); } else if (*s == '/') { ++s; char_t* name = cursor->name; - if (!name) PUGI__THROW_ERROR(status_end_element_mismatch, s); + if (!name) PUGI_THROW_ERROR(status_end_element_mismatch, s); - while (PUGI__IS_CHARTYPE(*s, ct_symbol)) + while (PUGI_IS_CHARTYPE(*s, ct_symbol)) { - if (*s++ != *name++) PUGI__THROW_ERROR(status_end_element_mismatch, s); + if (*s++ != *name++) PUGI_THROW_ERROR(status_end_element_mismatch, s); } if (*name) { - if (*s == 0 && name[0] == endch && name[1] == 0) PUGI__THROW_ERROR(status_bad_end_element, s); - else PUGI__THROW_ERROR(status_end_element_mismatch, s); + if (*s == 0 && name[0] == endch && name[1] == 0) PUGI_THROW_ERROR(status_bad_end_element, s); + else PUGI_THROW_ERROR(status_end_element_mismatch, s); } - PUGI__POPNODE(); // Pop. + PUGI_POPNODE(); // Pop. - PUGI__SKIPWS(); + PUGI_SKIPWS(); if (*s == 0) { - if (endch != '>') PUGI__THROW_ERROR(status_bad_end_element, s); + if (endch != '>') PUGI_THROW_ERROR(status_bad_end_element, s); } else { - if (*s != '>') PUGI__THROW_ERROR(status_bad_end_element, s); + if (*s != '>') PUGI_THROW_ERROR(status_bad_end_element, s); ++s; } } @@ -2814,54 +2814,54 @@ if (!s) return s; assert(cursor); - if (PUGI__NODETYPE(cursor) == node_declaration) goto LOC_ATTRIBUTES; + if (PUGI_NODETYPE(cursor) == node_declaration) goto LOC_ATTRIBUTES; } else if (*s == '!') // 'first_child) continue; } } - if (!PUGI__OPTSET(parse_trim_pcdata)) + if (!PUGI_OPTSET(parse_trim_pcdata)) s = mark; - if (cursor->parent || PUGI__OPTSET(parse_fragment)) + if (cursor->parent || PUGI_OPTSET(parse_fragment)) { - PUGI__PUSHNODE(node_pcdata); // Append a new node on the tree. + PUGI_PUSHNODE(node_pcdata); // Append a new node on the tree. cursor->value = s; // Save the offset. s = strconv_pcdata(s); - PUGI__POPNODE(); // Pop since this is a standalone. + PUGI_POPNODE(); // Pop since this is a standalone. if (!*s) break; } else { - PUGI__SCANFOR(*s == '<'); // '...<' + PUGI_SCANFOR(*s == '<'); // '...<' if (!*s) break; ++s; @@ -2873,7 +2873,7 @@ } // check that last tag is closed - if (cursor != root) PUGI__THROW_ERROR(status_end_element_mismatch, s); + if (cursor != root) PUGI_THROW_ERROR(status_end_element_mismatch, s); return s; } @@ -2895,7 +2895,7 @@ { while (node) { - if (PUGI__NODETYPE(node) == node_element) return true; + if (PUGI_NODETYPE(node) == node_element) return true; node = node->next_sibling; } @@ -2910,7 +2910,7 @@ // early-out for empty documents if (length == 0) - return make_parse_result(PUGI__OPTSET(parse_fragment) ? status_ok : status_no_document_element); + return make_parse_result(PUGI_OPTSET(parse_fragment) ? status_ok : status_no_document_element); // get last child of the root before parsing xml_node_struct* last_root_child = root->first_child ? root->first_child->prev_sibling_c : 0; @@ -2943,7 +2943,7 @@ // check if there are any element nodes parsed xml_node_struct* first_root_child_parsed = last_root_child ? last_root_child->next_sibling : root->first_child; - if (!PUGI__OPTSET(parse_fragment) && !has_element_node_siblings(first_root_child_parsed)) + if (!PUGI_OPTSET(parse_fragment) && !has_element_node_siblings(first_root_child_parsed)) return make_parse_result(status_no_document_element, length - 1); } else @@ -2958,7 +2958,7 @@ }; // Output facilities - PUGI__FN xml_encoding get_write_native_encoding() + PUGI_FN xml_encoding get_write_native_encoding() { #ifdef PUGIXML_WCHAR_MODE return get_wchar_encoding(); @@ -2967,7 +2967,7 @@ #endif } - PUGI__FN xml_encoding get_write_encoding(xml_encoding encoding) + PUGI_FN xml_encoding get_write_encoding(xml_encoding encoding) { // replace wchar encoding with utf implementation if (encoding == encoding_wchar) return get_wchar_encoding(); @@ -2986,7 +2986,7 @@ } #ifdef PUGIXML_WCHAR_MODE - PUGI__FN size_t get_valid_length(const char_t* data, size_t length) + PUGI_FN size_t get_valid_length(const char_t* data, size_t length) { if (length < 1) return 0; @@ -2994,7 +2994,7 @@ return (sizeof(wchar_t) == 2 && static_cast(static_cast(data[length - 1]) - 0xD800) < 0x400) ? length - 1 : length; } - PUGI__FN size_t convert_buffer_output(char_t* r_char, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding) + PUGI_FN size_t convert_buffer_output(char_t* r_char, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding) { // only endian-swapping is required if (need_endian_swap_utf(encoding, get_wchar_encoding())) @@ -3058,7 +3058,7 @@ return 0; } #else - PUGI__FN size_t get_valid_length(const char_t* data, size_t length) + PUGI_FN size_t get_valid_length(const char_t* data, size_t length) { if (length < 5) return 0; @@ -3074,7 +3074,7 @@ return length; } - PUGI__FN size_t convert_buffer_output(char_t* /* r_char */, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding) + PUGI_FN size_t convert_buffer_output(char_t* /* r_char */, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding) { if (encoding == encoding_utf16_be || encoding == encoding_utf16_le) { @@ -3127,7 +3127,7 @@ public: xml_buffered_writer(xml_writer& writer_, xml_encoding user_encoding): writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding)) { - PUGI__STATIC_ASSERT(bufcapacity >= 8); + PUGI_STATIC_ASSERT(bufcapacity >= 8); } ~xml_buffered_writer() @@ -3338,14 +3338,14 @@ xml_encoding encoding; }; - PUGI__FN void text_output_escaped(xml_buffered_writer& writer, const char_t* s, chartypex_t type) + PUGI_FN void text_output_escaped(xml_buffered_writer& writer, const char_t* s, chartypex_t type) { while (*s) { const char_t* prev = s; // While *s is a usual symbol - PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPEX(ss, type)); + PUGI_SCANWHILE_UNROLL(!PUGI_IS_CHARTYPEX(ss, type)); writer.write_buffer(prev, static_cast(s - prev)); @@ -3379,7 +3379,7 @@ } } - PUGI__FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags) + PUGI_FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags) { if (flags & format_no_escapes) writer.write_string(s); @@ -3387,7 +3387,7 @@ text_output_escaped(writer, s, type); } - PUGI__FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s) + PUGI_FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s) { do { @@ -3409,7 +3409,7 @@ while (*s); } - PUGI__FN void text_output_indent(xml_buffered_writer& writer, const char_t* indent, size_t indent_length, unsigned int depth) + PUGI_FN void text_output_indent(xml_buffered_writer& writer, const char_t* indent, size_t indent_length, unsigned int depth) { switch (indent_length) { @@ -3449,7 +3449,7 @@ } } - PUGI__FN void node_output_comment(xml_buffered_writer& writer, const char_t* s) + PUGI_FN void node_output_comment(xml_buffered_writer& writer, const char_t* s) { writer.write('<', '!', '-', '-'); @@ -3474,7 +3474,7 @@ writer.write('-', '-', '>'); } - PUGI__FN void node_output_attributes(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) + PUGI_FN void node_output_attributes(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) { const char_t* default_name = PUGIXML_TEXT(":anonymous"); @@ -3491,7 +3491,7 @@ } } - PUGI__FN bool node_output_start(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) + PUGI_FN bool node_output_start(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) { const char_t* default_name = PUGIXML_TEXT(":anonymous"); const char_t* name = node->name ? node->name : default_name; @@ -3519,13 +3519,13 @@ if (!first) writer.write(' ', '/', '>', '\n'); - else if (!first->next_sibling && (PUGI__NODETYPE(first) == node_pcdata || PUGI__NODETYPE(first) == node_cdata)) + else if (!first->next_sibling && (PUGI_NODETYPE(first) == node_pcdata || PUGI_NODETYPE(first) == node_cdata)) { writer.write('>'); const char_t* value = first->value ? first->value : PUGIXML_TEXT(""); - if (PUGI__NODETYPE(first) == node_pcdata) + if (PUGI_NODETYPE(first) == node_pcdata) text_output(writer, value, ctx_special_pcdata, flags); else text_output_cdata(writer, value); @@ -3545,7 +3545,7 @@ return false; } - PUGI__FN void node_output_end(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) + PUGI_FN void node_output_end(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) { const char_t* default_name = PUGIXML_TEXT(":anonymous"); const char_t* name = node->name ? node->name : default_name; @@ -3559,11 +3559,11 @@ writer.write('>', '\n'); } - PUGI__FN void node_output_simple(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) + PUGI_FN void node_output_simple(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags) { const char_t* default_name = PUGIXML_TEXT(":anonymous"); - switch (PUGI__NODETYPE(node)) + switch (PUGI_NODETYPE(node)) { case node_pcdata: text_output(writer, node->value ? node->value : PUGIXML_TEXT(""), ctx_special_pcdata, flags); @@ -3621,7 +3621,7 @@ } } - PUGI__FN void node_output(xml_buffered_writer& writer, xml_node_struct* root, const char_t* indent, unsigned int flags, unsigned int depth) + PUGI_FN void node_output(xml_buffered_writer& writer, xml_node_struct* root, const char_t* indent, unsigned int flags, unsigned int depth) { size_t indent_length = ((flags & (format_indent | format_raw)) == format_indent) ? strlength(indent) : 0; @@ -3635,7 +3635,7 @@ if (indent_length) text_output_indent(writer, indent, indent_length, depth); - if (PUGI__NODETYPE(node) == node_element) + if (PUGI_NODETYPE(node) == node_element) { if (node_output_start(writer, node, flags)) { @@ -3644,7 +3644,7 @@ continue; } } - else if (PUGI__NODETYPE(node) == node_document) + else if (PUGI_NODETYPE(node) == node_document) { if (node->first_child) { @@ -3669,7 +3669,7 @@ node = node->parent; // write closing node - if (PUGI__NODETYPE(node) == node_element) + if (PUGI_NODETYPE(node) == node_element) { depth--; @@ -3683,11 +3683,11 @@ while (node != root); } - PUGI__FN bool has_declaration(xml_node_struct* node) + PUGI_FN bool has_declaration(xml_node_struct* node) { for (xml_node_struct* child = node->first_child; child; child = child->next_sibling) { - xml_node_type type = PUGI__NODETYPE(child); + xml_node_type type = PUGI_NODETYPE(child); if (type == node_declaration) return true; if (type == node_element) return false; @@ -3696,7 +3696,7 @@ return false; } - PUGI__FN bool is_attribute_of(xml_attribute_struct* attr, xml_node_struct* node) + PUGI_FN bool is_attribute_of(xml_attribute_struct* attr, xml_node_struct* node) { for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute) if (a == attr) @@ -3705,12 +3705,12 @@ return false; } - PUGI__FN bool allow_insert_attribute(xml_node_type parent) + PUGI_FN bool allow_insert_attribute(xml_node_type parent) { return parent == node_element || parent == node_declaration; } - PUGI__FN bool allow_insert_child(xml_node_type parent, xml_node_type child) + PUGI_FN bool allow_insert_child(xml_node_type parent, xml_node_type child) { if (parent != node_document && parent != node_element) return false; if (child == node_document || child == node_null) return false; @@ -3719,7 +3719,7 @@ return true; } - PUGI__FN bool allow_move(xml_node parent, xml_node child) + PUGI_FN bool allow_move(xml_node parent, xml_node child) { // check that child can be a child of parent if (!allow_insert_child(parent.type(), child.type())) @@ -3743,7 +3743,7 @@ return true; } - PUGI__FN void node_copy_string(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char_t* source, uintptr_t& source_header, xml_allocator* alloc) + PUGI_FN void node_copy_string(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char_t* source, uintptr_t& source_header, xml_allocator* alloc) { assert(!dest && (header & header_mask) == 0); @@ -3762,7 +3762,7 @@ } } - PUGI__FN void node_copy_contents(xml_node_struct* dn, xml_node_struct* sn, xml_allocator* shared_alloc) + PUGI_FN void node_copy_contents(xml_node_struct* dn, xml_node_struct* sn, xml_allocator* shared_alloc) { node_copy_string(dn->name, dn->header, xml_memory_page_name_allocated_mask, sn->name, sn->header, shared_alloc); node_copy_string(dn->value, dn->header, xml_memory_page_value_allocated_mask, sn->value, sn->header, shared_alloc); @@ -3779,7 +3779,7 @@ } } - PUGI__FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn) + PUGI_FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn) { xml_allocator& alloc = get_allocator(dn); xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0; @@ -3793,7 +3793,7 @@ { if (sit != dn) { - xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit)); + xml_node_struct* copy = append_new_node(dit, alloc, PUGI_NODETYPE(sit)); if (copy) { @@ -3826,17 +3826,17 @@ inline bool is_text_node(xml_node_struct* node) { - xml_node_type type = PUGI__NODETYPE(node); + xml_node_type type = PUGI_NODETYPE(node); return type == node_pcdata || type == node_cdata; } // get value with conversion functions - PUGI__FN int get_integer_base(const char_t* value) + PUGI_FN int get_integer_base(const char_t* value) { const char_t* s = value; - while (PUGI__IS_CHARTYPE(*s, ct_space)) + while (PUGI_IS_CHARTYPE(*s, ct_space)) s++; if (*s == '-') @@ -3845,7 +3845,7 @@ return (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) ? 16 : 10; } - PUGI__FN int get_value_int(const char_t* value, int def) + PUGI_FN int get_value_int(const char_t* value, int def) { if (!value) return def; @@ -3858,7 +3858,7 @@ #endif } - PUGI__FN unsigned int get_value_uint(const char_t* value, unsigned int def) + PUGI_FN unsigned int get_value_uint(const char_t* value, unsigned int def) { if (!value) return def; @@ -3871,7 +3871,7 @@ #endif } - PUGI__FN double get_value_double(const char_t* value, double def) + PUGI_FN double get_value_double(const char_t* value, double def) { if (!value) return def; @@ -3882,7 +3882,7 @@ #endif } - PUGI__FN float get_value_float(const char_t* value, float def) + PUGI_FN float get_value_float(const char_t* value, float def) { if (!value) return def; @@ -3893,7 +3893,7 @@ #endif } - PUGI__FN bool get_value_bool(const char_t* value, bool def) + PUGI_FN bool get_value_bool(const char_t* value, bool def) { if (!value) return def; @@ -3905,20 +3905,20 @@ } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN long long get_value_llong(const char_t* value, long long def) + PUGI_FN long long get_value_llong(const char_t* value, long long def) { if (!value) return def; int base = get_integer_base(value); #ifdef PUGIXML_WCHAR_MODE - #ifdef PUGI__MSVC_CRT_VERSION + #ifdef PUGI_MSVC_CRT_VERSION return _wcstoi64(value, 0, base); #else return wcstoll(value, 0, base); #endif #else - #ifdef PUGI__MSVC_CRT_VERSION + #ifdef PUGI_MSVC_CRT_VERSION return _strtoi64(value, 0, base); #else return strtoll(value, 0, base); @@ -3926,20 +3926,20 @@ #endif } - PUGI__FN unsigned long long get_value_ullong(const char_t* value, unsigned long long def) + PUGI_FN unsigned long long get_value_ullong(const char_t* value, unsigned long long def) { if (!value) return def; int base = get_integer_base(value); #ifdef PUGIXML_WCHAR_MODE - #ifdef PUGI__MSVC_CRT_VERSION + #ifdef PUGI_MSVC_CRT_VERSION return _wcstoui64(value, 0, base); #else return wcstoull(value, 0, base); #endif #else - #ifdef PUGI__MSVC_CRT_VERSION + #ifdef PUGI_MSVC_CRT_VERSION return _strtoui64(value, 0, base); #else return strtoull(value, 0, base); @@ -3949,7 +3949,7 @@ #endif // set value with conversion functions - PUGI__FN bool set_value_buffer(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char (&buf)[128]) + PUGI_FN bool set_value_buffer(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char (&buf)[128]) { #ifdef PUGIXML_WCHAR_MODE char_t wbuf[128]; @@ -3961,7 +3961,7 @@ #endif } - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, int value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, int value) { char buf[128]; sprintf(buf, "%d", value); @@ -3969,7 +3969,7 @@ return set_value_buffer(dest, header, header_mask, buf); } - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned int value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned int value) { char buf[128]; sprintf(buf, "%u", value); @@ -3977,7 +3977,7 @@ return set_value_buffer(dest, header, header_mask, buf); } - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, float value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, float value) { char buf[128]; sprintf(buf, "%.9g", value); @@ -3985,7 +3985,7 @@ return set_value_buffer(dest, header, header_mask, buf); } - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, double value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, double value) { char buf[128]; sprintf(buf, "%.17g", value); @@ -3993,13 +3993,13 @@ return set_value_buffer(dest, header, header_mask, buf); } - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, bool value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, bool value) { return strcpy_insitu(dest, header, header_mask, value ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false")); } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, long long value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, long long value) { char buf[128]; sprintf(buf, "%lld", value); @@ -4007,7 +4007,7 @@ return set_value_buffer(dest, header, header_mask, buf); } - PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned long long value) + PUGI_FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned long long value) { char buf[128]; sprintf(buf, "%llu", value); @@ -4017,9 +4017,9 @@ #endif // we need to get length of entire file to load it in memory; the only (relatively) sane way to do it is via seek/tell trick - PUGI__FN xml_parse_status get_file_size(FILE* file, size_t& out_result) + PUGI_FN xml_parse_status get_file_size(FILE* file, size_t& out_result) { - #if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE) + #if defined(PUGI_MSVC_CRT_VERSION) && PUGI_MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE) // there are 64-bit versions of fseek/ftell, let's use them typedef __int64 length_type; @@ -4056,7 +4056,7 @@ return status_ok; } - PUGI__FN size_t zero_terminate_buffer(void* buffer, size_t size, xml_encoding encoding) + PUGI_FN size_t zero_terminate_buffer(void* buffer, size_t size, xml_encoding encoding) { // We only need to zero-terminate if encoding conversion does not do it for us #ifdef PUGIXML_WCHAR_MODE @@ -4080,7 +4080,7 @@ return size; } - PUGI__FN xml_parse_result load_file_impl(xml_document& doc, FILE* file, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result load_file_impl(xml_document& doc, FILE* file, unsigned int options, xml_encoding encoding) { if (!file) return make_parse_result(status_file_not_found); @@ -4155,7 +4155,7 @@ T data[xml_memory_page_size / sizeof(T)]; }; - template PUGI__FN xml_parse_status load_stream_data_noseek(std::basic_istream& stream, void** out_buffer, size_t* out_size) + template PUGI_FN xml_parse_status load_stream_data_noseek(std::basic_istream& stream, void** out_buffer, size_t* out_size) { buffer_holder chunks(0, xml_stream_chunk::destroy); @@ -4209,7 +4209,7 @@ return status_ok; } - template PUGI__FN xml_parse_status load_stream_data_seek(std::basic_istream& stream, void** out_buffer, size_t* out_size) + template PUGI_FN xml_parse_status load_stream_data_seek(std::basic_istream& stream, void** out_buffer, size_t* out_size) { // get length of remaining data in stream typename std::basic_istream::pos_type pos = stream.tellg(); @@ -4245,7 +4245,7 @@ return status_ok; } - template PUGI__FN xml_parse_result load_stream_impl(xml_document& doc, std::basic_istream& stream, unsigned int options, xml_encoding encoding) + template PUGI_FN xml_parse_result load_stream_impl(xml_document& doc, std::basic_istream& stream, unsigned int options, xml_encoding encoding) { void* buffer = 0; size_t size = 0; @@ -4271,13 +4271,13 @@ } #endif -#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) || (defined(__MINGW32__) && (!defined(__STRICT_ANSI__) || defined(__MINGW64_VERSION_MAJOR))) - PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode) +#if defined(PUGI_MSVC_CRT_VERSION) || defined(__BORLANDC__) || (defined(__MINGW32__) && (!defined(__STRICT_ANSI__) || defined(__MINGW64_VERSION_MAJOR))) + PUGI_FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode) { return _wfopen(path, mode); } #else - PUGI__FN char* convert_path_heap(const wchar_t* str) + PUGI_FN char* convert_path_heap(const wchar_t* str) { assert(str); @@ -4295,7 +4295,7 @@ return result; } - PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode) + PUGI_FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode) { // there is no standard function to open wide paths, so our best bet is to try utf8 path char* path_utf8 = convert_path_heap(path); @@ -4315,7 +4315,7 @@ } #endif - PUGI__FN bool save_file_impl(const xml_document& doc, FILE* file, const char_t* indent, unsigned int flags, xml_encoding encoding) + PUGI_FN bool save_file_impl(const xml_document& doc, FILE* file, const char_t* indent, unsigned int flags, xml_encoding encoding) { if (!file) return false; @@ -4329,7 +4329,7 @@ return result == 0; } - PUGI__FN xml_parse_result load_buffer_impl(xml_document_struct* doc, xml_node_struct* root, void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own, char_t** out_buffer) + PUGI_FN xml_parse_result load_buffer_impl(xml_document_struct* doc, xml_node_struct* root, void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own, char_t** out_buffer) { // check input buffer assert(contents || size == 0); @@ -4360,30 +4360,30 @@ return res; } -PUGI__NS_END +PUGI_NS_END namespace pugi { - PUGI__FN xml_writer_file::xml_writer_file(void* file_): file(file_) + PUGI_FN xml_writer_file::xml_writer_file(void* file_): file(file_) { } - PUGI__FN void xml_writer_file::write(const void* data, size_t size) + PUGI_FN void xml_writer_file::write(const void* data, size_t size) { size_t result = fwrite(data, 1, size, static_cast(file)); (void)!result; // unfortunately we can't do proper error handling here } #ifndef PUGIXML_NO_STL - PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream >& stream): narrow_stream(&stream), wide_stream(0) + PUGI_FN xml_writer_stream::xml_writer_stream(std::basic_ostream >& stream): narrow_stream(&stream), wide_stream(0) { } - PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream >& stream): narrow_stream(0), wide_stream(&stream) + PUGI_FN xml_writer_stream::xml_writer_stream(std::basic_ostream >& stream): narrow_stream(0), wide_stream(&stream) { } - PUGI__FN void xml_writer_stream::write(const void* data, size_t size) + PUGI_FN void xml_writer_stream::write(const void* data, size_t size) { if (narrow_stream) { @@ -4400,251 +4400,251 @@ } #endif - PUGI__FN xml_tree_walker::xml_tree_walker(): _depth(0) + PUGI_FN xml_tree_walker::xml_tree_walker(): _depth(0) { } - PUGI__FN xml_tree_walker::~xml_tree_walker() + PUGI_FN xml_tree_walker::~xml_tree_walker() { } - PUGI__FN int xml_tree_walker::depth() const + PUGI_FN int xml_tree_walker::depth() const { return _depth; } - PUGI__FN bool xml_tree_walker::begin(xml_node&) + PUGI_FN bool xml_tree_walker::begin(xml_node&) { return true; } - PUGI__FN bool xml_tree_walker::end(xml_node&) + PUGI_FN bool xml_tree_walker::end(xml_node&) { return true; } - PUGI__FN xml_attribute::xml_attribute(): _attr(0) + PUGI_FN xml_attribute::xml_attribute(): _attr(0) { } - PUGI__FN xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr) + PUGI_FN xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr) { } - PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***) + PUGI_FN static void unspecified_bool_xml_attribute(xml_attribute***) { } - PUGI__FN xml_attribute::operator xml_attribute::unspecified_bool_type() const + PUGI_FN xml_attribute::operator xml_attribute::unspecified_bool_type() const { return _attr ? unspecified_bool_xml_attribute : 0; } - PUGI__FN bool xml_attribute::operator!() const + PUGI_FN bool xml_attribute::operator!() const { return !_attr; } - PUGI__FN bool xml_attribute::operator==(const xml_attribute& r) const + PUGI_FN bool xml_attribute::operator==(const xml_attribute& r) const { return (_attr == r._attr); } - PUGI__FN bool xml_attribute::operator!=(const xml_attribute& r) const + PUGI_FN bool xml_attribute::operator!=(const xml_attribute& r) const { return (_attr != r._attr); } - PUGI__FN bool xml_attribute::operator<(const xml_attribute& r) const + PUGI_FN bool xml_attribute::operator<(const xml_attribute& r) const { return (_attr < r._attr); } - PUGI__FN bool xml_attribute::operator>(const xml_attribute& r) const + PUGI_FN bool xml_attribute::operator>(const xml_attribute& r) const { return (_attr > r._attr); } - PUGI__FN bool xml_attribute::operator<=(const xml_attribute& r) const + PUGI_FN bool xml_attribute::operator<=(const xml_attribute& r) const { return (_attr <= r._attr); } - PUGI__FN bool xml_attribute::operator>=(const xml_attribute& r) const + PUGI_FN bool xml_attribute::operator>=(const xml_attribute& r) const { return (_attr >= r._attr); } - PUGI__FN xml_attribute xml_attribute::next_attribute() const + PUGI_FN xml_attribute xml_attribute::next_attribute() const { return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute(); } - PUGI__FN xml_attribute xml_attribute::previous_attribute() const + PUGI_FN xml_attribute xml_attribute::previous_attribute() const { return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute(); } - PUGI__FN const char_t* xml_attribute::as_string(const char_t* def) const + PUGI_FN const char_t* xml_attribute::as_string(const char_t* def) const { return (_attr && _attr->value) ? _attr->value : def; } - PUGI__FN int xml_attribute::as_int(int def) const + PUGI_FN int xml_attribute::as_int(int def) const { return impl::get_value_int(_attr ? _attr->value : 0, def); } - PUGI__FN unsigned int xml_attribute::as_uint(unsigned int def) const + PUGI_FN unsigned int xml_attribute::as_uint(unsigned int def) const { return impl::get_value_uint(_attr ? _attr->value : 0, def); } - PUGI__FN double xml_attribute::as_double(double def) const + PUGI_FN double xml_attribute::as_double(double def) const { return impl::get_value_double(_attr ? _attr->value : 0, def); } - PUGI__FN float xml_attribute::as_float(float def) const + PUGI_FN float xml_attribute::as_float(float def) const { return impl::get_value_float(_attr ? _attr->value : 0, def); } - PUGI__FN bool xml_attribute::as_bool(bool def) const + PUGI_FN bool xml_attribute::as_bool(bool def) const { return impl::get_value_bool(_attr ? _attr->value : 0, def); } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN long long xml_attribute::as_llong(long long def) const + PUGI_FN long long xml_attribute::as_llong(long long def) const { return impl::get_value_llong(_attr ? _attr->value : 0, def); } - PUGI__FN unsigned long long xml_attribute::as_ullong(unsigned long long def) const + PUGI_FN unsigned long long xml_attribute::as_ullong(unsigned long long def) const { return impl::get_value_ullong(_attr ? _attr->value : 0, def); } #endif - PUGI__FN bool xml_attribute::empty() const + PUGI_FN bool xml_attribute::empty() const { return !_attr; } - PUGI__FN const char_t* xml_attribute::name() const + PUGI_FN const char_t* xml_attribute::name() const { return (_attr && _attr->name) ? _attr->name : PUGIXML_TEXT(""); } - PUGI__FN const char_t* xml_attribute::value() const + PUGI_FN const char_t* xml_attribute::value() const { return (_attr && _attr->value) ? _attr->value : PUGIXML_TEXT(""); } - PUGI__FN size_t xml_attribute::hash_value() const + PUGI_FN size_t xml_attribute::hash_value() const { return static_cast(reinterpret_cast(_attr) / sizeof(xml_attribute_struct)); } - PUGI__FN xml_attribute_struct* xml_attribute::internal_object() const + PUGI_FN xml_attribute_struct* xml_attribute::internal_object() const { return _attr; } - PUGI__FN xml_attribute& xml_attribute::operator=(const char_t* rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(const char_t* rhs) { set_value(rhs); return *this; } - PUGI__FN xml_attribute& xml_attribute::operator=(int rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(int rhs) { set_value(rhs); return *this; } - PUGI__FN xml_attribute& xml_attribute::operator=(unsigned int rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(unsigned int rhs) { set_value(rhs); return *this; } - PUGI__FN xml_attribute& xml_attribute::operator=(double rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(double rhs) { set_value(rhs); return *this; } - PUGI__FN xml_attribute& xml_attribute::operator=(float rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(float rhs) { set_value(rhs); return *this; } - PUGI__FN xml_attribute& xml_attribute::operator=(bool rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(bool rhs) { set_value(rhs); return *this; } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN xml_attribute& xml_attribute::operator=(long long rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(long long rhs) { set_value(rhs); return *this; } - PUGI__FN xml_attribute& xml_attribute::operator=(unsigned long long rhs) + PUGI_FN xml_attribute& xml_attribute::operator=(unsigned long long rhs) { set_value(rhs); return *this; } #endif - PUGI__FN bool xml_attribute::set_name(const char_t* rhs) + PUGI_FN bool xml_attribute::set_name(const char_t* rhs) { if (!_attr) return false; return impl::strcpy_insitu(_attr->name, _attr->header, impl::xml_memory_page_name_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(const char_t* rhs) + PUGI_FN bool xml_attribute::set_value(const char_t* rhs) { if (!_attr) return false; return impl::strcpy_insitu(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(int rhs) + PUGI_FN bool xml_attribute::set_value(int rhs) { if (!_attr) return false; return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(unsigned int rhs) + PUGI_FN bool xml_attribute::set_value(unsigned int rhs) { if (!_attr) return false; return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(double rhs) + PUGI_FN bool xml_attribute::set_value(double rhs) { if (!_attr) return false; return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(float rhs) + PUGI_FN bool xml_attribute::set_value(float rhs) { if (!_attr) return false; return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(bool rhs) + PUGI_FN bool xml_attribute::set_value(bool rhs) { if (!_attr) return false; @@ -4652,14 +4652,14 @@ } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN bool xml_attribute::set_value(long long rhs) + PUGI_FN bool xml_attribute::set_value(long long rhs) { if (!_attr) return false; return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs); } - PUGI__FN bool xml_attribute::set_value(unsigned long long rhs) + PUGI_FN bool xml_attribute::set_value(unsigned long long rhs) { if (!_attr) return false; @@ -4668,125 +4668,125 @@ #endif #ifdef __BORLANDC__ - PUGI__FN bool operator&&(const xml_attribute& lhs, bool rhs) + PUGI_FN bool operator&&(const xml_attribute& lhs, bool rhs) { return (bool)lhs && rhs; } - PUGI__FN bool operator||(const xml_attribute& lhs, bool rhs) + PUGI_FN bool operator||(const xml_attribute& lhs, bool rhs) { return (bool)lhs || rhs; } #endif - PUGI__FN xml_node::xml_node(): _root(0) + PUGI_FN xml_node::xml_node(): _root(0) { } - PUGI__FN xml_node::xml_node(xml_node_struct* p): _root(p) + PUGI_FN xml_node::xml_node(xml_node_struct* p): _root(p) { } - PUGI__FN static void unspecified_bool_xml_node(xml_node***) + PUGI_FN static void unspecified_bool_xml_node(xml_node***) { } - PUGI__FN xml_node::operator xml_node::unspecified_bool_type() const + PUGI_FN xml_node::operator xml_node::unspecified_bool_type() const { return _root ? unspecified_bool_xml_node : 0; } - PUGI__FN bool xml_node::operator!() const + PUGI_FN bool xml_node::operator!() const { return !_root; } - PUGI__FN xml_node::iterator xml_node::begin() const + PUGI_FN xml_node::iterator xml_node::begin() const { return iterator(_root ? _root->first_child : 0, _root); } - PUGI__FN xml_node::iterator xml_node::end() const + PUGI_FN xml_node::iterator xml_node::end() const { return iterator(0, _root); } - PUGI__FN xml_node::attribute_iterator xml_node::attributes_begin() const + PUGI_FN xml_node::attribute_iterator xml_node::attributes_begin() const { return attribute_iterator(_root ? _root->first_attribute : 0, _root); } - PUGI__FN xml_node::attribute_iterator xml_node::attributes_end() const + PUGI_FN xml_node::attribute_iterator xml_node::attributes_end() const { return attribute_iterator(0, _root); } - PUGI__FN xml_object_range xml_node::children() const + PUGI_FN xml_object_range xml_node::children() const { return xml_object_range(begin(), end()); } - PUGI__FN xml_object_range xml_node::children(const char_t* name_) const + PUGI_FN xml_object_range xml_node::children(const char_t* name_) const { return xml_object_range(xml_named_node_iterator(child(name_)._root, _root, name_), xml_named_node_iterator(0, _root, name_)); } - PUGI__FN xml_object_range xml_node::attributes() const + PUGI_FN xml_object_range xml_node::attributes() const { return xml_object_range(attributes_begin(), attributes_end()); } - PUGI__FN bool xml_node::operator==(const xml_node& r) const + PUGI_FN bool xml_node::operator==(const xml_node& r) const { return (_root == r._root); } - PUGI__FN bool xml_node::operator!=(const xml_node& r) const + PUGI_FN bool xml_node::operator!=(const xml_node& r) const { return (_root != r._root); } - PUGI__FN bool xml_node::operator<(const xml_node& r) const + PUGI_FN bool xml_node::operator<(const xml_node& r) const { return (_root < r._root); } - PUGI__FN bool xml_node::operator>(const xml_node& r) const + PUGI_FN bool xml_node::operator>(const xml_node& r) const { return (_root > r._root); } - PUGI__FN bool xml_node::operator<=(const xml_node& r) const + PUGI_FN bool xml_node::operator<=(const xml_node& r) const { return (_root <= r._root); } - PUGI__FN bool xml_node::operator>=(const xml_node& r) const + PUGI_FN bool xml_node::operator>=(const xml_node& r) const { return (_root >= r._root); } - PUGI__FN bool xml_node::empty() const + PUGI_FN bool xml_node::empty() const { return !_root; } - PUGI__FN const char_t* xml_node::name() const + PUGI_FN const char_t* xml_node::name() const { return (_root && _root->name) ? _root->name : PUGIXML_TEXT(""); } - PUGI__FN xml_node_type xml_node::type() const + PUGI_FN xml_node_type xml_node::type() const { - return _root ? PUGI__NODETYPE(_root) : node_null; + return _root ? PUGI_NODETYPE(_root) : node_null; } - PUGI__FN const char_t* xml_node::value() const + PUGI_FN const char_t* xml_node::value() const { return (_root && _root->value) ? _root->value : PUGIXML_TEXT(""); } - PUGI__FN xml_node xml_node::child(const char_t* name_) const + PUGI_FN xml_node xml_node::child(const char_t* name_) const { if (!_root) return xml_node(); @@ -4796,7 +4796,7 @@ return xml_node(); } - PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const + PUGI_FN xml_attribute xml_node::attribute(const char_t* name_) const { if (!_root) return xml_attribute(); @@ -4807,7 +4807,7 @@ return xml_attribute(); } - PUGI__FN xml_node xml_node::next_sibling(const char_t* name_) const + PUGI_FN xml_node xml_node::next_sibling(const char_t* name_) const { if (!_root) return xml_node(); @@ -4817,12 +4817,12 @@ return xml_node(); } - PUGI__FN xml_node xml_node::next_sibling() const + PUGI_FN xml_node xml_node::next_sibling() const { return _root ? xml_node(_root->next_sibling) : xml_node(); } - PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const + PUGI_FN xml_node xml_node::previous_sibling(const char_t* name_) const { if (!_root) return xml_node(); @@ -4832,7 +4832,7 @@ return xml_node(); } - PUGI__FN xml_node xml_node::previous_sibling() const + PUGI_FN xml_node xml_node::previous_sibling() const { if (!_root) return xml_node(); @@ -4840,22 +4840,22 @@ else return xml_node(); } - PUGI__FN xml_node xml_node::parent() const + PUGI_FN xml_node xml_node::parent() const { return _root ? xml_node(_root->parent) : xml_node(); } - PUGI__FN xml_node xml_node::root() const + PUGI_FN xml_node xml_node::root() const { return _root ? xml_node(&impl::get_document(_root)) : xml_node(); } - PUGI__FN xml_text xml_node::text() const + PUGI_FN xml_text xml_node::text() const { return xml_text(_root); } - PUGI__FN const char_t* xml_node::child_value() const + PUGI_FN const char_t* xml_node::child_value() const { if (!_root) return PUGIXML_TEXT(""); @@ -4866,32 +4866,32 @@ return PUGIXML_TEXT(""); } - PUGI__FN const char_t* xml_node::child_value(const char_t* name_) const + PUGI_FN const char_t* xml_node::child_value(const char_t* name_) const { return child(name_).child_value(); } - PUGI__FN xml_attribute xml_node::first_attribute() const + PUGI_FN xml_attribute xml_node::first_attribute() const { return _root ? xml_attribute(_root->first_attribute) : xml_attribute(); } - PUGI__FN xml_attribute xml_node::last_attribute() const + PUGI_FN xml_attribute xml_node::last_attribute() const { return _root && _root->first_attribute ? xml_attribute(_root->first_attribute->prev_attribute_c) : xml_attribute(); } - PUGI__FN xml_node xml_node::first_child() const + PUGI_FN xml_node xml_node::first_child() const { return _root ? xml_node(_root->first_child) : xml_node(); } - PUGI__FN xml_node xml_node::last_child() const + PUGI_FN xml_node xml_node::last_child() const { return _root && _root->first_child ? xml_node(_root->first_child->prev_sibling_c) : xml_node(); } - PUGI__FN bool xml_node::set_name(const char_t* rhs) + PUGI_FN bool xml_node::set_name(const char_t* rhs) { switch (type()) { @@ -4905,7 +4905,7 @@ } } - PUGI__FN bool xml_node::set_value(const char_t* rhs) + PUGI_FN bool xml_node::set_value(const char_t* rhs) { switch (type()) { @@ -4921,7 +4921,7 @@ } } - PUGI__FN xml_attribute xml_node::append_attribute(const char_t* name_) + PUGI_FN xml_attribute xml_node::append_attribute(const char_t* name_) { if (!impl::allow_insert_attribute(type())) return xml_attribute(); @@ -4935,7 +4935,7 @@ return a; } - PUGI__FN xml_attribute xml_node::prepend_attribute(const char_t* name_) + PUGI_FN xml_attribute xml_node::prepend_attribute(const char_t* name_) { if (!impl::allow_insert_attribute(type())) return xml_attribute(); @@ -4949,7 +4949,7 @@ return a; } - PUGI__FN xml_attribute xml_node::insert_attribute_after(const char_t* name_, const xml_attribute& attr) + PUGI_FN xml_attribute xml_node::insert_attribute_after(const char_t* name_, const xml_attribute& attr) { if (!impl::allow_insert_attribute(type())) return xml_attribute(); if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute(); @@ -4964,7 +4964,7 @@ return a; } - PUGI__FN xml_attribute xml_node::insert_attribute_before(const char_t* name_, const xml_attribute& attr) + PUGI_FN xml_attribute xml_node::insert_attribute_before(const char_t* name_, const xml_attribute& attr) { if (!impl::allow_insert_attribute(type())) return xml_attribute(); if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute(); @@ -4979,7 +4979,7 @@ return a; } - PUGI__FN xml_attribute xml_node::append_copy(const xml_attribute& proto) + PUGI_FN xml_attribute xml_node::append_copy(const xml_attribute& proto) { if (!proto) return xml_attribute(); @@ -4989,7 +4989,7 @@ return result; } - PUGI__FN xml_attribute xml_node::prepend_copy(const xml_attribute& proto) + PUGI_FN xml_attribute xml_node::prepend_copy(const xml_attribute& proto) { if (!proto) return xml_attribute(); @@ -4999,7 +4999,7 @@ return result; } - PUGI__FN xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr) + PUGI_FN xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr) { if (!proto) return xml_attribute(); @@ -5009,7 +5009,7 @@ return result; } - PUGI__FN xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr) + PUGI_FN xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr) { if (!proto) return xml_attribute(); @@ -5019,7 +5019,7 @@ return result; } - PUGI__FN xml_node xml_node::append_child(xml_node_type type_) + PUGI_FN xml_node xml_node::append_child(xml_node_type type_) { if (!impl::allow_insert_child(type(), type_)) return xml_node(); @@ -5033,7 +5033,7 @@ return n; } - PUGI__FN xml_node xml_node::prepend_child(xml_node_type type_) + PUGI_FN xml_node xml_node::prepend_child(xml_node_type type_) { if (!impl::allow_insert_child(type(), type_)) return xml_node(); @@ -5047,7 +5047,7 @@ return n; } - PUGI__FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node) + PUGI_FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node) { if (!impl::allow_insert_child(type(), type_)) return xml_node(); if (!node._root || node._root->parent != _root) return xml_node(); @@ -5062,7 +5062,7 @@ return n; } - PUGI__FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node) + PUGI_FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node) { if (!impl::allow_insert_child(type(), type_)) return xml_node(); if (!node._root || node._root->parent != _root) return xml_node(); @@ -5077,7 +5077,7 @@ return n; } - PUGI__FN xml_node xml_node::append_child(const char_t* name_) + PUGI_FN xml_node xml_node::append_child(const char_t* name_) { xml_node result = append_child(node_element); @@ -5086,7 +5086,7 @@ return result; } - PUGI__FN xml_node xml_node::prepend_child(const char_t* name_) + PUGI_FN xml_node xml_node::prepend_child(const char_t* name_) { xml_node result = prepend_child(node_element); @@ -5095,7 +5095,7 @@ return result; } - PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node) + PUGI_FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node) { xml_node result = insert_child_after(node_element, node); @@ -5104,7 +5104,7 @@ return result; } - PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node) + PUGI_FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node) { xml_node result = insert_child_before(node_element, node); @@ -5113,7 +5113,7 @@ return result; } - PUGI__FN xml_node xml_node::append_copy(const xml_node& proto) + PUGI_FN xml_node xml_node::append_copy(const xml_node& proto) { xml_node_type type_ = proto.type(); if (!impl::allow_insert_child(type(), type_)) return xml_node(); @@ -5127,7 +5127,7 @@ return n; } - PUGI__FN xml_node xml_node::prepend_copy(const xml_node& proto) + PUGI_FN xml_node xml_node::prepend_copy(const xml_node& proto) { xml_node_type type_ = proto.type(); if (!impl::allow_insert_child(type(), type_)) return xml_node(); @@ -5141,7 +5141,7 @@ return n; } - PUGI__FN xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node) + PUGI_FN xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node) { xml_node_type type_ = proto.type(); if (!impl::allow_insert_child(type(), type_)) return xml_node(); @@ -5156,7 +5156,7 @@ return n; } - PUGI__FN xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node) + PUGI_FN xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node) { xml_node_type type_ = proto.type(); if (!impl::allow_insert_child(type(), type_)) return xml_node(); @@ -5171,7 +5171,7 @@ return n; } - PUGI__FN xml_node xml_node::append_move(const xml_node& moved) + PUGI_FN xml_node xml_node::append_move(const xml_node& moved) { if (!impl::allow_move(*this, moved)) return xml_node(); @@ -5184,7 +5184,7 @@ return moved; } - PUGI__FN xml_node xml_node::prepend_move(const xml_node& moved) + PUGI_FN xml_node xml_node::prepend_move(const xml_node& moved) { if (!impl::allow_move(*this, moved)) return xml_node(); @@ -5197,7 +5197,7 @@ return moved; } - PUGI__FN xml_node xml_node::insert_move_after(const xml_node& moved, const xml_node& node) + PUGI_FN xml_node xml_node::insert_move_after(const xml_node& moved, const xml_node& node) { if (!impl::allow_move(*this, moved)) return xml_node(); if (!node._root || node._root->parent != _root) return xml_node(); @@ -5212,7 +5212,7 @@ return moved; } - PUGI__FN xml_node xml_node::insert_move_before(const xml_node& moved, const xml_node& node) + PUGI_FN xml_node xml_node::insert_move_before(const xml_node& moved, const xml_node& node) { if (!impl::allow_move(*this, moved)) return xml_node(); if (!node._root || node._root->parent != _root) return xml_node(); @@ -5227,12 +5227,12 @@ return moved; } - PUGI__FN bool xml_node::remove_attribute(const char_t* name_) + PUGI_FN bool xml_node::remove_attribute(const char_t* name_) { return remove_attribute(attribute(name_)); } - PUGI__FN bool xml_node::remove_attribute(const xml_attribute& a) + PUGI_FN bool xml_node::remove_attribute(const xml_attribute& a) { if (!_root || !a._attr) return false; if (!impl::is_attribute_of(a._attr, _root)) return false; @@ -5243,12 +5243,12 @@ return true; } - PUGI__FN bool xml_node::remove_child(const char_t* name_) + PUGI_FN bool xml_node::remove_child(const char_t* name_) { return remove_child(child(name_)); } - PUGI__FN bool xml_node::remove_child(const xml_node& n) + PUGI_FN bool xml_node::remove_child(const xml_node& n) { if (!_root || !n._root || n._root->parent != _root) return false; @@ -5258,7 +5258,7 @@ return true; } - PUGI__FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding) { // append_buffer is only valid for elements/documents if (!impl::allow_insert_child(type(), node_element)) return impl::make_parse_result(status_append_invalid_root); @@ -5295,7 +5295,7 @@ return res; } - PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const + PUGI_FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const { if (!_root) return xml_node(); @@ -5310,7 +5310,7 @@ return xml_node(); } - PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const + PUGI_FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const { if (!_root) return xml_node(); @@ -5323,7 +5323,7 @@ } #ifndef PUGIXML_NO_STL - PUGI__FN string_t xml_node::path(char_t delimiter) const + PUGI_FN string_t xml_node::path(char_t delimiter) const { xml_node cursor = *this; // Make a copy. @@ -5343,7 +5343,7 @@ } #endif - PUGI__FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const + PUGI_FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const { xml_node found = *this; // Current search context. @@ -5390,7 +5390,7 @@ } } - PUGI__FN bool xml_node::traverse(xml_tree_walker& walker) + PUGI_FN bool xml_node::traverse(xml_tree_walker& walker) { walker._depth = -1; @@ -5438,17 +5438,17 @@ return walker.end(arg_end); } - PUGI__FN size_t xml_node::hash_value() const + PUGI_FN size_t xml_node::hash_value() const { return static_cast(reinterpret_cast(_root) / sizeof(xml_node_struct)); } - PUGI__FN xml_node_struct* xml_node::internal_object() const + PUGI_FN xml_node_struct* xml_node::internal_object() const { return _root; } - PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const + PUGI_FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const { if (!_root) return; @@ -5458,14 +5458,14 @@ } #ifndef PUGIXML_NO_STL - PUGI__FN void xml_node::print(std::basic_ostream >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const + PUGI_FN void xml_node::print(std::basic_ostream >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const { xml_writer_stream writer(stream); print(writer, indent, flags, encoding, depth); } - PUGI__FN void xml_node::print(std::basic_ostream >& stream, const char_t* indent, unsigned int flags, unsigned int depth) const + PUGI_FN void xml_node::print(std::basic_ostream >& stream, const char_t* indent, unsigned int flags, unsigned int depth) const { xml_writer_stream writer(stream); @@ -5473,7 +5473,7 @@ } #endif - PUGI__FN ptrdiff_t xml_node::offset_debug() const + PUGI_FN ptrdiff_t xml_node::offset_debug() const { if (!_root) return -1; @@ -5504,22 +5504,22 @@ } #ifdef __BORLANDC__ - PUGI__FN bool operator&&(const xml_node& lhs, bool rhs) + PUGI_FN bool operator&&(const xml_node& lhs, bool rhs) { return (bool)lhs && rhs; } - PUGI__FN bool operator||(const xml_node& lhs, bool rhs) + PUGI_FN bool operator||(const xml_node& lhs, bool rhs) { return (bool)lhs || rhs; } #endif - PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root) + PUGI_FN xml_text::xml_text(xml_node_struct* root): _root(root) { } - PUGI__FN xml_node_struct* xml_text::_data() const + PUGI_FN xml_node_struct* xml_text::_data() const { if (!_root || impl::is_text_node(_root)) return _root; @@ -5530,7 +5530,7 @@ return 0; } - PUGI__FN xml_node_struct* xml_text::_data_new() + PUGI_FN xml_node_struct* xml_text::_data_new() { xml_node_struct* d = _data(); if (d) return d; @@ -5538,72 +5538,72 @@ return xml_node(_root).append_child(node_pcdata).internal_object(); } - PUGI__FN xml_text::xml_text(): _root(0) + PUGI_FN xml_text::xml_text(): _root(0) { } - PUGI__FN static void unspecified_bool_xml_text(xml_text***) + PUGI_FN static void unspecified_bool_xml_text(xml_text***) { } - PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const + PUGI_FN xml_text::operator xml_text::unspecified_bool_type() const { return _data() ? unspecified_bool_xml_text : 0; } - PUGI__FN bool xml_text::operator!() const + PUGI_FN bool xml_text::operator!() const { return !_data(); } - PUGI__FN bool xml_text::empty() const + PUGI_FN bool xml_text::empty() const { return _data() == 0; } - PUGI__FN const char_t* xml_text::get() const + PUGI_FN const char_t* xml_text::get() const { xml_node_struct* d = _data(); return (d && d->value) ? d->value : PUGIXML_TEXT(""); } - PUGI__FN const char_t* xml_text::as_string(const char_t* def) const + PUGI_FN const char_t* xml_text::as_string(const char_t* def) const { xml_node_struct* d = _data(); return (d && d->value) ? d->value : def; } - PUGI__FN int xml_text::as_int(int def) const + PUGI_FN int xml_text::as_int(int def) const { xml_node_struct* d = _data(); return impl::get_value_int(d ? d->value : 0, def); } - PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const + PUGI_FN unsigned int xml_text::as_uint(unsigned int def) const { xml_node_struct* d = _data(); return impl::get_value_uint(d ? d->value : 0, def); } - PUGI__FN double xml_text::as_double(double def) const + PUGI_FN double xml_text::as_double(double def) const { xml_node_struct* d = _data(); return impl::get_value_double(d ? d->value : 0, def); } - PUGI__FN float xml_text::as_float(float def) const + PUGI_FN float xml_text::as_float(float def) const { xml_node_struct* d = _data(); return impl::get_value_float(d ? d->value : 0, def); } - PUGI__FN bool xml_text::as_bool(bool def) const + PUGI_FN bool xml_text::as_bool(bool def) const { xml_node_struct* d = _data(); @@ -5611,14 +5611,14 @@ } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN long long xml_text::as_llong(long long def) const + PUGI_FN long long xml_text::as_llong(long long def) const { xml_node_struct* d = _data(); return impl::get_value_llong(d ? d->value : 0, def); } - PUGI__FN unsigned long long xml_text::as_ullong(unsigned long long def) const + PUGI_FN unsigned long long xml_text::as_ullong(unsigned long long def) const { xml_node_struct* d = _data(); @@ -5626,42 +5626,42 @@ } #endif - PUGI__FN bool xml_text::set(const char_t* rhs) + PUGI_FN bool xml_text::set(const char_t* rhs) { xml_node_struct* dn = _data_new(); return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false; } - PUGI__FN bool xml_text::set(int rhs) + PUGI_FN bool xml_text::set(int rhs) { xml_node_struct* dn = _data_new(); return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false; } - PUGI__FN bool xml_text::set(unsigned int rhs) + PUGI_FN bool xml_text::set(unsigned int rhs) { xml_node_struct* dn = _data_new(); return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false; } - PUGI__FN bool xml_text::set(float rhs) + PUGI_FN bool xml_text::set(float rhs) { xml_node_struct* dn = _data_new(); return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false; } - PUGI__FN bool xml_text::set(double rhs) + PUGI_FN bool xml_text::set(double rhs) { xml_node_struct* dn = _data_new(); return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false; } - PUGI__FN bool xml_text::set(bool rhs) + PUGI_FN bool xml_text::set(bool rhs) { xml_node_struct* dn = _data_new(); @@ -5669,14 +5669,14 @@ } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN bool xml_text::set(long long rhs) + PUGI_FN bool xml_text::set(long long rhs) { xml_node_struct* dn = _data_new(); return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false; } - PUGI__FN bool xml_text::set(unsigned long long rhs) + PUGI_FN bool xml_text::set(unsigned long long rhs) { xml_node_struct* dn = _data_new(); @@ -5684,244 +5684,244 @@ } #endif - PUGI__FN xml_text& xml_text::operator=(const char_t* rhs) + PUGI_FN xml_text& xml_text::operator=(const char_t* rhs) { set(rhs); return *this; } - PUGI__FN xml_text& xml_text::operator=(int rhs) + PUGI_FN xml_text& xml_text::operator=(int rhs) { set(rhs); return *this; } - PUGI__FN xml_text& xml_text::operator=(unsigned int rhs) + PUGI_FN xml_text& xml_text::operator=(unsigned int rhs) { set(rhs); return *this; } - PUGI__FN xml_text& xml_text::operator=(double rhs) + PUGI_FN xml_text& xml_text::operator=(double rhs) { set(rhs); return *this; } - PUGI__FN xml_text& xml_text::operator=(float rhs) + PUGI_FN xml_text& xml_text::operator=(float rhs) { set(rhs); return *this; } - PUGI__FN xml_text& xml_text::operator=(bool rhs) + PUGI_FN xml_text& xml_text::operator=(bool rhs) { set(rhs); return *this; } #ifdef PUGIXML_HAS_LONG_LONG - PUGI__FN xml_text& xml_text::operator=(long long rhs) + PUGI_FN xml_text& xml_text::operator=(long long rhs) { set(rhs); return *this; } - PUGI__FN xml_text& xml_text::operator=(unsigned long long rhs) + PUGI_FN xml_text& xml_text::operator=(unsigned long long rhs) { set(rhs); return *this; } #endif - PUGI__FN xml_node xml_text::data() const + PUGI_FN xml_node xml_text::data() const { return xml_node(_data()); } #ifdef __BORLANDC__ - PUGI__FN bool operator&&(const xml_text& lhs, bool rhs) + PUGI_FN bool operator&&(const xml_text& lhs, bool rhs) { return (bool)lhs && rhs; } - PUGI__FN bool operator||(const xml_text& lhs, bool rhs) + PUGI_FN bool operator||(const xml_text& lhs, bool rhs) { return (bool)lhs || rhs; } #endif - PUGI__FN xml_node_iterator::xml_node_iterator() + PUGI_FN xml_node_iterator::xml_node_iterator() { } - PUGI__FN xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node), _parent(node.parent()) + PUGI_FN xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node), _parent(node.parent()) { } - PUGI__FN xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent) + PUGI_FN xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent) { } - PUGI__FN bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const + PUGI_FN bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const { return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root; } - PUGI__FN bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const + PUGI_FN bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const { return _wrap._root != rhs._wrap._root || _parent._root != rhs._parent._root; } - PUGI__FN xml_node& xml_node_iterator::operator*() const + PUGI_FN xml_node& xml_node_iterator::operator*() const { assert(_wrap._root); return _wrap; } - PUGI__FN xml_node* xml_node_iterator::operator->() const + PUGI_FN xml_node* xml_node_iterator::operator->() const { assert(_wrap._root); return const_cast(&_wrap); // BCC32 workaround } - PUGI__FN const xml_node_iterator& xml_node_iterator::operator++() + PUGI_FN const xml_node_iterator& xml_node_iterator::operator++() { assert(_wrap._root); _wrap._root = _wrap._root->next_sibling; return *this; } - PUGI__FN xml_node_iterator xml_node_iterator::operator++(int) + PUGI_FN xml_node_iterator xml_node_iterator::operator++(int) { xml_node_iterator temp = *this; ++*this; return temp; } - PUGI__FN const xml_node_iterator& xml_node_iterator::operator--() + PUGI_FN const xml_node_iterator& xml_node_iterator::operator--() { _wrap = _wrap._root ? _wrap.previous_sibling() : _parent.last_child(); return *this; } - PUGI__FN xml_node_iterator xml_node_iterator::operator--(int) + PUGI_FN xml_node_iterator xml_node_iterator::operator--(int) { xml_node_iterator temp = *this; --*this; return temp; } - PUGI__FN xml_attribute_iterator::xml_attribute_iterator() + PUGI_FN xml_attribute_iterator::xml_attribute_iterator() { } - PUGI__FN xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent): _wrap(attr), _parent(parent) + PUGI_FN xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent): _wrap(attr), _parent(parent) { } - PUGI__FN xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent) + PUGI_FN xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent) { } - PUGI__FN bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const + PUGI_FN bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const { return _wrap._attr == rhs._wrap._attr && _parent._root == rhs._parent._root; } - PUGI__FN bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const + PUGI_FN bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const { return _wrap._attr != rhs._wrap._attr || _parent._root != rhs._parent._root; } - PUGI__FN xml_attribute& xml_attribute_iterator::operator*() const + PUGI_FN xml_attribute& xml_attribute_iterator::operator*() const { assert(_wrap._attr); return _wrap; } - PUGI__FN xml_attribute* xml_attribute_iterator::operator->() const + PUGI_FN xml_attribute* xml_attribute_iterator::operator->() const { assert(_wrap._attr); return const_cast(&_wrap); // BCC32 workaround } - PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator++() + PUGI_FN const xml_attribute_iterator& xml_attribute_iterator::operator++() { assert(_wrap._attr); _wrap._attr = _wrap._attr->next_attribute; return *this; } - PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator++(int) + PUGI_FN xml_attribute_iterator xml_attribute_iterator::operator++(int) { xml_attribute_iterator temp = *this; ++*this; return temp; } - PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator--() + PUGI_FN const xml_attribute_iterator& xml_attribute_iterator::operator--() { _wrap = _wrap._attr ? _wrap.previous_attribute() : _parent.last_attribute(); return *this; } - PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator--(int) + PUGI_FN xml_attribute_iterator xml_attribute_iterator::operator--(int) { xml_attribute_iterator temp = *this; --*this; return temp; } - PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0) + PUGI_FN xml_named_node_iterator::xml_named_node_iterator(): _name(0) { } - PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _wrap(node), _parent(node.parent()), _name(name) + PUGI_FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _wrap(node), _parent(node.parent()), _name(name) { } - PUGI__FN xml_named_node_iterator::xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name): _wrap(ref), _parent(parent), _name(name) + PUGI_FN xml_named_node_iterator::xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name): _wrap(ref), _parent(parent), _name(name) { } - PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const + PUGI_FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const { return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root; } - PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const + PUGI_FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const { return _wrap._root != rhs._wrap._root || _parent._root != rhs._parent._root; } - PUGI__FN xml_node& xml_named_node_iterator::operator*() const + PUGI_FN xml_node& xml_named_node_iterator::operator*() const { assert(_wrap._root); return _wrap; } - PUGI__FN xml_node* xml_named_node_iterator::operator->() const + PUGI_FN xml_node* xml_named_node_iterator::operator->() const { assert(_wrap._root); return const_cast(&_wrap); // BCC32 workaround } - PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++() + PUGI_FN const xml_named_node_iterator& xml_named_node_iterator::operator++() { assert(_wrap._root); _wrap = _wrap.next_sibling(_name); return *this; } - PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int) + PUGI_FN xml_named_node_iterator xml_named_node_iterator::operator++(int) { xml_named_node_iterator temp = *this; ++*this; return temp; } - PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator--() + PUGI_FN const xml_named_node_iterator& xml_named_node_iterator::operator--() { if (_wrap._root) _wrap = _wrap.previous_sibling(_name); @@ -5936,23 +5936,23 @@ return *this; } - PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator--(int) + PUGI_FN xml_named_node_iterator xml_named_node_iterator::operator--(int) { xml_named_node_iterator temp = *this; --*this; return temp; } - PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto) + PUGI_FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto) { } - PUGI__FN xml_parse_result::operator bool() const + PUGI_FN xml_parse_result::operator bool() const { return status == status_ok; } - PUGI__FN const char* xml_parse_result::description() const + PUGI_FN const char* xml_parse_result::description() const { switch (status) { @@ -5983,23 +5983,23 @@ } } - PUGI__FN xml_document::xml_document(): _buffer(0) + PUGI_FN xml_document::xml_document(): _buffer(0) { create(); } - PUGI__FN xml_document::~xml_document() + PUGI_FN xml_document::~xml_document() { destroy(); } - PUGI__FN void xml_document::reset() + PUGI_FN void xml_document::reset() { destroy(); create(); } - PUGI__FN void xml_document::reset(const xml_document& proto) + PUGI_FN void xml_document::reset(const xml_document& proto) { reset(); @@ -6007,12 +6007,12 @@ append_copy(cur); } - PUGI__FN void xml_document::create() + PUGI_FN void xml_document::create() { assert(!_root); // initialize sentinel page - PUGI__STATIC_ASSERT(sizeof(impl::xml_memory_page) + sizeof(impl::xml_document_struct) + impl::xml_memory_page_alignment - sizeof(void*) <= sizeof(_memory)); + PUGI_STATIC_ASSERT(sizeof(impl::xml_memory_page) + sizeof(impl::xml_document_struct) + impl::xml_memory_page_alignment - sizeof(void*) <= sizeof(_memory)); // align upwards to page boundary void* page_memory = reinterpret_cast((reinterpret_cast(_memory) + (impl::xml_memory_page_alignment - 1)) & ~(impl::xml_memory_page_alignment - 1)); @@ -6034,7 +6034,7 @@ assert(reinterpret_cast(_root) + sizeof(impl::xml_document_struct) <= _memory + sizeof(_memory)); } - PUGI__FN void xml_document::destroy() + PUGI_FN void xml_document::destroy() { assert(_root); @@ -6069,14 +6069,14 @@ } #ifndef PUGIXML_NO_STL - PUGI__FN xml_parse_result xml_document::load(std::basic_istream >& stream, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_document::load(std::basic_istream >& stream, unsigned int options, xml_encoding encoding) { reset(); return impl::load_stream_impl(*this, stream, options, encoding); } - PUGI__FN xml_parse_result xml_document::load(std::basic_istream >& stream, unsigned int options) + PUGI_FN xml_parse_result xml_document::load(std::basic_istream >& stream, unsigned int options) { reset(); @@ -6084,7 +6084,7 @@ } #endif - PUGI__FN xml_parse_result xml_document::load_string(const char_t* contents, unsigned int options) + PUGI_FN xml_parse_result xml_document::load_string(const char_t* contents, unsigned int options) { // Force native encoding (skip autodetection) #ifdef PUGIXML_WCHAR_MODE @@ -6096,12 +6096,12 @@ return load_buffer(contents, impl::strlength(contents) * sizeof(char_t), options, encoding); } - PUGI__FN xml_parse_result xml_document::load(const char_t* contents, unsigned int options) + PUGI_FN xml_parse_result xml_document::load(const char_t* contents, unsigned int options) { return load_string(contents, options); } - PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding) { reset(); @@ -6110,7 +6110,7 @@ return impl::load_file_impl(*this, file, options, encoding); } - PUGI__FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding) { reset(); @@ -6119,28 +6119,28 @@ return impl::load_file_impl(*this, file, options, encoding); } - PUGI__FN xml_parse_result xml_document::load_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_document::load_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding) { reset(); return impl::load_buffer_impl(static_cast(_root), _root, const_cast(contents), size, options, encoding, false, false, &_buffer); } - PUGI__FN xml_parse_result xml_document::load_buffer_inplace(void* contents, size_t size, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_document::load_buffer_inplace(void* contents, size_t size, unsigned int options, xml_encoding encoding) { reset(); return impl::load_buffer_impl(static_cast(_root), _root, contents, size, options, encoding, true, false, &_buffer); } - PUGI__FN xml_parse_result xml_document::load_buffer_inplace_own(void* contents, size_t size, unsigned int options, xml_encoding encoding) + PUGI_FN xml_parse_result xml_document::load_buffer_inplace_own(void* contents, size_t size, unsigned int options, xml_encoding encoding) { reset(); return impl::load_buffer_impl(static_cast(_root), _root, contents, size, options, encoding, true, true, &_buffer); } - PUGI__FN void xml_document::save(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding) const + PUGI_FN void xml_document::save(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding) const { impl::xml_buffered_writer buffered_writer(writer, encoding); @@ -6167,14 +6167,14 @@ } #ifndef PUGIXML_NO_STL - PUGI__FN void xml_document::save(std::basic_ostream >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding) const + PUGI_FN void xml_document::save(std::basic_ostream >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding) const { xml_writer_stream writer(stream); save(writer, indent, flags, encoding); } - PUGI__FN void xml_document::save(std::basic_ostream >& stream, const char_t* indent, unsigned int flags) const + PUGI_FN void xml_document::save(std::basic_ostream >& stream, const char_t* indent, unsigned int flags) const { xml_writer_stream writer(stream); @@ -6182,67 +6182,67 @@ } #endif - PUGI__FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const + PUGI_FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const { FILE* file = fopen(path_, (flags & format_save_file_text) ? "w" : "wb"); return impl::save_file_impl(*this, file, indent, flags, encoding); } - PUGI__FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const + PUGI_FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const { FILE* file = impl::open_file_wide(path_, (flags & format_save_file_text) ? L"w" : L"wb"); return impl::save_file_impl(*this, file, indent, flags, encoding); } - PUGI__FN xml_node xml_document::document_element() const + PUGI_FN xml_node xml_document::document_element() const { assert(_root); for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling) - if (PUGI__NODETYPE(i) == node_element) + if (PUGI_NODETYPE(i) == node_element) return xml_node(i); return xml_node(); } #ifndef PUGIXML_NO_STL - PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str) + PUGI_FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str) { assert(str); return impl::as_utf8_impl(str, impl::strlength_wide(str)); } - PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string& str) + PUGI_FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string& str) { return impl::as_utf8_impl(str.c_str(), str.size()); } - PUGI__FN std::basic_string PUGIXML_FUNCTION as_wide(const char* str) + PUGI_FN std::basic_string PUGIXML_FUNCTION as_wide(const char* str) { assert(str); return impl::as_wide_impl(str, strlen(str)); } - PUGI__FN std::basic_string PUGIXML_FUNCTION as_wide(const std::string& str) + PUGI_FN std::basic_string PUGIXML_FUNCTION as_wide(const std::string& str) { return impl::as_wide_impl(str.c_str(), str.size()); } #endif - PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate) + PUGI_FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate) { impl::xml_memory::allocate = allocate; impl::xml_memory::deallocate = deallocate; } - PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function() + PUGI_FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function() { return impl::xml_memory::allocate; } - PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function() + PUGI_FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function() { return impl::xml_memory::deallocate; } @@ -6252,17 +6252,17 @@ namespace std { // Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier) - PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_node_iterator&) + PUGI_FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_node_iterator&) { return std::bidirectional_iterator_tag(); } - PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_attribute_iterator&) + PUGI_FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_attribute_iterator&) { return std::bidirectional_iterator_tag(); } - PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_named_node_iterator&) + PUGI_FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_named_node_iterator&) { return std::bidirectional_iterator_tag(); } @@ -6273,17 +6273,17 @@ namespace std { // Workarounds for (non-standard) iterator category detection - PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_node_iterator&) + PUGI_FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_node_iterator&) { return std::bidirectional_iterator_tag(); } - PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_attribute_iterator&) + PUGI_FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_attribute_iterator&) { return std::bidirectional_iterator_tag(); } - PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_named_node_iterator&) + PUGI_FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_named_node_iterator&) { return std::bidirectional_iterator_tag(); } @@ -6292,7 +6292,7 @@ #ifndef PUGIXML_NO_XPATH // STL replacements -PUGI__NS_BEGIN +PUGI_NS_BEGIN struct equal_to { template bool operator()(const T& lhs, const T& rhs) const @@ -6516,10 +6516,10 @@ // insertion sort small chunk if (begin != end) insertion_sort(begin, end, pred, &*begin); } -PUGI__NS_END +PUGI_NS_END // Allocator used for AST and evaluation stacks -PUGI__NS_BEGIN +PUGI_NS_BEGIN struct xpath_memory_block { xpath_memory_block* next; @@ -6732,10 +6732,10 @@ temp.release(); } }; -PUGI__NS_END +PUGI_NS_END // String class -PUGI__NS_BEGIN +PUGI_NS_BEGIN class xpath_string { const char_t* _buffer; @@ -6863,10 +6863,10 @@ return _uses_heap; } }; -PUGI__NS_END +PUGI_NS_END -PUGI__NS_BEGIN - PUGI__FN bool starts_with(const char_t* string, const char_t* pattern) +PUGI_NS_BEGIN + PUGI_FN bool starts_with(const char_t* string, const char_t* pattern) { while (*pattern && *string == *pattern) { @@ -6877,7 +6877,7 @@ return *pattern == 0; } - PUGI__FN const char_t* find_char(const char_t* s, char_t c) + PUGI_FN const char_t* find_char(const char_t* s, char_t c) { #ifdef PUGIXML_WCHAR_MODE return wcschr(s, c); @@ -6886,7 +6886,7 @@ #endif } - PUGI__FN const char_t* find_substring(const char_t* s, const char_t* p) + PUGI_FN const char_t* find_substring(const char_t* s, const char_t* p) { #ifdef PUGIXML_WCHAR_MODE // MSVC6 wcsstr bug workaround (if s is empty it always returns 0) @@ -6897,12 +6897,12 @@ } // Converts symbol to lower case, if it is an ASCII one - PUGI__FN char_t tolower_ascii(char_t ch) + PUGI_FN char_t tolower_ascii(char_t ch) { return static_cast(ch - 'A') < 26 ? static_cast(ch | ' ') : ch; } - PUGI__FN xpath_string string_value(const xpath_node& na, xpath_allocator* alloc) + PUGI_FN xpath_string string_value(const xpath_node& na, xpath_allocator* alloc) { if (na.attribute()) return xpath_string::from_const(na.attribute().value()); @@ -6952,7 +6952,7 @@ } } - PUGI__FN bool node_is_before_sibling(xml_node_struct* ln, xml_node_struct* rn) + PUGI_FN bool node_is_before_sibling(xml_node_struct* ln, xml_node_struct* rn) { assert(ln->parent == rn->parent); @@ -6976,7 +6976,7 @@ return !rs; } - PUGI__FN bool node_is_before(xml_node_struct* ln, xml_node_struct* rn) + PUGI_FN bool node_is_before(xml_node_struct* ln, xml_node_struct* rn) { // find common ancestor at the same depth, if any xml_node_struct* lp = ln; @@ -7019,14 +7019,14 @@ return node_is_before_sibling(ln, rn); } - PUGI__FN bool node_is_ancestor(xml_node_struct* parent, xml_node_struct* node) + PUGI_FN bool node_is_ancestor(xml_node_struct* parent, xml_node_struct* node) { while (node && node != parent) node = node->parent; return parent && node == parent; } - PUGI__FN const void* document_buffer_order(const xpath_node& xnode) + PUGI_FN const void* document_buffer_order(const xpath_node& xnode) { xml_node_struct* node = xnode.node().internal_object(); @@ -7120,7 +7120,7 @@ } }; - PUGI__FN double gen_nan() + PUGI_FN double gen_nan() { #if defined(__STDC_IEC_559__) || ((FLT_RADIX - 0 == 2) && (FLT_MAX_EXP - 0 == 128) && (FLT_MANT_DIG - 0 == 24)) union { float f; uint32_t i; } u[sizeof(float) == sizeof(uint32_t) ? 1 : -1]; @@ -7133,9 +7133,9 @@ #endif } - PUGI__FN bool is_nan(double value) + PUGI_FN bool is_nan(double value) { - #if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) + #if defined(PUGI_MSVC_CRT_VERSION) || defined(__BORLANDC__) return !!_isnan(value); #elif defined(fpclassify) && defined(FP_NAN) return fpclassify(value) == FP_NAN; @@ -7146,9 +7146,9 @@ #endif } - PUGI__FN const char_t* convert_number_to_string_special(double value) + PUGI_FN const char_t* convert_number_to_string_special(double value) { - #if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) + #if defined(PUGI_MSVC_CRT_VERSION) || defined(__BORLANDC__) if (_finite(value)) return (value == 0) ? PUGIXML_TEXT("0") : 0; if (_isnan(value)) return PUGIXML_TEXT("NaN"); return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity"); @@ -7178,12 +7178,12 @@ #endif } - PUGI__FN bool convert_number_to_boolean(double value) + PUGI_FN bool convert_number_to_boolean(double value) { return (value != 0 && !is_nan(value)); } - PUGI__FN void truncate_zeros(char* begin, char* end) + PUGI_FN void truncate_zeros(char* begin, char* end) { while (begin != end && end[-1] == '0') end--; @@ -7191,8 +7191,8 @@ } // gets mantissa digits in the form of 0.xxxxx with 0. implied and the exponent -#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE) - PUGI__FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent) +#if defined(PUGI_MSVC_CRT_VERSION) && PUGI_MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE) + PUGI_FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent) { // get base values int sign, exponent; @@ -7206,7 +7206,7 @@ *out_exponent = exponent; } #else - PUGI__FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent) + PUGI_FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent) { // get a scientific notation value with IEEE DBL_DIG decimals sprintf(buffer, "%.*e", DBL_DIG, value); @@ -7237,7 +7237,7 @@ } #endif - PUGI__FN xpath_string convert_number_to_string(double value, xpath_allocator* alloc) + PUGI_FN xpath_string convert_number_to_string(double value, xpath_allocator* alloc) { // try special number conversion const char_t* special = convert_number_to_string_special(value); @@ -7304,10 +7304,10 @@ return xpath_string::from_heap_preallocated(result, s); } - PUGI__FN bool check_string_to_number_format(const char_t* string) + PUGI_FN bool check_string_to_number_format(const char_t* string) { // parse leading whitespace - while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string; + while (PUGI_IS_CHARTYPE(*string, ct_space)) ++string; // parse sign if (*string == '-') ++string; @@ -7315,26 +7315,26 @@ if (!*string) return false; // if there is no integer part, there should be a decimal part with at least one digit - if (!PUGI__IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' || !PUGI__IS_CHARTYPEX(string[1], ctx_digit))) return false; + if (!PUGI_IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' || !PUGI_IS_CHARTYPEX(string[1], ctx_digit))) return false; // parse integer part - while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string; + while (PUGI_IS_CHARTYPEX(*string, ctx_digit)) ++string; // parse decimal part if (*string == '.') { ++string; - while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string; + while (PUGI_IS_CHARTYPEX(*string, ctx_digit)) ++string; } // parse trailing whitespace - while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string; + while (PUGI_IS_CHARTYPE(*string, ct_space)) ++string; return *string == 0; } - PUGI__FN double convert_string_to_number(const char_t* string) + PUGI_FN double convert_string_to_number(const char_t* string) { // check string format if (!check_string_to_number_format(string)) return gen_nan(); @@ -7347,7 +7347,7 @@ #endif } - PUGI__FN bool convert_string_to_number_scratch(char_t (&buffer)[32], const char_t* begin, const char_t* end, double* out_result) + PUGI_FN bool convert_string_to_number_scratch(char_t (&buffer)[32], const char_t* begin, const char_t* end, double* out_result) { size_t length = static_cast(end - begin); char_t* scratch = buffer; @@ -7371,24 +7371,24 @@ return true; } - PUGI__FN double round_nearest(double value) + PUGI_FN double round_nearest(double value) { return floor(value + 0.5); } - PUGI__FN double round_nearest_nzero(double value) + PUGI_FN double round_nearest_nzero(double value) { // same as round_nearest, but returns -0 for [-0.5, -0] // ceil is used to differentiate between +0 and -0 (we return -0 for [-0.5, -0] and +0 for +0) return (value >= -0.5 && value <= 0) ? ceil(value) : floor(value + 0.5); } - PUGI__FN const char_t* qualified_name(const xpath_node& node) + PUGI_FN const char_t* qualified_name(const xpath_node& node) { return node.attribute() ? node.attribute().name() : node.node().name(); } - PUGI__FN const char_t* local_name(const xpath_node& node) + PUGI_FN const char_t* local_name(const xpath_node& node) { const char_t* name = qualified_name(node); const char_t* p = find_char(name, ':'); @@ -7419,7 +7419,7 @@ } }; - PUGI__FN const char_t* namespace_uri(xml_node node) + PUGI_FN const char_t* namespace_uri(xml_node node) { namespace_uri_predicate pred = node.name(); @@ -7437,7 +7437,7 @@ return PUGIXML_TEXT(""); } - PUGI__FN const char_t* namespace_uri(xml_attribute attr, xml_node parent) + PUGI_FN const char_t* namespace_uri(xml_attribute attr, xml_node parent) { namespace_uri_predicate pred = attr.name(); @@ -7458,12 +7458,12 @@ return PUGIXML_TEXT(""); } - PUGI__FN const char_t* namespace_uri(const xpath_node& node) + PUGI_FN const char_t* namespace_uri(const xpath_node& node) { return node.attribute() ? namespace_uri(node.attribute(), node.parent()) : namespace_uri(node.node()); } - PUGI__FN void normalize_space(char_t* buffer) + PUGI_FN void normalize_space(char_t* buffer) { char_t* write = buffer; @@ -7471,10 +7471,10 @@ { char_t ch = *it++; - if (PUGI__IS_CHARTYPE(ch, ct_space)) + if (PUGI_IS_CHARTYPE(ch, ct_space)) { // replace whitespace sequence with single space - while (PUGI__IS_CHARTYPE(*it, ct_space)) it++; + while (PUGI_IS_CHARTYPE(*it, ct_space)) it++; // avoid leading spaces if (write != buffer) *write++ = ' '; @@ -7483,19 +7483,19 @@ } // remove trailing space - if (write != buffer && PUGI__IS_CHARTYPE(write[-1], ct_space)) write--; + if (write != buffer && PUGI_IS_CHARTYPE(write[-1], ct_space)) write--; // zero-terminate *write = 0; } - PUGI__FN void translate(char_t* buffer, const char_t* from, const char_t* to, size_t to_length) + PUGI_FN void translate(char_t* buffer, const char_t* from, const char_t* to, size_t to_length) { char_t* write = buffer; while (*buffer) { - PUGI__DMC_VOLATILE char_t ch = *buffer++; + PUGI_DMC_VOLATILE char_t ch = *buffer++; const char_t* pos = find_char(from, ch); @@ -7509,7 +7509,7 @@ *write = 0; } - PUGI__FN unsigned char* translate_table_generate(xpath_allocator* alloc, const char_t* from, const char_t* to) + PUGI_FN unsigned char* translate_table_generate(xpath_allocator* alloc, const char_t* from, const char_t* to) { unsigned char table[128] = {0}; @@ -7543,7 +7543,7 @@ return static_cast(result); } - PUGI__FN void translate_table(char_t* buffer, const unsigned char* table) + PUGI_FN void translate_table(char_t* buffer, const unsigned char* table) { char_t* write = buffer; @@ -7619,7 +7619,7 @@ static const xpath_node_set dummy_node_set; - PUGI__FN unsigned int hash_string(const char_t* str) + PUGI_FN unsigned int hash_string(const char_t* str) { // Jenkins one-at-a-time hash (http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time) unsigned int result = 0; @@ -7638,7 +7638,7 @@ return result; } - template PUGI__FN T* new_xpath_variable(const char_t* name) + template PUGI_FN T* new_xpath_variable(const char_t* name) { size_t length = strlength(name); if (length == 0) return 0; // empty variable names are invalid @@ -7654,7 +7654,7 @@ return result; } - PUGI__FN xpath_variable* new_xpath_variable(xpath_value_type type, const char_t* name) + PUGI_FN xpath_variable* new_xpath_variable(xpath_value_type type, const char_t* name) { switch (type) { @@ -7675,13 +7675,13 @@ } } - template PUGI__FN void delete_xpath_variable(T* var) + template PUGI_FN void delete_xpath_variable(T* var) { var->~T(); xml_memory::deallocate(var); } - PUGI__FN void delete_xpath_variable(xpath_value_type type, xpath_variable* var) + PUGI_FN void delete_xpath_variable(xpath_value_type type, xpath_variable* var) { switch (type) { @@ -7706,7 +7706,7 @@ } } - PUGI__FN xpath_variable* get_variable_scratch(char_t (&buffer)[32], xpath_variable_set* set, const char_t* begin, const char_t* end) + PUGI_FN xpath_variable* get_variable_scratch(char_t (&buffer)[32], xpath_variable_set* set, const char_t* begin, const char_t* end) { size_t length = static_cast(end - begin); char_t* scratch = buffer; @@ -7729,11 +7729,11 @@ return result; } -PUGI__NS_END +PUGI_NS_END // Internal node set class -PUGI__NS_BEGIN - PUGI__FN xpath_node_set::type_t xpath_get_order(const xpath_node* begin, const xpath_node* end) +PUGI_NS_BEGIN + PUGI_FN xpath_node_set::type_t xpath_get_order(const xpath_node* begin, const xpath_node* end) { if (end - begin < 2) return xpath_node_set::type_sorted; @@ -7749,7 +7749,7 @@ return first ? xpath_node_set::type_sorted : xpath_node_set::type_sorted_reverse; } - PUGI__FN xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool rev) + PUGI_FN xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool rev) { xpath_node_set::type_t order = rev ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted; @@ -7772,7 +7772,7 @@ return order; } - PUGI__FN xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type) + PUGI_FN xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type) { if (begin == end) return xpath_node(); @@ -7896,7 +7896,7 @@ } }; - PUGI__FN_NO_INLINE void xpath_node_set_raw::push_back_grow(const xpath_node& node, xpath_allocator* alloc) + PUGI_FN_NO_INLINE void xpath_node_set_raw::push_back_grow(const xpath_node& node, xpath_allocator* alloc) { size_t capacity = static_cast(_eos - _begin); @@ -7915,9 +7915,9 @@ // push *_end++ = node; } -PUGI__NS_END +PUGI_NS_END -PUGI__NS_BEGIN +PUGI_NS_BEGIN struct xpath_context { xpath_node n; @@ -7999,7 +7999,7 @@ { const char_t* cur = _cur; - while (PUGI__IS_CHARTYPE(*cur, ct_space)) ++cur; + while (PUGI_IS_CHARTYPE(*cur, ct_space)) ++cur; // save lexeme position for error reporting _cur_lexeme_pos = cur; @@ -8081,17 +8081,17 @@ case '$': cur += 1; - if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol)) + if (PUGI_IS_CHARTYPEX(*cur, ctx_start_symbol)) { _cur_lexeme_contents.begin = cur; - while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_symbol)) cur++; - if (cur[0] == ':' && PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // qname + if (cur[0] == ':' && PUGI_IS_CHARTYPEX(cur[1], ctx_symbol)) // qname { cur++; // : - while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_symbol)) cur++; } _cur_lexeme_contents.end = cur; @@ -8154,13 +8154,13 @@ cur += 2; _cur_lexeme = lex_double_dot; } - else if (PUGI__IS_CHARTYPEX(*(cur+1), ctx_digit)) + else if (PUGI_IS_CHARTYPEX(*(cur+1), ctx_digit)) { _cur_lexeme_contents.begin = cur; // . ++cur; - while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_digit)) cur++; _cur_lexeme_contents.end = cur; @@ -8214,28 +8214,28 @@ break; default: - if (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) + if (PUGI_IS_CHARTYPEX(*cur, ctx_digit)) { _cur_lexeme_contents.begin = cur; - while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_digit)) cur++; if (*cur == '.') { cur++; - while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_digit)) cur++; } _cur_lexeme_contents.end = cur; _cur_lexeme = lex_number; } - else if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol)) + else if (PUGI_IS_CHARTYPEX(*cur, ctx_start_symbol)) { _cur_lexeme_contents.begin = cur; - while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_symbol)) cur++; if (cur[0] == ':') { @@ -8243,11 +8243,11 @@ { cur += 2; // :* } - else if (PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // namespace test qname + else if (PUGI_IS_CHARTYPEX(cur[1], ctx_symbol)) // namespace test qname { cur++; // : - while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++; + while (PUGI_IS_CHARTYPEX(*cur, ctx_symbol)) cur++; } } @@ -8746,7 +8746,7 @@ { assert(n); - xml_node_type type = PUGI__NODETYPE(n); + xml_node_type type = PUGI_NODETYPE(n); switch (_test) { @@ -10632,7 +10632,7 @@ // This is either a function call, or not - if not, we shall proceed with location path const char_t* state = _lexer.state(); - while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state; + while (PUGI_IS_CHARTYPE(*state, ct_space)) ++state; if (*state != '(') return parse_location_path(); @@ -10854,7 +10854,7 @@ xpath_memory_block block; }; - PUGI__FN xpath_string evaluate_string_impl(xpath_query_impl* impl, const xpath_node& n, xpath_stack_data& sd) + PUGI_FN xpath_string evaluate_string_impl(xpath_query_impl* impl, const xpath_node& n, xpath_stack_data& sd) { if (!impl) return xpath_string(); @@ -10867,7 +10867,7 @@ return impl->root->eval_string(c, sd.stack); } - PUGI__FN impl::xpath_ast_node* evaluate_node_set_prepare(xpath_query_impl* impl) + PUGI_FN impl::xpath_ast_node* evaluate_node_set_prepare(xpath_query_impl* impl) { if (!impl) return 0; @@ -10885,91 +10885,91 @@ return impl->root; } -PUGI__NS_END +PUGI_NS_END namespace pugi { #ifndef PUGIXML_NO_EXCEPTIONS - PUGI__FN xpath_exception::xpath_exception(const xpath_parse_result& result_): _result(result_) + PUGI_FN xpath_exception::xpath_exception(const xpath_parse_result& result_): _result(result_) { assert(_result.error); } - PUGI__FN const char* xpath_exception::what() const throw() + PUGI_FN const char* xpath_exception::what() const throw() { return _result.error; } - PUGI__FN const xpath_parse_result& xpath_exception::result() const + PUGI_FN const xpath_parse_result& xpath_exception::result() const { return _result; } #endif - PUGI__FN xpath_node::xpath_node() + PUGI_FN xpath_node::xpath_node() { } - PUGI__FN xpath_node::xpath_node(const xml_node& node_): _node(node_) + PUGI_FN xpath_node::xpath_node(const xml_node& node_): _node(node_) { } - PUGI__FN xpath_node::xpath_node(const xml_attribute& attribute_, const xml_node& parent_): _node(attribute_ ? parent_ : xml_node()), _attribute(attribute_) + PUGI_FN xpath_node::xpath_node(const xml_attribute& attribute_, const xml_node& parent_): _node(attribute_ ? parent_ : xml_node()), _attribute(attribute_) { } - PUGI__FN xml_node xpath_node::node() const + PUGI_FN xml_node xpath_node::node() const { return _attribute ? xml_node() : _node; } - PUGI__FN xml_attribute xpath_node::attribute() const + PUGI_FN xml_attribute xpath_node::attribute() const { return _attribute; } - PUGI__FN xml_node xpath_node::parent() const + PUGI_FN xml_node xpath_node::parent() const { return _attribute ? _node : _node.parent(); } - PUGI__FN static void unspecified_bool_xpath_node(xpath_node***) + PUGI_FN static void unspecified_bool_xpath_node(xpath_node***) { } - PUGI__FN xpath_node::operator xpath_node::unspecified_bool_type() const + PUGI_FN xpath_node::operator xpath_node::unspecified_bool_type() const { return (_node || _attribute) ? unspecified_bool_xpath_node : 0; } - PUGI__FN bool xpath_node::operator!() const + PUGI_FN bool xpath_node::operator!() const { return !(_node || _attribute); } - PUGI__FN bool xpath_node::operator==(const xpath_node& n) const + PUGI_FN bool xpath_node::operator==(const xpath_node& n) const { return _node == n._node && _attribute == n._attribute; } - PUGI__FN bool xpath_node::operator!=(const xpath_node& n) const + PUGI_FN bool xpath_node::operator!=(const xpath_node& n) const { return _node != n._node || _attribute != n._attribute; } #ifdef __BORLANDC__ - PUGI__FN bool operator&&(const xpath_node& lhs, bool rhs) + PUGI_FN bool operator&&(const xpath_node& lhs, bool rhs) { return (bool)lhs && rhs; } - PUGI__FN bool operator||(const xpath_node& lhs, bool rhs) + PUGI_FN bool operator||(const xpath_node& lhs, bool rhs) { return (bool)lhs || rhs; } #endif - PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_) + PUGI_FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_) { assert(begin_ <= end_); @@ -11011,26 +11011,26 @@ } } - PUGI__FN xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(&_storage), _end(&_storage) + PUGI_FN xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(&_storage), _end(&_storage) { } - PUGI__FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_), _begin(&_storage), _end(&_storage) + PUGI_FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_), _begin(&_storage), _end(&_storage) { _assign(begin_, end_); } - PUGI__FN xpath_node_set::~xpath_node_set() + PUGI_FN xpath_node_set::~xpath_node_set() { if (_begin != &_storage) impl::xml_memory::deallocate(_begin); } - PUGI__FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(ns._type), _begin(&_storage), _end(&_storage) + PUGI_FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(ns._type), _begin(&_storage), _end(&_storage) { _assign(ns._begin, ns._end); } - PUGI__FN xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns) + PUGI_FN xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns) { if (this == &ns) return *this; @@ -11040,66 +11040,66 @@ return *this; } - PUGI__FN xpath_node_set::type_t xpath_node_set::type() const + PUGI_FN xpath_node_set::type_t xpath_node_set::type() const { return _type; } - PUGI__FN size_t xpath_node_set::size() const + PUGI_FN size_t xpath_node_set::size() const { return _end - _begin; } - PUGI__FN bool xpath_node_set::empty() const + PUGI_FN bool xpath_node_set::empty() const { return _begin == _end; } - PUGI__FN const xpath_node& xpath_node_set::operator[](size_t index) const + PUGI_FN const xpath_node& xpath_node_set::operator[](size_t index) const { assert(index < size()); return _begin[index]; } - PUGI__FN xpath_node_set::const_iterator xpath_node_set::begin() const + PUGI_FN xpath_node_set::const_iterator xpath_node_set::begin() const { return _begin; } - PUGI__FN xpath_node_set::const_iterator xpath_node_set::end() const + PUGI_FN xpath_node_set::const_iterator xpath_node_set::end() const { return _end; } - PUGI__FN void xpath_node_set::sort(bool reverse) + PUGI_FN void xpath_node_set::sort(bool reverse) { _type = impl::xpath_sort(_begin, _end, _type, reverse); } - PUGI__FN xpath_node xpath_node_set::first() const + PUGI_FN xpath_node xpath_node_set::first() const { return impl::xpath_first(_begin, _end, _type); } - PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0) + PUGI_FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0) { } - PUGI__FN xpath_parse_result::operator bool() const + PUGI_FN xpath_parse_result::operator bool() const { return error == 0; } - PUGI__FN const char* xpath_parse_result::description() const + PUGI_FN const char* xpath_parse_result::description() const { return error ? error : "No error"; } - PUGI__FN xpath_variable::xpath_variable(): _type(xpath_type_none), _next(0) + PUGI_FN xpath_variable::xpath_variable(): _type(xpath_type_none), _next(0) { } - PUGI__FN const char_t* xpath_variable::name() const + PUGI_FN const char_t* xpath_variable::name() const { switch (_type) { @@ -11121,33 +11121,33 @@ } } - PUGI__FN xpath_value_type xpath_variable::type() const + PUGI_FN xpath_value_type xpath_variable::type() const { return _type; } - PUGI__FN bool xpath_variable::get_boolean() const + PUGI_FN bool xpath_variable::get_boolean() const { return (_type == xpath_type_boolean) ? static_cast(this)->value : false; } - PUGI__FN double xpath_variable::get_number() const + PUGI_FN double xpath_variable::get_number() const { return (_type == xpath_type_number) ? static_cast(this)->value : impl::gen_nan(); } - PUGI__FN const char_t* xpath_variable::get_string() const + PUGI_FN const char_t* xpath_variable::get_string() const { const char_t* value = (_type == xpath_type_string) ? static_cast(this)->value : 0; return value ? value : PUGIXML_TEXT(""); } - PUGI__FN const xpath_node_set& xpath_variable::get_node_set() const + PUGI_FN const xpath_node_set& xpath_variable::get_node_set() const { return (_type == xpath_type_node_set) ? static_cast(this)->value : impl::dummy_node_set; } - PUGI__FN bool xpath_variable::set(bool value) + PUGI_FN bool xpath_variable::set(bool value) { if (_type != xpath_type_boolean) return false; @@ -11155,7 +11155,7 @@ return true; } - PUGI__FN bool xpath_variable::set(double value) + PUGI_FN bool xpath_variable::set(double value) { if (_type != xpath_type_number) return false; @@ -11163,7 +11163,7 @@ return true; } - PUGI__FN bool xpath_variable::set(const char_t* value) + PUGI_FN bool xpath_variable::set(const char_t* value) { if (_type != xpath_type_string) return false; @@ -11184,7 +11184,7 @@ return true; } - PUGI__FN bool xpath_variable::set(const xpath_node_set& value) + PUGI_FN bool xpath_variable::set(const xpath_node_set& value) { if (_type != xpath_type_node_set) return false; @@ -11192,12 +11192,12 @@ return true; } - PUGI__FN xpath_variable_set::xpath_variable_set() + PUGI_FN xpath_variable_set::xpath_variable_set() { for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i) _data[i] = 0; } - PUGI__FN xpath_variable_set::~xpath_variable_set() + PUGI_FN xpath_variable_set::~xpath_variable_set() { for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i) { @@ -11214,7 +11214,7 @@ } } - PUGI__FN xpath_variable* xpath_variable_set::find(const char_t* name) const + PUGI_FN xpath_variable* xpath_variable_set::find(const char_t* name) const { const size_t hash_size = sizeof(_data) / sizeof(_data[0]); size_t hash = impl::hash_string(name) % hash_size; @@ -11227,7 +11227,7 @@ return 0; } - PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type) + PUGI_FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type) { const size_t hash_size = sizeof(_data) / sizeof(_data[0]); size_t hash = impl::hash_string(name) % hash_size; @@ -11251,41 +11251,41 @@ return result; } - PUGI__FN bool xpath_variable_set::set(const char_t* name, bool value) + PUGI_FN bool xpath_variable_set::set(const char_t* name, bool value) { xpath_variable* var = add(name, xpath_type_boolean); return var ? var->set(value) : false; } - PUGI__FN bool xpath_variable_set::set(const char_t* name, double value) + PUGI_FN bool xpath_variable_set::set(const char_t* name, double value) { xpath_variable* var = add(name, xpath_type_number); return var ? var->set(value) : false; } - PUGI__FN bool xpath_variable_set::set(const char_t* name, const char_t* value) + PUGI_FN bool xpath_variable_set::set(const char_t* name, const char_t* value) { xpath_variable* var = add(name, xpath_type_string); return var ? var->set(value) : false; } - PUGI__FN bool xpath_variable_set::set(const char_t* name, const xpath_node_set& value) + PUGI_FN bool xpath_variable_set::set(const char_t* name, const xpath_node_set& value) { xpath_variable* var = add(name, xpath_type_node_set); return var ? var->set(value) : false; } - PUGI__FN xpath_variable* xpath_variable_set::get(const char_t* name) + PUGI_FN xpath_variable* xpath_variable_set::get(const char_t* name) { return find(name); } - PUGI__FN const xpath_variable* xpath_variable_set::get(const char_t* name) const + PUGI_FN const xpath_variable* xpath_variable_set::get(const char_t* name) const { return find(name); } - PUGI__FN xpath_query::xpath_query(const char_t* query, xpath_variable_set* variables): _impl(0) + PUGI_FN xpath_query::xpath_query(const char_t* query, xpath_variable_set* variables): _impl(0) { impl::xpath_query_impl* qimpl = impl::xpath_query_impl::create(); @@ -11313,19 +11313,19 @@ } } - PUGI__FN xpath_query::~xpath_query() + PUGI_FN xpath_query::~xpath_query() { impl::xpath_query_impl::destroy(_impl); } - PUGI__FN xpath_value_type xpath_query::return_type() const + PUGI_FN xpath_value_type xpath_query::return_type() const { if (!_impl) return xpath_type_none; return static_cast(_impl)->root->rettype(); } - PUGI__FN bool xpath_query::evaluate_boolean(const xpath_node& n) const + PUGI_FN bool xpath_query::evaluate_boolean(const xpath_node& n) const { if (!_impl) return false; @@ -11339,7 +11339,7 @@ return static_cast(_impl)->root->eval_boolean(c, sd.stack); } - PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const + PUGI_FN double xpath_query::evaluate_number(const xpath_node& n) const { if (!_impl) return impl::gen_nan(); @@ -11354,7 +11354,7 @@ } #ifndef PUGIXML_NO_STL - PUGI__FN string_t xpath_query::evaluate_string(const xpath_node& n) const + PUGI_FN string_t xpath_query::evaluate_string(const xpath_node& n) const { impl::xpath_stack_data sd; @@ -11364,7 +11364,7 @@ } #endif - PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const + PUGI_FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const { impl::xpath_stack_data sd; @@ -11384,7 +11384,7 @@ return full_size; } - PUGI__FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const + PUGI_FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const { impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast(_impl)); if (!root) return xpath_node_set(); @@ -11401,7 +11401,7 @@ return xpath_node_set(r.begin(), r.end(), r.type()); } - PUGI__FN xpath_node xpath_query::evaluate_node(const xpath_node& n) const + PUGI_FN xpath_node xpath_query::evaluate_node(const xpath_node& n) const { impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast(_impl)); if (!root) return xpath_node(); @@ -11418,54 +11418,54 @@ return r.first(); } - PUGI__FN const xpath_parse_result& xpath_query::result() const + PUGI_FN const xpath_parse_result& xpath_query::result() const { return _result; } - PUGI__FN static void unspecified_bool_xpath_query(xpath_query***) + PUGI_FN static void unspecified_bool_xpath_query(xpath_query***) { } - PUGI__FN xpath_query::operator xpath_query::unspecified_bool_type() const + PUGI_FN xpath_query::operator xpath_query::unspecified_bool_type() const { return _impl ? unspecified_bool_xpath_query : 0; } - PUGI__FN bool xpath_query::operator!() const + PUGI_FN bool xpath_query::operator!() const { return !_impl; } - PUGI__FN xpath_node xml_node::select_node(const char_t* query, xpath_variable_set* variables) const + PUGI_FN xpath_node xml_node::select_node(const char_t* query, xpath_variable_set* variables) const { xpath_query q(query, variables); return select_node(q); } - PUGI__FN xpath_node xml_node::select_node(const xpath_query& query) const + PUGI_FN xpath_node xml_node::select_node(const xpath_query& query) const { return query.evaluate_node(*this); } - PUGI__FN xpath_node_set xml_node::select_nodes(const char_t* query, xpath_variable_set* variables) const + PUGI_FN xpath_node_set xml_node::select_nodes(const char_t* query, xpath_variable_set* variables) const { xpath_query q(query, variables); return select_nodes(q); } - PUGI__FN xpath_node_set xml_node::select_nodes(const xpath_query& query) const + PUGI_FN xpath_node_set xml_node::select_nodes(const xpath_query& query) const { return query.evaluate_node_set(*this); } - PUGI__FN xpath_node xml_node::select_single_node(const char_t* query, xpath_variable_set* variables) const + PUGI_FN xpath_node xml_node::select_single_node(const char_t* query, xpath_variable_set* variables) const { xpath_query q(query, variables); return select_single_node(q); } - PUGI__FN xpath_node xml_node::select_single_node(const xpath_query& query) const + PUGI_FN xpath_node xml_node::select_single_node(const xpath_query& query) const { return query.evaluate_node(*this); } @@ -11484,30 +11484,30 @@ #endif // Undefine all local macros (makes sure we're not leaking macros in header-only mode) -#undef PUGI__NO_INLINE -#undef PUGI__UNLIKELY -#undef PUGI__STATIC_ASSERT -#undef PUGI__DMC_VOLATILE -#undef PUGI__MSVC_CRT_VERSION -#undef PUGI__NS_BEGIN -#undef PUGI__NS_END -#undef PUGI__FN -#undef PUGI__FN_NO_INLINE -#undef PUGI__NODETYPE -#undef PUGI__IS_CHARTYPE_IMPL -#undef PUGI__IS_CHARTYPE -#undef PUGI__IS_CHARTYPEX -#undef PUGI__ENDSWITH -#undef PUGI__SKIPWS -#undef PUGI__OPTSET -#undef PUGI__PUSHNODE -#undef PUGI__POPNODE -#undef PUGI__SCANFOR -#undef PUGI__SCANWHILE -#undef PUGI__SCANWHILE_UNROLL -#undef PUGI__ENDSEG -#undef PUGI__THROW_ERROR -#undef PUGI__CHECK_ERROR +#undef PUGI_NO_INLINE +#undef PUGI_UNLIKELY +#undef PUGI_STATIC_ASSERT +#undef PUGI_DMC_VOLATILE +#undef PUGI_MSVC_CRT_VERSION +#undef PUGI_NS_BEGIN +#undef PUGI_NS_END +#undef PUGI_FN +#undef PUGI_FN_NO_INLINE +#undef PUGI_NODETYPE +#undef PUGI_IS_CHARTYPE_IMPL +#undef PUGI_IS_CHARTYPE +#undef PUGI_IS_CHARTYPEX +#undef PUGI_ENDSWITH +#undef PUGI_SKIPWS +#undef PUGI_OPTSET +#undef PUGI_PUSHNODE +#undef PUGI_POPNODE +#undef PUGI_SCANFOR +#undef PUGI_SCANWHILE +#undef PUGI_SCANWHILE_UNROLL +#undef PUGI_ENDSEG +#undef PUGI_THROW_ERROR +#undef PUGI_CHECK_ERROR #endif diff -Nru pbbam-2.1.0+dfsg/src/ReadGroupInfo.cpp pbbam-2.3.0+dfsg/src/ReadGroupInfo.cpp --- pbbam-2.1.0+dfsg/src/ReadGroupInfo.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/ReadGroupInfo.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -103,6 +103,7 @@ static const std::string platformModelType_RS{"RS"}; static const std::string platformModelType_SEQUEL{"SEQUEL"}; static const std::string platformModelType_SEQUELII{"SEQUELII"}; +static const std::string platformModelType_REVIO{"REVIO"}; std::string BaseFeatureName(const BaseFeature& feature) { @@ -185,7 +186,8 @@ {PlatformModelType::ASTRO, platformModelType_ASTRO}, {PlatformModelType::RS, platformModelType_RS}, {PlatformModelType::SEQUEL, platformModelType_SEQUEL}, - {PlatformModelType::SEQUELII, platformModelType_SEQUELII}}; + {PlatformModelType::SEQUELII, platformModelType_SEQUELII}, + {PlatformModelType::REVIO, platformModelType_REVIO}}; const auto found = lookup.find(type); if (found != lookup.cend()) { @@ -235,7 +237,8 @@ {platformModelType_ASTRO, PlatformModelType::ASTRO}, {platformModelType_RS, PlatformModelType::RS}, {platformModelType_SEQUEL, PlatformModelType::SEQUEL}, - {platformModelType_SEQUELII, PlatformModelType::SEQUELII}}; + {platformModelType_SEQUELII, PlatformModelType::SEQUELII}, + {platformModelType_REVIO, PlatformModelType::REVIO}}; bool IsLikelyBarcodeKey(const std::string& name) { return name.find("Barcode") == 0; } @@ -643,9 +646,9 @@ std::string ReadGroupInfo::EncodeSamDescription() const { - constexpr static const char SEP = ';'; - constexpr static const char COLON = ':'; - constexpr static const char EQ = '='; + constexpr char SEP = ';'; + constexpr char COLON = ':'; + constexpr char EQ = '='; std::string result{token_RT + EQ + readType_}; if (sourceReadType_.has_value()) { diff -Nru pbbam-2.1.0+dfsg/src/RunMetadataParser.cpp pbbam-2.3.0+dfsg/src/RunMetadataParser.cpp --- pbbam-2.1.0+dfsg/src/RunMetadataParser.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/RunMetadataParser.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -23,28 +23,28 @@ } const internal::FromInputXml fromInputXml; - if (name == Element::Automation) { + if (name == Element::AUTOMATION) { return std::make_shared(fromInputXml); } - if (name == Element::AutomationParameter) { + if (name == Element::AUTOMATION_PARAMETER) { return std::make_shared(fromInputXml); } - if (name == Element::AutomationParameters) { + if (name == Element::AUTOMATION_PARAMETERS) { return std::make_shared(fromInputXml); } - if (name == Element::BindingKit) { + if (name == Element::BINDING_KIT) { return std::make_shared(fromInputXml); } - if (name == Element::Collections) { + if (name == Element::COLLECTIONS) { return std::make_shared(fromInputXml); } - if (name == Element::ControlKit) { + if (name == Element::CONTROL_KIT) { return std::make_shared(fromInputXml); } - if (name == Element::SequencingKitPlate) { + if (name == Element::SEQUENCING_KIT_PLATE) { return std::make_shared(fromInputXml); } - if (name == Element::TemplatePrepKit) { + if (name == Element::TEMPLATE_PREP_KIT) { return std::make_shared(fromInputXml); } @@ -84,9 +84,9 @@ const pugi::xml_node& subreadSetNode) { // find & initialize CollectionMetadata from node - const auto cmNode = subreadSetNode.child(Element::DataSetMetadata) - .child(Element::Collections) - .child(Element::CollectionMetadata); + const auto cmNode = subreadSetNode.child(Element::DATASET_METADATA) + .child(Element::COLLECTIONS) + .child(Element::COLLECTION_METADATA); if (!cmNode) { throw std::runtime_error{"[pbbam] run metadata ERROR: XML is missing expected elements"}; } @@ -120,18 +120,18 @@ if (!rootNode) { throw std::runtime_error{"[pbbam] run metadata ERROR: could not fetch XML root node"}; } - if (std::string{rootNode.name()} != Element::PacBioDataModel) { + if (std::string{rootNode.name()} != Element::PACBIO_DATA_MODEL) { throw std::runtime_error{ "[pbbam] run metadata ERROR: expected 'PacBioDataModel' as root node, instead " "found: " + std::string{rootNode.name()}}; } - const auto result = rootNode.child(Element::ExperimentContainer) - .child(Element::Runs) - .child(Element::Run) - .child(Element::Outputs) - .child(Element::SubreadSets); + const auto result = rootNode.child(Element::EXPERIMENT_CONTAINER) + .child(Element::RUNS) + .child(Element::RUN) + .child(Element::OUTPUTS) + .child(Element::SUBREADSETS); if (!result) { throw std::runtime_error{"[pbbam] run metadata ERROR: XML is missing expected elements"}; } diff -Nru pbbam-2.1.0+dfsg/src/RunMetadataParser.h pbbam-2.3.0+dfsg/src/RunMetadataParser.h --- pbbam-2.1.0+dfsg/src/RunMetadataParser.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/RunMetadataParser.h 2023-01-03 21:57:00.000000000 +0000 @@ -16,48 +16,48 @@ // clang-format off namespace Element { -constexpr const char Automation[] = "Automation"; -constexpr const char AutomationParameter[] = "AutomationParameter"; -constexpr const char AutomationParameters[] = "AutomationParameters"; -constexpr const char BindingKit[] = "BindingKit"; -constexpr const char CellNFCIndex[] = "CellNFCIndex"; -constexpr const char CollectionMetadata[] = "CollectionMetadata"; -constexpr const char CollectionNumber[] = "CollectionNumber"; -constexpr const char Collections[] = "Collections"; -constexpr const char ControlKit[] = "ControlKit"; -constexpr const char CustomSequence[] = "CustomSequence"; -constexpr const char DataSetMetadata[] = "DataSetMetadata"; -constexpr const char ExperimentContainer[] = "ExperimentContainer"; -constexpr const char Exposure[] = "Exposure"; -constexpr const char ExtendFirst[] = "ExtendFirst"; -constexpr const char ExtensionTime[] = "ExtensionTime"; -constexpr const char ExtraIMWashes[] = "ExtraIMWashes"; -constexpr const char HasN2Switch[] = "HasN2Switch"; -constexpr const char HQRFMethod[] = "HQRFMethod"; -constexpr const char ImmobilizationTime[] = "ImmobilizationTime"; -constexpr const char InsertSize[] = "InsertSize"; -constexpr const char LeftAdapter[] = "LeftAdapter"; -constexpr const char LeftAdaptorSequence[] = "LeftAdaptorSequence"; -constexpr const char LeftPrimerSequence[] = "LeftPrimerSequence"; -constexpr const char MovieLength[] = "MovieLength"; -constexpr const char Outputs[] = "Outputs"; -constexpr const char PacBioDataModel[] = "PacBioDataModel"; -constexpr const char PartNumber[] = "PartNumber"; -constexpr const char PCDinPlate[] = "PCDinPlate"; -constexpr const char PreExtensionWorkflow[] = "PreExtensionWorkflow"; -constexpr const char RightAdapter[] = "RightAdapter"; -constexpr const char RightAdaptorSequence[] = "RightAdaptorSequence"; -constexpr const char RightPrimerSequence[] = "RightPrimerSequence"; -constexpr const char Run[] = "Run"; -constexpr const char Runs[] = "Runs"; -constexpr const char Sequence[] = "Sequence"; -constexpr const char SequencingKitPlate[] = "SequencingKitPlate"; -constexpr const char SNRCut[] = "SNRCut"; -constexpr const char SubreadSet[] = "SubreadSet"; -constexpr const char SubreadSets[] = "SubreadSets"; -constexpr const char TemplatePrepKit[] = "TemplatePrepKit"; -constexpr const char TipSearchMaxDuration[] = "TipSearchMaxDuration"; -constexpr const char UseStageHotStart[] = "UseStageHotStart"; +constexpr char AUTOMATION[] = "Automation"; +constexpr char AUTOMATION_PARAMETER[] = "AutomationParameter"; +constexpr char AUTOMATION_PARAMETERS[] = "AutomationParameters"; +constexpr char BINDING_KIT[] = "BindingKit"; +constexpr char CELL_NFC_INDEX[] = "CellNFCIndex"; +constexpr char COLLECTION_METADATA[] = "CollectionMetadata"; +constexpr char COLLECTION_NUMBER[] = "CollectionNumber"; +constexpr char COLLECTIONS[] = "Collections"; +constexpr char CONTROL_KIT[] = "ControlKit"; +constexpr char CUSTOM_SEQUENCE[] = "CustomSequence"; +constexpr char DATASET_METADATA[] = "DataSetMetadata"; +constexpr char EXPERIMENT_CONTAINER[] = "ExperimentContainer"; +constexpr char EXPOSURE[] = "Exposure"; +constexpr char EXTEND_FIRST[] = "ExtendFirst"; +constexpr char EXTENSION_TIME[] = "ExtensionTime"; +constexpr char EXTRA_IM_WASHES[] = "ExtraIMWashes"; +constexpr char HAS_N2_SWITCH[] = "HasN2Switch"; +constexpr char HQRF_METHOD[] = "HQRFMethod"; +constexpr char IMMOBILIZATION_TIME[] = "ImmobilizationTime"; +constexpr char INSERT_SIZE[] = "InsertSize"; +constexpr char LEFT_ADAPTER[] = "LeftAdapter"; +constexpr char LEFT_ADAPTOR_SEQUENCE[] = "LeftAdaptorSequence"; +constexpr char LEFT_PRIMER_SEQUENCE[] = "LeftPrimerSequence"; +constexpr char MOVIE_LENGTH[] = "MovieLength"; +constexpr char OUTPUTS[] = "Outputs"; +constexpr char PACBIO_DATA_MODEL[] = "PacBioDataModel"; +constexpr char PART_NUMBER[] = "PartNumber"; +constexpr char PCD_IN_PLATE[] = "PCDinPlate"; +constexpr char PRE_EXTENSION_WORKFLOW[] = "PreExtensionWorkflow"; +constexpr char RIGHT_ADAPTER[] = "RightAdapter"; +constexpr char RIGHT_ADAPTOR_SEQUENCE[] = "RightAdaptorSequence"; +constexpr char RIGHT_PRIMER_SEQUENCE[] = "RightPrimerSequence"; +constexpr char RUN[] = "Run"; +constexpr char RUNS[] = "Runs"; +constexpr char SEQUENCE[] = "Sequence"; +constexpr char SEQUENCING_KIT_PLATE[] = "SequencingKitPlate"; +constexpr char SNR_CUT[] = "SNRCut"; +constexpr char SUBREADSET[] = "SubreadSet"; +constexpr char SUBREADSETS[] = "SubreadSets"; +constexpr char TEMPLATE_PREP_KIT[] = "TemplatePrepKit"; +constexpr char TIP_SEARCH_MAX_DURATION[] = "TipSearchMaxDuration"; +constexpr char USE_STAGE_HOT_START[] = "UseStageHotStart"; } // namespace Element // clang-format on diff -Nru pbbam-2.1.0+dfsg/src/SequenceUtils.h pbbam-2.3.0+dfsg/src/SequenceUtils.h --- pbbam-2.1.0+dfsg/src/SequenceUtils.h 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/SequenceUtils.h 2023-01-03 21:57:00.000000000 +0000 @@ -17,7 +17,7 @@ inline char Complement(const char character) { - constexpr const std::array lookupTable{ + constexpr std::array LOOKUP_TABLE{ {/* 0 - 7: */ 0, 0, 0, 0, 0, 0, 0, 0, /* 8 - 15: */ 0, 0, 0, 0, 0, 0, 0, 0, /* 16 - 23: */ 0, 0, 0, 0, 0, 0, 0, 0, @@ -54,7 +54,7 @@ /* 240 - 247: */ 0, 0, 0, 0, 0, 0, 0, 0, /* 248 - 255: */ 0, 0, 0, 0, 0, 0, 0, 0}}; - return lookupTable[static_cast(character)]; + return LOOKUP_TABLE[static_cast(character)]; } template @@ -98,7 +98,7 @@ inline void ReverseComplementCaseSens(std::string& seq) { const std::string original = seq; - constexpr const static int8_t rc_table[128] = { + constexpr std::array RC_TABLE{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 32, 4, 4, 4, 4, 4, 4, 4, 4, 4, 42, 4, 4, 45, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 84, 4, 71, 4, 4, 4, 67, 4, 4, 4, 4, 4, 4, @@ -106,8 +106,7 @@ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 97, 97, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; std::string reverseCompl(original.length(), 'N'); for (uint32_t i = 0; i < original.length(); ++i) { - reverseCompl[original.length() - i - 1] = - static_cast(rc_table[static_cast(original[i])]); + reverseCompl[original.length() - i - 1] = RC_TABLE[static_cast(original[i])]; } seq = reverseCompl; } diff -Nru pbbam-2.1.0+dfsg/src/Tag.cpp pbbam-2.3.0+dfsg/src/Tag.cpp --- pbbam-2.1.0+dfsg/src/Tag.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/Tag.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -17,10 +17,10 @@ template bool InAsciiRange(const T x) { - return (x >= 33 && x <= 127); + return (x >= 33) && (x <= 127); } -struct AsciiConvertVisitor : public boost::static_visitor +struct AsciiConvertVisitor { // only valid for numeric types - maybe even more restrictive? char operator()(const int8_t& x) const { return Helper(x); } @@ -50,38 +50,38 @@ } }; -struct BytesUsedVisitor : public boost::static_visitor +struct BytesUsedVisitor { - static constexpr int BaseVariantSize = sizeof(Tag::var_t) + sizeof(TagModifier); + static constexpr int BASE_VARIANT_SIZE = sizeof(Tag::var_t) + sizeof(TagModifier); - int operator()(const boost::blank&) const noexcept { return BaseVariantSize; } - int operator()(const int8_t&) const noexcept { return BaseVariantSize; } - int operator()(const uint8_t&) const noexcept { return BaseVariantSize; } - int operator()(const int16_t&) const noexcept { return BaseVariantSize; } - int operator()(const uint16_t&) const noexcept { return BaseVariantSize; } - int operator()(const int32_t&) const noexcept { return BaseVariantSize; } - int operator()(const uint32_t&) const noexcept { return BaseVariantSize; } - int operator()(const float&) const noexcept { return BaseVariantSize; } + int operator()(const std::monostate&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const int8_t&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const uint8_t&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const int16_t&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const uint16_t&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const int32_t&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const uint32_t&) const noexcept { return BASE_VARIANT_SIZE; } + int operator()(const float&) const noexcept { return BASE_VARIANT_SIZE; } int operator()(const std::string& s) const noexcept { static const int sso = static_cast(std::string().capacity()); if (Utility::Ssize(s) <= sso) { - return BaseVariantSize; // can squeeze into std::string on stack + return BASE_VARIANT_SIZE; // can squeeze into std::string on stack } else { - return BaseVariantSize + s.capacity(); + return BASE_VARIANT_SIZE + s.capacity(); } } template int operator()(const std::vector& v) const noexcept { - return BaseVariantSize + (v.capacity() * sizeof(T)); + return BASE_VARIANT_SIZE + (v.capacity() * sizeof(T)); } }; template -struct NumericConvertVisitor : public boost::static_visitor +struct NumericConvertVisitor { // only valid for integral types DesiredType operator()(const int8_t& x) const { return boost::numeric_cast(x); } @@ -110,7 +110,7 @@ using ToInt32ConvertVisitor = NumericConvertVisitor; using ToUInt32ConvertVisitor = NumericConvertVisitor; -struct IsEqualVisitor : public boost::static_visitor +struct IsEqualVisitor { template bool operator()(const T&, const U&) const noexcept @@ -120,7 +120,7 @@ return false; } - bool operator()(const boost::blank&, const boost::blank&) const noexcept { return true; } + bool operator()(const std::monostate&, const std::monostate&) const noexcept { return true; } template bool operator()(const T& lhs, const T& rhs) const noexcept @@ -129,9 +129,9 @@ } }; -struct TypenameVisitor : public boost::static_visitor +struct TypenameVisitor { - std::string operator()(const boost::blank&) const { return "none"; } + std::string operator()(const std::monostate&) const { return "none"; } std::string operator()(const int8_t&) const { return "int8_t"; } std::string operator()(const uint8_t&) const { return "uint8_t"; } std::string operator()(const int16_t&) const { return "int16_t"; } @@ -149,11 +149,11 @@ std::string operator()(const std::vector&) const { return "vector"; } }; -struct OutputVisitor : public boost::static_visitor +struct OutputVisitor { OutputVisitor(std::ostream& out) : out_{out} {} - void operator()(const boost::blank) const { ; } + void operator()(const std::monostate) const {} void operator()(const int8_t value) const { out_ << static_cast(value); } void operator()(const uint8_t value) const { out_ << static_cast(value); } void operator()(const int16_t value) const { out_ << value; } @@ -242,7 +242,7 @@ } } -Tag& Tag::operator=(boost::blank value) +Tag& Tag::operator=(std::monostate value) { data_ = value; return *this; @@ -340,16 +340,12 @@ bool Tag::operator==(const Tag& other) const { - return boost::apply_visitor(IsEqualVisitor(), data_, other.data_) && - (modifier_ == other.modifier_); + return std::visit(IsEqualVisitor{}, data_, other.data_) && (modifier_ == other.modifier_); } bool Tag::operator!=(const Tag& other) const { return !(*this == other); } -int Tag::EstimatedBytesUsed() const noexcept -{ - return boost::apply_visitor(BytesUsedVisitor(), data_); -} +int Tag::EstimatedBytesUsed() const noexcept { return std::visit(BytesUsedVisitor{}, data_); } bool Tag::HasModifier(const TagModifier m) const { @@ -415,87 +411,81 @@ return *this; } -char Tag::ToAscii() const { return boost::apply_visitor(AsciiConvertVisitor(), data_); } +char Tag::ToAscii() const { return std::visit(AsciiConvertVisitor{}, data_); } int8_t Tag::ToInt8() const { if (IsInt8()) { - return boost::get(data_); + return std::get(data_); } - return boost::apply_visitor(ToInt8ConvertVisitor(), data_); + return std::visit(ToInt8ConvertVisitor{}, data_); } uint8_t Tag::ToUInt8() const { if (IsUInt8()) { - return boost::get(data_); + return std::get(data_); } - return boost::apply_visitor(ToUInt8ConvertVisitor(), data_); + return std::visit(ToUInt8ConvertVisitor{}, data_); } int16_t Tag::ToInt16() const { if (IsInt16()) { - return boost::get(data_); + return std::get(data_); } - return boost::apply_visitor(ToInt16ConvertVisitor(), data_); + return std::visit(ToInt16ConvertVisitor{}, data_); } uint16_t Tag::ToUInt16() const { if (IsUInt16()) { - return boost::get(data_); + return std::get(data_); } - return boost::apply_visitor(ToUInt16ConvertVisitor(), data_); + return std::visit(ToUInt16ConvertVisitor{}, data_); } int32_t Tag::ToInt32() const { if (IsInt32()) { - return boost::get(data_); + return std::get(data_); } - return boost::apply_visitor(ToInt32ConvertVisitor(), data_); + return std::visit(ToInt32ConvertVisitor{}, data_); } uint32_t Tag::ToUInt32() const { if (IsUInt32()) { - return boost::get(data_); + return std::get(data_); } - return boost::apply_visitor(ToUInt32ConvertVisitor(), data_); + return std::visit(ToUInt32ConvertVisitor{}, data_); } -float Tag::ToFloat() const { return boost::get(data_); } +float Tag::ToFloat() const { return std::get(data_); } -std::string Tag::ToString() const { return boost::get(data_); } +std::string Tag::ToString() const { return std::get(data_); } -std::vector Tag::ToInt8Array() const { return boost::get >(data_); } +std::vector Tag::ToInt8Array() const { return std::get >(data_); } -std::vector Tag::ToUInt8Array() const { return boost::get >(data_); } +std::vector Tag::ToUInt8Array() const { return std::get >(data_); } -std::vector Tag::ToInt16Array() const { return boost::get >(data_); } +std::vector Tag::ToInt16Array() const { return std::get >(data_); } -std::vector Tag::ToUInt16Array() const -{ - return boost::get >(data_); -} +std::vector Tag::ToUInt16Array() const { return std::get >(data_); } -std::vector Tag::ToInt32Array() const { return boost::get >(data_); } +std::vector Tag::ToInt32Array() const { return std::get >(data_); } -std::vector Tag::ToUInt32Array() const -{ - return boost::get >(data_); -} +std::vector Tag::ToUInt32Array() const { return std::get >(data_); } -std::vector Tag::ToFloatArray() const { return boost::get >(data_); } +std::vector Tag::ToFloatArray() const { return std::get >(data_); } -TagDataType Tag::Type() const { return TagDataType(data_.which()); } +TagDataType Tag::Type() const { return TagDataType(data_.index()); } -std::string Tag::Typename() const { return boost::apply_visitor(TypenameVisitor(), data_); } +std::string Tag::Typename() const { return std::visit(TypenameVisitor{}, data_); } std::ostream& operator<<(std::ostream& out, const Tag& tag) { - boost::apply_visitor(OutputVisitor(out), tag.data_); + std::visit(OutputVisitor{out}, tag.data_); return out; } diff -Nru pbbam-2.1.0+dfsg/src/vcf/VcfFormat.cpp pbbam-2.3.0+dfsg/src/vcf/VcfFormat.cpp --- pbbam-2.1.0+dfsg/src/vcf/VcfFormat.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/vcf/VcfFormat.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -22,25 +22,25 @@ namespace { // using htslib's current version for better compatibility -static constexpr const char current_version[] = "VCFv4.2"; +constexpr std::string_view CURRENT_VERSION{"VCFv4.2"}; namespace Tokens { -static constexpr const char file_format[] = "fileformat"; +constexpr std::string_view FILE_FORMAT{"fileformat"}; -static constexpr const char double_hash[] = "##"; -static constexpr const char contig_lead[] = "##contig=<"; -static constexpr const char filter_lead[] = "##FILTER=<"; -static constexpr const char format_lead[] = "##FORMAT=<"; -static constexpr const char info_lead[] = "##INFO=<"; -static constexpr const char chrom_lead[] = "#CHROM"; - -static constexpr const char id[] = "ID"; -static constexpr const char number[] = "Number"; -static constexpr const char type[] = "Type"; -static constexpr const char description[] = "Description"; -static constexpr const char source[] = "Source"; -static constexpr const char version[] = "Version"; +constexpr std::string_view DOUBLE_HASH{"##"}; +constexpr std::string_view CONTIG_LEAD{"##contig=<"}; +constexpr std::string_view FILTER_LEAD{"##FILTER=<"}; +constexpr std::string_view FORMAT_LEAD{"##FORMAT=<"}; +constexpr std::string_view INFO_LEAD{"##INFO=<"}; +constexpr std::string_view CHROM_LEAD{"#CHROM"}; + +constexpr std::string_view ID{"ID"}; +constexpr std::string_view NUMBER{"Number"}; +constexpr std::string_view TYPE{"Type"}; +constexpr std::string_view DESCRIPTION{"Description"}; +constexpr std::string_view SOURCE{"Source"}; +constexpr std::string_view VERSION{"Version"}; } // namespace Tokens @@ -56,14 +56,14 @@ } // namespace -const char* VcfFormat::CurrentVersion() { return current_version; } +std::string_view VcfFormat::CurrentVersion() { return CURRENT_VERSION; } std::string VcfFormat::FormattedContigDefinition(const ContigDefinition& def) { std::ostringstream text; // ID - text << Tokens::contig_lead << Tokens::id << '=' << def.Id(); + text << Tokens::CONTIG_LEAD << Tokens::ID << '=' << def.Id(); // attributes if (!def.Attributes().empty()) { @@ -84,7 +84,7 @@ std::string VcfFormat::FormattedFilterDefinition(const FilterDefinition& def) { std::ostringstream text; - text << Tokens::filter_lead << Tokens::id << '=' << def.Id() << ',' << Tokens::description + text << Tokens::FILTER_LEAD << Tokens::ID << '=' << def.Id() << ',' << Tokens::DESCRIPTION << '=' << QuotedText(def.Description()) << '>'; return text.str(); } @@ -92,8 +92,8 @@ std::string VcfFormat::FormattedFormatDefinition(const FormatDefinition& def) { std::ostringstream text; - text << Tokens::format_lead << Tokens::id << '=' << def.Id() << ',' << Tokens::number << '=' - << def.Number() << ',' << Tokens::type << '=' << def.Type() << ',' << Tokens::description + text << Tokens::FORMAT_LEAD << Tokens::ID << '=' << def.Id() << ',' << Tokens::NUMBER << '=' + << def.Number() << ',' << Tokens::TYPE << '=' << def.Type() << ',' << Tokens::DESCRIPTION << '=' << QuotedText(def.Description()) << '>'; return text.str(); } @@ -101,23 +101,23 @@ std::string VcfFormat::FormattedGeneralDefinition(const GeneralDefinition& def) { std::ostringstream text; - text << Tokens::double_hash << def.Id() << '=' << def.Text(); + text << Tokens::DOUBLE_HASH << def.Id() << '=' << def.Text(); return text.str(); } std::string VcfFormat::FormattedInfoDefinition(const InfoDefinition& def) { std::ostringstream text; - text << Tokens::info_lead << Tokens::id << '=' << def.Id() << ',' << Tokens::number << '=' - << def.Number() << ',' << Tokens::type << '=' << def.Type() << ',' << Tokens::description + text << Tokens::INFO_LEAD << Tokens::ID << '=' << def.Id() << ',' << Tokens::NUMBER << '=' + << def.Number() << ',' << Tokens::TYPE << '=' << def.Type() << ',' << Tokens::DESCRIPTION << '=' << QuotedText(def.Description()); if (def.Source() && !def.Source()->empty()) { - text << ',' << Tokens::source << '=' << QuotedText(*def.Source()); + text << ',' << Tokens::SOURCE << '=' << QuotedText(*def.Source()); } if (def.Version() && !def.Version()->empty()) { - text << ',' << Tokens::version << '=' << QuotedText(*def.Version()); + text << ',' << Tokens::VERSION << '=' << QuotedText(*def.Version()); } text << '>'; @@ -128,12 +128,12 @@ { std::ostringstream out; - const auto& fileformat = header.GeneralDefinition(Tokens::file_format); + const auto& fileformat = header.GeneralDefinition(std::string{Tokens::FILE_FORMAT}); out << FormattedGeneralDefinition(fileformat) << '\n'; // remaining general definiitions for (const auto& def : header.GeneralDefinitions()) { - if (def.Id() != Tokens::file_format) { + if (def.Id() != Tokens::FILE_FORMAT) { out << FormattedGeneralDefinition(def) << '\n'; } } @@ -176,7 +176,7 @@ ContigDefinition VcfFormat::ParsedContigDefinition(std::string line) { // should already be checked by "normal" code path - assert(line.find(Tokens::contig_lead) == 0); + assert(line.find(Tokens::CONTIG_LEAD) == 0); // substring between brackets const auto lastBracketPos = line.find_last_of('>'); @@ -195,7 +195,7 @@ throw VcfFormatException{"malformed ##contig line: " + line}; } - if (tokens[0] == Tokens::id) { + if (tokens[0] == Tokens::ID) { id = tokens[1]; } else { attributes.push_back(std::make_pair(tokens[0], tokens[1])); @@ -208,7 +208,7 @@ FilterDefinition VcfFormat::ParsedFilterDefinition(std::string line) { // should already be checked by "normal" code path - assert(line.find(Tokens::filter_lead) == 0); + assert(line.find(Tokens::FILTER_LEAD) == 0); // substring between brackets const auto lastBracketPos = line.find_last_of('>'); @@ -227,9 +227,9 @@ throw VcfFormatException{"malformed FILTER line: " + line}; } - if (tokens[0] == Tokens::id) { + if (tokens[0] == Tokens::ID) { id = tokens[1]; - } else if (tokens[0] == Tokens::description) { + } else if (tokens[0] == Tokens::DESCRIPTION) { description = UnquotedText(tokens[1]); } else { throw VcfFormatException{"unrecognized FILTER field: " + tokens[0]}; @@ -242,7 +242,7 @@ FormatDefinition VcfFormat::ParsedFormatDefinition(std::string line) { // should already be checked by "normal" code path - assert(line.find(Tokens::format_lead) == 0); + assert(line.find(Tokens::FORMAT_LEAD) == 0); // substring between brackets const auto lastBracketPos = line.find_last_of('>'); @@ -262,13 +262,13 @@ if (tokens.size() != 2) { throw VcfFormatException{"malformed FORMAT line: " + line}; } - if (tokens[0] == Tokens::id) { + if (tokens[0] == Tokens::ID) { id = tokens[1]; - } else if (tokens[0] == Tokens::number) { + } else if (tokens[0] == Tokens::NUMBER) { number = tokens[1]; - } else if (tokens[0] == Tokens::type) { + } else if (tokens[0] == Tokens::TYPE) { type = tokens[1]; - } else if (tokens[0] == Tokens::description) { + } else if (tokens[0] == Tokens::DESCRIPTION) { description = UnquotedText(tokens[1]); } else { throw VcfFormatException{"unrecognized FORMAT field: " + tokens[0]}; @@ -282,7 +282,7 @@ GeneralDefinition VcfFormat::ParsedGeneralDefinition(const std::string& line) { const auto tokens = BAM::Split(line, '='); - if (tokens.size() != 2 || tokens[0].find(Tokens::double_hash) != 0) { + if (tokens.size() != 2 || tokens[0].find(Tokens::DOUBLE_HASH) != 0) { throw VcfFormatException{"malformed header line: " + line}; } return GeneralDefinition{tokens[0].substr(2), tokens[1]}; @@ -291,7 +291,7 @@ InfoDefinition VcfFormat::ParsedInfoDefinition(std::string line) { // should already be checked by "normal" code path - assert(line.find(Tokens::info_lead) == 0); + assert(line.find(Tokens::INFO_LEAD) == 0); // substring between brackets const auto lastBracketPos = line.find_last_of('>'); @@ -314,17 +314,17 @@ throw VcfFormatException{"malformed INFO line: " + line}; } - if (tokens[0] == Tokens::id) { + if (tokens[0] == Tokens::ID) { id = tokens[1]; - } else if (tokens[0] == Tokens::number) { + } else if (tokens[0] == Tokens::NUMBER) { number = tokens[1]; - } else if (tokens[0] == Tokens::type) { + } else if (tokens[0] == Tokens::TYPE) { type = tokens[1]; - } else if (tokens[0] == Tokens::description) { + } else if (tokens[0] == Tokens::DESCRIPTION) { description = UnquotedText(tokens[1]); - } else if (tokens[0] == Tokens::source) { + } else if (tokens[0] == Tokens::SOURCE) { source = UnquotedText(tokens[1]); - } else if (tokens[0] == Tokens::version) { + } else if (tokens[0] == Tokens::VERSION) { version = UnquotedText(tokens[1]); } else { throw VcfFormatException{"unrecognized INFO field: " + tokens[0]}; @@ -345,7 +345,7 @@ // quick check for fileformat - should be the first line std::getline(text, line); auto genDef = ParsedGeneralDefinition(line); - if (genDef.Id() != Tokens::file_format) { + if (genDef.Id() != Tokens::FILE_FORMAT) { throw VcfFormatException{"file must begin with #fileformat line"}; } hdr.AddGeneralDefinition(std::move(genDef)); @@ -358,19 +358,19 @@ } // info line - if (line.find(Tokens::info_lead) == 0) { + if (line.find(Tokens::INFO_LEAD) == 0) { hdr.AddInfoDefinition(ParsedInfoDefinition(line)); // filter line - } else if (line.find(Tokens::filter_lead) == 0) { + } else if (line.find(Tokens::FILTER_LEAD) == 0) { hdr.AddFilterDefinition(ParsedFilterDefinition(line)); // format line - } else if (line.find(Tokens::format_lead) == 0) { + } else if (line.find(Tokens::FORMAT_LEAD) == 0) { hdr.AddFormatDefinition(ParsedFormatDefinition(line)); // contig line - } else if (line.find(Tokens::contig_lead) == 0) { + } else if (line.find(Tokens::CONTIG_LEAD) == 0) { hdr.AddContigDefinition(ParsedContigDefinition(line)); // general comment line @@ -378,11 +378,11 @@ // NOTE: Check this after all other specific header line types. This // catches all remaining lines starting with "##" // - } else if (line.find(Tokens::double_hash) == 0) { + } else if (line.find(Tokens::DOUBLE_HASH) == 0) { hdr.AddGeneralDefinition(ParsedGeneralDefinition(line)); // CHROM line (maybe w/ samples) - } else if (line.find(Tokens::chrom_lead) == 0) { + } else if (line.find(Tokens::CHROM_LEAD) == 0) { std::vector samples; // If samples are present, skip the fixed colums & FORMAT column (9) diff -Nru pbbam-2.1.0+dfsg/src/vcf/VcfHeader.cpp pbbam-2.3.0+dfsg/src/vcf/VcfHeader.cpp --- pbbam-2.1.0+dfsg/src/vcf/VcfHeader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/vcf/VcfHeader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -9,7 +9,7 @@ namespace PacBio { namespace VCF { -VcfHeader::VcfHeader() { Version(VcfFormat::CurrentVersion()); } +VcfHeader::VcfHeader() { Version(std::string{VcfFormat::CurrentVersion()}); } VcfHeader::VcfHeader(const std::string& hdrText) { *this = VcfFormat::ParsedHeader(hdrText); } diff -Nru pbbam-2.1.0+dfsg/src/vcf/VcfVariant.cpp pbbam-2.3.0+dfsg/src/vcf/VcfVariant.cpp --- pbbam-2.1.0+dfsg/src/vcf/VcfVariant.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/vcf/VcfVariant.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -16,7 +16,7 @@ VcfVariant::VcfVariant(const std::string& text) { *this = VcfFormat::ParsedVariant(text); } -VcfVariant::VcfVariant() : pos_{Data::UnmappedPosition}, qual_{NAN}, filter_{"PASS"} {} +VcfVariant::VcfVariant() : pos_{Data::UNMAPPED_POSITION}, qual_{NAN}, filter_{"PASS"} {} VcfVariant::VcfVariant(std::string id, std::string chrom, Data::Position pos, std::string refAllele, std::string altAllele) diff -Nru pbbam-2.1.0+dfsg/src/VirtualZmwBamRecord.cpp pbbam-2.3.0+dfsg/src/VirtualZmwBamRecord.cpp --- pbbam-2.1.0+dfsg/src/VirtualZmwBamRecord.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/src/VirtualZmwBamRecord.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -205,14 +205,14 @@ barcodes = b.Barcodes(); } - static constexpr const auto regionType = VirtualRegionType::SUBREAD; - if (!HasVirtualRegionType(regionType)) { - virtualRegionsMap_[regionType] = std::vector{}; + constexpr auto REGION_TYPE = VirtualRegionType::SUBREAD; + if (!HasVirtualRegionType(REGION_TYPE)) { + virtualRegionsMap_[REGION_TYPE] = std::vector{}; } - virtualRegionsMap_[regionType].emplace_back(regionType, b.QueryStart(), b.QueryEnd(), - b.LocalContextFlags(), barcodes.first, - barcodes.second); + virtualRegionsMap_[REGION_TYPE].emplace_back(REGION_TYPE, b.QueryStart(), b.QueryEnd(), + b.LocalContextFlags(), barcodes.first, + barcodes.second); } if (b.HasBarcodes() && !this->HasBarcodes()) { diff -Nru pbbam-2.1.0+dfsg/tests/meson.build pbbam-2.3.0+dfsg/tests/meson.build --- pbbam-2.1.0+dfsg/tests/meson.build 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/meson.build 2023-01-03 21:57:00.000000000 +0000 @@ -1,6 +1,6 @@ subdir('src') -pbbam_python = find_program('python') +pbbam_python = import('python').find_installation('python3') pbbam_cram_script = find_program('cram', required : false) if not pbbam_cram_script.found() warning('Using bundled cram script') diff -Nru pbbam-2.1.0+dfsg/tests/src/cram/ccs-kinetics-bystrandify.t pbbam-2.3.0+dfsg/tests/src/cram/ccs-kinetics-bystrandify.t --- pbbam-2.1.0+dfsg/tests/src/cram/ccs-kinetics-bystrandify.t 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/cram/ccs-kinetics-bystrandify.t 2023-01-03 21:57:00.000000000 +0000 @@ -6,7 +6,7 @@ > "${TESTDIR}"/../../data/ccs-kinetics-bystrandify/ccs-kinetics-bystrandify-mock-input.bam \ > "${CRAMTMP}"/out.bam - $ "${SAMTOOLS}" view -h "${CRAMTMP}"/out.bam | grep -v '@PG ID:samtools' + $ samtools view -h "${CRAMTMP}"/out.bam | grep -v '@PG ID:samtools' @HD VN:1.5 SO:unknown pb:3.0.1 @RG ID:ab118ebd PL:PACBIO DS:READTYPE=CCS;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=101-490-800;SEQUENCINGKIT=101-490-900;BASECALLERVERSION=5.0.0;FRAMERATEHZ=100.000000 PU:m64011_190228_190319 PM:SEQUELII CM:S/P3-C1/5.0-8M @PG\tID:ccs-kinetics-bystrandify-*\tPN:ccs-kinetics-bystrandify\tVN:* (glob) @@ -28,7 +28,7 @@ > "${TESTDIR}"/../../data/ccs-kinetics-bystrandify/ccs-kinetics-bystrandify-mock-input.bam \ > "${CRAMTMP}"/out-coverage.bam - $ "${SAMTOOLS}" view "${CRAMTMP}"/out-coverage.bam + $ samtools view "${CRAMTMP}"/out-coverage.bam m64011_190228_190319/4/ccs/rev 4 * 0 255 * * 0 0 CGTACGTACGT ARWPRRRQWRa cx:i:3 np:i:4 ip:B:C,251,201,151,111,101,41,31,21,11,6,2 pw:B:C,250,200,150,110,100,40,30,20,10,5,1 zm:i:4 sn:B:f,13.4413,20.9895,4.68673,8.39738 rq:f:0.999867 RG:Z:ab118ebd ----------------------------------------- @@ -67,7 +67,7 @@ ---- Output BAM - $ "${SAMTOOLS}" view -h "${CRAMTMP}"/ccs-kinetics-bystrandify-mock-input.bystrand.bam | grep -v '@PG ID:samtools' + $ samtools view -h "${CRAMTMP}"/ccs-kinetics-bystrandify-mock-input.bystrand.bam | grep -v '@PG ID:samtools' @HD VN:1.5 SO:unknown pb:3.0.1 @RG ID:ab118ebd PL:PACBIO DS:READTYPE=CCS;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=101-490-800;SEQUENCINGKIT=101-490-900;BASECALLERVERSION=5.0.0;FRAMERATEHZ=100.000000 PU:m64011_190228_190319 PM:SEQUELII CM:S/P3-C1/5.0-8M @PG\tID:ccs-kinetics-bystrandify-*\tPN:ccs-kinetics-bystrandify\tVN:* (glob) @@ -80,7 +80,7 @@ m64011_190228_190319/4/ccs/fwd 4 * 0 255 * * 0 0 TACGT QRRRP cx:i:3 np:i:2 ip:B:C,20,30,40,100,110 pw:B:C,21,31,41,101,111 zm:i:4 sn:B:f,13.4413,20.9895,4.68673,8.39738 rq:f:0.999867 RG:Z:ab118ebd m64011_190228_190319/4/ccs/rev 4 * 0 255 * * 0 0 CGTACGTACGT ARWPRRRQWRa cx:i:3 np:i:4 ip:B:C,251,201,151,111,101,41,31,21,11,6,2 pw:B:C,250,200,150,110,100,40,30,20,10,5,1 zm:i:4 sn:B:f,13.4413,20.9895,4.68673,8.39738 rq:f:0.999867 RG:Z:ab118ebd - $ "${SAMTOOLS}" view -h "${CRAMTMP}"/ccs-kinetics-bystrandify-mock-input.2.bystrand.bam | grep -v '@PG ID:samtools' + $ samtools view -h "${CRAMTMP}"/ccs-kinetics-bystrandify-mock-input.2.bystrand.bam | grep -v '@PG ID:samtools' @HD VN:1.5 SO:unknown pb:3.0.1 @RG ID:ab118ebd PL:PACBIO DS:READTYPE=CCS;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=101-490-800;SEQUENCINGKIT=101-490-900;BASECALLERVERSION=5.0.0;FRAMERATEHZ=100.000000 PU:m64011_190228_190319 PM:SEQUELII CM:S/P3-C1/5.0-8M @PG\tID:ccs-kinetics-bystrandify-*\tPN:ccs-kinetics-bystrandify\tVN:* (glob) @@ -124,7 +124,7 @@ ---- Output BAM - $ "${SAMTOOLS}" view -h "${CRAMTMP}"/out.bam | grep -v '@PG ID:samtools' + $ samtools view -h "${CRAMTMP}"/out.bam | grep -v '@PG ID:samtools' @HD VN:1.5 SO:unknown pb:3.0.1 @RG ID:ab118ebd PL:PACBIO DS:READTYPE=CCS;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=101-490-800;SEQUENCINGKIT=101-490-900;BASECALLERVERSION=5.0.0;FRAMERATEHZ=100.000000 PU:m64011_190228_190319 PM:SEQUELII CM:S/P3-C1/5.0-8M @PG\tID:ccs-kinetics-bystrandify-*\tPN:ccs-kinetics-bystrandify\tVN:* (glob) diff -Nru pbbam-2.1.0+dfsg/tests/src/cram/pbbamify.t.in pbbam-2.3.0+dfsg/tests/src/cram/pbbamify.t.in --- pbbam-2.1.0+dfsg/tests/src/cram/pbbamify.t.in 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/cram/pbbamify.t.in 2023-01-03 21:57:00.000000000 +0000 @@ -8,7 +8,7 @@ Forward alignments with and without user specified tags, one alignment with undefined mapq, some alignments with basic CIGAR operations, 2 alignemtns with hard clipping, and several invalid alignments (1 without a seq field and 1 not present in the dataset) which should be skipped: - $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-1.bam $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_1.subreads.bam | $SAMTOOLS view -h | grep -v '@PG ID:samtools' + $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-1.bam $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_1.subreads.bam | samtools view -h | grep -v '@PG ID:samtools' @HD\tVN:1.5\tSO:unknown\tpb:3.0.3 (esc) @SQ\tSN:synthetic_ref_1\tLN:150\tM5:e1e940d621d949c9617566ddf3055922 (esc) @RG\tID:8d2370c0\tPL:PACBIO\tDS:READTYPE=SUBREAD;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=100-862-200;SEQUENCINGKIT=100-861-800;BASECALLERVERSION=5.0.0.5552;FRAMERATEHZ=80.000000\tPU:synthetic_movie_1\tPM:SEQUEL (esc) @@ -36,7 +36,7 @@ $ rm pbbamify.log Reverse alignments: 2 primary alignments and 7 secondary, 6 alignments with extended CIGAR and 2 with basic CIGAR strings, 1 alignment with undefined (255) mapq, 2 alignments with hard clipping, 1 alignment with user defined tag. All alignments have a read group assigned which is different than the dataset. - $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-2.bam $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_2.subreads.bam | $SAMTOOLS view -h | grep -v '@PG ID:samtools' + $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-2.bam $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_2.subreads.bam | samtools view -h | grep -v '@PG ID:samtools' @HD\tVN:1.5\tSO:unknown\tpb:3.0.3 (esc) @SQ\tSN:synthetic_ref_1\tLN:150\tM5:e1e940d621d949c9617566ddf3055922 (esc) @RG\tID:7a515ee0\tPL:PACBIO\tDS:READTYPE=SUBREAD;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=100-862-200;SEQUENCINGKIT=100-861-800;BASECALLERVERSION=5.0.0.5552;FRAMERATEHZ=80.000000\tPU:synthetic_movie_2\tPM:SEQUEL (esc) @@ -60,7 +60,7 @@ CCS read: - $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-3.bam $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_3.subreads.bam | $SAMTOOLS view -h | grep -v '@PG ID:samtools' + $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-3.bam $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_3.subreads.bam | samtools view -h | grep -v '@PG ID:samtools' @HD\tVN:1.5\tSO:unknown\tpb:3.0.1 (esc) @SQ\tSN:synthetic_ref_1\tLN:150\tM5:e1e940d621d949c9617566ddf3055922 (esc) @RG\tID:67e06f58\tPL:PACBIO\tDS:READTYPE=CCS;BINDINGKIT=100-862-200;SEQUENCINGKIT=101-093-700;BASECALLERVERSION=5.0.0.5049;FRAMERATEHZ=80.000000\tPU:synthetic_movie_3\tPM:SEQUEL (esc) @@ -74,7 +74,7 @@ No verbose output: - $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-1.bam --verbose-level=0 $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_1.subreads.bam | $SAMTOOLS view -h | grep -v '@PG ID:samtools' + $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-1.bam --verbose-level=0 $DATADIR/pbbamify/synthetic-ref-1.fa $DATADIR/pbbamify/synthetic_movie_1.subreads.bam | samtools view -h | grep -v '@PG ID:samtools' @HD\tVN:1.5\tSO:unknown\tpb:3.0.3 (esc) @SQ\tSN:synthetic_ref_1\tLN:150\tM5:e1e940d621d949c9617566ddf3055922 (esc) @RG\tID:8d2370c0\tPL:PACBIO\tDS:READTYPE=SUBREAD;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;BINDINGKIT=100-862-200;SEQUENCINGKIT=100-861-800;BASECALLERVERSION=5.0.0.5552;FRAMERATEHZ=80.000000\tPU:synthetic_movie_1\tPM:SEQUEL (esc) @@ -101,7 +101,7 @@ Test on a dataset, input contains alignments from all subread sets. - $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-all.bam $DATADIR/pbbamify/synthetic-ref-1.fa $GENERATEDDATADIR/synthetic_movie_all.subreadset.xml | $SAMTOOLS view -h | grep -v '@PG ID:samtools' + $ $PBBAMIFY --log-file=pbbamify.log --input=$DATADIR/pbbamify/input-aligned-all.bam $DATADIR/pbbamify/synthetic-ref-1.fa $GENERATEDDATADIR/synthetic_movie_all.subreadset.xml | samtools view -h | grep -v '@PG ID:samtools' @HD\tVN:1.5\tSO:unknown\tpb:3.0.3 (esc) @SQ\tSN:synthetic_ref_1\tLN:150\tM5:e1e940d621d949c9617566ddf3055922 (esc) @RG\tID:67e06f58\tPL:PACBIO\tDS:READTYPE=CCS;BINDINGKIT=100-862-200;SEQUENCINGKIT=101-093-700;BASECALLERVERSION=5.0.0.5049;FRAMERATEHZ=80.000000\tPU:synthetic_movie_3\tPM:SEQUEL (esc) diff -Nru pbbam-2.1.0+dfsg/tests/src/meson.build pbbam-2.3.0+dfsg/tests/src/meson.build --- pbbam-2.1.0+dfsg/tests/src/meson.build 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/meson.build 2023-01-03 21:57:00.000000000 +0000 @@ -44,7 +44,6 @@ 'test_PacBioIndex.cpp', 'test_PbiFilter.cpp', 'test_PbiFilterQuery.cpp', - 'test_QualityValues.cpp', 'test_Pulse2BaseCache.cpp', 'test_ReadGroupHashing.cpp', 'test_ReadGroupInfo.cpp', diff -Nru pbbam-2.1.0+dfsg/tests/src/test_AlignmentPrinter.cpp pbbam-2.3.0+dfsg/tests/src/test_AlignmentPrinter.cpp --- pbbam-2.1.0+dfsg/tests/src/test_AlignmentPrinter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_AlignmentPrinter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -50,7 +50,7 @@ "\n"}; auto record = *it++; - EXPECT_EQ(expected, pretty.Print(record, Orientation::GENOMIC)); + EXPECT_EQ(expected, pretty.Print(record, Data::Orientation::GENOMIC)); expected = "Read : singleInsertion/200/0_49\n" @@ -71,7 +71,7 @@ "\n"; record = *it++; - EXPECT_EQ(expected, pretty.Print(record, Orientation::GENOMIC)); + EXPECT_EQ(expected, pretty.Print(record, Data::Orientation::GENOMIC)); expected = "Read : singleInsertion/100/0_111\n" @@ -93,7 +93,7 @@ "\n"; record = *it++; - EXPECT_EQ(expected, pretty.Print(record, Orientation::GENOMIC)); + EXPECT_EQ(expected, pretty.Print(record, Data::Orientation::GENOMIC)); expected = "Read : singleInsertion/100/0_111\n" @@ -115,5 +115,5 @@ "\n"; record = *it++; - EXPECT_EQ(expected, pretty.Print(record, Orientation::GENOMIC)); + EXPECT_EQ(expected, pretty.Print(record, Data::Orientation::GENOMIC)); } diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BamHeader.cpp pbbam-2.3.0+dfsg/tests/src/test_BamHeader.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BamHeader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BamHeader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -447,3 +447,14 @@ header.AddReadGroup(ReadGroupInfo{"rg1"}); EXPECT_EQ(originalText, header.ToSam()); } + +TEST(BAM_BamHeader, can_handle_lookup_with_mixed_correct_and_legacy_barcoded_rg_ids) +{ + const std::string text{ + "@HD\tVN:1.5\tSO:unknown\tpb:3.0.1\n" + "@RG\tID:3cecb623\tPL:PACBIO\tDS:READTYPE=CCS;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw\n"}; + + const BamHeader header{text}; + EXPECT_NO_THROW(header.ReadGroup("3cecb623")); + EXPECT_NO_THROW(header.ReadGroup("3cecb623/73--73")); +} diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BamRecordClipping.cpp pbbam-2.3.0+dfsg/tests/src/test_BamRecordClipping.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BamRecordClipping.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BamRecordClipping.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -36,8 +36,8 @@ } static -BamRecord MakeRecord(const Position qStart, - const Position qEnd, +BamRecord MakeRecord(const Data::Position qStart, + const Data::Position qEnd, const std::string& seq, const std::string& quals, const std::string& tagBases, @@ -126,8 +126,8 @@ TEST(BAM_BamRecordClipping, correctly_performs_clip_to_query_simple) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -140,11 +140,11 @@ const f_data pulseFrames = { 0,0,10,0,10,0,0,20,20,30,0,0,0,0,40,40,10,0,0,0,30,20,0 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 502; - const Position clipEnd = 509; + const Data::Position clipStart = 502; + const Data::Position clipEnd = 509; const std::string seq_clipped = "CCGTTAG"; const std::string quals_clipped = "?]?]?]?"; @@ -195,15 +195,15 @@ EXPECT_FALSE(s0.IsMapped()); EXPECT_EQ(clipStart, s0.QueryStart()); EXPECT_EQ(clipEnd, s0.QueryEnd()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.AlignedStart()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.AlignedEnd()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.ReferenceStart()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.ReferenceEnd()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.AlignedStart()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.AlignedEnd()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.ReferenceStart()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.ReferenceEnd()); const BamRecordView view { s0, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -221,11 +221,11 @@ { SCOPED_TRACE("s1 - FORWARD"); - BamRecord s1 = prototype.Mapped(tId, tPos, Strand::FORWARD, s1_cigar, mapQual); + BamRecord s1 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s1_cigar, mapQual); s1.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s1.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(clipStart, s1.QueryStart()); EXPECT_EQ(clipEnd, s1.QueryEnd()); EXPECT_EQ(clipStart, s1.AlignedStart()); // queryStart (no soft clips) @@ -238,7 +238,7 @@ const BamRecordView view { s1, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -256,10 +256,10 @@ { SCOPED_TRACE("s1 - REVERSE"); - BamRecord s1_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s1_cigar, mapQual); + BamRecord s1_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s1_cigar, mapQual); EXPECT_TRUE(s1_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(500, s1_rev.QueryStart()); EXPECT_EQ(510, s1_rev.QueryEnd()); EXPECT_EQ(500, s1_rev.AlignedStart()); // queryStart (no soft clips) @@ -270,7 +270,7 @@ s1_rev.Clip(ClipType::CLIP_TO_QUERY, 502, 509); EXPECT_TRUE(s1_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(502, s1_rev.QueryStart()); EXPECT_EQ(509, s1_rev.QueryEnd()); EXPECT_EQ(502, s1_rev.AlignedStart()); // queryStart (no soft clips) @@ -282,7 +282,7 @@ const BamRecordView view { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -299,11 +299,11 @@ { SCOPED_TRACE("s2 - FORWARD"); - BamRecord s2 = prototype.Mapped(tId, tPos, Strand::FORWARD, s2_cigar, mapQual); + BamRecord s2 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s2_cigar, mapQual); s2.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s2.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(clipStart, s2.QueryStart()); EXPECT_EQ(clipEnd, s2.QueryEnd()); EXPECT_EQ(clipStart, s2.AlignedStart()); // queryStart (no soft clips) @@ -316,7 +316,7 @@ const BamRecordView view { s2, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -333,11 +333,11 @@ { SCOPED_TRACE("s2 - REVERSE"); - BamRecord s2_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s2_cigar, mapQual); + BamRecord s2_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s2_cigar, mapQual); s2_rev.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s2_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(clipStart, s2_rev.QueryStart()); EXPECT_EQ(clipEnd, s2_rev.QueryEnd()); EXPECT_EQ(clipStart, s2_rev.AlignedStart()); // queryStart (no soft clips) @@ -350,7 +350,7 @@ const BamRecordView view { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -368,11 +368,11 @@ { SCOPED_TRACE("s3 - FORWARD"); - BamRecord s3 = prototype.Mapped(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + BamRecord s3 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); s3.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(clipStart, s3.QueryStart()); EXPECT_EQ(clipEnd, s3.QueryEnd()); EXPECT_EQ(clipStart, s3.AlignedStart()); // queryStart (no soft clips) @@ -385,7 +385,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -403,11 +403,11 @@ { SCOPED_TRACE("s3 - REVERSE"); - BamRecord s3_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s3_cigar, mapQual); + BamRecord s3_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s3_cigar, mapQual); s3_rev.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(clipStart, s3_rev.QueryStart()); EXPECT_EQ(clipEnd, s3_rev.QueryEnd()); EXPECT_EQ(clipStart, s3_rev.AlignedStart()); // queryStart (no soft clips) @@ -420,7 +420,7 @@ const BamRecordView view { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -439,8 +439,8 @@ TEST(BAM_BamRecordClipping, correctly_performs_clip_to_query_with_soft_clips) { - const Position qStart = 500; - const Position qEnd = 515; + const Data::Position qStart = 500; + const Data::Position qEnd = 515; const std::string seq = "TTAACCGTTAGCAAA"; const std::string seq_rev = "TTTGCTAACGGTTAA"; const std::string quals = "--?]?]?]?]?*+++"; @@ -451,11 +451,11 @@ const f_data frames_rev = { 10, 10, 10, 20, 30, 10, 40, 40, 30, 20, 20, 10, 10, 40, 40 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 502; - const Position clipEnd = 509; + const Data::Position clipStart = 502; + const Data::Position clipEnd = 509; const std::string s1_cigar = "2S10=3S"; const std::string s1_cigar_clipped = "7="; @@ -505,7 +505,7 @@ { SCOPED_TRACE("s1 - FORWARD"); - BamRecord s1 = prototype.Mapped(tId, tPos, Strand::FORWARD, s1_cigar, mapQual); + BamRecord s1 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s1_cigar, mapQual); EXPECT_TRUE(s1.IsMapped()); EXPECT_EQ(100, s1.ReferenceStart()); EXPECT_EQ(110, s1.ReferenceEnd()); // 10= @@ -513,7 +513,7 @@ s1.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s1.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(clipStart, s1.QueryStart()); EXPECT_EQ(clipEnd, s1.QueryEnd()); EXPECT_EQ(clipStart, s1.AlignedStart()); // queryStart (no soft clips left) @@ -526,7 +526,7 @@ const BamRecordView view { s1, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -541,7 +541,7 @@ { SCOPED_TRACE("s1 - REVERSE"); - BamRecord s1_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s1_cigar, mapQual); + BamRecord s1_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s1_cigar, mapQual); EXPECT_TRUE(s1_rev.IsMapped()); EXPECT_EQ(100, s1_rev.ReferenceStart()); EXPECT_EQ(110, s1_rev.ReferenceEnd()); // 10= @@ -549,7 +549,7 @@ s1_rev.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s1_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(clipStart, s1_rev.QueryStart()); EXPECT_EQ(clipEnd, s1_rev.QueryEnd()); EXPECT_EQ(503, s1_rev.AlignedStart()); // queryStart (no soft clips) @@ -562,7 +562,7 @@ const BamRecordView view { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -577,7 +577,7 @@ { SCOPED_TRACE("s2 - FORWARD"); - BamRecord s2 = prototype.Mapped(tId, tPos, Strand::FORWARD, s2_cigar, mapQual); + BamRecord s2 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s2_cigar, mapQual); EXPECT_TRUE(s2.IsMapped()); EXPECT_EQ(100, s2.ReferenceStart()); EXPECT_EQ(113, s2.ReferenceEnd()); // 5= + 3D + 5= @@ -585,7 +585,7 @@ s2.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s2.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(clipStart, s2.QueryStart()); EXPECT_EQ(clipEnd, s2.QueryEnd()); EXPECT_EQ(clipStart, s2.AlignedStart()); // queryStart (no soft clips left) @@ -598,7 +598,7 @@ const BamRecordView view { s2, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -613,7 +613,7 @@ { SCOPED_TRACE("s2 - REVERSE"); - BamRecord s2_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s2_cigar, mapQual); + BamRecord s2_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s2_cigar, mapQual); EXPECT_TRUE(s2_rev.IsMapped()); EXPECT_EQ(100, s2_rev.ReferenceStart()); EXPECT_EQ(113, s2_rev.ReferenceEnd()); // 5= + 3D + 5= @@ -621,7 +621,7 @@ s2_rev.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s2_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(clipStart, s2_rev.QueryStart()); EXPECT_EQ(clipEnd, s2_rev.QueryEnd()); EXPECT_EQ(503, s2_rev.AlignedStart()); // queryStart (no soft clips left) @@ -634,7 +634,7 @@ const BamRecordView view { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -650,7 +650,7 @@ { SCOPED_TRACE("s3 - FORWARD"); - BamRecord s3 = prototype.Mapped(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + BamRecord s3 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); EXPECT_TRUE(s3.IsMapped()); EXPECT_EQ(100, s3.ReferenceStart()); EXPECT_EQ(111, s3.ReferenceEnd()); // 4= + 1D + 2D + 4= @@ -658,7 +658,7 @@ s3.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(clipStart, s3.QueryStart()); EXPECT_EQ(clipEnd, s3.QueryEnd()); EXPECT_EQ(clipStart, s3.AlignedStart()); // queryStart (no soft clips left) @@ -671,7 +671,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -688,7 +688,7 @@ { SCOPED_TRACE("s3 - REVERSE"); - BamRecord s3_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s3_cigar, mapQual); + BamRecord s3_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s3_cigar, mapQual); EXPECT_TRUE(s3_rev.IsMapped()); EXPECT_EQ(100, s3_rev.ReferenceStart()); EXPECT_EQ(111, s3_rev.ReferenceEnd()); // 4= + 1D + 2D + 4= @@ -696,7 +696,7 @@ s3_rev.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(clipStart, s3_rev.QueryStart()); EXPECT_EQ(clipEnd, s3_rev.QueryEnd()); EXPECT_EQ(503, s3_rev.AlignedStart()); // queryStart + 1S @@ -709,7 +709,7 @@ const BamRecordView view { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -727,8 +727,8 @@ TEST(BAM_BamRecordClipping, correctly_performs_clip_to_reference_simple) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -737,11 +737,11 @@ const f_data frames = { 10, 10, 20, 20, 30, 40, 40, 10, 30, 20 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 102; - const Position clipEnd = 107; + const Data::Position clipStart = 102; + const Data::Position clipEnd = 107; const std::string s1_cigar = "10="; const std::string s1_cigar_clipped = "5="; @@ -785,12 +785,12 @@ const BamRecord prototype = BamRecordClippingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); BamRecord s0 = prototype; - BamRecord s1 = prototype.Mapped(tId, tPos, Strand::FORWARD, s1_cigar, mapQual); - BamRecord s2 = prototype.Mapped(tId, tPos, Strand::FORWARD, s2_cigar, mapQual); - BamRecord s3 = prototype.Mapped(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); - BamRecord s1_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s1_cigar, mapQual); - BamRecord s2_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s2_cigar, mapQual); - BamRecord s3_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s3_cigar, mapQual); + BamRecord s1 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s1_cigar, mapQual); + BamRecord s2 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s2_cigar, mapQual); + BamRecord s3 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); + BamRecord s1_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s1_cigar, mapQual); + BamRecord s2_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s2_cigar, mapQual); + BamRecord s3_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s3_cigar, mapQual); s0.Clip(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd); s1.Clip(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd); @@ -813,7 +813,7 @@ const BamRecordView protoView { prototype, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -822,7 +822,7 @@ const BamRecordView view { s0, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -840,7 +840,7 @@ { // s1 - FORWARD EXPECT_TRUE(s1.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(502, s1.QueryStart()); EXPECT_EQ(507, s1.QueryEnd()); EXPECT_EQ(502, s1.AlignedStart()); // queryStart (no soft clips) @@ -853,7 +853,7 @@ const BamRecordView view { s1, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -871,7 +871,7 @@ { // s1 - REVERSE EXPECT_TRUE(s1_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(503, s1_rev.QueryStart()); EXPECT_EQ(508, s1_rev.QueryEnd()); EXPECT_EQ(503, s1_rev.AlignedStart()); // queryStart (no soft clips) @@ -884,7 +884,7 @@ const BamRecordView view { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -902,7 +902,7 @@ { // s2 - FORWARD EXPECT_TRUE(s2.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(502, s2.QueryStart()); EXPECT_EQ(505, s2.QueryEnd()); EXPECT_EQ(502, s2.AlignedStart()); // queryStart (no soft clips) @@ -915,7 +915,7 @@ const BamRecordView view { s2, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -933,7 +933,7 @@ { // s2 - REVERSE EXPECT_TRUE(s2_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(505, s2_rev.QueryStart()); EXPECT_EQ(508, s2_rev.QueryEnd()); EXPECT_EQ(505, s2_rev.AlignedStart()); // queryStart (no soft clips) @@ -946,7 +946,7 @@ const BamRecordView view { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -964,7 +964,7 @@ { // s3 - FORWARD EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(502, s3.QueryStart()); EXPECT_EQ(506, s3.QueryEnd()); EXPECT_EQ(502, s3.AlignedStart()); // queryStart (no soft clips) @@ -977,7 +977,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -995,7 +995,7 @@ { // s3 - REVERSE EXPECT_TRUE(s3_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(504, s3_rev.QueryStart()); EXPECT_EQ(508, s3_rev.QueryEnd()); EXPECT_EQ(504, s3_rev.AlignedStart()); // queryStart (no soft clips) @@ -1008,7 +1008,7 @@ const BamRecordView view { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1026,8 +1026,8 @@ TEST(BAM_BamRecordClipping, correctly_performs_clip_to_reference_with_soft_clips) { - const Position qStart = 500; - const Position qEnd = 515; + const Data::Position qStart = 500; + const Data::Position qEnd = 515; const std::string seq = "TTAACCGTTAGCAAA"; const std::string quals = "--?]?]?]?]?*+++"; const std::string tagBases = "TTAACCGTTAGCAAA"; @@ -1036,11 +1036,11 @@ const f_data frames = { 40, 40, 10, 10, 20, 20, 30, 40, 40, 10, 30, 20, 10, 10, 10 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 102; - const Position clipEnd = 107; + const Data::Position clipStart = 102; + const Data::Position clipEnd = 107; const std::string seq_rev = "TTTGCTAACGGTTAA"; const std::string quals_rev = "+++*?]?]?]?]?--"; @@ -1088,12 +1088,12 @@ const BamRecord prototype = BamRecordClippingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); BamRecord s0 = prototype; - BamRecord s1 = prototype.Mapped(tId, tPos, Strand::FORWARD, s1_cigar, mapQual); - BamRecord s2 = prototype.Mapped(tId, tPos, Strand::FORWARD, s2_cigar, mapQual); - BamRecord s3 = prototype.Mapped(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); - BamRecord s1_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s1_cigar, mapQual); - BamRecord s2_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s2_cigar, mapQual); - BamRecord s3_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s3_cigar, mapQual); + BamRecord s1 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s1_cigar, mapQual); + BamRecord s2 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s2_cigar, mapQual); + BamRecord s3 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); + BamRecord s1_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s1_cigar, mapQual); + BamRecord s2_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s2_cigar, mapQual); + BamRecord s3_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s3_cigar, mapQual); // sanity checks before clipping EXPECT_FALSE(s0.IsMapped()); @@ -1167,7 +1167,7 @@ const BamRecordView protoView { prototype, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1176,7 +1176,7 @@ const BamRecordView view { s0, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1194,7 +1194,7 @@ { // s1 - FORWARD EXPECT_TRUE(s1.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(504, s1.QueryStart()); // new queryStart EXPECT_EQ(509, s1.QueryEnd()); // queryStart + new seqLength EXPECT_EQ(504, s1.AlignedStart()); // queryStart (no soft clips remaining) @@ -1207,7 +1207,7 @@ const BamRecordView view { s1, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1225,7 +1225,7 @@ { // s1 - REVERSE EXPECT_TRUE(s1_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(506, s1_rev.QueryStart()); // new queryStart EXPECT_EQ(511, s1_rev.QueryEnd()); // queryStart + new seqLength EXPECT_EQ(506, s1_rev.AlignedStart()); // queryStart (no soft clips remaining) @@ -1238,7 +1238,7 @@ const BamRecordView view { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1256,7 +1256,7 @@ { // s2 - FORWARD EXPECT_TRUE(s2.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(504, s2.QueryStart()); EXPECT_EQ(507, s2.QueryEnd()); EXPECT_EQ(504, s2.AlignedStart()); // queryStart (no soft clips) @@ -1269,7 +1269,7 @@ const BamRecordView view { s2, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1287,7 +1287,7 @@ { // s2 - REVERSE EXPECT_TRUE(s2_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(508, s2_rev.QueryStart()); // new queryStart EXPECT_EQ(511, s2_rev.QueryEnd()); // queryStart + new seqLength EXPECT_EQ(508, s2_rev.AlignedStart()); // queryStart (no soft clips remaining) @@ -1300,7 +1300,7 @@ const BamRecordView view { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1317,7 +1317,7 @@ { // s3 - FORWARD EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(504, s3.QueryStart()); EXPECT_EQ(508, s3.QueryEnd()); EXPECT_EQ(504, s3.AlignedStart()); // queryStart (no soft clips) @@ -1330,7 +1330,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1347,7 +1347,7 @@ { // s3 - REVERSE EXPECT_TRUE(s3_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(507, s3_rev.QueryStart()); // new queryStart EXPECT_EQ(511, s3_rev.QueryEnd()); // queryStart + new seqLength EXPECT_EQ(507, s3_rev.AlignedStart()); // queryStart (no soft clips remaining) @@ -1360,7 +1360,7 @@ const BamRecordView view { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1378,13 +1378,13 @@ TEST(BAM_BamRecordClipping, can_create_new_record_clipped_to_query) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 502; - const Position clipEnd = 509; + const Data::Position clipStart = 502; + const Data::Position clipEnd = 509; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; @@ -1403,12 +1403,12 @@ BamRecord prototype = BamRecordClippingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); - prototype.Map(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + prototype.Map(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); BamRecord s3 = prototype.Clipped(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(clipStart, s3.QueryStart()); EXPECT_EQ(clipEnd, s3.QueryEnd()); EXPECT_EQ(clipStart, s3.AlignedStart()); // queryStart (no soft clips) @@ -1421,7 +1421,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1438,18 +1438,18 @@ TEST(BAM_BamRecordClipping, can_create_new_record_clipped_to_reference) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; const std::string tagQuals = "?]?]?]?]?*"; const f_data frames = { 10, 10, 20, 20, 30, 40, 40, 10, 30, 20 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 102; - const Position clipEnd = 107; + const Data::Position clipStart = 102; + const Data::Position clipEnd = 107; const std::string s3_cigar = "4=1D2I2D4="; const std::string s3_cigar_clipped = "2=1D2I2D"; @@ -1461,13 +1461,13 @@ BamRecord prototype = BamRecordClippingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); - prototype.Map(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + prototype.Map(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); const BamRecord s3 = prototype.Clipped(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd); // s3 - FORWARD EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(502, s3.QueryStart()); EXPECT_EQ(506, s3.QueryEnd()); EXPECT_EQ(502, s3.AlignedStart()); // queryStart (no soft clips) @@ -1480,7 +1480,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1497,13 +1497,13 @@ TEST(BAM_BamRecordClipping, can_create_new_record_clipped_to_query_static_method) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 502; - const Position clipEnd = 509; + const Data::Position clipStart = 502; + const Data::Position clipEnd = 509; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; @@ -1522,12 +1522,12 @@ BamRecord prototype = BamRecordClippingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); - prototype.Map(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + prototype.Map(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); const BamRecord s3 = BamRecord::Clipped(prototype, ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(clipStart, s3.QueryStart()); EXPECT_EQ(clipEnd, s3.QueryEnd()); EXPECT_EQ(clipStart, s3.AlignedStart()); // queryStart (no soft clips) @@ -1540,7 +1540,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1557,18 +1557,18 @@ TEST(BAM_BamRecordClipping, can_create_new_record_clipped_to_reference_static_method) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; const std::string tagQuals = "?]?]?]?]?*"; const f_data frames = { 10, 10, 20, 20, 30, 40, 40, 10, 30, 20 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 102; - const Position clipEnd = 107; + const Data::Position clipStart = 102; + const Data::Position clipEnd = 107; const std::string s3_cigar = "4=1D2I2D4="; const std::string s3_cigar_clipped = "2=1D2I2D"; @@ -1580,13 +1580,13 @@ BamRecord prototype = BamRecordClippingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); - prototype.Map(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + prototype.Map(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); const BamRecord s3 = BamRecord::Clipped(prototype, ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd); // s3 - FORWARD EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(502, s3.QueryStart()); EXPECT_EQ(506, s3.QueryEnd()); EXPECT_EQ(502, s3.AlignedStart()); // queryStart (no soft clips) @@ -1599,7 +1599,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1616,8 +1616,8 @@ TEST(BAM_BamRecordClipping, correctly_clips_cigar) { - const Position qStart = 500; - const Position qEnd = 515; + const Data::Position qStart = 500; + const Data::Position qEnd = 515; const std::string seq = "TTAACCGTTAGCAAA"; const std::string quals = "--?]?]?]?]?*+++"; const std::string tagBases = "TTAACCGTTAGCAAA"; @@ -1630,11 +1630,11 @@ seq, tagBases, tagQuals, frames); const std::string s3_cigar = "5H2S4=1D2I2D4=3S7H"; - s3.Map(0, 100, Strand::FORWARD, s3_cigar, mapQual); - s3_rev.Map(0, 100, Strand::REVERSE, s3_cigar, mapQual); + s3.Map(0, 100, Data::Strand::FORWARD, s3_cigar, mapQual); + s3_rev.Map(0, 100, Data::Strand::REVERSE, s3_cigar, mapQual); - const Cigar s3_cigar_raw = s3.CigarData(); - const Cigar s3_cigar_clipped = s3.CigarData(true); + const Data::Cigar s3_cigar_raw = s3.CigarData(); + const Data::Cigar s3_cigar_clipped = s3.CigarData(true); EXPECT_EQ(s3_cigar, s3_cigar_raw.ToStdString()); EXPECT_EQ(std::string("4=1D2I2D4="), s3_cigar_clipped.ToStdString()); @@ -1643,10 +1643,10 @@ TEST(BAM_BamRecordClipping, can_make_ccs_record_clipped_to_query) { const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 2; - const Position clipEnd = 9; + const Data::Position clipStart = 2; + const Data::Position clipEnd = 9; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; @@ -1665,12 +1665,12 @@ BamRecord prototype = BamRecordClippingTests::MakeCCSRecord(seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); - prototype.Map(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + prototype.Map(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); BamRecord s3 = prototype.Clipped(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(0, s3.AlignedStart()); // record start (no soft clips) EXPECT_EQ(7, s3.AlignedEnd()); // alignStart + clipped seqLength EXPECT_EQ(102, s3.ReferenceStart()); // 100 + startOffset @@ -1681,7 +1681,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1704,10 +1704,10 @@ const std::string tagQuals = "?]?]?]?]?*"; const f_data frames = { 10, 10, 20, 20, 30, 40, 40, 10, 30, 20 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 102; - const Position clipEnd = 107; + const Data::Position clipStart = 102; + const Data::Position clipEnd = 107; const std::string s3_cigar = "4=1D2I2D4="; const std::string s3_cigar_clipped = "2=1D2I2D"; @@ -1719,12 +1719,12 @@ BamRecord prototype = BamRecordClippingTests::MakeCCSRecord(seq, quals, tagBases, tagQuals, frames, seq, tagBases, tagQuals, frames); - prototype.Map(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); + prototype.Map(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); const BamRecord s3 = BamRecord::Clipped(prototype, ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd); EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(0, s3.AlignedStart()); // record tart (no soft clips) EXPECT_EQ(4, s3.AlignedEnd()); // alignStart + clipped seqLength (4) EXPECT_EQ(clipStart, s3.ReferenceStart()); // clipStart @@ -1735,7 +1735,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1752,8 +1752,8 @@ TEST(BAM_BamRecordClipping, correctly_clips_encoded_frames) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -1766,11 +1766,11 @@ const f_data pulseFrames = { 0,0,10,0,10,0,0,20,20,30,0,0,0,0,40,40,10,0,0,0,30,20,0 }; const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Position clipStart = 502; - const Position clipEnd = 509; + const Data::Position clipStart = 502; + const Data::Position clipEnd = 509; const std::string seq_clipped = "CCGTTAG"; const std::string quals_clipped = "?]?]?]?"; @@ -1813,12 +1813,12 @@ pulseCall, pulseBases, pulseQuals, pulseFrames, FrameCodec::V1); BamRecord s0 = prototype; // unmapped record - BamRecord s1 = prototype.Mapped(tId, tPos, Strand::FORWARD, s1_cigar, mapQual); - BamRecord s2 = prototype.Mapped(tId, tPos, Strand::FORWARD, s2_cigar, mapQual); - BamRecord s3 = prototype.Mapped(tId, tPos, Strand::FORWARD, s3_cigar, mapQual); - BamRecord s1_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s1_cigar, mapQual); - BamRecord s2_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s2_cigar, mapQual); - BamRecord s3_rev = prototype.Mapped(tId, tPos, Strand::REVERSE, s3_cigar, mapQual); + BamRecord s1 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s1_cigar, mapQual); + BamRecord s2 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s2_cigar, mapQual); + BamRecord s3 = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, s3_cigar, mapQual); + BamRecord s1_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s1_cigar, mapQual); + BamRecord s2_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s2_cigar, mapQual); + BamRecord s3_rev = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, s3_cigar, mapQual); s0.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); s1.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd); @@ -1833,15 +1833,15 @@ EXPECT_FALSE(s0.IsMapped()); EXPECT_EQ(clipStart, s0.QueryStart()); EXPECT_EQ(clipEnd, s0.QueryEnd()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.AlignedStart()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.AlignedEnd()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.ReferenceStart()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, s0.ReferenceEnd()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.AlignedStart()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.AlignedEnd()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.ReferenceStart()); + EXPECT_EQ(Data::UNMAPPED_POSITION, s0.ReferenceEnd()); const BamRecordView view { s0, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1860,7 +1860,7 @@ { // s1 - FORWARD EXPECT_TRUE(s1.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(clipStart, s1.QueryStart()); EXPECT_EQ(clipEnd, s1.QueryEnd()); EXPECT_EQ(clipStart, s1.AlignedStart()); // queryStart (no soft clips) @@ -1873,7 +1873,7 @@ const BamRecordView view { s1, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1892,7 +1892,7 @@ { // s1 - REVERSE EXPECT_TRUE(s1_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(clipStart, s1_rev.QueryStart()); EXPECT_EQ(clipEnd, s1_rev.QueryEnd()); EXPECT_EQ(clipStart, s1_rev.AlignedStart()); // queryStart (no soft clips) @@ -1905,7 +1905,7 @@ const BamRecordView view { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1924,7 +1924,7 @@ { // s2 - FORWARD EXPECT_TRUE(s2.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(clipStart, s2.QueryStart()); EXPECT_EQ(clipEnd, s2.QueryEnd()); EXPECT_EQ(clipStart, s2.AlignedStart()); // queryStart (no soft clips) @@ -1937,7 +1937,7 @@ const BamRecordView view { s2, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1955,7 +1955,7 @@ { // s2 - REVERSE EXPECT_TRUE(s2_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(clipStart, s2_rev.QueryStart()); EXPECT_EQ(clipEnd, s2_rev.QueryEnd()); EXPECT_EQ(clipStart, s2_rev.AlignedStart()); // queryStart (no soft clips) @@ -1968,7 +1968,7 @@ const BamRecordView view { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -1987,7 +1987,7 @@ { // s3 - FORWARD EXPECT_TRUE(s3.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(clipStart, s3.QueryStart()); EXPECT_EQ(clipEnd, s3.QueryEnd()); EXPECT_EQ(clipStart, s3.AlignedStart()); // queryStart (no soft clips) @@ -2000,7 +2000,7 @@ const BamRecordView view { s3, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -2019,7 +2019,7 @@ { // s3 - REVERSE EXPECT_TRUE(s3_rev.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(clipStart, s3_rev.QueryStart()); EXPECT_EQ(clipEnd, s3_rev.QueryEnd()); EXPECT_EQ(clipStart, s3_rev.AlignedStart()); // queryStart (no soft clips) @@ -2032,7 +2032,7 @@ const BamRecordView view { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -2052,7 +2052,7 @@ TEST(BAM_BamRecordClipping, can_excise_soft_clips_from_frames_with_deletions) { const std::string expectedName{"m141008_060349_42194_c100704972550000001823137703241586_s1_p0/14/2409_2745"}; - const PacBio::BAM::Strand expectedStrand = PacBio::BAM::Strand::FORWARD; + const Data::Strand expectedStrand = Data::Strand::FORWARD; const std::string expectedCigar{ "20S11=1I47=1I2=1I6=1I22=1I2=1I9=1I29=1D6=1I16=1I6=1I7=1I8=2I5=1I5=1I11=1I5=5I2=3I1=1I1=1I1=3I5=2D19=1I14=1I17=28S"}; const std::string expectedRawSeq{ @@ -2103,14 +2103,14 @@ EXPECT_EQ(expectedStrand, record.AlignedStrand()); EXPECT_EQ(expectedCigar, record.CigarData().ToStdString()); - const auto rawSeq = record.Sequence(PacBio::BAM::Orientation::GENOMIC); - const auto clippedSeq = record.Sequence(PacBio::BAM::Orientation::GENOMIC, false, true); + const auto rawSeq = record.Sequence(Data::Orientation::GENOMIC); + const auto clippedSeq = record.Sequence(Data::Orientation::GENOMIC, false, true); EXPECT_EQ(expectedRawSeq, rawSeq); EXPECT_EQ(expectedClippedSeq, clippedSeq); ASSERT_TRUE(record.HasIPD()); - const auto rawIpds = record.IPD(PacBio::BAM::Orientation::GENOMIC).Encode(); - const auto clippedIpds = record.IPD(PacBio::BAM::Orientation::GENOMIC, false, true).Encode(); + const auto rawIpds = record.IPD(Data::Orientation::GENOMIC).Encode(); + const auto clippedIpds = record.IPD(Data::Orientation::GENOMIC, false, true).Encode(); EXPECT_EQ(expectedRawIpds, rawIpds); EXPECT_EQ(expectedClippedIpds, clippedIpds); } @@ -2125,13 +2125,13 @@ EntireFileQuery query{bamFile}; for (auto& i : query) { - Strand expectedStrand; + Data::Strand expectedStrand; std::string scope; if (first) { - expectedStrand = Strand::FORWARD; + expectedStrand = Data::Strand::FORWARD; scope = "First record (FORWARD strand)"; } else { - expectedStrand = Strand::REVERSE; + expectedStrand = Data::Strand::REVERSE; scope = "Second record (REVERSE strand)"; } @@ -2155,8 +2155,8 @@ EXPECT_EQ("3=1I", i.CigarData().ToStdString()); // second clip - Position qS; - Position qE; + Data::Position qS; + Data::Position qE; if (first) { qS = i.QueryStart(); qE = i.QueryEnd() - 1; @@ -2178,8 +2178,8 @@ TEST(BAM_BamRecordClipping, clipping_flanking_inserts_is_ignored_on_clip_to_query) { - const Position qStart = 500; - const Position qEnd = 515; + const Data::Position qStart = 500; + const Data::Position qEnd = 515; const std::string seq = "TTAACCGTTAGCAAA"; const std::string quals = "--?]?]?]?]?*+++"; const std::string tagBases = "TTAACCGTTAGCAAA"; @@ -2193,11 +2193,11 @@ { // aligned forward const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Cigar cigar{"4I5=6I"}; + const Data::Cigar cigar{"4I5=6I"}; - BamRecord s = prototype.Mapped(tId, tPos, Strand::FORWARD, cigar, mapQual); + BamRecord s = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, cigar, mapQual); EXPECT_TRUE(s.IsMapped()); EXPECT_EQ(100, s.ReferenceStart()); EXPECT_EQ(105, s.ReferenceEnd()); @@ -2209,7 +2209,7 @@ s.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd, exciseFlankingInserts); EXPECT_TRUE(s.IsMapped()); - EXPECT_EQ(Strand::FORWARD, s.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s.AlignedStrand()); EXPECT_EQ("2I5=3I", s.CigarData().ToStdString()); EXPECT_EQ(clipStart, s.QueryStart()); @@ -2222,11 +2222,11 @@ { // aligned reverse const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Cigar cigar{"4I5=6I"}; + const Data::Cigar cigar{"4I5=6I"}; - BamRecord s = prototype.Mapped(tId, tPos, Strand::REVERSE, cigar, mapQual); + BamRecord s = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, cigar, mapQual); EXPECT_TRUE(s.IsMapped()); EXPECT_EQ(100, s.ReferenceStart()); EXPECT_EQ(105, s.ReferenceEnd()); @@ -2238,7 +2238,7 @@ s.Clip(ClipType::CLIP_TO_QUERY, clipStart, clipEnd, exciseFlankingInserts); EXPECT_TRUE(s.IsMapped()); - EXPECT_EQ(Strand::REVERSE, s.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s.AlignedStrand()); EXPECT_EQ("1I5=4I", s.CigarData().ToStdString()); EXPECT_EQ(clipStart, s.QueryStart()); @@ -2252,8 +2252,8 @@ TEST(BAM_BamRecordClipping, can_excise_flanking_insertsion_when_clipping_to_reference_forward) { - const Position qStart = 500; - const Position qEnd = 526; + const Data::Position qStart = 500; + const Data::Position qEnd = 526; const std::string seq = "TTAACCGTTAGCAAATTAACCGTTAG"; const std::string quals = "--?]?]?]?]?*+++--?]?]?]?]?"; const std::string tagBases = "TTAACCGTTAGCAAATTAACCGTTAG"; @@ -2268,9 +2268,9 @@ frames, seq, tagBases, tagQuals, frames); const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Cigar cigar{"3=6I10=6I1="}; + const Data::Cigar cigar{"3=6I10=6I1="}; const size_t clipStart = 103; const size_t clipEnd = 113; @@ -2280,7 +2280,7 @@ bool exciseFlankingInserts = false; - BamRecord withInserts = prototype.Mapped(tId, tPos, Strand::FORWARD, cigar, mapQual); + BamRecord withInserts = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, cigar, mapQual); EXPECT_TRUE(withInserts.IsMapped()); EXPECT_EQ(100, withInserts.ReferenceStart()); EXPECT_EQ(114, withInserts.ReferenceEnd()); @@ -2288,7 +2288,7 @@ withInserts.Clip(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd, exciseFlankingInserts); EXPECT_TRUE(withInserts.IsMapped()); - EXPECT_EQ(Strand::FORWARD, withInserts.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, withInserts.AlignedStrand()); EXPECT_EQ("6I10=6I", withInserts.CigarData().ToStdString()); EXPECT_EQ(503, withInserts.QueryStart()); @@ -2303,7 +2303,7 @@ exciseFlankingInserts = true; - BamRecord withoutInserts = prototype.Mapped(tId, tPos, Strand::FORWARD, cigar, mapQual); + BamRecord withoutInserts = prototype.Mapped(tId, tPos, Data::Strand::FORWARD, cigar, mapQual); EXPECT_TRUE(withoutInserts.IsMapped()); EXPECT_EQ(100, withoutInserts.ReferenceStart()); EXPECT_EQ(114, withoutInserts.ReferenceEnd()); @@ -2311,7 +2311,7 @@ withoutInserts.Clip(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd, exciseFlankingInserts); EXPECT_TRUE(withoutInserts.IsMapped()); - EXPECT_EQ(Strand::FORWARD, withoutInserts.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, withoutInserts.AlignedStrand()); EXPECT_EQ("10=", withoutInserts.CigarData().ToStdString()); EXPECT_EQ(509, withoutInserts.QueryStart()); @@ -2324,8 +2324,8 @@ TEST(BAM_BamRecordClipping, can_excise_flanking_insertsion_when_clipping_to_reference_reverse) { - const Position qStart = 500; - const Position qEnd = 526; + const Data::Position qStart = 500; + const Data::Position qEnd = 526; const std::string seq = "TTAACCGTTAGCAAATTAACCGTTAG"; const std::string quals = "--?]?]?]?]?*+++--?]?]?]?]?"; const std::string tagBases = "TTAACCGTTAGCAAATTAACCGTTAG"; @@ -2340,9 +2340,9 @@ frames, seq, tagBases, tagQuals, frames); const int32_t tId = 0; - const Position tPos = 100; + const Data::Position tPos = 100; const uint8_t mapQual = 80; - const Cigar cigar{"3=6I10=6I1="}; + const Data::Cigar cigar{"3=6I10=6I1="}; const size_t clipStart = 103; const size_t clipEnd = 113; @@ -2352,7 +2352,7 @@ bool exciseFlankingInserts = false; - BamRecord withInserts = prototype.Mapped(tId, tPos, Strand::REVERSE, cigar, mapQual); + BamRecord withInserts = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, cigar, mapQual); EXPECT_TRUE(withInserts.IsMapped()); EXPECT_EQ(100, withInserts.ReferenceStart()); @@ -2361,7 +2361,7 @@ withInserts.Clip(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd, exciseFlankingInserts); EXPECT_TRUE(withInserts.IsMapped()); - EXPECT_EQ(Strand::REVERSE, withInserts.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, withInserts.AlignedStrand()); EXPECT_EQ("6I10=6I", withInserts.CigarData().ToStdString()); EXPECT_EQ(501, withInserts.QueryStart()); @@ -2376,7 +2376,7 @@ exciseFlankingInserts = true; - BamRecord withoutInserts = prototype.Mapped(tId, tPos, Strand::REVERSE, cigar, mapQual); + BamRecord withoutInserts = prototype.Mapped(tId, tPos, Data::Strand::REVERSE, cigar, mapQual); EXPECT_TRUE(withoutInserts.IsMapped()); EXPECT_EQ(100, withoutInserts.ReferenceStart()); EXPECT_EQ(114, withoutInserts.ReferenceEnd()); @@ -2384,7 +2384,7 @@ withoutInserts.Clip(ClipType::CLIP_TO_REFERENCE, clipStart, clipEnd, exciseFlankingInserts); EXPECT_TRUE(withoutInserts.IsMapped()); - EXPECT_EQ(Strand::REVERSE, withoutInserts.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, withoutInserts.AlignedStrand()); EXPECT_EQ("10=", withoutInserts.CigarData().ToStdString()); EXPECT_EQ(507, withoutInserts.QueryStart()); @@ -2554,15 +2554,16 @@ // clang-format on -constexpr char defaultSequence[] = "ACTCCACGACTCGTCACACTCACGTCTCA"; -constexpr char defaultBasemods[] = "C+m,3,1,4;"; +constexpr char DEFAULT_SEQUENCE[] = "ACTCCACGACTCGTCACACTCACGTCTCA"; +constexpr char DEFAULT_BASEMODS[] = "C+m,3,1,4;"; +constexpr char DEFAULT_BASEMODS_SPEC[] = "C+m?,3,1,4;"; const std::vector defaultBasemodsQVs = {18, 128, 234}; TEST(BAM_BamRecordClipping, clips_basemods_tags) { - const auto MakeCcsBasemodsRecord = [](const std::string& str = defaultSequence, + const auto MakeCcsBasemodsRecord = [](const std::string& str = DEFAULT_SEQUENCE, const std::string& qual = "hNfLpfSlpk59K>22LC'x*2W=*0GWv", - const std::string& basemods = defaultBasemods, + const std::string& basemods = DEFAULT_BASEMODS, const std::vector& basemodsQVs = defaultBasemodsQVs) { BamRecordImpl impl; @@ -2585,23 +2586,23 @@ { // empty clip, no CpG site - 1,4 static const char seq[] = "ATTGA"; static const char basemods[] = "C+m;"; - constexpr int32_t start = 1; - constexpr int32_t end = 4; + constexpr int32_t START = 1; + constexpr int32_t END = 4; auto bamRecord = MakeCcsBasemodsRecord(seq, "!#a%(", basemods, {}); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "TTG"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "#a%"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m;"); + EXPECT_EQ(basemodsString, "C+m?;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = - BamRecord::ClipBasemodsTag(seq, basemods, {}, start, end - start); + BamRecord::ClipBasemodsTag(seq, basemods, {}, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); @@ -2615,23 +2616,23 @@ } { // lost all basemods clip (before first CpG site) - 1,5 - constexpr int32_t start = 1; - constexpr int32_t end = 5; + constexpr int32_t START = 1; + constexpr int32_t END = 5; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CTCC"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "NfLp"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m;"); + EXPECT_EQ(basemodsString, "C+m?;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); @@ -2645,23 +2646,23 @@ } { // lost all basemods clip (between CpG sites) - 13,16 - constexpr int32_t start = 13; - constexpr int32_t end = 16; + constexpr int32_t START = 13; + constexpr int32_t END = 16; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "TCA"); EXPECT_EQ(bamRecord.Qualities().Fastq(), ">22"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m;"); + EXPECT_EQ(basemodsString, "C+m?;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{3, 1})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{18, 128})); @@ -2675,23 +2676,23 @@ } { // lost all basemods clip (past last CpG site) - 25,28 - constexpr int32_t start = 25; - constexpr int32_t end = 28; + constexpr int32_t START = 25; + constexpr int32_t END = 28; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CTC"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "0GW"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m;"); + EXPECT_EQ(basemodsString, "C+m?;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{3, 1, 4})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{18, 128, 234})); @@ -2705,23 +2706,23 @@ } { // normal clip, first CpG site, lost some leading Cs - 3,9 - constexpr int32_t start = 3; - constexpr int32_t end = 9; + constexpr int32_t START = 3; + constexpr int32_t END = 9; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CCACGA"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "LpfSlp"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,2;"); + EXPECT_EQ(basemodsString, "C+m?,2;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{18}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); @@ -2735,23 +2736,23 @@ } { // normal clip, first CpG site, lost all leading Cs - 6,10 - constexpr int32_t start = 6; - constexpr int32_t end = 10; + constexpr int32_t START = 6; + constexpr int32_t END = 10; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CGAC"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "Slpk"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,0;"); + EXPECT_EQ(basemodsString, "C+m?,0;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{18}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); @@ -2765,23 +2766,23 @@ } { // normal clip, middle CpG site - 9,18 - constexpr int32_t start = 9; - constexpr int32_t end = 18; + constexpr int32_t START = 9; + constexpr int32_t END = 18; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CTCGTCACA"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "k59K>22LC"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,1;"); + EXPECT_EQ(basemodsString, "C+m?,1;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{128}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{3})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{18})); @@ -2795,23 +2796,23 @@ } { // normal clip, last CpG site - 12,27 - constexpr int32_t start = 12; - constexpr int32_t end = 27; + constexpr int32_t START = 12; + constexpr int32_t END = 27; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "GTCACACTCACGTCT"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "K>22LC'x*2W=*0G"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,4;"); + EXPECT_EQ(basemodsString, "C+m?,4;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{234}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{3, 1})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{18, 128})); @@ -2825,23 +2826,23 @@ } { // normal clip, first two CpG sites - 4,20 - constexpr int32_t start = 4; - constexpr int32_t end = 20; + constexpr int32_t START = 4; + constexpr int32_t END = 20; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CACGACTCGTCACACT"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "pfSlpk59K>22LC'x"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,1,1;"); + EXPECT_EQ(basemodsString, "C+m?,1,1;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{18, 128}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); @@ -2855,23 +2856,54 @@ } { // normal clip, last two CpG sites - 10,26 - constexpr int32_t start = 10; - constexpr int32_t end = 26; + constexpr int32_t START = 10; + constexpr int32_t END = 26; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "TCGTCACACTCACGTC"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "59K>22LC'x*2W=*0"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,0,4;"); + EXPECT_EQ(basemodsString, "C+m?,0,4;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{128, 234}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); + + EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{3})); + EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{18})); + EXPECT_EQ(splitBasemods.PrefixLostBases, 1); + + EXPECT_EQ(splitBasemods.RetainedSeparatingC, (std::vector{0, 4})); + EXPECT_EQ(splitBasemods.RetainedQuals, (std::vector{128, 234})); + + EXPECT_EQ(splitBasemods.TrailingSeparatingC, (std::vector{})); + EXPECT_EQ(splitBasemods.TrailingQuals, (std::vector{})); + } + + { // using tag according to spec, normal clip, last two CpG sites - 10,26 + constexpr int32_t START = 10; + constexpr int32_t END = 26; + + auto bamRecord = MakeCcsBasemodsRecord(DEFAULT_SEQUENCE, "hNfLpfSlpk59K>22LC'x*2W=*0GWv", + DEFAULT_BASEMODS_SPEC, defaultBasemodsQVs); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); + EXPECT_EQ(bamRecord.Sequence(), "TCGTCACACTCACGTC"); + EXPECT_EQ(bamRecord.Qualities().Fastq(), "59K>22LC'x*2W=*0"); + + const BamRecordImpl impl = bamRecord.Impl(); + const std::string basemodsString{impl.TagValue("MM").ToString()}; + EXPECT_EQ(basemodsString, "C+m?,0,4;"); + const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; + const std::vector expectedQvs{128, 234}; + EXPECT_EQ(basemodsQVs, expectedQvs); + + const auto splitBasemods = BamRecord::ClipBasemodsTag( + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{3})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{18})); @@ -2885,23 +2917,23 @@ } { // cut into last CpG site - 1,23 - constexpr int32_t start = 1; - constexpr int32_t end = 23; + constexpr int32_t START = 1; + constexpr int32_t END = 23; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "CTCCACGACTCGTCACACTCAC"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "NfLpfSlpk59K>22LC'x*2W"); const BamRecordImpl impl = bamRecord.Impl(); const std::string basemodsString{impl.TagValue("MM").ToString()}; - EXPECT_EQ(basemodsString, "C+m,3,1,4;"); + EXPECT_EQ(basemodsString, "C+m?,3,1,4;"); const std::vector basemodsQVs{impl.TagValue("ML").ToUInt8Array()}; const std::vector expectedQvs{18, 128, 234}; EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); @@ -2915,11 +2947,11 @@ } { // no cut - 0,29 - constexpr int32_t start = 0; - constexpr int32_t end = 29; + constexpr int32_t START = 0; + constexpr int32_t END = 29; auto bamRecord = MakeCcsBasemodsRecord(); - bamRecord.Clip(ClipType::CLIP_TO_QUERY, start, end); + bamRecord.Clip(ClipType::CLIP_TO_QUERY, START, END); EXPECT_EQ(bamRecord.Sequence(), "ACTCCACGACTCGTCACACTCACGTCTCA"); EXPECT_EQ(bamRecord.Qualities().Fastq(), "hNfLpfSlpk59K>22LC'x*2W=*0GWv"); @@ -2931,7 +2963,7 @@ EXPECT_EQ(basemodsQVs, expectedQvs); const auto splitBasemods = BamRecord::ClipBasemodsTag( - defaultSequence, defaultBasemods, defaultBasemodsQVs, start, end - start); + DEFAULT_SEQUENCE, DEFAULT_BASEMODS, defaultBasemodsQVs, START, END - START); EXPECT_EQ(splitBasemods.LeadingSeparatingC, (std::vector{})); EXPECT_EQ(splitBasemods.LeadingQuals, (std::vector{})); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BamRecord.cpp pbbam-2.3.0+dfsg/tests/src/test_BamRecord.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BamRecord.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BamRecord.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -87,27 +87,27 @@ static BamRecordImpl MakeCigaredImpl(const std::string& seq, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { BamRecordImpl impl; impl.SetMapped(true).ReferenceId(0).Position(0).MapQuality(0); - impl.CigarData(Cigar::FromStdString(cigar)); + impl.CigarData(Data::Cigar::FromStdString(cigar)); impl.MateReferenceId(-1).MatePosition(-1).InsertSize(0); impl.SetSequenceAndQualities(seq, std::string(seq.size(), '*')); - impl.SetReverseStrand(strand == Strand::REVERSE); + impl.SetReverseStrand(strand == Data::Strand::REVERSE); return impl; } static BamRecord MakeCigaredRecord(const std::string& seq, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { return BamRecord{ MakeCigaredImpl(seq, cigar, strand) }; } static BamRecord MakeCigaredBaseRecord(const std::string& bases, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["dt"] = bases; @@ -122,7 +122,7 @@ static BamRecord MakeCigaredFrameRecord(const std::vector& frames, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["ip"] = frames; @@ -137,7 +137,7 @@ static BamRecord MakeCigaredQualRecord(const std::string& quals, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["dq"] = quals; @@ -156,7 +156,7 @@ const std::string& pulseCalls, const std::string& pulseBases, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["pc"] = pulseCalls; // PulseCall @@ -172,7 +172,7 @@ const std::string& pulseCalls, const std::string& pulseQuals, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["pc"] = pulseCalls; @@ -190,7 +190,7 @@ const std::string& pulseCalls, const std::vector& pulseFrames, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["pc"] = pulseCalls; @@ -207,7 +207,7 @@ const std::string& pulseCalls, const std::vector& pulseUInts, const std::string& cigar, - const Strand strand) + const Data::Strand strand) { TagCollection tags; tags["pc"] = pulseCalls; @@ -260,22 +260,22 @@ const FetchDataType& fetchData) { { // map to forward strand - const BamRecord b = makeRecord(input, cigar, Strand::FORWARD); - EXPECT_EQ(e.ForwardGenomic(), fetchData(b, Orientation::GENOMIC, false, false)); - EXPECT_EQ(e.ForwardNative(), fetchData(b, Orientation::NATIVE, false, false)); - EXPECT_EQ(e.ForwardGenomicAligned(), fetchData(b, Orientation::GENOMIC, true, false)); - EXPECT_EQ(e.ForwardNativeAligned(), fetchData(b, Orientation::NATIVE, true, false)); - EXPECT_EQ(e.ForwardGenomicAlignedClipped(), fetchData(b, Orientation::GENOMIC, true, true)); - EXPECT_EQ(e.ForwardNativeAlignedClipped(), fetchData(b, Orientation::NATIVE, true, true)); + const BamRecord b = makeRecord(input, cigar, Data::Strand::FORWARD); + EXPECT_EQ(e.ForwardGenomic(), fetchData(b, Data::Orientation::GENOMIC, false, false)); + EXPECT_EQ(e.ForwardNative(), fetchData(b, Data::Orientation::NATIVE, false, false)); + EXPECT_EQ(e.ForwardGenomicAligned(), fetchData(b, Data::Orientation::GENOMIC, true, false)); + EXPECT_EQ(e.ForwardNativeAligned(), fetchData(b, Data::Orientation::NATIVE, true, false)); + EXPECT_EQ(e.ForwardGenomicAlignedClipped(), fetchData(b, Data::Orientation::GENOMIC, true, true)); + EXPECT_EQ(e.ForwardNativeAlignedClipped(), fetchData(b, Data::Orientation::NATIVE, true, true)); } { // map to reverse strand - const BamRecord b = makeRecord(input, cigar, Strand::REVERSE); - EXPECT_EQ(e.ReverseGenomic(), fetchData(b, Orientation::GENOMIC, false, false)); - EXPECT_EQ(e.ReverseNative(), fetchData(b, Orientation::NATIVE, false, false)); - EXPECT_EQ(e.ReverseGenomicAligned(), fetchData(b, Orientation::GENOMIC, true, false)); - EXPECT_EQ(e.ReverseNativeAligned(), fetchData(b, Orientation::NATIVE, true, false)); - EXPECT_EQ(e.ReverseGenomicAlignedClipped(), fetchData(b, Orientation::GENOMIC, true, true)); - EXPECT_EQ(e.ReverseNativeAlignedClipped(), fetchData(b, Orientation::NATIVE, true, true)); + const BamRecord b = makeRecord(input, cigar, Data::Strand::REVERSE); + EXPECT_EQ(e.ReverseGenomic(), fetchData(b, Data::Orientation::GENOMIC, false, false)); + EXPECT_EQ(e.ReverseNative(), fetchData(b, Data::Orientation::NATIVE, false, false)); + EXPECT_EQ(e.ReverseGenomicAligned(), fetchData(b, Data::Orientation::GENOMIC, true, false)); + EXPECT_EQ(e.ReverseNativeAligned(), fetchData(b, Data::Orientation::NATIVE, true, false)); + EXPECT_EQ(e.ReverseGenomicAlignedClipped(), fetchData(b, Data::Orientation::GENOMIC, true, true)); + EXPECT_EQ(e.ReverseNativeAlignedClipped(), fetchData(b, Data::Orientation::NATIVE, true, true)); } } @@ -290,32 +290,32 @@ const FetchDataType& fetchData) { { // map to forward strand - const BamRecord b = makeRecord(seqBases, pulseCalls, input, cigar, Strand::FORWARD); + const BamRecord b = makeRecord(seqBases, pulseCalls, input, cigar, Data::Strand::FORWARD); - EXPECT_EQ(allPulses.ForwardGenomic(), fetchData(b, Orientation::GENOMIC, false, false, PulseBehavior::ALL)); - EXPECT_EQ(allPulses.ForwardNative(), fetchData(b, Orientation::NATIVE, false, false, PulseBehavior::ALL)); + EXPECT_EQ(allPulses.ForwardGenomic(), fetchData(b, Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL)); + EXPECT_EQ(allPulses.ForwardNative(), fetchData(b, Data::Orientation::NATIVE, false, false, PulseBehavior::ALL)); // no align/clipping operations available on ALL pulses - EXPECT_EQ(basecallsOnly.ForwardGenomic(), fetchData(b, Orientation::GENOMIC, false, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ForwardNative(), fetchData(b, Orientation::NATIVE, false, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ForwardGenomicAligned(), fetchData(b, Orientation::GENOMIC, true, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ForwardNativeAligned(), fetchData(b, Orientation::NATIVE, true, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ForwardGenomicAlignedClipped(), fetchData(b, Orientation::GENOMIC, true, true, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ForwardNativeAlignedClipped(), fetchData(b, Orientation::NATIVE, true, true, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ForwardGenomic(), fetchData(b, Data::Orientation::GENOMIC, false, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ForwardNative(), fetchData(b, Data::Orientation::NATIVE, false, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ForwardGenomicAligned(), fetchData(b, Data::Orientation::GENOMIC, true, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ForwardNativeAligned(), fetchData(b, Data::Orientation::NATIVE, true, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ForwardGenomicAlignedClipped(), fetchData(b, Data::Orientation::GENOMIC, true, true, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ForwardNativeAlignedClipped(), fetchData(b, Data::Orientation::NATIVE, true, true, PulseBehavior::BASECALLS_ONLY)); } { // map to reverse strand - const BamRecord b = makeRecord(seqBases, pulseCalls, input, cigar, Strand::REVERSE); + const BamRecord b = makeRecord(seqBases, pulseCalls, input, cigar, Data::Strand::REVERSE); - EXPECT_EQ(allPulses.ReverseGenomic(), fetchData(b, Orientation::GENOMIC, false, false, PulseBehavior::ALL)); - EXPECT_EQ(allPulses.ReverseNative(), fetchData(b, Orientation::NATIVE, false, false, PulseBehavior::ALL)); + EXPECT_EQ(allPulses.ReverseGenomic(), fetchData(b, Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL)); + EXPECT_EQ(allPulses.ReverseNative(), fetchData(b, Data::Orientation::NATIVE, false, false, PulseBehavior::ALL)); // no align/clipping operations available on ALL pulses - EXPECT_EQ(basecallsOnly.ReverseGenomic(), fetchData(b, Orientation::GENOMIC, false, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ReverseNative(), fetchData(b, Orientation::NATIVE, false, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ReverseGenomicAligned(), fetchData(b, Orientation::GENOMIC, true, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ReverseNativeAligned(), fetchData(b, Orientation::NATIVE, true, false, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ReverseGenomicAlignedClipped(), fetchData(b, Orientation::GENOMIC, true, true, PulseBehavior::BASECALLS_ONLY)); - EXPECT_EQ(basecallsOnly.ReverseNativeAlignedClipped(), fetchData(b, Orientation::NATIVE, true, true, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ReverseGenomic(), fetchData(b, Data::Orientation::GENOMIC, false, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ReverseNative(), fetchData(b, Data::Orientation::NATIVE, false, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ReverseGenomicAligned(), fetchData(b, Data::Orientation::GENOMIC, true, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ReverseNativeAligned(), fetchData(b, Data::Orientation::NATIVE, true, false, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ReverseGenomicAlignedClipped(), fetchData(b, Data::Orientation::GENOMIC, true, true, PulseBehavior::BASECALLS_ONLY)); + EXPECT_EQ(basecallsOnly.ReverseNativeAlignedClipped(), fetchData(b, Data::Orientation::NATIVE, true, true, PulseBehavior::BASECALLS_ONLY)); } } @@ -327,13 +327,13 @@ // aligned record + DeletionTag, SubstitutionTag auto makeRecord = [](const std::string& newBases, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return MakeCigaredBaseRecord(newBases, newCigar, newStrand); }; // DeletionTag CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.DeletionTag(orientation, aligned, exciseSoftClips); } @@ -342,7 +342,7 @@ // SubstitutionTag CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.SubstitutionTag(orientation, aligned, exciseSoftClips); } @@ -358,13 +358,13 @@ // aligned record + IPD, PulseWidth auto makeRecord = [](const std::vector& newFrames, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return BamRecordTests::MakeCigaredFrameRecord(newFrames, newCigar, newStrand); }; // IPD CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.IPD(orientation, aligned, exciseSoftClips).Data(); } @@ -373,7 +373,7 @@ // PulseWidth CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.PulseWidth(orientation, aligned, exciseSoftClips).Data(); } @@ -388,13 +388,13 @@ // aligned record + DeletionQV, InsertionQV, MergeQV, SubstitutionQV auto makeRecord = [](const std::string& newQuals, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return BamRecordTests::MakeCigaredQualRecord(newQuals, newCigar, newStrand); }; // DeletionQV CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.DeletionQV(orientation, aligned, exciseSoftClips).Fastq(); } @@ -403,7 +403,7 @@ // InsertionQV CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.InsertionQV(orientation, aligned, exciseSoftClips).Fastq(); } @@ -412,7 +412,7 @@ // MergeQV CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.MergeQV(orientation, aligned, exciseSoftClips).Fastq(); } @@ -421,7 +421,7 @@ // SubstitutionQV CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.SubstitutionQV(orientation, aligned, exciseSoftClips).Fastq(); } @@ -436,7 +436,7 @@ // aligned record w/ dummy SEQ & QUALs under test auto makeRecord = [](const std::string& newQuals, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { const std::string seq = std::string(newQuals.size(), 'N'); auto record = BamRecordTests::MakeCigaredRecord(seq, newCigar, newStrand); @@ -447,7 +447,7 @@ // QUAL CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.Qualities(orientation, aligned, exciseSoftClips).Fastq(); } @@ -462,13 +462,13 @@ // aligned record w/ SEQ auto makeRecord = [](const std::string& newSeq, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return BamRecordTests::MakeCigaredRecord(newSeq, newCigar, newStrand); }; // SEQ CheckAlignAndClip(cigar, input, e, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips) { return b.Sequence(orientation, aligned, exciseSoftClips); } @@ -488,13 +488,13 @@ const std::string& newPulseCalls, const std::string& newPulseBases, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return MakeCigaredPulseBaseRecord(newSeqBases, newPulseCalls, newPulseBases, newCigar, newStrand); }; // AltLabelTag CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseBases, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -503,7 +503,7 @@ // PulseCall CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseBases, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -524,13 +524,13 @@ const std::string& newPulseCalls, const std::vector& newPulseFrames, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return MakeCigaredPulseFrameRecord(newSeqBases, newPulseCalls, newPulseFrames, newCigar, newStrand); }; // PrePulseFrame CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseFrames, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -539,7 +539,7 @@ // PulseCallWidth CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseFrames, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -568,13 +568,13 @@ const std::string& newPulseCalls, const std::string& newPulseQuals, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return MakeCigaredPulseQualRecord(newSeqBases, newPulseCalls, newPulseQuals, newCigar, newStrand); }; // AltLabelQV CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseQuals, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -583,7 +583,7 @@ // LabelQV CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseQuals, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -592,7 +592,7 @@ // PulseMergeQV CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, pulseQuals, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -613,13 +613,13 @@ const std::string& newPulseCalls, const std::vector& newStartFrames, const std::string& newCigar, - const Strand newStrand) + const Data::Strand newStrand) { return MakeCigaredPulseUIntRecord(newSeqBases, newPulseCalls, newStartFrames, newCigar, newStrand); }; // StartFrame CheckPulseDataAlignAndClip(cigar, seqBases, pulseCalls, startFrames, allPulses, basecallsOnly, makeRecord, [](const BamRecord& b, - Orientation orientation, + Data::Orientation orientation, bool aligned, bool exciseSoftClips, PulseBehavior pulseBehavior) @@ -857,7 +857,7 @@ // create basic BAM with (generic) data BamRecord bam = BamRecordTests::CreateBam(); - QualityValues testQVs; + Data::QualityValues testQVs; testQVs.push_back(0); testQVs.push_back(1); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BamRecordImplVariableData.cpp pbbam-2.3.0+dfsg/tests/src/test_BamRecordImplVariableData.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BamRecordImplVariableData.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BamRecordImplVariableData.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -172,8 +172,8 @@ TEST(BAM_BamRecordImplVarData, can_set_cigar_from_cigar_object) { - Cigar cigar; - cigar.push_back(CigarOperation('=', 100)); + Data::Cigar cigar; + cigar.push_back(Data::CigarOperation('=', 100)); BamRecordImpl bam; bam.CigarData(cigar); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BamRecordMapping.cpp pbbam-2.3.0+dfsg/tests/src/test_BamRecordMapping.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BamRecordMapping.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BamRecordMapping.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -21,8 +21,8 @@ namespace BamRecordMappingTests { static -BamRecord MakeRecord(const Position qStart, - const Position qEnd, +BamRecord MakeRecord(const Data::Position qStart, + const Data::Position qEnd, const std::string& seq, const std::string& quals, const std::string& tagBases, @@ -54,8 +54,8 @@ TEST(BAM_BamRecordMapping, correctly_maps_records_using_cigar) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -80,17 +80,17 @@ BamRecord s2_rev = BamRecordMappingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); BamRecord s3_rev = BamRecordMappingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); - s1.Map(0, 100, Strand::FORWARD, s1_cigar, mapQual); - s2.Map(0, 100, Strand::FORWARD, s2_cigar, mapQual); - s3.Map(0, 100, Strand::FORWARD, s3_cigar, mapQual); - s1_rev.Map(0, 100, Strand::REVERSE, s1_cigar, mapQual); - s2_rev.Map(0, 100, Strand::REVERSE, s2_cigar, mapQual); - s3_rev.Map(0, 100, Strand::REVERSE, s3_cigar, mapQual); + s1.Map(0, 100, Data::Strand::FORWARD, s1_cigar, mapQual); + s2.Map(0, 100, Data::Strand::FORWARD, s2_cigar, mapQual); + s3.Map(0, 100, Data::Strand::FORWARD, s3_cigar, mapQual); + s1_rev.Map(0, 100, Data::Strand::REVERSE, s1_cigar, mapQual); + s2_rev.Map(0, 100, Data::Strand::REVERSE, s2_cigar, mapQual); + s3_rev.Map(0, 100, Data::Strand::REVERSE, s3_cigar, mapQual); { // s1 - FORWARD EXPECT_TRUE(s1.IsMapped()); EXPECT_EQ(0, s1.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(mapQual, s1.MapQuality()); EXPECT_EQ(qStart, s1.QueryStart()); @@ -103,7 +103,7 @@ const BamRecordView view { s1, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -122,7 +122,7 @@ EXPECT_TRUE(s1_rev.IsMapped()); EXPECT_EQ(0, s1_rev.ReferenceId()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(mapQual, s1_rev.MapQuality()); EXPECT_EQ(qStart, s1_rev.QueryStart()); @@ -136,7 +136,7 @@ const BamRecordView nativeView { s1_rev, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -153,7 +153,7 @@ const BamRecordView genomicView { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -171,7 +171,7 @@ EXPECT_TRUE(s2.IsMapped()); EXPECT_EQ(0, s2.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(mapQual, s2.MapQuality()); EXPECT_EQ(qStart, s2.QueryStart()); @@ -184,7 +184,7 @@ const BamRecordView view { s2, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -203,7 +203,7 @@ EXPECT_TRUE(s2_rev.IsMapped()); EXPECT_EQ(0, s2_rev.ReferenceId()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(mapQual, s2_rev.MapQuality()); EXPECT_EQ(qStart, s2_rev.QueryStart()); @@ -217,7 +217,7 @@ const BamRecordView nativeView { s2_rev, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -234,7 +234,7 @@ const BamRecordView genomicView { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -252,7 +252,7 @@ EXPECT_TRUE(s3.IsMapped()); EXPECT_EQ(0, s3.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(mapQual, s3.MapQuality()); EXPECT_EQ(qStart, s3.QueryStart()); @@ -265,7 +265,7 @@ const BamRecordView view { s3, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -284,7 +284,7 @@ EXPECT_TRUE(s3_rev.IsMapped()); EXPECT_EQ(0, s3_rev.ReferenceId()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(mapQual, s3_rev.MapQuality()); EXPECT_EQ(qStart, s3_rev.QueryStart()); @@ -298,7 +298,7 @@ const BamRecordView nativeView { s3_rev, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -315,7 +315,7 @@ const BamRecordView genomicView { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -332,8 +332,8 @@ TEST(BAM_BamRecordMapping, correctly_maps_records_using_cigar_with_soft_clips) { - const Position qStart = 500; - const Position qEnd = 515; + const Data::Position qStart = 500; + const Data::Position qEnd = 515; const std::string seq = "TTAACCGTTAGCAAA"; const std::string quals = "--?]?]?]?]?*+++"; const std::string tagBases = "TTAACCGTTAGCAAA"; @@ -358,18 +358,18 @@ BamRecord s2_rev = BamRecordMappingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); BamRecord s3_rev = BamRecordMappingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); - s1.Map(0, 100, Strand::FORWARD, s1_cigar, mapQual); - s2.Map(0, 100, Strand::FORWARD, s2_cigar, mapQual); - s3.Map(0, 100, Strand::FORWARD, s3_cigar, mapQual); - s1_rev.Map(0, 100, Strand::REVERSE, s1_cigar, mapQual); - s2_rev.Map(0, 100, Strand::REVERSE, s2_cigar, mapQual); - s3_rev.Map(0, 100, Strand::REVERSE, s3_cigar, mapQual); + s1.Map(0, 100, Data::Strand::FORWARD, s1_cigar, mapQual); + s2.Map(0, 100, Data::Strand::FORWARD, s2_cigar, mapQual); + s3.Map(0, 100, Data::Strand::FORWARD, s3_cigar, mapQual); + s1_rev.Map(0, 100, Data::Strand::REVERSE, s1_cigar, mapQual); + s2_rev.Map(0, 100, Data::Strand::REVERSE, s2_cigar, mapQual); + s3_rev.Map(0, 100, Data::Strand::REVERSE, s3_cigar, mapQual); { // s1 - FORWARD EXPECT_TRUE(s1.IsMapped()); EXPECT_EQ(0, s1.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, s1.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s1.AlignedStrand()); EXPECT_EQ(mapQual, s1.MapQuality()); EXPECT_EQ(qStart, s1.QueryStart()); // 500 @@ -382,7 +382,7 @@ const BamRecordView view { s1, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -401,7 +401,7 @@ EXPECT_TRUE(s1_rev.IsMapped()); EXPECT_EQ(0, s1_rev.ReferenceId()); - EXPECT_EQ(Strand::REVERSE, s1_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s1_rev.AlignedStrand()); EXPECT_EQ(mapQual, s1_rev.MapQuality()); EXPECT_EQ(qStart, s1_rev.QueryStart()); // 500 @@ -415,7 +415,7 @@ const BamRecordView nativeView { s1_rev, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -432,7 +432,7 @@ const BamRecordView genomicView { s1_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -450,7 +450,7 @@ EXPECT_TRUE(s2.IsMapped()); EXPECT_EQ(0, s2.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, s2.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s2.AlignedStrand()); EXPECT_EQ(mapQual, s2.MapQuality()); EXPECT_EQ(qStart, s2.QueryStart()); // 500 @@ -463,7 +463,7 @@ const BamRecordView view { s2, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -482,7 +482,7 @@ EXPECT_TRUE(s2_rev.IsMapped()); EXPECT_EQ(0, s2_rev.ReferenceId()); - EXPECT_EQ(Strand::REVERSE, s2_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s2_rev.AlignedStrand()); EXPECT_EQ(mapQual, s2_rev.MapQuality()); EXPECT_EQ(qStart, s2_rev.QueryStart()); // 500 @@ -496,7 +496,7 @@ const BamRecordView nativeView { s2_rev, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -513,7 +513,7 @@ const BamRecordView genomicView { s2_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -531,7 +531,7 @@ EXPECT_TRUE(s3.IsMapped()); EXPECT_EQ(0, s3.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, s3.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, s3.AlignedStrand()); EXPECT_EQ(mapQual, s3.MapQuality()); EXPECT_EQ(qStart, s3.QueryStart()); // 500 @@ -544,7 +544,7 @@ const BamRecordView view { s2, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -563,7 +563,7 @@ EXPECT_TRUE(s3_rev.IsMapped()); EXPECT_EQ(0, s3_rev.ReferenceId()); - EXPECT_EQ(Strand::REVERSE, s3_rev.AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, s3_rev.AlignedStrand()); EXPECT_EQ(mapQual, s3_rev.MapQuality()); EXPECT_EQ(qStart, s3_rev.QueryStart()); // 500 @@ -577,7 +577,7 @@ const BamRecordView nativeView { s3_rev, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -594,7 +594,7 @@ const BamRecordView genomicView { s3_rev, - Orientation::GENOMIC, + Data::Orientation::GENOMIC, false, false, PulseBehavior::ALL @@ -611,8 +611,8 @@ TEST(BAM_BamRecordMapping, can_created_mapped_copy_of_record) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -622,11 +622,11 @@ const std::string cigar = "4=1D2I2D4="; const BamRecord orig = BamRecordMappingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); - const BamRecord mapped = orig.Mapped(0, 100, Strand::FORWARD, cigar, mapQual); + const BamRecord mapped = orig.Mapped(0, 100, Data::Strand::FORWARD, cigar, mapQual); EXPECT_TRUE(mapped.IsMapped()); EXPECT_EQ(0, mapped.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, mapped.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, mapped.AlignedStrand()); EXPECT_EQ(mapQual, mapped.MapQuality()); EXPECT_EQ(500, mapped.QueryStart()); // 500 @@ -639,7 +639,7 @@ const BamRecordView view { mapped, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL @@ -656,8 +656,8 @@ TEST(BAM_BamRecordMapping, can_created_mapped_copy_of_record_static) { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -667,11 +667,11 @@ const std::string cigar = "4=1D2I2D4="; const BamRecord orig = BamRecordMappingTests::MakeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); - const BamRecord mapped = BamRecord::Mapped(orig, 0, 100, Strand::FORWARD, cigar, mapQual); + const BamRecord mapped = BamRecord::Mapped(orig, 0, 100, Data::Strand::FORWARD, cigar, mapQual); EXPECT_TRUE(mapped.IsMapped()); EXPECT_EQ(0, mapped.ReferenceId()); - EXPECT_EQ(Strand::FORWARD, mapped.AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, mapped.AlignedStrand()); EXPECT_EQ(mapQual, mapped.MapQuality()); EXPECT_EQ(500, mapped.QueryStart()); // 500 @@ -684,7 +684,7 @@ const BamRecordView view { mapped, - Orientation::NATIVE, + Data::Orientation::NATIVE, false, false, PulseBehavior::ALL diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BedReader.cpp pbbam-2.3.0+dfsg/tests/src/test_BedReader.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BedReader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BedReader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -5,7 +5,7 @@ #include -#include +#include #include "PbbamTestData.h" @@ -18,7 +18,7 @@ const std::string BedFn = PacBio::BAM::PbbamTestsConfig::Data_Dir + "/bed/test.bed"; const std::string GzipBedFn = PacBio::BAM::PbbamTestsConfig::Data_Dir + "/bed/test.bed.gz"; -const std::vector ExpectedIntervals { +const std::vector ExpectedIntervals { {"chr1", 213941196, 213942363}, {"chr1", 213942363, 213943530}, {"chr1", 213943530, 213944697}, @@ -34,7 +34,7 @@ { size_t count = 0; BedReader reader{fn}; - PacBio::BAM::GenomicInterval interval; + PacBio::Data::GenomicInterval interval; while (reader.GetNext(interval)) { EXPECT_EQ(BedReaderTests::ExpectedIntervals.at(count), interval); ++count; diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BedWriter.cpp pbbam-2.3.0+dfsg/tests/src/test_BedWriter.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BedWriter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BedWriter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -9,14 +9,15 @@ #include #include -#include #include +#include + #include "PbbamTestData.h" using BedReader = PacBio::BED::BedReader; using BedWriter = PacBio::BED::BedWriter; -using GenomicInterval = PacBio::BAM::GenomicInterval; +using GenomicInterval = PacBio::Data::GenomicInterval; using HtslibCompression = PacBio::BAM::HtslibCompression; namespace BedWriterTests { diff -Nru pbbam-2.1.0+dfsg/tests/src/test_BgzipFastqWriter.cpp pbbam-2.3.0+dfsg/tests/src/test_BgzipFastqWriter.cpp --- pbbam-2.1.0+dfsg/tests/src/test_BgzipFastqWriter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_BgzipFastqWriter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -18,9 +18,9 @@ const std::string fn{PbbamTestsConfig::GeneratedData_Dir + "/bgzf_fastq_out.fq.gz"}; const std::vector sequences{ - FastqSequence{"seq1", "ACGT", QualityValues{"zzzz"}}, - FastqSequence{"seq2", "GATTACA", QualityValues{"~~~~~~~"}}, - FastqSequence{"seq3", "CCCC", QualityValues{"$$$$"}}}; + FastqSequence{"seq1", "ACGT", Data::QualityValues{"zzzz"}}, + FastqSequence{"seq2", "GATTACA", Data::QualityValues{"~~~~~~~"}}, + FastqSequence{"seq3", "CCCC", Data::QualityValues{"$$$$"}}}; { BgzipFastqWriter writer{fn}; diff -Nru pbbam-2.1.0+dfsg/tests/src/test_Compare.cpp pbbam-2.3.0+dfsg/tests/src/test_Compare.cpp --- pbbam-2.1.0+dfsg/tests/src/test_Compare.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_Compare.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -26,8 +26,8 @@ } static -BamRecord makeRecord(const Position qStart, - const Position qEnd, +BamRecord makeRecord(const Data::Position qStart, + const Data::Position qEnd, const std::string& seq, const std::string& quals, const std::string& tagBases, @@ -58,8 +58,8 @@ static std::vector makeMappedRecords() { - const Position qStart = 500; - const Position qEnd = 510; + const Data::Position qStart = 500; + const Data::Position qEnd = 510; const std::string seq = "AACCGTTAGC"; const std::string quals = "?]?]?]?]?*"; const std::string tagBases = "AACCGTTAGC"; @@ -78,12 +78,12 @@ BamRecord s2_rev = CompareTests::makeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); BamRecord s3_rev = CompareTests::makeRecord(qStart, qEnd, seq, quals, tagBases, tagQuals, frames); - s1.Map(0, 100, Strand::FORWARD, s1_cigar, mapQual); - s2.Map(0, 100, Strand::FORWARD, s2_cigar, mapQual); - s3.Map(0, 100, Strand::FORWARD, s3_cigar, mapQual); - s1_rev.Map(0, 100, Strand::REVERSE, s1_cigar, mapQual); - s2_rev.Map(0, 100, Strand::REVERSE, s2_cigar, mapQual); - s3_rev.Map(0, 100, Strand::REVERSE, s3_cigar, mapQual); + s1.Map(0, 100, Data::Strand::FORWARD, s1_cigar, mapQual); + s2.Map(0, 100, Data::Strand::FORWARD, s2_cigar, mapQual); + s3.Map(0, 100, Data::Strand::FORWARD, s3_cigar, mapQual); + s1_rev.Map(0, 100, Data::Strand::REVERSE, s1_cigar, mapQual); + s2_rev.Map(0, 100, Data::Strand::REVERSE, s2_cigar, mapQual); + s3_rev.Map(0, 100, Data::Strand::REVERSE, s3_cigar, mapQual); return std::vector { s1, s2, s3, s1_rev, s2_rev, s3_rev }; } @@ -157,16 +157,16 @@ TEST(BAM_Compare, can_compare_bam_record_aligned_end) { BamRecord r1; - r1.Map(0, 290, Strand::FORWARD, Cigar{"10="}, 255); + r1.Map(0, 290, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); BamRecord r2; - r2.Map(0, 190, Strand::FORWARD, Cigar{"10="}, 255); + r2.Map(0, 190, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); BamRecord r3; - r3.Map(0, 290, Strand::FORWARD, Cigar{"10="}, 255); + r3.Map(0, 290, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); BamRecord r4; - r4.Map(0, 90, Strand::FORWARD, Cigar{"10="}, 255); + r4.Map(0, 90, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); auto records = std::vector{ r1, r2, r3, r4 }; std::sort(records.begin(), records.end(), Compare::AlignedEnd()); @@ -180,16 +180,16 @@ TEST(BAM_Compare, can_compare_bam_record_aligned_start) { BamRecord r1; - r1.Map(0, 300, Strand::FORWARD, Cigar{"10="}, 255); + r1.Map(0, 300, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); BamRecord r2; - r2.Map(0, 200, Strand::FORWARD, Cigar{"10="}, 255); + r2.Map(0, 200, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); BamRecord r3; - r3.Map(0, 400, Strand::FORWARD, Cigar{"10="}, 255); + r3.Map(0, 400, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); BamRecord r4; - r4.Map(0, 100, Strand::FORWARD, Cigar{"10="}, 255); + r4.Map(0, 100, Data::Strand::FORWARD, Data::Cigar{"10="}, 255); auto records = std::vector{ r1, r2, r3, r4 }; std::sort(records.begin(), records.end(), Compare::AlignedStart()); @@ -210,10 +210,10 @@ auto records = std::vector{ r1, r2, r3, r4 }; std::sort(records.begin(), records.end(), Compare::AlignedStrand()); - EXPECT_EQ(Strand::FORWARD, records.at(0).AlignedStrand()); - EXPECT_EQ(Strand::FORWARD, records.at(1).AlignedStrand()); - EXPECT_EQ(Strand::REVERSE, records.at(2).AlignedStrand()); - EXPECT_EQ(Strand::REVERSE, records.at(3).AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, records.at(0).AlignedStrand()); + EXPECT_EQ(Data::Strand::FORWARD, records.at(1).AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, records.at(2).AlignedStrand()); + EXPECT_EQ(Data::Strand::REVERSE, records.at(3).AlignedStrand()); } TEST(BAM_Compare, can_compare_bam_record_barcode_forward) @@ -317,10 +317,10 @@ TEST(BAM_Compare, can_compare_bam_record_local_context_flag) { - BamRecord r1; r1.LocalContextFlags(LocalContextFlags::BARCODE_AFTER); - BamRecord r2; r2.LocalContextFlags(LocalContextFlags::ADAPTER_AFTER); - BamRecord r3; r3.LocalContextFlags(LocalContextFlags::REVERSE_PASS); - BamRecord r4; r4.LocalContextFlags(LocalContextFlags::NO_LOCAL_CONTEXT); + BamRecord r1; r1.LocalContextFlags(Data::LocalContextFlags::BARCODE_AFTER); + BamRecord r2; r2.LocalContextFlags(Data::LocalContextFlags::ADAPTER_AFTER); + BamRecord r3; r3.LocalContextFlags(Data::LocalContextFlags::REVERSE_PASS); + BamRecord r4; r4.LocalContextFlags(Data::LocalContextFlags::NO_LOCAL_CONTEXT); auto records = std::vector{ r1, r2, r3, r4 }; std::sort(records.begin(), records.end(), Compare::LocalContextFlag()); @@ -488,10 +488,10 @@ TEST(BAM_Compare, can_compare_bam_record_query_end) { - Position q1 = 30; - Position q2 = 20; - Position q3 = 40; - Position q4 = 10; + Data::Position q1 = 30; + Data::Position q2 = 20; + Data::Position q3 = 40; + Data::Position q4 = 10; auto records = std::vector { @@ -510,10 +510,10 @@ TEST(BAM_Compare, can_compare_bam_record_query_start) { - Position q1 = 30; - Position q2 = 20; - Position q3 = 40; - Position q4 = 10; + Data::Position q1 = 30; + Data::Position q2 = 20; + Data::Position q3 = 40; + Data::Position q4 = 10; auto records = std::vector { @@ -586,10 +586,10 @@ TEST(BAM_Compare, can_compare_bam_record_read_accuracy) { - Accuracy a1 = 30; - Accuracy a2 = 20; - Accuracy a3 = 40; - Accuracy a4 = 10; + Data::Accuracy a1 = 30; + Data::Accuracy a2 = 20; + Data::Accuracy a3 = 40; + Data::Accuracy a4 = 10; auto records = std::vector { diff -Nru pbbam-2.1.0+dfsg/tests/src/test_CompositeBamReaders.cpp pbbam-2.3.0+dfsg/tests/src/test_CompositeBamReaders.cpp --- pbbam-2.1.0+dfsg/tests/src/test_CompositeBamReaders.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_CompositeBamReaders.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -23,7 +23,7 @@ BamFile{CompositeBamReaderTests::alignedBamFn}}; // setup with normal interval - GenomicInterval interval{refName, 5000, 6000}; + PacBio::Data::GenomicInterval interval{refName, 5000, 6000}; GenomicIntervalCompositeBamReader reader{interval, bamFiles}; EXPECT_EQ(4, std::distance(reader.begin(), reader.end())); @@ -58,7 +58,7 @@ TEST(BAM_GenomicIntervalCompositeBamReader, throws_on_missing_bai) { - const GenomicInterval interval{"lambda_NEB3011", 0, 100}; + const PacBio::Data::GenomicInterval interval{"lambda_NEB3011", 0, 100}; { // single file, missing BAI const std::vector bamFiles{BamFile{CompositeBamReaderTests::phi29BamFn}}; @@ -91,7 +91,7 @@ EXPECT_EQ(0, std::distance(reader.begin(), reader.end())); // pass in actual interval - GenomicInterval interval{"lambda_NEB3011", 9300, 9400}; + PacBio::Data::GenomicInterval interval{"lambda_NEB3011", 9300, 9400}; reader.Interval(interval); EXPECT_EQ(4, std::distance(reader.begin(), reader.end())); } @@ -120,7 +120,7 @@ { // all records aligned to reverse strand && pos >= 9200 const std::string queryName{"m140905_042212_sidney_c100564852550000001823085912221377_s1_X0/14743/5615_6237"}; - const Strand strand = Strand::REVERSE; + const PacBio::Data::Strand strand = PacBio::Data::Strand::REVERSE; const uint32_t minPos = 9200; const auto filter = PbiFilter::Intersection({ PbiAlignedStrandFilter{strand}, @@ -131,7 +131,7 @@ const auto count = std::count_if(reader.begin(), reader.end(), [&](const BamRecord& r) { return r.AlignedStrand() == strand && - r.ReferenceStart() >= static_cast(minPos) && + r.ReferenceStart() >= static_cast(minPos) && r.FullName() == queryName; }); EXPECT_EQ(2, count); @@ -139,7 +139,7 @@ { // all records aligned to forward strand && pos >= 9200 const std::string queryName{"m140905_042212_sidney_c100564852550000001823085912221377_s1_X0/14743/2114_2531"}; - const Strand strand = Strand::FORWARD; + const PacBio::Data::Strand strand = PacBio::Data::Strand::FORWARD; const uint32_t minPos = 9200; const auto filter = PbiFilter::Intersection({ PbiAlignedStrandFilter{strand}, @@ -150,7 +150,7 @@ const auto count = std::count_if(reader.begin(), reader.end(), [&](const BamRecord& r) { return r.AlignedStrand() == strand && - r.ReferenceStart() >= static_cast(minPos) && + r.ReferenceStart() >= static_cast(minPos) && r.FullName() == queryName; }); EXPECT_EQ(1, count); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_DataSetGenomicIntervals.cpp pbbam-2.3.0+dfsg/tests/src/test_DataSetGenomicIntervals.cpp --- pbbam-2.1.0+dfsg/tests/src/test_DataSetGenomicIntervals.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_DataSetGenomicIntervals.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -19,8 +19,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "no_filter.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 0, 20}, {"contig2", 0, 10}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 0, 20}, {"contig2", 0, 10}}; EXPECT_EQ(correct, result); } @@ -30,8 +30,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "empty.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct; EXPECT_EQ(correct, result); } @@ -42,8 +42,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "out_of_range.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct; EXPECT_EQ(correct, result); } @@ -53,8 +53,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "single_interval.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 3, 10}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 3, 10}}; EXPECT_EQ(correct, result); } @@ -64,8 +64,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "whole_contig.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 0, 20}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 0, 20}}; EXPECT_EQ(correct, result); } @@ -75,8 +75,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "contig_name_only.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 0, 20}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 0, 20}}; EXPECT_EQ(correct, result); } @@ -86,8 +86,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "single_interval_start_lte.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 3, 11}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 3, 11}}; EXPECT_EQ(correct, result); } @@ -97,8 +97,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "single_interval_end_gte.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 2, 10}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 2, 10}}; EXPECT_EQ(correct, result); } @@ -108,8 +108,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "disjoint_intervals.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 3, 7}, {"contig1", 13, 17}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 3, 7}, {"contig1", 13, 17}}; EXPECT_EQ(correct, result); } @@ -120,8 +120,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "adjacent_intervals.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 3, 17}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 3, 17}}; EXPECT_EQ(correct, result); } @@ -132,8 +132,8 @@ DataSet ds{GenomicIntervalsTests::inputDir + "two_contigs.alignmentset.xml"}; ds.Type(DataSet::ALIGNMENT); - const std::vector result = ds.GenomicIntervals(); - const std::vector correct{{"contig1", 3, 11}, {"contig2", 2, 7}}; + const std::vector result = ds.GenomicIntervals(); + const std::vector correct{{"contig1", 3, 11}, {"contig2", 2, 7}}; EXPECT_EQ(correct, result); } diff -Nru pbbam-2.1.0+dfsg/tests/src/test_DataSetQuery.cpp pbbam-2.3.0+dfsg/tests/src/test_DataSetQuery.cpp --- pbbam-2.1.0+dfsg/tests/src/test_DataSetQuery.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_DataSetQuery.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -165,7 +165,7 @@ const DataSet dataset{DataSetQueryTests::alignedBamFn}; // from BAM filename // count records - GenomicInterval interval{rname, 5000, 6000}; + Data::GenomicInterval interval{rname, 5000, 6000}; GenomicIntervalQuery query{interval, dataset}; EXPECT_EQ(2, std::distance(query.begin(), query.end())); @@ -203,7 +203,7 @@ int count = 0; int prevId = 0; int prevPos = 0; - GenomicInterval interval{rname, 5000, 6000}; + Data::GenomicInterval interval{rname, 5000, 6000}; GenomicIntervalQuery query{interval, dataset}; for (const BamRecord& record : query) { @@ -253,7 +253,7 @@ int count = 0; int prevId = 0; int prevPos = 0; - GenomicInterval interval{rname, 5000, 6000}; + Data::GenomicInterval interval{rname, 5000, 6000}; GenomicIntervalQuery query{interval, dataset}; for (const BamRecord& record : query) { diff -Nru pbbam-2.1.0+dfsg/tests/src/test_EntireFileQuery.cpp pbbam-2.3.0+dfsg/tests/src/test_EntireFileQuery.cpp --- pbbam-2.1.0+dfsg/tests/src/test_EntireFileQuery.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_EntireFileQuery.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -35,8 +35,8 @@ EntireFileQuery entireFile{bamFile}; for (const BamRecord& record : entireFile) { - const auto rawQualities = record.Qualities(Orientation::GENOMIC, false); - const auto alignedQualities = record.Qualities(Orientation::GENOMIC, true); + const auto rawQualities = record.Qualities(Data::Orientation::GENOMIC, false); + const auto alignedQualities = record.Qualities(Data::Orientation::GENOMIC, true); const std::string rawExpected{ "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII" diff -Nru pbbam-2.1.0+dfsg/tests/src/test_FastqSequence.cpp pbbam-2.3.0+dfsg/tests/src/test_FastqSequence.cpp --- pbbam-2.1.0+dfsg/tests/src/test_FastqSequence.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_FastqSequence.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -13,7 +13,7 @@ EXPECT_EQ("[[[[[[[", seq1.Qualities().Fastq()); const std::vector quals{58, 58, 58, 58, 58, 58, 58}; - const FastqSequence seq2{"1", "GATTACA", QualityValues{quals}}; + const FastqSequence seq2{"1", "GATTACA", Data::QualityValues{quals}}; EXPECT_EQ("1", seq2.Name()); EXPECT_EQ("GATTACA", seq2.Bases()); EXPECT_EQ("[[[[[[[", seq2.Qualities().Fastq()); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_GenomicIntervalQuery.cpp pbbam-2.3.0+dfsg/tests/src/test_GenomicIntervalQuery.cpp --- pbbam-2.1.0+dfsg/tests/src/test_GenomicIntervalQuery.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_GenomicIntervalQuery.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -25,7 +25,7 @@ const BamFile bamFile{GenomicIntervalQueryTests::inputBamFn}; // setup with normal interval - GenomicInterval interval{rname, 5000, 6000}; + Data::GenomicInterval interval{rname, 5000, 6000}; GenomicIntervalQuery query{interval, bamFile}; EXPECT_EQ(2, std::distance(query.begin(), query.end())); @@ -61,14 +61,14 @@ TEST(BAM_GenomicIntervalQuery, loads_expected_read_count) { const BamFile bamFile{GenomicIntervalQueryTests::inputBamFn}; - const GenomicInterval interval{"lambda_NEB3011", 8000, 10000}; + const Data::GenomicInterval interval{"lambda_NEB3011", 8000, 10000}; GenomicIntervalQuery query{interval, bamFile}; EXPECT_EQ(2, std::distance(query.begin(), query.end())); } TEST(BAM_GenomicIntervalQuery, throws_on_missing_bai) { - const GenomicInterval interval{"lambda_NEB3011", 0, 100}; + const Data::GenomicInterval interval{"lambda_NEB3011", 0, 100}; const std::string phi29Bam = PbbamTestsConfig::Data_Dir + "/phi29.bam"; const std::string hasBaiBam = PbbamTestsConfig::Data_Dir + "/aligned.bam"; @@ -103,7 +103,7 @@ EXPECT_EQ(0, std::distance(query.begin(), query.end())); // pass in actual interval - GenomicInterval interval{"lambda_NEB3011", 9300, 9400}; + Data::GenomicInterval interval{"lambda_NEB3011", 9300, 9400}; query.Interval(interval); EXPECT_EQ(2, std::distance(query.begin(), query.end())); } @@ -117,13 +117,13 @@ const DataSet ds{filenames}; const auto indexCache = MakeBaiIndexCache(ds); - auto checkInterval = [](GenomicIntervalQuery& query, const GenomicInterval& interval, + auto checkInterval = [](GenomicIntervalQuery& query, const Data::GenomicInterval& interval, const size_t expectedCount) { // update query query.Interval(interval); // checkout results - std::vector startPositions; + std::vector startPositions; for (const BamRecord& r : query) { EXPECT_EQ(interval.Name(), r.ReferenceName()); EXPECT_TRUE(r.ReferenceStart() < interval.Stop()); @@ -137,24 +137,24 @@ // reuse cache between interval updates GenomicIntervalQuery query{ds, indexCache}; { - const GenomicInterval interval{refName, 5000, 8000}; + const Data::GenomicInterval interval{refName, 5000, 8000}; const size_t expectedCount = 7; checkInterval(query, interval, expectedCount); } { - const GenomicInterval interval{refName, 0, 100}; + const Data::GenomicInterval interval{refName, 0, 100}; const size_t expectedCount = 1; checkInterval(query, interval, expectedCount); } { - const GenomicInterval interval{refName, 9300, 9400}; + const Data::GenomicInterval interval{refName, 9300, 9400}; const size_t expectedCount = 2; checkInterval(query, interval, expectedCount); } // reuse cache in independent query GenomicIntervalQuery query2{ds, indexCache}; - const GenomicInterval interval{refName, 5000, 8000}; + const Data::GenomicInterval interval{refName, 5000, 8000}; const size_t expectedCount = 7; checkInterval(query2, interval, expectedCount); } diff -Nru pbbam-2.1.0+dfsg/tests/src/test_IndexedFastaReader.cpp pbbam-2.3.0+dfsg/tests/src/test_IndexedFastaReader.cpp --- pbbam-2.1.0+dfsg/tests/src/test_IndexedFastaReader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_IndexedFastaReader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -73,7 +73,7 @@ EXPECT_EQ(1, r.NumSequences()); EXPECT_EQ(48502, r.SequenceLength("lambda_NEB3011")); - std::string seq = r.Subsequence("lambda_NEB3011:0-10"); + std::string seq = r.Subsequence("lambda_NEB3011:1-10"); EXPECT_EQ("GGGCGGCGAC", seq); std::string seq2 = r.Subsequence("lambda_NEB3011", 0, 10); @@ -99,48 +99,48 @@ auto it = bamQuery.begin(); auto record = *it++; EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::NATIVE, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true)); EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::NATIVE, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true, true)); EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true)); EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true, true)); record = *it++; EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::NATIVE, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true)); EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::NATIVE, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true, true)); EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true)); EXPECT_EQ("GGCTGCAGTGTACAGCGGTCAGGAGGCC-ATTGATGCCGGACTGGCTGAT", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true, true)); record = *it++; EXPECT_EQ( "----------------------------------------------------" "AAGTCACCAATGTGGGACGTCCGTCGATGGCAGAAGATCGCAGCACGGT-AACAGCGGCAA", - r.ReferenceSubsequence(record, Orientation::NATIVE, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true)); EXPECT_EQ("AAGTCACCAATGTGGGACGTCCGTCGATGGCAGAAGATCGCAGCACGGT-AACAGCGGCAA", - r.ReferenceSubsequence(record, Orientation::NATIVE, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true, true)); EXPECT_EQ( "----------------------------------------------------" "AAGTCACCAATGTGGGACGTCCGTCGATGGCAGAAGATCGCAGCACGGT-AACAGCGGCAA", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true)); EXPECT_EQ("AAGTCACCAATGTGGGACGTCCGTCGATGGCAGAAGATCGCAGCACGGT-AACAGCGGCAA", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true, true)); record = *it++; EXPECT_EQ( "AAGTCACCAATGTGGGACGTCCGTCGATGGCAGAAGATCGCAGCACGGT-AACAGCGGCAA-----------------------------" "-----------------------", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true)); EXPECT_EQ( "----------------------------------------------------TTGCCGCTGTT-" "ACCGTGCTGCGATCTTCTGCCATCGACGGACGTCCCACATTGGTGACTT", - r.ReferenceSubsequence(record, Orientation::NATIVE, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true)); EXPECT_EQ("AAGTCACCAATGTGGGACGTCCGTCGATGGCAGAAGATCGCAGCACGGT-AACAGCGGCAA", - r.ReferenceSubsequence(record, Orientation::GENOMIC, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::GENOMIC, true, true)); EXPECT_EQ("TTGCCGCTGTT-ACCGTGCTGCGATCTTCTGCCATCGACGGACGTCCCACATTGGTGACTT", - r.ReferenceSubsequence(record, Orientation::NATIVE, true, true)); + r.ReferenceSubsequence(record, Data::Orientation::NATIVE, true, true)); } // Come back diff -Nru pbbam-2.1.0+dfsg/tests/src/test_IndexedFastqReader.cpp pbbam-2.3.0+dfsg/tests/src/test_IndexedFastqReader.cpp --- pbbam-2.1.0+dfsg/tests/src/test_IndexedFastqReader.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_IndexedFastqReader.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -60,7 +60,7 @@ IndexedFastqReader r{FastxTests::simpleFastqFn}; { const std::string expectedSeq{"GCATGCATGC"}; - const QualityValues expectedQuals{"~}|{zyxwvu"}; + const Data::QualityValues expectedQuals{"~}|{zyxwvu"}; const auto subsequence = r.Subsequence("seq2", 0, 10); @@ -69,7 +69,7 @@ } { const std::string expectedSeq{"ATGCATGCAT"}; - const QualityValues expectedQuals{R"(`_^]\[ZYXW)"}; + const Data::QualityValues expectedQuals{R"(`_^]\[ZYXW)"}; const auto subsequence = r.Subsequence("seq6", 30, 40); @@ -83,7 +83,7 @@ IndexedFastqReader r{FastxTests::simpleFastqBgzfFn}; { const std::string expectedSeq{"GCATGCATGC"}; - const QualityValues expectedQuals{"~}|{zyxwvu"}; + const Data::QualityValues expectedQuals{"~}|{zyxwvu"}; const auto subsequence = r.Subsequence("seq2", 0, 10); @@ -92,7 +92,7 @@ } { const std::string expectedSeq{"ATGCATGCAT"}; - const QualityValues expectedQuals{R"(`_^]\[ZYXW)"}; + const Data::QualityValues expectedQuals{R"(`_^]\[ZYXW)"}; const auto subsequence = r.Subsequence("seq6", 30, 40); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_LongCigar.cpp pbbam-2.3.0+dfsg/tests/src/test_LongCigar.cpp --- pbbam-2.1.0+dfsg/tests/src/test_LongCigar.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_LongCigar.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -14,9 +14,9 @@ using BamReader = PacBio::BAM::BamReader; using BamRecord = PacBio::BAM::BamRecord; using BamWriter = PacBio::BAM::BamWriter; -using Cigar = PacBio::BAM::Cigar; -using CigarOp = PacBio::BAM::CigarOperation; -using PacBio::BAM::CigarOperationType; +using Cigar = PacBio::Data::Cigar; +using CigarOp = PacBio::Data::CigarOperation; +using PacBio::Data::CigarOperationType; using Tag = PacBio::BAM::Tag; namespace LongCigarTests { @@ -40,9 +40,9 @@ // check against v1.7 const int versionMajor = std::stoi(versionParts[0]); const int versionMinor = std::stoi(versionParts[1]); - static constexpr const int v17_major = 1; - static constexpr const int v17_minor = 7; - return std::tie(versionMajor, versionMinor) >= std::tie(v17_major, v17_minor); + constexpr int V17_MAJOR = 1; + constexpr int V17_MINOR = 7; + return std::tie(versionMajor, versionMinor) >= std::tie(V17_MAJOR, V17_MINOR); } const bool has_native_long_cigar_support = DoesHtslibSupportLongCigar(); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_PbiFilter.cpp pbbam-2.3.0+dfsg/tests/src/test_PbiFilter.cpp --- pbbam-2.1.0+dfsg/tests/src/test_PbiFilter.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_PbiFilter.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -435,26 +435,27 @@ TEST(BAM_PbiFilter, can_filter_on_aligned_strand) { { - const auto filter = PbiFilter{PbiAlignedStrandFilter{Strand::FORWARD}}; + const auto filter = PbiFilter{PbiAlignedStrandFilter{Data::Strand::FORWARD}}; PbiFilterTests::checkFilterRows(filter, std::vector{0, 2}); } { - const auto filter = PbiFilter{PbiAlignedStrandFilter{Strand::REVERSE}}; + const auto filter = PbiFilter{PbiAlignedStrandFilter{Data::Strand::REVERSE}}; PbiFilterTests::checkFilterRows(filter, std::vector{1, 3}); } { const auto filter = PbiFilter{PbiAlignedStrandFilter{ - Strand::FORWARD, Compare::NOT_EQUAL}}; // same as Strand::REVERSE + Data::Strand::FORWARD, Compare::NOT_EQUAL}}; // same as Data::Strand::REVERSE PbiFilterTests::checkFilterRows(filter, std::vector{1, 3}); } // unsupported compare types throw - EXPECT_THROW(PbiAlignedStrandFilter(Strand::FORWARD, Compare::LESS_THAN), std::runtime_error); - EXPECT_THROW(PbiAlignedStrandFilter(Strand::FORWARD, Compare::LESS_THAN_EQUAL), + EXPECT_THROW(PbiAlignedStrandFilter(Data::Strand::FORWARD, Compare::LESS_THAN), std::runtime_error); - EXPECT_THROW(PbiAlignedStrandFilter(Strand::FORWARD, Compare::GREATER_THAN), + EXPECT_THROW(PbiAlignedStrandFilter(Data::Strand::FORWARD, Compare::LESS_THAN_EQUAL), std::runtime_error); - EXPECT_THROW(PbiAlignedStrandFilter(Strand::FORWARD, Compare::GREATER_THAN_EQUAL), + EXPECT_THROW(PbiAlignedStrandFilter(Data::Strand::FORWARD, Compare::GREATER_THAN), + std::runtime_error); + EXPECT_THROW(PbiAlignedStrandFilter(Data::Strand::FORWARD, Compare::GREATER_THAN_EQUAL), std::runtime_error); } @@ -555,49 +556,50 @@ TEST(BAM_PbiFilter, can_filter_on_local_context_flags) { { // == NO_LOCAL_CONTEXT - const auto filter = PbiFilter{PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT}}; + const auto filter = + PbiFilter{PbiLocalContextFilter{Data::LocalContextFlags::NO_LOCAL_CONTEXT}}; PbiFilterTests::checkFilterRows(filter, std::vector{0}); } { // != ADAPTER_BEFORE (exact match) - const auto filter = - PbiFilter{PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_EQUAL}}; + const auto filter = PbiFilter{ + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_EQUAL}}; PbiFilterTests::checkFilterRows(filter, std::vector{0, 2, 3}); } { // contains ADAPTER_BEFORE - const auto filter = - PbiFilter{PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}}; + const auto filter = PbiFilter{ + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}}; PbiFilterTests::checkFilterRows(filter, std::vector{1, 3}); } { // does not contain ADAPTER_BEFORE const auto filter = PbiFilter{ - PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}}; + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}}; PbiFilterTests::checkFilterRows(filter, std::vector{0, 2}); } { // include both ADAPTER_BEFORE and ADAPTER_AFTER const auto filter = PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); PbiFilterTests::checkFilterRows(filter, std::vector{3}); } { // exclude both ADAPTER_BEFORE and ADAPTER_AFTER const auto filter = PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}}); PbiFilterTests::checkFilterRows(filter, std::vector{0}); } { // include everything with either ADAPTER_BEFORE or ADAPTER_AFTER const auto filter = PbiFilter::Union( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); PbiFilterTests::checkFilterRows(filter, std::vector{1, 2, 3}); } { // include everything with either ADAPTER_BEFORE or ADAPTER_AFTER, but not both const auto filter = PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL}, - PbiFilter::Union( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, - Compare::NOT_CONTAINS}})}); + {PbiLocalContextFilter{Data::LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL}, + PbiFilter::Union({PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, + Compare::NOT_CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, + Compare::NOT_CONTAINS}})}); PbiFilterTests::checkFilterRows(filter, std::vector{1, 2}); } } @@ -1098,7 +1100,7 @@ { // no adapters or barcodes const auto expectedFilter = - PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT, Compare::EQUAL}; + PbiLocalContextFilter{Data::LocalContextFlags::NO_LOCAL_CONTEXT, Compare::EQUAL}; // XML: Property property("cx", "0", "=="); @@ -1115,7 +1117,7 @@ { // any adapters or barcodes const auto expectedFilter = - PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL}; + PbiLocalContextFilter{Data::LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL}; // XML: Property property("cx", "0", "!="); @@ -1132,7 +1134,7 @@ { // contains adapter_before const auto expectedFilter = - PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}; + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}; // XML: Property property("cx", "1", "&"); @@ -1149,7 +1151,7 @@ { // contains adapter_before const auto expectedFilter = - PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}; + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}; // XML: Property property("cx", "ADAPTER_BEFORE", "&"); @@ -1166,7 +1168,7 @@ { // contains adapter_after const auto expectedFilter = - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}; + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}; // XML: Property property("cx", "2", "&"); @@ -1183,7 +1185,7 @@ { // contains adapter_before or adapter_after const auto expectedFilter = PbiLocalContextFilter{ - LocalContextFlags::ADAPTER_BEFORE | LocalContextFlags::ADAPTER_AFTER, + Data::LocalContextFlags::ADAPTER_BEFORE | Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}; // XML: @@ -1201,7 +1203,7 @@ { // contains adapter_before or adapter_after const auto expectedFilter = PbiLocalContextFilter{ - LocalContextFlags::ADAPTER_BEFORE | LocalContextFlags::ADAPTER_AFTER, + Data::LocalContextFlags::ADAPTER_BEFORE | Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}; // XML: @@ -1219,7 +1221,7 @@ { // contains adapter_before or adapter_after - no whitespace separation const auto expectedFilter = PbiLocalContextFilter{ - LocalContextFlags::ADAPTER_BEFORE | LocalContextFlags::ADAPTER_AFTER, + Data::LocalContextFlags::ADAPTER_BEFORE | Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}; // XML: @@ -1237,7 +1239,7 @@ { // contains adapter_before or adapter_after - a lot of whitespace separation const auto expectedFilter = PbiLocalContextFilter{ - LocalContextFlags::ADAPTER_BEFORE | LocalContextFlags::ADAPTER_AFTER, + Data::LocalContextFlags::ADAPTER_BEFORE | Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}; // XML: @@ -1254,14 +1256,17 @@ } { // contains adapter_before or adapter_after, but not both - const auto expectedFilter = PbiFilter::Union( - {PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}}), - PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, - Compare::NOT_CONTAINS}})}); + const auto expectedFilter = + PbiFilter::Union({PbiFilter::Intersection( + {PbiLocalContextFilter{Data::LocalContextFlags::NO_LOCAL_CONTEXT, + Compare::NOT_EQUAL}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, + Compare::NOT_CONTAINS}}), + PbiFilter::Intersection( + {PbiLocalContextFilter{Data::LocalContextFlags::NO_LOCAL_CONTEXT, + Compare::NOT_EQUAL}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, + Compare::NOT_CONTAINS}})}); // XML: // @@ -1298,8 +1303,8 @@ { // contains adapter_before or adapter_after const auto expectedFilter = PbiFilter::Union( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); // XML: // @@ -1332,8 +1337,8 @@ { // adapter_before and adapter_after const auto expectedFilter = PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::CONTAINS}}); // XML: // @@ -1354,8 +1359,8 @@ { // adapter_before, but no adapter_after const auto expectedFilter = PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}}); // XML: // @@ -1376,7 +1381,7 @@ { // contains no adapter_before const auto expectedFilter = - PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}; + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}; // XML: Property property("cx", "1", "~"); @@ -1393,8 +1398,8 @@ { // contains no adapter_before or adapter_after const auto expectedFilter = PbiFilter::Intersection( - {PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}, - PbiLocalContextFilter{LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}}); + {PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_BEFORE, Compare::NOT_CONTAINS}, + PbiLocalContextFilter{Data::LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}}); // XML: // @@ -1415,7 +1420,7 @@ { // contains no adapter_before or adapter_after const auto expectedFilter = PbiLocalContextFilter{ - LocalContextFlags::ADAPTER_BEFORE | LocalContextFlags::ADAPTER_AFTER, + Data::LocalContextFlags::ADAPTER_BEFORE | Data::LocalContextFlags::ADAPTER_AFTER, Compare::NOT_CONTAINS}; // XML: diff -Nru pbbam-2.1.0+dfsg/tests/src/test_PbiFilterQuery.cpp pbbam-2.3.0+dfsg/tests/src/test_PbiFilterQuery.cpp --- pbbam-2.1.0+dfsg/tests/src/test_PbiFilterQuery.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_PbiFilterQuery.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -29,8 +29,8 @@ // all records aligned to reverse strand && pos >= 9200 const std::string queryName{ "m140905_042212_sidney_c100564852550000001823085912221377_s1_X0/14743/5615_6237"}; - const Strand strand = Strand::REVERSE; - const Position start = 9200; + const Data::Strand strand = Data::Strand::REVERSE; + const Data::Position start = 9200; const auto filter = PbiFilter::Intersection({PbiAlignedStrandFilter{strand}, PbiReferenceStartFilter{start, Compare::GREATER_THAN_EQUAL}}); @@ -47,10 +47,10 @@ // all records aligned to forward strand && pos >= 9200 const std::string queryName{ "m140905_042212_sidney_c100564852550000001823085912221377_s1_X0/14743/2114_2531"}; - const Strand strand = Strand::FORWARD; - const Position start = 9200; + const Data::Strand strand = Data::Strand::FORWARD; + const Data::Position start = 9200; const auto filter = - PbiFilter::Intersection({PbiAlignedStrandFilter{Strand::FORWARD}, + PbiFilter::Intersection({PbiAlignedStrandFilter{Data::Strand::FORWARD}, PbiReferenceStartFilter{9200, Compare::GREATER_THAN_EQUAL}}); PbiFilterQuery query(filter, bamFile); diff -Nru pbbam-2.1.0+dfsg/tests/src/test_QualityValues.cpp pbbam-2.3.0+dfsg/tests/src/test_QualityValues.cpp --- pbbam-2.1.0+dfsg/tests/src/test_QualityValues.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_QualityValues.cpp 1970-01-01 00:00:00.000000000 +0000 @@ -1,84 +0,0 @@ -#include - -#include -#include - -#include -#include -#include - -#include - -using namespace PacBio; -using namespace PacBio::BAM; - -TEST(BAM_QualityValue, defaults_to_zero) -{ - const QualityValue value; - EXPECT_EQ(0, value); - EXPECT_EQ('!', value.Fastq()); -} - -TEST(BAM_QualityValue, can_create_from_integer) -{ - const QualityValue zero = 0; - const QualityValue thirtyThree = 33; - const QualityValue valid = 42; - const QualityValue max = 93; - const QualityValue tooHigh = 94; - const QualityValue wayTooHigh = std::numeric_limits::max(); - - EXPECT_EQ(0, zero); - EXPECT_EQ(33, thirtyThree); - EXPECT_EQ(42, valid); - EXPECT_EQ(93, max); - EXPECT_EQ(93, tooHigh); - EXPECT_EQ(93, wayTooHigh); - - EXPECT_EQ('!', zero.Fastq()); - EXPECT_EQ('B', thirtyThree.Fastq()); - EXPECT_EQ('K', valid.Fastq()); - EXPECT_EQ('~', max.Fastq()); - EXPECT_EQ('~', tooHigh.Fastq()); - EXPECT_EQ('~', wayTooHigh.Fastq()); -} - -TEST(QualityValueTest, can_create_from_fastq_character) -{ - EXPECT_EQ(0, QualityValue::FromFastq('!')); - EXPECT_EQ(33, QualityValue::FromFastq('B')); - EXPECT_EQ(42, QualityValue::FromFastq('K')); - EXPECT_EQ(93, QualityValue::FromFastq('~')); -} - -TEST(BAM_QualityValues, default_is_empty) -{ - const QualityValues qvs; - EXPECT_TRUE(qvs.empty()); - EXPECT_EQ("", qvs.Fastq()); -} - -TEST(BAM_QualityValues, can_create_from_integer_vector) -{ - const std::string fastqString{"~~~KKBB!!"}; - const std::vector values{93, 93, 93, 42, 42, 33, 33, 0, 0}; - - QualityValues qvs; - for (auto qv : values) { - qvs.push_back(qv); - } - EXPECT_EQ(fastqString, qvs.Fastq()); -} - -TEST(BAM_QualityValues, can_create_from_fastq_string) -{ - const std::string fastqString{"~~~KKBB!!"}; - const std::vector values{93, 93, 93, 42, 42, 33, 33, 0, 0}; - - const auto qvs = QualityValues::FromFastq(fastqString); - EXPECT_EQ(fastqString.size(), qvs.size()); - EXPECT_EQ(values.size(), qvs.size()); - for (size_t i = 0; i < fastqString.size(); ++i) { - EXPECT_EQ(values.at(i), qvs.at(i)); - } -} diff -Nru pbbam-2.1.0+dfsg/tests/src/test_Tags.cpp pbbam-2.3.0+dfsg/tests/src/test_Tags.cpp --- pbbam-2.1.0+dfsg/tests/src/test_Tags.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_Tags.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -809,7 +809,9 @@ ASSERT_FALSE("unreachable"); } catch (const std::exception& e) { const std::string msg = e.what(); - EXPECT_TRUE(msg.find("boost::blank") != std::string::npos); + // cannot fully qualify std::monostate due to + // inline namespaces in libc++ + EXPECT_TRUE(msg.find("monostate") != std::string::npos); } } diff -Nru pbbam-2.1.0+dfsg/tests/src/test_Validator.cpp pbbam-2.3.0+dfsg/tests/src/test_Validator.cpp --- pbbam-2.1.0+dfsg/tests/src/test_Validator.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_Validator.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -9,9 +9,10 @@ #include #include #include -#include #include +#include + #include "../src/ValidationErrors.h" using namespace PacBio; @@ -33,7 +34,7 @@ impl.ReferenceId(0); impl.SetMapped(true); impl.SetSequenceAndQualities("AATGAGGAGA"); - impl.CigarData(Cigar{"10="}); + impl.CigarData(Data::Cigar{"10="}); TagCollection tags; tags["RG"] = std::string{"db972a04"}; @@ -311,6 +312,28 @@ ASSERT_NO_THROW(Validator::Validate(validUnmappedHeader)); } +TEST(BAM_Validator, success_on_valid_revio_header) +{ + static const BamHeader validMappedHeader{ + "@HD\tVN:1.5\tSO:coordinate\tpb:3.0.7\n" + "@SQ\tSN:ecoliK12_pbi_March2013_2955000_to_2980000\tLN:25000\tM5:" + "734d5f3b2859595f4bd87a2fe6b7389b\n" + "@RG\tID:db972a04\tPL:PACBIO\tDS:READTYPE=SUBREAD;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;" + "BINDINGKIT=101-717-300;SEQUENCINGKIT=101-644-500;BASECALLERVERSION=5.0.0;FRAMERATEHZ=100." + "000000" + "\tPU:m64004_190414_193017\tPM:REVIO\n"}; + + static const BamHeader validUnmappedHeader{ + "@HD\tVN:1.5\tSO:unknown\tpb:3.0.7\n" + "@RG\tID:db972a04\tPL:PACBIO\tDS:READTYPE=SUBREAD;Ipd:CodecV1=ip;PulseWidth:CodecV1=pw;" + "BINDINGKIT=101-717-300;SEQUENCINGKIT=101-644-500;BASECALLERVERSION=5.0.0;FRAMERATEHZ=100." + "000000\t" + "PU:m64004_190414_193017\tPM:REVIO\n"}; + + ASSERT_NO_THROW(Validator::Validate(validMappedHeader)); + ASSERT_NO_THROW(Validator::Validate(validUnmappedHeader)); +} + TEST(BAM_Validator, reports_invalid_header_data) { static const BamHeader validMappedHeader{ @@ -435,14 +458,14 @@ EXPECT_FALSE(Validator::IsValid(record)); } - CheckInvalidTagLength("dq", QualityValues("@@").Fastq()); // DeletionQV - CheckInvalidTagLength("iq", QualityValues("@@").Fastq()); // InsertionQV - CheckInvalidTagLength("mq", QualityValues("@@").Fastq()); // MergeQV - CheckInvalidTagLength("sq", QualityValues("@@").Fastq()); // SubstitutionQV - CheckInvalidTagLength("dt", std::string("AA")); // DeletionTag - CheckInvalidTagLength("st", std::string("AA")); // SubstitutionTag + CheckInvalidTagLength("dq", Data::QualityValues("@@").Fastq()); // DeletionQV + CheckInvalidTagLength("iq", Data::QualityValues("@@").Fastq()); // InsertionQV + CheckInvalidTagLength("mq", Data::QualityValues("@@").Fastq()); // MergeQV + CheckInvalidTagLength("sq", Data::QualityValues("@@").Fastq()); // SubstitutionQV + CheckInvalidTagLength("dt", std::string("AA")); // DeletionTag + CheckInvalidTagLength("st", std::string("AA")); // SubstitutionTag - const Frames f{{42, 42, 42}}; + const Data::Frames f{{42, 42, 42}}; const auto& frames = f.Data(); CheckInvalidTagLength("ip", frames); // IPD diff -Nru pbbam-2.1.0+dfsg/tests/src/test_VcfFormat.cpp pbbam-2.3.0+dfsg/tests/src/test_VcfFormat.cpp --- pbbam-2.1.0+dfsg/tests/src/test_VcfFormat.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_VcfFormat.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -71,7 +71,7 @@ TEST(VCF_VcfFormat, provides_current_version) { - const std::string version = VcfFormat::CurrentVersion(); + const auto version = VcfFormat::CurrentVersion(); EXPECT_EQ("VCFv4.2", version); } diff -Nru pbbam-2.1.0+dfsg/tests/src/test_VcfVariant.cpp pbbam-2.3.0+dfsg/tests/src/test_VcfVariant.cpp --- pbbam-2.1.0+dfsg/tests/src/test_VcfVariant.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tests/src/test_VcfVariant.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -22,7 +22,7 @@ VcfVariant v; EXPECT_TRUE(v.Chrom().empty()); - EXPECT_EQ(PacBio::BAM::UnmappedPosition, v.Position()); + EXPECT_EQ(PacBio::Data::UNMAPPED_POSITION, v.Position()); EXPECT_TRUE(v.Id().empty()); EXPECT_TRUE(v.RefAllele().empty()); EXPECT_TRUE(v.AltAllele().empty()); diff -Nru pbbam-2.1.0+dfsg/tools/meson.build pbbam-2.3.0+dfsg/tools/meson.build --- pbbam-2.1.0+dfsg/tools/meson.build 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tools/meson.build 2023-01-03 21:57:00.000000000 +0000 @@ -233,8 +233,6 @@ '--xunit-file=' + join_paths(meson.project_build_root(), 'pbbam-cram-pbbamify.xml'), '--verbose'] + [ pbbamify_t], - env : [ - 'SAMTOOLS=' + pbbam_test_samtools.full_path()], timeout : 1800) endif @@ -280,6 +278,5 @@ '--verbose'] + files('../tests/src/cram/ccs-kinetics-bystrandify.t'), env : [ 'CCS_KINETICS_BYSTRANDIFY=' + pbbam_ccs_kinetics_bystrandify.full_path(), - 'SAMTOOLS=' + pbbam_test_samtools.full_path(), ]) endif diff -Nru pbbam-2.1.0+dfsg/tools/pbbamify/src/PbBamifyWorkflow.cpp pbbam-2.3.0+dfsg/tools/pbbamify/src/PbBamifyWorkflow.cpp --- pbbam-2.1.0+dfsg/tools/pbbamify/src/PbBamifyWorkflow.cpp 2022-04-19 10:25:13.000000000 +0000 +++ pbbam-2.3.0+dfsg/tools/pbbamify/src/PbBamifyWorkflow.cpp 2023-01-03 21:57:00.000000000 +0000 @@ -205,7 +205,7 @@ std::string qseq{record.Impl().Sequence()}; std::string rseq = - indexedRefReader.ReferenceSubsequence(record, BAM::Orientation::GENOMIC, false, false); + indexedRefReader.ReferenceSubsequence(record, Data::Orientation::GENOMIC, false, false); size_t qpos = 0, rpos = 0; // The rpos should be 0 because the reference portion is yanked out. for (const auto& cigar : cigarData) {