src/mapparser.h

#ifndef express_mapparser_h
#define express_mapparser_h

#include <api/BamReader.h>
#include <api/BamWriter.h>
#include <boost/scoped_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/unordered_map.hpp>
#include <string>
#include <vector>

#include <iostream>

class Fragment;
class TargetTable;
class FragHit;
struct ParseThreadSafety;
struct ReadHit;
struct Library;

typedef boost::unordered_map<std::string, size_t> TransIndex;

class Parser {
 protected:
  TransIndex _targ_index;
  TransIndex _targ_lengths;
  ReadHit* _read_buff;

 public:
  virtual ~Parser(){};
  virtual const std::string header() const=0;
  const TransIndex& targ_index() const { return _targ_index; }
  const TransIndex& targ_lengths() const { return _targ_lengths; }
  virtual bool next_fragment(Fragment& f)=0;
  virtual void reset() = 0;
};

class Writer {
 protected:
  bool _sample;

 public:
  virtual ~Writer(){}
  virtual void write_fragment(Fragment& f)=0;
};

class BAMParser : public Parser {
  boost::scoped_ptr<BamTools::BamReader> _reader;
  bool map_end_from_alignment(BamTools::BamAlignment& alignment);

 public:
  BAMParser(BamTools::BamReader* reader);
  const std::string header() const { return _reader->GetHeaderText(); }
  bool next_fragment(Fragment& f);
  void reset();
};

class SAMParser : public Parser
{
  std::istream* _in;
  std::string _header;
  bool map_end_from_line(char* line);

public:
  SAMParser(std::istream* in);
  const std::string header() const { return _header; }
  bool next_fragment(Fragment& f);
  void reset();
};

class BAMWriter : public Writer {
  boost::scoped_ptr<BamTools::BamWriter> _writer;

 public:
  BAMWriter(BamTools::BamWriter* writer, bool sample);
  ~BAMWriter();
  void write_fragment(Fragment& f);
};

class SAMWriter : public Writer {
  boost::scoped_ptr<std::ostream> _out;

 public:
  SAMWriter(std::ostream* out, bool sample);
  ~SAMWriter();
  void write_fragment(Fragment& f);
};

class MapParser
{
  boost::scoped_ptr<Parser> _parser;
  boost::scoped_ptr<Writer> _writer;
  Library* _lib;
  bool _write_active;

 public:
  MapParser(Library* lib, bool write_active);
  void threaded_parse(ParseThreadSafety* thread_safety, size_t stop_at=0,
                      size_t num_neighbors=0);
  const TransIndex& targ_index() { return _parser->targ_index(); }
  const TransIndex& targ_lengths() { return _parser->targ_lengths(); }
  void write_active(bool b) { _write_active = b; }
  void reset_reader() { _parser->reset(); }
};

#endif