maplist.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_MAPLIST_HPP__
#define SHORE_IO_MAPLIST_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/program/av_parser.hpp"
#include "shore/datatype/alignment_processing.hpp"
#include "shore/datatype/datatypes.hpp"
#include "shore/datatype/coor.hpp"
#include "shore/processing/pipeline.hpp"
#include "shore/stream/streams.hpp"
#include "shore/fmtio/text.hpp"

namespace shore {

std::ostream& operator<<(std::ostream& os,const shore::alignment& en);

class maplist_tags_parser
{
 private:

        typedef boost::function<void ()> tagfun_t;
        tagfun_t *m_tagfuns;

        std::string::const_iterator m_tagbeg;
        std::string::const_iterator m_tagend;

        template<typename Iterator>
        static size_t th(Iterator s)
        {
                return (uint32_t(s[0])&127u)|((uint32_t(s[1])&127u)<<7);//|((uint32_t(s[2])&127u)<<14);
        }

 protected:

        static const size_t MAXTAGS=128*128;

        shore::alignment::accessory *m_alignment_tags;

        maplist_tags_parser();
        ~maplist_tags_parser();

        void parse_tags(std::string::const_iterator b,std::string::const_iterator e);

        void tagfun_invalid();
        void tagfun_RGR();
        void tagfun_MPQ();
        void tagfun_ORI();
        void tagfun_NUM();
        void tagfun_NXP();
        void tagfun_OCL();
};

class basic_maplist_reader
:public maplist_tags_parser
{
 private:

        shore::alignment::InsertState m_insstate_conv[256];

        shore::basic_line_reader m_linereader;
        std::string m_linebuf;

        std::string m_indexfile;

        std::string m_readgroup_default;
        shore::alignment::InsertState m_pestate_default;

        void init();

        void parse(shore::alignment &f);

        void pe_legacy_compat(shore::alignment &f);

        void set_default_tags(shore::alignment &a);
        void guess_default_tags(const std::string &fn);

 public:

        typedef shore::alignment current_type;

        basic_maplist_reader(const std::string &fn);
        basic_maplist_reader(std::istream *const is);

        bool next(shore::alignment &a);

        const std::string& get_name() const;

        const std::string& current_line() const;
};

class maplist_reader
:public maplist_tags_parser
{
 private:

        shore::alignment::InsertState m_insstate_conv[256];

        shore::line_reader m_linereader;

        // alternating input buffers for sort verification
        shore::alignment m_ft1;
        shore::alignment m_ft2;

        bool m_hasdata;
        bool m_useft1;

        // comparator for sort verification
        shore::alignment::cmp_type m_cmp;

        std::string m_indexfile;

        std::string m_readgroup_default;
        shore::alignment::InsertState m_pestate_default;


        void parse(shore::alignment &f);

        void pe_legacy_compat(shore::alignment &f);

        void set_default_tags(shore::alignment &a);
        void guess_default_tags(const std::string &fn);

 public:

        typedef shore::alignment current_type;

        maplist_reader(const std::string& fn,shore::alignment::cmp_type c=shore::alignment::cmp_coor);

        const shore::alignment& current() const;

        bool has_data() const;

        void next();

        const std::string& filename() const;

        const std::string& current_line() const;

        void set_range(
          const shore::refseq_coor& s,const shore::refseq_coor& e,const long maxrl=0l);
};

typedef shore::source<maplist_reader> maplist_source;

class maplist_writer
{
 private:

        shore::ostreams m_out;

        maplist_writer();

 public:

        typedef shore::alignment append_type;

        maplist_writer(const std::string& fn=std::string("stdout"));
        maplist_writer(std::ostream *const out);
        void append(const shore::alignment& f);
        void append(const shore::segment &f);
        void flush();
};

typedef shore::sink<maplist_writer> maplist_sink;

} // namespace

#endif // SHORE_IO_MAPLIST_HPP__