sff.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 IO_SFF_HPP__
#define IO_SFF_HPP__

#include <iostream>
#include <string>

#include "shore/processing/pipeline.hpp"
#include "shore/datatype/datatypes.hpp"
#include "shore/stream/streams.hpp"
#include "shore/processing/monolithic_source.hpp"

namespace shore {

template<typename T>
std::istream& read_bigendian(std::istream& in,T& value)
{
        char buf;
        value=0;
        for(int n=(sizeof(T)-1)<<3;n>=0;n-=8)
        {
                in.get(buf);
                value+=static_cast<T>(static_cast<uint8_t>(buf))<<n;
        }
        return in;
}

class basic_sff_reader
{
 private:

        shore::istreams m_is;
        std::streampos m_streampos;

        sff_read::commonhead m_header;

        size_t m_nreads;

 public:

        typedef shore::sff_read current_type;
        
        static void read_commonhead(std::istream& in,shore::sff_read::commonhead*const ch);
        static void read_readhead(std::istream& in,shore::sff_read::readhead*const rh);
        static size_t read_readdata(std::istream& in,const shore::sff_read::commonhead& ch,
                                    const shore::sff_read::readhead& rh,
                                    shore::sff_read::readdata*const rd);

        static void print_commonhead(std::ostream& out,const shore::sff_read::commonhead& ch);
        static void print_readhead(std::ostream& out,const shore::sff_read::readhead& rh);
        static void print_readdata(std::ostream& out,const shore::sff_read::readdata& rd);

        basic_sff_reader(const std::string& fn);
        basic_sff_reader(std::istream*const in);

        bool next(sff_read & buf);

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

typedef shore::monolithic<basic_sff_reader,
                          sff_read,sff_read::compare_type> sff_reader;

typedef shore::source<sff_reader> sff_source;

class sff_flatten_pipe
:public shore::pipe_facade<sff_flatten_pipe,sff_read,read>,
 public buffer_chain<read>
{
 private:

        friend class shore::pipeline_core_access;

        void next();
        void append(const shore::sff_read &r);
        void flush();
};

} // namespace

#endif // IO_SFF_HPP__