Locus.hpp

Go to the documentation of this file.

// Copyright 2010 Complete Genomics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you
// may not use this file except in compliance with the License. You
// may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.

#ifndef CGATOOLS_VARIANTS_LOCUS_HPP_
#define CGATOOLS_VARIANTS_LOCUS_HPP_ 1


#include "cgatools/core.hpp"
#include "cgatools/variants/Call.hpp"
#include "cgatools/variants/Allele.hpp"
#include "cgatools/reference/CrrFile.hpp"
#include "cgatools/cgdata/EvidenceReader.hpp"

#include <map>

namespace cgatools { namespace variants {

    class LocusAnnotations
    {
    public:
        LocusAnnotations()
        {
        }

        LocusAnnotations(
            const std::vector<std::string>& annotationColumnHeaders,
            bool xRefIsAlleleSpecificInit);

        size_t count() const
        {
            return names_.size();
        }

        size_t getIndex(const std::string& name) const
        {
            for(size_t ii=0; ii<names_.size(); ii++)
            {
                if (names_[ii] == name)
                    return ii;
            }
            return names_.size();
        }

        size_t getSwapOrder(size_t idx) const
        {
            return swapOrder_[idx];
        }

        const std::string& emptyString() const
        {
            return emptyString_;
        }

        bool xRefIsAlleleSpecific() const
        {
            return xRefIsAlleleSpecific_;
        }

    private:
        std::vector< std::string > names_;
        std::vector< size_t > swapOrder_;
        std::string emptyString_;
        bool xRefIsAlleleSpecific_;
    };

    class Locus
    {
        typedef reference::CrrFile CrrFile;
        typedef reference::Location Location;
        typedef reference::Range Range;
    public:
        Locus()
            : crr_(0),
              ann_(new LocusAnnotations())
        {
        }

        Locus(const CrrFile& crr)
            : crr_(&crr),
              ann_(new LocusAnnotations())
        {
        }

        Locus(const Locus& other);

        Locus& operator=(const Locus& other);

        const std::vector<Call>& getCalls() const
        {
            return calls_;
        }

        std::vector<Call>& getCalls()
        {
            return calls_;
        }

        const std::vector<Allele>& getAlleles() const
        {
            return alleles_;
        }

        const Range& getRange() const
        {
            return range_;
        }

        void setRange(const Range& range);

        const CrrFile& getReference() const
        {
            return *crr_;
        }

        boost::uint32_t getId() const;

        void setId(boost::uint32_t locusId);

        boost::uint16_t getPloidy() const;

        void setHapLink(size_t alleleOffset, const std::string& hapLink);

        bool isRefCallLocus() const;

        bool isNoCallLocus() const;

        bool isRefConsistent() const;

        bool hasNoCalls() const;

        void computeReadCounts(int32_t* allele1ReadCount,
                               int32_t* allele2ReadCount,
                               int32_t* referenceAlleleReadCount,
                               int32_t* totalReadCount,
                               cgdata::EvidenceReader& evidence) const;

        void clearCalls();

        void addCall(const Call& call);

        void initFromCalls(bool relaxedReferenceValidation = true);

        void locationCalls(const Location& loc, std::vector< std::pair<char, const Call*> >& calls) const;

        std::string getType() const;

        void setType(const std::string& olplType);

        std::string getZygosity() const;

        void reorderAlleles();

        void writeAsOneLine(std::ostream& out, bool writeExtras = true, char sep = '\t') const;

        bool hasAnnotation(const std::string& name) const;

        const std::string& getAnnotation(const std::string& name) const;

        std::string getAllXRef() const;

        bool xRefIsAlleleSpecific() const;

        void setLocusAnnotations(const LocusAnnotations& ann);

        static void writeOneLineFileHeader(
            std::ostream& out, bool alleleSpecificXRef, char sep = '\t');
    private:
        void validateCalls(bool relaxedReferenceValidation) const;
        void validateAllelesAndInitRange();
        void callError (const std::string&, const Call&) const;
        void locusError(const std::string&) const;

        Range range_;
        const CrrFile* crr_;
        std::vector<Call> calls_;
        std::vector<Allele> alleles_;
        std::string olplType_; // varType, from olpl file
        boost::shared_ptr< LocusAnnotations > ann_;

        // For each interval allele, true if it's compatible to the object
        // of interest (variant allele or reference, depending on the context).
        typedef boost::array<bool, 4> EvidenceMatchMap;

        // For each locus allele, true if the allele is compatible to the
        // interval allele 0, 1 and 2. For alleles with no-calls, false in
        // all three slots.
        typedef std::vector< EvidenceMatchMap > AlleleMatchMap;

        // Returns true if the read count should be printed for the specified allele
        bool hasCount(const AlleleMatchMap& m, size_t alleleIdx) const;

        // Returns 1 or 0 depending on whether dnb strongly supports the interval alleles
        // marked as "true" in the match map over the alleles marked as "false".
        size_t countSupport(
            const cgdata::EvidenceReader::DnbRecord& dnb, const EvidenceMatchMap& mm) const;

        // For each allele in the locus, find the compatible alleles in the
        // evidence file interval
        void matchAlleles(const cgdata::EvidenceReader::IntervalRecord& interval,
                          bool& hasLengthChange,
                          AlleleMatchMap& m,
                          EvidenceMatchMap& rm) const;

        bool hasFullyCalledNonReferenceAllele() const;

    public:
        std::vector<std::string> extras_;
    };

    std::ostream& operator<<(std::ostream& out, const Locus& locus);

} } // cgatools::variants

#endif // CGATOOLS_VARIANTS_LOCUS_HPP_

---