PbiFilterTypes

#include <pbbam/PbiFilterTypes.h>

Defines the built-in PBI filters.

namespace PacBio
namespace BAM
struct PbiAlignedEndFilter
#include <pbbam/PbiFilterTypes.h>

The PbiAlignedEndFilter class provides a PbiFilter-compatible filter on aligned end.

Example: 

PbiFilterQuery query(PbiAlignedEndFilter{3000, Compare::GREATER_THAN});
for (const BamRecord& record : query) {
    assert(record.AlignedEnd() > 3000);
}

See
BamRecord::AlignedEnd

Inherits from PacBio::BAM::internal::MappedDataFilterBase< uint32_t, MappedLookupData::A_END >

Public Functions

PbiAlignedEndFilter(const uint32_t position, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on aligned end.

Parameters
  • position: value to compare on
  • cmp: compare type

struct PbiAlignedLengthFilter
#include <pbbam/PbiFilterTypes.h>

The PbiAlignedLengthFilter class provides a PbiFilter-compatible filter on aligned length.

Example: 

PbiFilterQuery query(PbiAlignedLengthFilter{1000, Compare::GREATER_THAN});
for (const BamRecord& record : query) {
    assert((record.AlignedEnd() - record.AlignedStart()) > 1000);
}

See
BamRecord::AlignedEnd, BamRecord::AlignedStart

Inherits from PacBio::BAM::internal::FilterBase< uint32_t >

Public Functions

PbiAlignedLengthFilter(const uint32_t length, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on aligned length.

Parameters
  • length: value to compare on
  • cmp: compare type

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

struct PbiAlignedStartFilter
#include <pbbam/PbiFilterTypes.h>

The PbiAlignedStartFilter class provides a PbiFilter-compatible filter on aligned start.

Example: 

PbiFilterQuery query(PbiAlignedStartFilter{3000, Compare::GREATER_THAN});
for (const BamRecord& record : query) {
    assert(record.AlignedStart() > 3000);
}

See
BamRecord::AlignedStart

Inherits from PacBio::BAM::internal::MappedDataFilterBase< uint32_t, MappedLookupData::A_START >

Public Functions

PbiAlignedStartFilter(const uint32_t position, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on aligned start.

Parameters
  • position: value to compare on
  • cmp: compare type

struct PbiAlignedStrandFilter
#include <pbbam/PbiFilterTypes.h>

The PbiAlignedStrandFilter class provides a PbiFilter-compatible filter on aligned strand.

Example: 

PbiFilterQuery query(PbiAlignedStrandFilter{Strand::FORWARD});
for (const BamRecord& record : query) {
    assert(record.AlignedStrand() == Strand::FORWARD);
}

See
BamRecord::AlignedStrand

Inherits from PacBio::BAM::internal::MappedDataFilterBase< Strand, MappedLookupData::STRAND >

Public Functions

PbiAlignedStrandFilter(const Strand strand, const Compare::Type cmp = Compare::EQUAL)

Creates a strand filter.

Parameters
  • strand: strand value to compare on
  • cmp: compare type

struct PbiBarcodeFilter
#include <pbbam/PbiFilterTypes.h>

The PbiBarcodeFilter class provides a PbiFilter-compatible filter on barcode ID.

Any record with this barcode ID (forward or reverse) will pass this filter.

Example: 

// single value
PbiFilter filter{ PbiBarcodeFilter{17} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    const auto barcodes = record.Barcodes();
    assert(barcodes.first == 17 || barcodes.second == 17);
}

// whitelist
vector<int16_t> whitelist = { 50, 100 };
PbiFilter filter{ PbiBarcodeFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    const auto barcodes = record.Barcodes();
    assert(barcodes.first == 50  || barcodes.second == 50 ||
           barcodes.first == 100 || barcodes.second == 100);
}

See
BamRecord::BarcodeForward, BamRecord::BarcodeReverse

Public Functions

PbiBarcodeFilter(const int16_t barcode, const Compare::Type cmp = Compare::EQUAL)

Creates a single-value barcode filter.

Parameters
  • barcode: barcode ID to compare on
  • cmp: compare type

PbiBarcodeFilter(const std::vector<int16_t> &whitelist)

Creates a ‘whitelisted’ barcode filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly, in either bc_forward or bc_reverse.
Parameters
  • whitelist: barcode IDs to compare on

PbiBarcodeFilter(std::vector<int16_t> &&whitelist)

Creates a ‘whitelisted’ barcode filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly, in either bc_forward or bc_reverse.
Parameters
  • whitelist: barcode IDs to compare on

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

Private Members

PbiFilter compositeFilter_
struct PbiBarcodeForwardFilter
#include <pbbam/PbiFilterTypes.h>

The PbiBarcodeForwardFilter class provides a PbiFilter-compatible filter on forward barcode ID.

Example: 

// single value
PbiFilter filter{ PbiBarcodeForwardFilter{50} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.BarcodeForward() == 50);
}

// whitelist
vector<int16_t> whitelist = { 50, 100 };
PbiFilter filter{ PbiBarcodeForwardFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.BarcodeForward() == 50 || record.BarcodeForward() == 100);
}

See
BamRecord::BarcodeForward

Inherits from PacBio::BAM::internal::BarcodeDataFilterBase< int16_t, BarcodeLookupData::BC_FORWARD >

Public Functions

PbiBarcodeForwardFilter(const int16_t bcFwdId, const Compare::Type cmp = Compare::EQUAL)

Creates a single-value forward barcode filter.

Parameters
  • bcFwdId: (forward) barcode ID to compare on
  • cmp: compare type

PbiBarcodeForwardFilter(const std::vector<int16_t> &whitelist)

Creates a ‘whitelisted’ forward barcode filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly, in bc_forward.
Parameters
  • whitelist: barcode IDs to compare on

PbiBarcodeForwardFilter(std::vector<int16_t> &&whitelist)

Creates a ‘whitelisted’ forward barcode filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly, in bc_forward.
Parameters
  • whitelist: barcode IDs to compare on

struct PbiBarcodeQualityFilter
#include <pbbam/PbiFilterTypes.h>

The PbiBarcodeQualityFilter class provides a PbiFilter-compatible filter on barcode quality.

Example: 

PbiFilter filter{ PbiBarcodeQualityFilter{42, Compare::GREATER_THAN_EQUAL} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.BarcodeQuality() >= 42);
}

See
BamRecord::BarcodeQuality

Inherits from PacBio::BAM::internal::BarcodeDataFilterBase< uint8_t, BarcodeLookupData::BC_QUALITY >

Public Functions

PbiBarcodeQualityFilter(const uint8_t bcQuality, const Compare::Type cmp = Compare::EQUAL)

Creates a single-value barcode quality filter.

Parameters
  • bcQuality: barcode quality to compare on
  • cmp: compare type

struct PbiBarcodeReverseFilter
#include <pbbam/PbiFilterTypes.h>

The PbiBarcodeReverseFilter class provides a PbiFilter-compatible filter on forward barcode ID.

Example: 

// single value
PbiFilter filter{ PbiBarcodeReverseFilter{50} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.BarcodeReverse() == 50);
}

// whitelist
vector<int16_t> whitelist = { 50, 100 };
PbiFilter filter{ PbiBarcodeReverseFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.BarcodeReverse() == 50 || record.BarcodeReverse() == 100);
}

See
BamRecord::BarcodeReverse

Inherits from PacBio::BAM::internal::BarcodeDataFilterBase< int16_t, BarcodeLookupData::BC_REVERSE >

Public Functions

PbiBarcodeReverseFilter(const int16_t bcRevId, const Compare::Type cmp = Compare::EQUAL)

Creates a single-value reverse barcode filter.

Parameters
  • bcRevId: (reverse) barcode ID to compare on
  • cmp: compare type

PbiBarcodeReverseFilter(const std::vector<int16_t> &whitelist)

Creates a ‘whitelisted’ reverse barcode filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly, in bc_reverse.
Parameters
  • whitelist: barcode IDs to compare on

PbiBarcodeReverseFilter(std::vector<int16_t> &&whitelist)

Creates a ‘whitelisted’ reverse barcode filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly, in bc_reverse.
Parameters
  • whitelist: barcode IDs to compare on

struct PbiBarcodesFilter
#include <pbbam/PbiFilterTypes.h>

The PbiBarcodesFilter class provides a PbiFilter-compatible filter on both forward & reverse barcode IDs.

A record must match both IDs to pass the filter.

Example: 

PbiFilter filter{ PbiBarcodesFilter{17, 18} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.BarcodeForward() == 17 && 
           record.BarcodeReverse() == 18);
}

See
BamRecord::Barcodes

Public Functions

PbiBarcodesFilter(const std::pair<int16_t, int16_t> barcodes, const Compare::Type cmp = Compare::EQUAL)

Creates a barcodes filter from a std::pair of IDs.

pair.first -> BarcodeForward pair.second -> BarcodeReverse

Parameters
  • barcodes: barcode IDs to compare on
  • cmp: compare type

PbiBarcodesFilter(const int16_t bcForward, const int16_t bcReverse, const Compare::Type cmp = Compare::EQUAL)

Creates a barcodes filter from forward & reverse IDs.

Parameters
  • bcForward: forward barcode ID to compare on
  • bcReverse: reverse barcode ID to compare on
  • cmp: compare type

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

Private Members

PbiFilter compositeFilter_
struct PbiIdentityFilter
#include <pbbam/PbiFilterTypes.h>

The PbiIdentityFilter class provides a PbiFilter-compatible filter on read identity (% aligned match).

Read identity is equivalent to: 1.0 - (nMM + nDel + nIns)/readLength.

Example: 

// single value
PbiFilter filter{ PbiIdentityFilter{ 0.5, Compare::GREATER_THAN_EQUAL } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    // ... at least 50% of record was aligned ...
}

Inherits from PacBio::BAM::internal::FilterBase< float >

Public Functions

PbiIdentityFilter(const float identity, const Compare::Type cmp = Compare::EQUAL)

Creates a read identity filter.

Parameters
  • identity: value to compare on
  • cmp: compare type

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

struct PbiLocalContextFilter
#include <pbbam/PbiFilterTypes.h>

The PbiLocalContextFilter class provides a PbiFilter-compatible filter on local context (adapter, barcode, etc.).

The primary Compare::Type operators intended for this filter are: Compare::EQUAL, Compare::NOT_EQUAL, Compare::CONTAINS, and Compare::NOT_CONTAINS.

Example: 


// --------------------
// has adapter_before
// --------------------

PbiFilter filter{ PbiLocalContextFilter{LocalContextFlags::ADAPTER_BEFORE, Compare::CONTAINS} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    const bool hasAdapterBefore = (record.LocalContextFlags() & LocalContextFlags::ADAPTER_BEFORE) != 0;
    assert(hasAdapterBefore);
}

// ----------------------------------
// has any adapters, barcodes, etc.
// ----------------------------------

PbiFilter filter{ PbiLocalContextFilter{LocalContextFlags::NO_LOCAL_CONTEXT, Compare::NOT_EQUAL} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    const bool hasContext = (record.LocalContextFlags() != LocalContextFlags::NO_LOCAL_CONTEXT);
    assert(hasContext);
}

Inherits from PacBio::BAM::internal::BasicDataFilterBase< LocalContextFlags, BasicLookupData::CONTEXT_FLAG >

Public Functions

PbiLocalContextFilter(const LocalContextFlags &flags, const Compare::Type cmp = Compare::EQUAL)
struct PbiMapQualityFilter
#include <pbbam/PbiFilterTypes.h>

The PbiMapQualityFilter class provides a PbiFilter-compatible filter on mapping quality.

Example: 

PbiFilter filter{ PbiMapQualityFilter{75, Compare::GREATER_THAN_EQUAL} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.MapQuality() >= 75);
}

See
BamRecord::MapQuality

Inherits from PacBio::BAM::internal::MappedDataFilterBase< uint8_t, MappedLookupData::MAP_QUALITY >

Public Functions

PbiMapQualityFilter(const uint8_t mapQual, const Compare::Type cmp = Compare::EQUAL)

Creates a map quality filter.

Parameters
  • mapQual: value to compare on
  • cmp: compare type

struct PbiMovieNameFilter
#include <pbbam/PbiFilterTypes.h>

The PbiMovieNameFilter class provides a PbiFilter-compatible filter on movie name.

Example: 

// single value
PbiFilter filter{ PbiMovieFilter{ "foo" } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.MovieName() == "foo");
}

// whitelist
vector<string> whitelist = { "foo", "bar" };
PbiFilter filter{ PbiMovieNameFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.MovieName() == "foo" || record.MovieName() == "bar");
}

See
BamRecord::MovieName

Public Functions

PbiMovieNameFilter(const std::string &movieName)

Creates a single-value movie name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match movie name, exactly.
Parameters
  • movieName: movie name to compare on

PbiMovieNameFilter(const std::vector<std::string> &whitelist)

Creates a ‘whitelisted’ movie name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: movie names to compare on

PbiMovieNameFilter(std::vector<std::string> &&whitelist)

Creates a ‘whitelisted’ movie name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: movie names to compare on

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

Private Members

PbiFilter compositeFilter_
struct PbiNumDeletedBasesFilter
#include <pbbam/PbiFilterTypes.h>

The PbiNumDeletedBasesFilter class provides a PbiFilter-compatible filter on the number of deleted bases.

Example: 

PbiFilter filter{ PbiNumDeletedBasesFilter{50, Compare::LESS_THAN} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.NumDeletedBases() < 50);
}

See
BamRecord::NumDeletedBases

Inherits from PacBio::BAM::internal::MappedDataFilterBase< size_t, MappedLookupData::N_DEL >

Public Functions

PbiNumDeletedBasesFilter(const size_t numDeletions, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on the number of deleted bases.

Parameters
  • numDeletions: value to compare on
  • cmp: compare type

struct PbiNumInsertedBasesFilter
#include <pbbam/PbiFilterTypes.h>

The PbiNumInsertededBasesFilter class provides a PbiFilter-compatible filter on the number of inserted bases.

Example: 

PbiFilter filter{ PbiNumInsertedBasesFilter{50, Compare::LESS_THAN} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.NumInsertedBases() < 50);
}

See
BamRecord::NumInsertedBases

Inherits from PacBio::BAM::internal::MappedDataFilterBase< size_t, MappedLookupData::N_INS >

Public Functions

PbiNumInsertedBasesFilter(const size_t numInsertions, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on the number of inserted bases.

Parameters
  • numInsertions: value to compare on
  • cmp: compare type

struct PbiNumMatchesFilter
#include <pbbam/PbiFilterTypes.h>

The PbiNumMatchesFilter class provides a PbiFilter-compatible filter on the number of matched bases.

Example: 

PbiFilter filter{ PbiNumMatchesFilter{2000, Compare::GREATER_THAN_EQUAL} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.NumMatches() >= 2000);
}

See
BamRecord::NumMatches

Inherits from PacBio::BAM::internal::MappedDataFilterBase< size_t, MappedLookupData::N_M >

Public Functions

PbiNumMatchesFilter(const size_t numMatchedBases, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on the number of matched bases.

Parameters
  • numMatchedBases: value to compare on
  • cmp: compare type

struct PbiNumMismatchesFilter
#include <pbbam/PbiFilterTypes.h>

The PbiNumMismatchesFilter class provides a PbiFilter-compatible filter on the number of mismatched bases.

Example: 

PbiFilter filter{ PbiNumMismatchesFilter{500, Compare::LESS_THAN} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.NumMismatches() < 500);
}

See
BamRecord::NumMismatches

Inherits from PacBio::BAM::internal::MappedDataFilterBase< size_t, MappedLookupData::N_MM >

Public Functions

PbiNumMismatchesFilter(const size_t numMismatchedBases, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on the number of mismatched bases.

Parameters
  • numMismatchedBases: value to compare on
  • cmp: compare type

struct PbiQueryEndFilter
#include <pbbam/PbiFilterTypes.h>

The PbiQueryEndFilter class provides a PbiFilter-compatible filter on query end.

Example: 

PbiFilter filter{ PbiQueryEndFilter{3000, Compare::GREATER_THAN} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.QueryEnd() > 3000);
}

See
BamRecord::QueryEnd

Inherits from PacBio::BAM::internal::BasicDataFilterBase< int32_t, BasicLookupData::Q_END >

Public Functions

PbiQueryEndFilter(const int32_t position, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on query end position.

Parameters
  • position: value to compare on
  • cmp: compare type

struct PbiQueryLengthFilter
#include <pbbam/PbiFilterTypes.h>

The PbiQueryLengthFilter class provides a PbiFilter-compatible filter on query length.

queryLength = (queryEnd - queryStart)

Example: 

PbiFilter filter{ PbiQueryLengthFilter{2000, Compare::GREATER_THAN} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert( (record.QueryEnd() - record.QueryStart()) > 2000 );
}

See
BamRecord::QueryEnd, BamRecord::QueryStart

Inherits from PacBio::BAM::internal::FilterBase< int32_t >

Public Functions

PbiQueryLengthFilter(const int32_t length, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on query length.

Parameters
  • length: value to compare on
  • cmp: compare type

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

struct PbiQueryNameFilter
#include <pbbam/PbiFilterTypes.h>

The PbiQueryNameFilter class provides a PbiFilter-compatible filter on name length.

Example: 

// single value
PbiFilter filter{ PbiQueryNameFilter{ "movie_1/42/100_200" } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.FullName() == "movie_1/42/100_200");
}

// whitelist
vector<string> whitelist = { "movie_1/42/100_200", "movie_3/24/300_500" };
PbiFilter filter{ PbiQueryNameFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.FullName() == "movie_1/42/100_200" || 
           record.FullName() == "movie_3/24/300_500");
}

See
BamRecord::FullName

Public Functions

PbiQueryNameFilter(const std::string &qname)

Creates a single-value query name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match query name, exactly.
Parameters
  • qname: query name to compare on

PbiQueryNameFilter(const std::vector<std::string> &whitelist)

Creates a ‘whitelisted’ query name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: query names to compare on

PbiQueryNameFilter(const PbiQueryNameFilter &other)
~PbiQueryNameFilter()
bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

Private Members

std::unique_ptr<PbiQueryNameFilterPrivate> d_
struct PbiQueryStartFilter
#include <pbbam/PbiFilterTypes.h>

The PbiQueryStartFilter class provides a PbiFilter-compatible filter on query start.

Example: 

PbiFilter filter{ PbiQueryStartFilter{3000, Compare::GREATER_THAN} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.QueryStart() > 3000);
}

See
BamRecord::QueryStart

Inherits from PacBio::BAM::internal::BasicDataFilterBase< int32_t, BasicLookupData::Q_START >

Public Functions

PbiQueryStartFilter(const int32_t position, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on query start position.

Parameters
  • position: value to compare on
  • cmp: compare type

struct PbiReadAccuracyFilter
#include <pbbam/PbiFilterTypes.h>

The PbiReadAccuracyFilter class provides a PbiFilter-compatible filter on read accuracy.

Example: 

PbiFilter filter{ PbiReadAccuracyFilter{0.8, Compare::GREATER_THAN_EQUAL} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadAccuracy() >= 0.8);
}

See
BamRecord::ReadAccuracy

Inherits from PacBio::BAM::internal::BasicDataFilterBase< Accuracy, BasicLookupData::READ_QUALITY >

Public Functions

PbiReadAccuracyFilter(const Accuracy accuracy, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on read accuracy.

Parameters
  • accuracy: value to compare on
  • cmp: compare type

struct PbiReadGroupFilter
#include <pbbam/PbiFilterTypes.h>

The PbiReadGroupFilter class provides a PbiFilter-compatible filter on read group.

Example: 

// -------------------------
// numeric ID
// -------------------------

// single value
PbiFilter filter{ PbiReadGroupFilter{ 2458765 } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadGroupNumericId() == 2458765);
}

// whitelist
vector<int32_t> whitelist = { 2458765, -32143 };
PbiFilter filter{ PbiReadGroupFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadGroupNumericId() == 2458765 ||
           record.ReadGroupNumericId() == -32143);
}

// -------------------------
// printable ID
// -------------------------

// single value 
PbiFilter filter{ PbiReadGroupFilter{ "12B33F00" } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadGroupId() == "12B33F00");
}

// whitelist
vector<string> whitelist = { "12B33F00", "123ABC77" };
PbiFilter filter{ PbiReadGroupFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadGroupId() == "12B33F00" ||
           record.ReadGroupId() == "123ABC77");
}


// -------------------------
// read group 
// -------------------------

BamFile file("foo.bam");
BamHeader header = file.Header();
assert(header.ReadGroups().size() > 1);

// single value 
PbiFilter filter{ PbiReadGroupFilter{ header.ReadGroups()[0] } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadGroup() == header.ReadGroups()[0]);
}

// whitelist
vector<ReadGroupInfo> whitelist = { header.ReadGroups()[0], header.ReadGroups()[1] };
PbiFilter filter{ PbiReadGroupFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReadGroup() == header.ReadGroups()[0] ||
           record.ReadGroup() == header.ReadGroups()[1]);
}

See
BamRecord::ReadGroup, BamRecord::ReadGroupId, BamRecord::ReadGroupNumericId

Inherits from PacBio::BAM::internal::BasicDataFilterBase< int32_t, BasicLookupData::RG_ID >

Public Functions

PbiReadGroupFilter(const int32_t rgId, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on read group (numeric) ID value.

See
BamRecord::ReadGroupNumericId
Parameters
  • rgId: numeric read group ID
  • cmp: compare type

PbiReadGroupFilter(const std::string rgId, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on printable read group ID value.

See
BamRecord::ReadGroupId
Parameters
  • rgId: read group ID string
  • cmp: compare type

PbiReadGroupFilter(const ReadGroupInfo &rg, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on read group (object).

See
BamRecord::ReadGroup
Parameters
  • rg: read group object
  • cmp: compare type

PbiReadGroupFilter(const std::vector<int32_t> &whitelist)

Creates a ‘whitelisted’ filter on read group numeric IDs.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: read group IDs to compare on

PbiReadGroupFilter(std::vector<int32_t> &&whitelist)

Creates a ‘whitelisted’ filter on read group numeric IDs.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: read group IDs to compare on

PbiReadGroupFilter(const std::vector<std::string> &whitelist)

Creates a ‘whitelisted’ filter on read group printable IDs.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: read group ID strings to compare on

PbiReadGroupFilter(std::vector<std::string> &&whitelist)

Creates a ‘whitelisted’ filter on read group printable IDs.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: read group ID strings to compare on

PbiReadGroupFilter(const std::vector<ReadGroupInfo> &whitelist)

Creates a ‘whitelisted’ filter using read group objects.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: read group objects to compare on

PbiReadGroupFilter(std::vector<ReadGroupInfo> &&whitelist)

Creates a ‘whitelisted’ filter using read group objects.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: read group objects to compare on

struct PbiReferenceEndFilter
#include <pbbam/PbiFilterTypes.h>

The PbiReferenceEndFilter class provides a PbiFilter-compatible filter on reference end.

Example: 

PbiFilter filter{ PbiReferenceEndFilter{ 2000 } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReferenceEnd() == 2000);
}

See
BamRecord::ReferenceEnd

Inherits from PacBio::BAM::internal::MappedDataFilterBase< uint32_t, MappedLookupData::T_END >

Public Functions

PbiReferenceEndFilter(const uint32_t tEnd, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on reference end.

Parameters
  • tEnd: value to compare on
  • cmp: compare type

struct PbiReferenceIdFilter
#include <pbbam/PbiFilterTypes.h>

The PbiReferenceIdFilter class provides a PbiFilter-compatible filter on reference ID.

Example: 

// single value
PbiFilter filter{ PbiReferenceIdFilter{ 4 } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReferenceId() == 4);
}

// whitelist
vector<int32_t> whitelist = { 0, 1 };
PbiFilter filter{ PbiReferenceIdFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReferenceId() == 0 || 
           record.ReferenceId() == 1);
}

See
BamRecord::ReferenceId

Inherits from PacBio::BAM::internal::MappedDataFilterBase< int32_t, MappedLookupData::T_ID >

Public Functions

PbiReferenceIdFilter(const int32_t tId, const Compare::Type cmp = Compare::EQUAL)

Creates a single-value reference ID filter.

Parameters
  • tId: reference ID to compare on
  • cmp: compare type

PbiReferenceIdFilter(const std::vector<int32_t> &whitelist)

Creates a ‘whitelisted’ reference ID filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: reference IDs to compare on

PbiReferenceIdFilter(std::vector<int32_t> &&whitelist)

Creates a ‘whitelisted’ reference ID filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: reference IDs to compare on

struct PbiReferenceNameFilter
#include <pbbam/PbiFilterTypes.h>

The PbiReferenceNameFilter class provides a PbiFilter-compatible filter on reference name.

Example: 

// single value
PbiFilter filter{ PbiReferenceNameFilter{ "chr1" } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReferenceName() == "chr1");
}

// whitelist
vector<string> whitelist = { "chr1", "chr5" };
PbiFilter filter{ PbiReferenceNameFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReferenceName() == "chr1" ||
           record.ReferenceName() == "chr5");
}

See
BamRecord::ReferenceName

Public Functions

PbiReferenceNameFilter(std::string rname, Compare::Type cmp = Compare::EQUAL)

Creates a single-value reference name filter.

Parameters
  • rname: reference ID to compare on
  • cmp: compare type

PbiReferenceNameFilter(const std::vector<std::string> &whitelist)

Creates a ‘whitelisted’ reference name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: reference names to compare on

PbiReferenceNameFilter(std::vector<std::string> &&whitelist)

Creates a ‘whitelisted’ reference name filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: reference names to compare on

bool Accepts(const PbiRawData &idx, const size_t row) const

Performs the actual index lookup.

Most client code should not need to use this method directly.

Private Functions

void Initialize(const PbiRawData &idx) const

Private Members

bool initialized_ = false
PbiFilter subFilter_
std::string rname_
boost::optional<std::vector<std::string>> rnameWhitelist_
Compare::Type cmp_
struct PbiReferenceStartFilter
#include <pbbam/PbiFilterTypes.h>

The PbiReferenceStartFilter class provides a PbiFilter-compatible filter on reference start.

Example: 

PbiFilter filter{ PbiReferenceStartFilter{ 2000 } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.ReferenceStart() == 2000);
}

See
BamRecord::ReferenceStart

Inherits from PacBio::BAM::internal::MappedDataFilterBase< uint32_t, MappedLookupData::T_START >

Public Functions

PbiReferenceStartFilter(const uint32_t tStart, const Compare::Type cmp = Compare::EQUAL)

Creates a filter on reference start.

Parameters
  • tStart: value to compare on
  • cmp: compare type

struct PbiZmwFilter
#include <pbbam/PbiFilterTypes.h>

The PbiZmwFilter class provides a PbiFilter-compatible filter on ZMW hole number.

Example: 

// single value
PbiFilter filter{ PbiZmwFilter{ 4000 } };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.HoleNumber() == 4000);
}

// whitelist
vector<int32_t> whitelist = { 4000, 8000 };
PbiFilter filter{ PbiZmwFilter{whitelist} };
PbiFilterQuery query(filter);
for (const BamRecord& record : query) {
    assert(record.HoleNumber() == 4000 || 
           record.HoleNumber() == 8000);
}

See
BamRecord::HoleNumber

Inherits from PacBio::BAM::internal::BasicDataFilterBase< int32_t, BasicLookupData::ZMW >

Public Functions

PbiZmwFilter(const int32_t zmw, const Compare::Type cmp = Compare::EQUAL)

Creates a single-value ZMW hole number filter.

Parameters
  • zmw: value to compare on
  • cmp: compare type

PbiZmwFilter(const std::vector<int32_t> &whitelist)

Creates a ‘whitelisted’ ZMW hole number filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: ZMW hole numbers to compare on

PbiZmwFilter(std::vector<int32_t> &&whitelist)

Creates a ‘whitelisted’ ZMW hole number filter.

Note
There is no compare type parameter here, it is always Compare::EQUAL. Records will match at least one value from the whitelist, exactly.
Parameters
  • whitelist: ZMW hole numbers to compare on