alignment.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_IO_ALIGNMENT_HPP__
#define SHORE_IO_ALIGNMENT_HPP__

#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <boost/function.hpp>

#include "shore/datatype/alignment_string_ops.hpp"
#include "shore/datatype/alignment_processing.hpp"
#include "shore/program/av_parser.hpp"
#include "shore/datatype/datatypes.hpp"
#include "shore/datatype/coor.hpp"
#include "shore/base/memops.hpp"
#include "shore/processing/pipeline.hpp"
#include "shore/stream/streams.hpp"
#include "shore/fmtio/text.hpp"
#include "shore/fmtio/sam.hpp"
#include "shore/fmtio/read.hpp"

namespace shore {


class alignment_reader
{
 public:

        typedef shore::alignment current_type;

        struct config
        {
                shore::alignment_filter_pipe::config filters;

                int seek_maxreadlen;

                sam_base::config sam;

                config();

                void publish_options(shore::av_parser& p,
                                     const char*const D="strand,T",
                                     const char*const F="duplicate-estimation,F",
                                     const char*const N="read-lengths,N",
                                     const char*const X="p3fix,X",
                                     const char*const B="duplicates,B",
                                     const char*const A="assume-length",
                                     const char*const R="region,R",
                                     const char*const M="mm-range,M",
                                     const char*const H="hits-range,H",
                                     const char*const samref="sam-refseq",
                                     const char*const pe="peflags",
                                     const char*const jh="join-happy,Y",
                                     const char*const ju="join-unique,U");

                void sanity_check(shore::av_parser& p);

                void setup();
        };

        enum Sorting
        {
                SORTING_POS,
                SORTING_ID,
                SORTING_NONE
        };

        typedef shore::alignment::cmp_type cmp_type;

 private:

        cmp_type m_cmp;

        config m_conf;
        static const config m_defaults;

        shore::source<shore::merge<shore::alignment,cmp_type> > *m_merge;
        shore::alignment_filter_pipe m_filter;
        shore::extractor<shore::alignment> m_scoff;
        shore::ptrkeeper m_cleaner;
        bool m_outofrange;

        shore::thru<shore::read> m_leftovers;

        void init(const std::string& fn);
        void init(const std::vector<std::string>& fn);

 public:

        alignment_reader(const std::string& fn,
                         const config& c=config(),const Sorting s=SORTING_POS);

        alignment_reader(const std::vector<std::string>& fn,
                         const config& c=config(),const Sorting s=SORTING_POS);

        alignment_reader(const std::string& fn,
                         const Sorting s);

        alignment_reader(const std::vector<std::string>& fn,
                         const Sorting s);

        const shore::alignment& current() const;

        bool has_data();

        void next();

        int current_fileid() const;

        shore::thru<shore::read> &leftovers();
        shore::thru<shore::alignment> &filtered();
};

typedef shore::source<alignment_reader> alignment_source;

} // namespace

#endif // SHORE_IO_ALIGNMENT_HPP__