Function bodies 431 total

AnnotationSource class · cpp · L30-L111 (82 LOC)

include/annotation_source.hpp

class AnnotationSource {
public:
    virtual ~AnnotationSource() = default;

    /**
     * Get the source name (e.g., "dbnsfp", "spliceai", "phylop")
     */
    virtual std::string name() const = 0;

    /**
     * Get the type of source for CLI help
     * (e.g., "pathogenicity", "conservation", "splice", "regulatory")
     */
    virtual std::string type() const = 0;

    /**
     * Get a description of this source
     */
    virtual std::string description() const = 0;

    /**
     * Check if the source is initialized and ready
     */
    virtual bool is_ready() const = 0;

    /**
     * Initialize the source (lazy loading)
     * Called automatically on first use if not manually initialized
     */
    virtual void initialize() = 0;

    /**
     * Annotate a variant, adding results to the annotations map
     * @param chrom Chromosome
     * @param pos Position (1-based)
     * @param ref Reference allele
     * @param alt Alternate allele
     * @param transcript Optional t

ensure_initialized method · cpp · L105-L110 (6 LOC)

include/annotation_source.hpp

    void ensure_initialized() {
        std::lock_guard<std::recursive_mutex> lock(mutex_);
        if (!is_ready()) {
            initialize();
        }
    }

ScoreAnnotationSource class · cpp · L116-L148 (33 LOC)

include/annotation_source.hpp

class ScoreAnnotationSource : public AnnotationSource {
public:
    /**
     * Get score at a specific position
     * @return Score value or nullopt if not available
     */
    virtual std::optional<double> get_score(
        const std::string& chrom,
        int pos
    ) const = 0;

    /**
     * Get scores for a range (for indels)
     * @return Vector of scores, may contain NaN for missing values
     */
    virtual std::vector<double> get_scores(
        const std::string& chrom,
        int start,
        int end
    ) const = 0;

    /**
     * Get aggregated score for a range (mean, max, min)
     */
    enum class Aggregation { MEAN, MAX, MIN, FIRST, LAST };

    virtual std::optional<double> get_aggregated_score(
        const std::string& chrom,
        int start,
        int end,
        Aggregation method = Aggregation::MEAN
    ) const;
};

IntervalAnnotationSource class · cpp · L153-L186 (34 LOC)

include/annotation_source.hpp

class IntervalAnnotationSource : public AnnotationSource {
public:
    /**
     * Feature structure for interval-based annotations
     */
    struct Feature {
        std::string chrom;
        int start;
        int end;
        std::string type;           // Feature type (e.g., "promoter", "enhancer")
        std::string id;             // Feature ID
        char strand = '.';
        std::unordered_map<std::string, std::string> attributes;
    };

    /**
     * Query overlapping features
     */
    virtual std::vector<Feature> query(
        const std::string& chrom,
        int start,
        int end
    ) const = 0;

    /**
     * Query overlapping features of a specific type
     */
    virtual std::vector<Feature> query_by_type(
        const std::string& chrom,
        int start,
        int end,
        const std::string& feature_type
    ) const = 0;
};

VariantAnnotationSource class · cpp · L192-L208 (17 LOC)

include/annotation_source.hpp

class VariantAnnotationSource : public AnnotationSource {
public:
    /**
     * Whether to require exact allele match (REF/ALT)
     */
    virtual bool requires_allele_match() const { return true; }

    /**
     * Query annotations for a specific variant
     */
    virtual std::unordered_map<std::string, std::string> query(
        const std::string& chrom,
        int pos,
        const std::string& ref,
        const std::string& alt
    ) const = 0;
};

AnnotationSourceManager class · cpp · L213-L276 (64 LOC)

include/annotation_source.hpp

class AnnotationSourceManager {
public:
    /**
     * Register an annotation source
     */
    void add_source(std::shared_ptr<AnnotationSource> source);

    /**
     * Get all registered sources
     */
    std::vector<std::shared_ptr<AnnotationSource>> get_sources() const;

    /**
     * Get source by name
     */
    std::shared_ptr<AnnotationSource> get_source(const std::string& name) const;

    /**
     * Enable/disable a source by name
     */
    void set_enabled(const std::string& name, bool enabled);

    /**
     * Check if a source is enabled
     */
    bool is_enabled(const std::string& name) const;

    /**
     * Initialize all sources
     */
    void initialize_all();

    /**
     * Annotate a variant with all enabled sources
     */
    void annotate_all(
        const std::string& chrom,
        int pos,
        const std::string& ref,
        const std::string& alt,
        const Transcript* transcript,
        std::unordered_map<std::string, std::string>& ann

get_all_dbnsfp_fields function · cpp · L189-L197 (9 LOC)

include/dbnsfp_fields.hpp

inline std::vector<DbNSFPField> get_all_dbnsfp_fields() {
    std::vector<DbNSFPField> all_fields;
    all_fields.insert(all_fields.end(), DBNSFP_PATHOGENICITY_FIELDS.begin(), DBNSFP_PATHOGENICITY_FIELDS.end());
    all_fields.insert(all_fields.end(), DBNSFP_CONSERVATION_FIELDS.begin(), DBNSFP_CONSERVATION_FIELDS.end());
    all_fields.insert(all_fields.end(), DBNSFP_SPLICE_FIELDS.begin(), DBNSFP_SPLICE_FIELDS.end());
    all_fields.insert(all_fields.end(), DBNSFP_FREQUENCY_FIELDS.begin(), DBNSFP_FREQUENCY_FIELDS.end());
    all_fields.insert(all_fields.end(), DBNSFP_CLINICAL_FIELDS.begin(), DBNSFP_CLINICAL_FIELDS.end());
    return all_fields;
}

All rows scored by the Repobility analyzer (https://repobility.com)

get_dbnsfp_field_names function · cpp · L202-L208 (7 LOC)

include/dbnsfp_fields.hpp

inline std::set<std::string> get_dbnsfp_field_names(const std::vector<DbNSFPField>& fields) {
    std::set<std::string> names;
    for (const auto& f : fields) {
        names.insert(f.name);
    }
    return names;
}

get_dbnsfp_preset function · cpp · L213-L235 (23 LOC)

include/dbnsfp_fields.hpp

inline std::vector<DbNSFPField> get_dbnsfp_preset(const std::string& preset) {
    if (preset == "essential") {
        // Most commonly used scores
        return {
            DBNSFP_PATHOGENICITY_FIELDS[0],  // SIFT_score
            DBNSFP_PATHOGENICITY_FIELDS[4],  // Polyphen2_HDIV_score
            DBNSFP_PATHOGENICITY_FIELDS[9],  // CADD_phred
            DBNSFP_PATHOGENICITY_FIELDS[10], // REVEL_score
            DBNSFP_PATHOGENICITY_FIELDS[11], // AlphaMissense_score
        };
    } else if (preset == "pathogenicity") {
        return DBNSFP_PATHOGENICITY_FIELDS;
    } else if (preset == "conservation") {
        return DBNSFP_CONSERVATION_FIELDS;
    } else if (preset == "frequency") {
        return DBNSFP_FREQUENCY_FIELDS;
    } else if (preset == "clinical") {
        return DBNSFP_CLINICAL_FIELDS;
    } else if (preset == "splicing") {
        return DBNSFP_SPLICE_FIELDS;
    }
    return get_all_dbnsfp_fields();
}

parse_dbnsfp_fields function · cpp · L241-L279 (39 LOC)

include/dbnsfp_fields.hpp

inline std::vector<DbNSFPField> parse_dbnsfp_fields(const std::string& field_spec) {
    std::vector<DbNSFPField> result;

    if (field_spec.empty() || field_spec == "all") {
        return get_all_dbnsfp_fields();
    }

    // Check for preset names
    if (field_spec == "essential" || field_spec == "pathogenicity" ||
        field_spec == "conservation" || field_spec == "frequency" ||
        field_spec == "clinical" || field_spec == "splicing") {
        return get_dbnsfp_preset(field_spec);
    }

    // Build lookup map
    std::map<std::string, DbNSFPField> lookup;
    for (const auto& f : get_all_dbnsfp_fields()) {
        lookup[f.name] = f;
    }

    // Parse comma-separated list
    std::istringstream iss(field_spec);
    std::string field;
    while (std::getline(iss, field, ',')) {
        // Trim whitespace
        size_t start = field.find_first_not_of(" \t");
        size_t end = field.find_last_not_of(" \t");
        if (start != std::string::npos) {
            fiel

to_string method · cpp · L40-L51 (12 LOC)