VariantFileIterator.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_VARIANTFILEITERATOR_HPP_
#define CGATOOLS_VARIANTS_VARIANTFILEITERATOR_HPP_ 1


#include "cgatools/core.hpp"
#include "cgatools/util/DelimitedFile.hpp"
#include "cgatools/variants/Locus.hpp"

namespace cgatools { namespace variants {

    class VariantFileIterator : boost::noncopyable
    {
        typedef reference::CrrFile CrrFile;
    public:
        VariantFileIterator(const CrrFile& crr);
        void open(const std::string& fn);
        void close();

        bool eof() const
        {
            return eof_;
        }

        const Locus& operator*() const
        {
            return locus_;
        }

        const Locus* operator->() const
        {
            return &locus_;
        }

        VariantFileIterator& operator++()
        {
            readLocus();
            return *this;
        }

        const std::string& getFileName()
        {
            return name_;
        }

        void error(const std::string& msg) const;
        void locusCallError(const std::string& msg, const Locus& locus, const Call& call) const;
        void locusError(const std::string& msg, const Locus& locus) const;

        void setReferenceCoverValidation(bool validate)
        {
            referenceCoverValidation_ = validate;
        }

        const util::DelimitedFile::Metadata& getMetadata() const
        {
            return df_->getMetadata();
        }

        const std::vector<std::string>& getColumnHeaders() const
        {
            return df_->getColumnHeaders();
        }

        const std::vector<std::string>& getAnnotationColumnHeaders() const
        {
            return annotationColumnHeaders_;
        }

        size_t getAnnotationIndex(const std::string& name) const;

        void fillOlplFileMetadata(util::DelimitedFile::Metadata& meta) const;
        void writeOlplFileHeader(std::ostream& out) const;
    private:
        struct LocusData
        {
            uint32_t locus_;
            uint16_t ploidy_;
            reference::Range range_;
            std::string zygosity_;
            std::string varType_;
            std::string reference_;
            boost::array<std::string, 2> alleleSeq_;
            boost::array<uint32_t, 2> alleleScore_;
            boost::array<std::string, 2> hapLink_;
            std::vector<std::string> extras_;
        };

        void readPending();
        void readLocus();
        void readMultilineLocus();
        void readOlplLocus();
        void fillOlplLocus();
        void detectFileType();
        void addOlplParsers();
        void createNoCallLocus(const reference::Range& r);
        bool isPureNoCall(const LocusData& d);
        void setupXrefAnnotation();
        void fillXrefAnnotation();

        const CrrFile* crr_;
        boost::shared_ptr<std::istream> istream_;
        boost::shared_ptr<util::DelimitedFile> df_;
        std::string name_;
        Locus locus_;
        Call pendingCall_;
        LocusData pendingLocusLine_;
        bool emptyFile_;
        bool eof_;
        bool hasPending_;
        bool referenceCoverValidation_;
        boost::uint64_t headerEnd_;
        boost::uint64_t fileEnd_;

        bool oneLinePerLocus_;
        std::vector<std::string> annotationColumnHeaders_;
        size_t xRefOffset_;
    };

} } // cgatools::variants

#endif // CGATOOLS_VARIANTS_VARIANTFILEITERATOR_HPP_

---