variant_filter_positional.hpp

Go to the documentation of this file.

#ifndef GENESIS_POPULATION_FILTER_VARIANT_FILTER_POSITIONAL_H_
#define GENESIS_POPULATION_FILTER_VARIANT_FILTER_POSITIONAL_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include "genesis/population/sample_counts.hpp"
#include "genesis/population/filter/variant_filter.hpp"
#include "genesis/population/function/genome_region.hpp"
#include "genesis/population/genome_locus_set.hpp"
#include "genesis/population/genome_region.hpp"
#include "genesis/population/variant.hpp"
 
#include <functional>
#include <iosfwd>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace genesis {
namespace population {
 
// =================================================================================================
//     Filter by region, excluding
// =================================================================================================
 
inline std::function<bool(Variant const&)> make_variant_filter_by_region_excluding(
    GenomeRegion const& region,
    bool complement = false
) {
    return [region, complement]( Variant const& variant ){
        return complement ^ is_covered( region, variant );
    };
}
 
inline std::function<bool(Variant const&)> make_variant_filter_by_region_excluding(
    std::shared_ptr<GenomeRegionList> regions,
    bool complement = false
) {
    if( ! regions ) {
        throw std::invalid_argument(
            "Can only used make_variant_filter_by_region_excluding() "
            "with a valid shared pointer to a GenomeRegionList."
        );
    }
    return [regions, complement]( Variant const& variant ){
        return complement ^ is_covered( *regions, variant );
    };
}
 
inline std::function<bool(Variant const&)> make_variant_filter_by_region_excluding(
    std::shared_ptr<GenomeLocusSet> loci,
    bool complement = false
) {
    if( ! loci ) {
        throw std::invalid_argument(
            "Can only used make_variant_filter_by_region_excluding() "
            "with a valid shared pointer to a GenomeLocusSet."
        );
    }
    return [loci, complement]( Variant const& variant ){
        return complement ^ is_covered( *loci, variant );
    };
}
 
// =================================================================================================
//     Filter by region, tagging
// =================================================================================================
 
inline std::function<void(Variant&)> make_variant_filter_by_region_tagging(
    GenomeRegion const& region,
    VariantFilterTag tag,
    bool complement = false
) {
    if( tag != VariantFilterTag::kMaskedPosition && tag != VariantFilterTag::kMaskedRegion ) {
        throw std::invalid_argument(
            "Can only use VariantFilterTag::kMaskedPosition or VariantFilterTag::kMaskedRegion "
            "as tags for make_variant_filter_by_region_tagging()."
        );
    }
    return [region, tag, complement]( Variant& variant )
    {
        if( ! variant.status.passing() ) {
            return;
        }
        auto const keep = complement ^ is_covered( region, variant );
        if( ! keep ) {
            variant.status.set( tag );
        }
    };
}
 
inline std::function<void(Variant&)> make_variant_filter_by_region_tagging(
    std::shared_ptr<GenomeRegionList> regions,
    VariantFilterTag tag,
    bool complement = false
) {
    if( tag != VariantFilterTag::kMaskedPosition && tag != VariantFilterTag::kMaskedRegion ) {
        throw std::invalid_argument(
            "Can only use VariantFilterTag::kMaskedPosition or VariantFilterTag::kMaskedRegion "
            "as tags for make_variant_filter_by_region_tagging()."
        );
    }
    if( ! regions ) {
        throw std::invalid_argument(
            "Can only used make_variant_filter_by_region_tagging() "
            "with a valid shared pointer to a GenomeRegionList."
        );
    }
    return [regions, tag, complement]( Variant& variant )
    {
        if( ! variant.status.passing() ) {
            return;
        }
        auto const keep = complement ^ is_covered( *regions, variant );
        if( ! keep ) {
            variant.status.set( tag );
        }
    };
}
 
inline std::function<void(Variant&)> make_variant_filter_by_region_tagging(
    std::shared_ptr<GenomeLocusSet> loci,
    VariantFilterTag tag,
    bool complement = false
) {
    if( tag != VariantFilterTag::kMaskedPosition && tag != VariantFilterTag::kMaskedRegion ) {
        throw std::invalid_argument(
            "Can only use VariantFilterTag::kMaskedPosition or VariantFilterTag::kMaskedRegion "
            "as tags for make_variant_filter_by_region_tagging()."
        );
    }
    if( ! loci ) {
        throw std::invalid_argument(
            "Can only used make_variant_filter_by_region_tagging() "
            "with a valid shared pointer to a GenomeLocusSet."
        );
    }
    return [loci, tag, complement]( Variant& variant )
    {
        if( ! variant.status.passing() ) {
            return;
        }
        auto const keep = complement ^ is_covered( *loci, variant );
        if( ! keep ) {
            variant.status.set( tag );
        }
    };
}
 
} // namespace population
} // namespace genesis
 
#endif // include guard