cuddl::kmer_blacklist Class Reference

Immutable canonical k-mers excluded from construction, independent of sketch size. More...

Public Member Functions
	kmer_blacklist ()=default
	kmer_blacklist (uint32_t k, std::vector< uint64_t > keys)
	Validates packed canonical words and normalizes their order and duplicates.
uint32_t	kmer_length () const noexcept
uint64_t	identity () const noexcept
uint8_t	version () const noexcept
std::vector< uint64_t > const &	keys () const noexcept

Static Public Member Functions
static Result< kmer_blacklist >	load (std::filesystem::path const &path, uint32_t k)
	Reads BBTools DDL FASTA/FASTQ, including gzip and fused records, or exact DNA lines.
static uint64_t	canonical (uint64_t word, uint32_t k) noexcept

Detailed Description

Immutable canonical k-mers excluded from construction, independent of sketch size.

Definition at line 77 of file blacklist.cuh.

Constructor & Destructor Documentation

kmer_blacklist() [1/2]

cuddl::kmer_blacklist::kmer_blacklist ( )

default

kmer_blacklist() [2/2]

cuddl::kmer_blacklist::kmer_blacklist ( uint32_t  k, std::vector< uint64_t >  keys  )

inline

Validates packed canonical words and normalizes their order and duplicates.

Definition at line 82 of file blacklist.cuh.

                                                         : k_(k), keys_(std::move(keys)) {
        if (k < 1 || k > 31 || keys_.size() > std::numeric_limits<uint32_t>::max()) {
            throw std::invalid_argument("invalid blacklist k or entry count");
        }
 
        for (auto key : keys_) {
            if ((key >> (2 * k)) != 0 || canonical(key, k) != key) {
                throw std::invalid_argument("blacklist words must be canonical packed k-mers");
            }
        }
 
        std::sort(keys_.begin(), keys_.end());
        keys_.erase(std::unique(keys_.begin(), keys_.end()), keys_.end());
 
        if (keys_.empty()) {
            k_ = 0;
            return;
        }
        // Explicit little-endian words make identity independent of host byte order.
        std::vector<uint64_t> words;
        words.reserve(keys_.size() + 3);
        words.insert(words.end(), {uint64_t{1}, k, keys_.size()});
        words.insert(words.end(), keys_.begin(), keys_.end());
 
        if constexpr (std::endian::native != std::endian::little) {
            for (auto& word : words) {
                word = cuda::std::byteswap(word);
            }
        }
 
        identity_ = detail::xxhash64(
            reinterpret_cast<uint8_t const*>(words.data()),
            words.size() * sizeof(uint64_t),
            0x435544444c424c31ULL  // CUDDLBL1
        );
 
        if (identity_ == 0) identity_ = 1;
    }

Here is the call graph for this function:

Member Function Documentation

canonical()

static uint64_t cuddl::kmer_blacklist::canonical ( uint64_t  word, uint32_t  k  )

inlinestaticnoexcept

Definition at line 189 of file blacklist.cuh.

                                                                  {
        return std::max(word, detail::reverse_complement(word, k));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

identity()

uint64_t cuddl::kmer_blacklist::identity ( ) const

inlinenoexcept

Definition at line 179 of file blacklist.cuh.

                                                     {
        return identity_;
    }

Here is the caller graph for this function:

keys()

std::vector< uint64_t > const & cuddl::kmer_blacklist::keys ( ) const

inlinenoexcept

Definition at line 185 of file blacklist.cuh.

                                                                   {
        return keys_;
    }

Here is the caller graph for this function:

kmer_length()

uint32_t cuddl::kmer_blacklist::kmer_length ( ) const

inlinenoexcept

Definition at line 176 of file blacklist.cuh.

                                                        {
        return k_;
    }

Here is the caller graph for this function:

load()

static Result< kmer_blacklist > cuddl::kmer_blacklist::load ( std::filesystem::path const &  path, uint32_t  k  )

inlinestatic

Reads BBTools DDL FASTA/FASTQ, including gzip and fused records, or exact DNA lines.

FASTX contributes every valid k-mer window; ambiguity and record boundaries reset it.

Definition at line 124 of file blacklist.cuh.

                                                        {
        if (k < 1 || k > 31) return Err(Error::invalid_argument("invalid blacklist k"));
 
        std::ifstream input(path);
        if (!input) return Err(Error::resource("cannot open blacklist: " + path.string()));
 
        input >> std::ws;
        auto const first = input.peek();
        if (first == '>' || first == '@' || first == 0x1f) {
            auto parsed = parse_fasta_file(path.string(), k, 1);
            if (!parsed) return Err(parsed.error());
            return kmer_blacklist(k, std::move(parsed->kmers));
        }
        input.clear();
        input.seekg(0);
        std::vector<uint64_t> keys;
        std::string line;
        size_t number = 0;
 
        while (std::getline(input, line)) {
            ++number;
            if (!line.empty() && line.back() == '\r') line.pop_back();
            if (line.empty()) continue;
            if (line.size() != k) {
                return Err(
                    Error::invalid_argument(
                        "invalid blacklist length at line " + std::to_string(number)
                    )
                );
            }
            uint64_t word = 0;
            for (char base : line) {
                auto const code = detail::encode_base(base);
                if (code == 0xffU) {
                    return Err(
                        Error::invalid_argument(
                            "invalid blacklist base at line " + std::to_string(number)
                        )
                    );
                }
                word = (word << 2) | code;
            }
            keys.push_back(canonical(word, k));
        }
        if (!input.eof()) return Err(Error::resource("cannot read blacklist: " + path.string()));
        return kmer_blacklist(k, std::move(keys));
    } catch (std::invalid_argument const& error) {
        return Err(Error::invalid_argument(error.what()));
    } catch (std::bad_alloc const& error) {
        return Err(Error::resource(error.what()));
    }

Here is the call graph for this function:

version()

uint8_t cuddl::kmer_blacklist::version ( ) const

inlinenoexcept

Definition at line 182 of file blacklist.cuh.

                                                   {
        return keys_.empty() ? 0U : 1U;
    }

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• blacklist.cuh