/*!
* Copy constructor
*/
file_name_composer_adapter(file_name_composer_adapter const& that) :
m_Formatter(that.m_Formatter),
m_FormattingStream(m_FileName)
{
m_FormattingStream.exceptions(std::ios_base::badbit | std::ios_base::failbit);
m_FormattingStream.imbue(that.m_FormattingStream.getloc());
}
/*!
* Initializing constructor
*/
explicit file_name_composer_adapter(formatter_type const& formatter, std::locale const& loc = std::locale()) :
m_Formatter(formatter),
m_FormattingStream(m_FileName)
{
m_FormattingStream.exceptions(std::ios_base::badbit | std::ios_base::failbit);
m_FormattingStream.imbue(loc);
}
static bool peekLinearChunk(stream_type & stream, uint64_t const refid, int64_t const chunkid)
{
::libmaus2::bambam::BamIndexLinearChunk LC;
if ( stream.peek() == stream_type::traits_type::eof() )
return false;
stream.read(reinterpret_cast<char *>(&LC),sizeof(::libmaus2::bambam::BamIndexLinearChunk));
stream.clear();
stream.seekg(-static_cast<int64_t>(sizeof(::libmaus2::bambam::BamIndexLinearChunk)),std::ios::cur);
return LC.refid == refid && LC.chunkid == chunkid;
}
static bool peekLinearChunk(stream_type & stream, uint64_t const refid, uint64_t const pos, unsigned int const posshift)
{
::libmaus2::bambam::BamIndexLinearChunk LC;
if ( stream.peek() == stream_type::traits_type::eof() )
return false;
stream.read(reinterpret_cast<char *>(&LC),sizeof(::libmaus2::bambam::BamIndexLinearChunk));
stream.clear();
stream.seekg(-static_cast<int64_t>(sizeof(::libmaus2::bambam::BamIndexLinearChunk)),std::ios::cur);
return (LC.refid == refid) && ((LC.pos >> posshift)==(pos>>posshift));
}
result_type operator() (stream_type& strm, value_type const& value) const
{
strm.flush();
typedef typename stream_type::streambuf_type streambuf_type;
string_type& str = *static_cast< streambuf_type* >(strm.rdbuf())->storage();
char_type buf[std::numeric_limits< unsigned int >::digits10 + 2];
char_type* p = buf;
typedef karma::uint_generator< unsigned int, 10 > uint_gen;
karma::generate(p, uint_gen(), value.line);
str.append(buf, p);
}
void open_next_file(stream_type& res) {
if(files_open_ >= concurrent_files_)
return;
while(paths_cur_ != paths_end_) {
std::string path = *paths_cur_;
++paths_cur_;
res.reset(new file_stream(path.c_str(), *this));
if(res->good())
return;
res.reset();
throw std::runtime_error(err::msg() << "Can't open file '" << path << "'");
}
}
void open_next_pipe(stream_type& res) {
while(!free_pipes_.empty()) {
const char* path = free_pipes_.front();
free_pipes_.pop_front();
res.reset(new pipe_stream(path, *this));
if(res->good()) {
busy_pipes_.insert(path);
return;
}
// The pipe failed to open, so it is not marked as busy. This
// reset will make us forget about this path.
res.reset();
}
}
std::pair<uint64_t,uint64_t> flush(stream_type & out)
{
uint64_t const start = out.tellp();
if ( pc != pa )
{
std::sort(pa,pc);
out.write(reinterpret_cast<char const *>(pa),(pc-pa)*sizeof(element_type));
pc = pa;
}
uint64_t const end = out.tellp();
return std::pair<uint64_t,uint64_t>(start,end);
}
// Called when the timer expires.
// We operate the timer continuously this simplifies the code.
//
void on_timer(error_code ec)
{
if(ec && ec != boost::asio::error::operation_aborted)
return fail("timer", ec);
// Verify that the timer really expired
// since the deadline may have moved.
//
if(timer_.expires_at() <= clock_type::now())
{
// Closing the socket cancels all outstanding
// operations. They will complete with
// boost::asio::error::operation_aborted
//
ws_.next_layer().close(ec);
return;
}
// Wait on the timer
timer_.async_wait(
strand_.wrap(std::bind(
&connection::on_timer,
shared_from_this(),
std::placeholders::_1)));
}
static bool readAlignmentGz(
stream_type & GZ,
::libmaus::bambam::BamAlignment & alignment,
::libmaus::bambam::BamHeader const * bamheader = 0,
bool const validate = true
)
{
/* read alignment block size */
int64_t const bs0 = GZ.get();
int64_t const bs1 = GZ.get();
int64_t const bs2 = GZ.get();
int64_t const bs3 = GZ.get();
if ( bs3 < 0 )
// reached end of file
return false;
/* assemble block size as LE integer */
alignment.blocksize = (bs0 << 0) | (bs1 << 8) | (bs2 << 16) | (bs3 << 24) ;
/* read alignment block */
if ( alignment.blocksize > alignment.D.size() )
alignment.D = ::libmaus::bambam::BamAlignment::D_array_type(alignment.blocksize,false);
GZ.read(reinterpret_cast<char *>(alignment.D.begin()),alignment.blocksize);
if ( static_cast<int64_t>(GZ.gcount()) != static_cast<int64_t>(alignment.blocksize) )
{
::libmaus::exception::LibMausException se;
se.getStream() << "Invalid alignment (EOF in alignment block of length " << alignment.blocksize << ")" << std::endl;
se.finish();
throw se;
}
if ( validate )
{
libmaus_bambam_alignment_validity const validity = bamheader ? alignment.valid(*bamheader) : alignment.valid();
if ( validity != ::libmaus::bambam::libmaus_bambam_alignment_validity_ok )
{
::libmaus::exception::LibMausException se;
se.getStream() << "Invalid alignment: " << validity << std::endl;
se.finish();
throw se;
}
}
return true;
}
CompactFastQHeader(stream_type & stream)
:
blocklen(::libmaus::util::NumberSerialisation::deserialiseNumber(stream)),
numreads(::libmaus::util::NumberSerialisation::deserialiseNumber(stream)),
qbits(stream.get()),
quant(stream)
{
}
static int64_t peekBin(stream_type & stream)
{
::libmaus2::bambam::BamIndexBinChunk BC;
if ( stream.peek() == stream_type::traits_type::eof() )
return -1;
stream.read(
reinterpret_cast<char *>(&BC),
sizeof(::libmaus2::bambam::BamIndexBinChunk)
);
assert ( stream.gcount() == sizeof(::libmaus2::bambam::BamIndexBinChunk) );
stream.clear();
stream.seekg(-static_cast<int64_t>(sizeof(::libmaus2::bambam::BamIndexBinChunk)),std::ios::cur);
return BC.refid;
}
/*!
* The operator generates a file name based on the log record
*/
result_type operator() (record_view const& rec) const
{
boost::log::aux::cleanup_guard< stream_type > cleanup1(m_FormattingStream);
boost::log::aux::cleanup_guard< result_type::string_type > cleanup2(m_FileName);
m_Formatter(rec, m_FormattingStream);
m_FormattingStream.flush();
return result_type(m_FileName);
}
void do_manip(stream_type& strm) const
{
if (error_m != std::ios_base::goodbit)
strm.setstate(error_m);
else
{
std::ios_base::iostate err(error_m);
try
{
(*pf_m)(strm, arg1_m, arg2_m);
}
catch (...)
{
err = handle_error(strm);
}
if (err) strm.setstate(err);
}
}
fcppt::io::basic_scoped_rdbuf<
Ch,
Traits
>::basic_scoped_rdbuf(
stream_type &_source,
stream_type &_receiver
)
:
receiver_(
_receiver
),
old_(
_receiver.rdbuf()
)
{
receiver_.rdbuf(
_source.rdbuf()
);
}
static value_type getLEInteger(stream_type & stream)
{
value_type v = 0;
for ( uint64_t i = 0; i < length; ++i )
if ( stream.peek() == stream_type::traits_type::eof() )
{
libmaus2::exception::LibMausException ex;
ex.getStream() << "Failed to little endian number of length " << length << " in BamIndex::getLEInteger." << std::endl;
ex.finish();
throw ex;
}
else
{
v |= static_cast<value_type>(stream.get()) << (8*i);
}
return v;
}
// Read a message from the websocket stream
void do_read()
{
// Put the read on the timer
timer_.expires_from_now(std::chrono::seconds(15));
// Read a message
ws_.async_read(buffer_,
strand_.wrap(std::bind(
&connection::on_read,
shared_from_this(),
std::placeholders::_1)));
}
// Called after the message read completes
void on_read(error_code ec)
{
// This error means the other side
// closed the websocket stream.
if(ec == websocket::error::closed)
return;
if(ec)
return fail("read", ec);
// Put the write on the timer
timer_.expires_from_now(std::chrono::seconds(15));
// Write the received message back
ws_.binary(ws_.got_binary());
ws_.async_write(buffer_.data(),
strand_.wrap(std::bind(
&connection::on_write,
shared_from_this(),
std::placeholders::_1)));
}
static uint8_t getByte(stream_type & in)
{
int const c = in.get();
if ( c < 0 )
{
::libmaus2::exception::LibMausException se;
se.getStream() << "Unexpected EOF in ::libmaus2::bambam::DecoderBase::getByte()" << std::endl;
se.finish();
throw se;
}
return c;
}
void serialise(stream_type & out) const
{
IHWT->serialise(out);
if ( IHWT->getN() )
for ( int s = IHWT->enctable.minsym; s <= IHWT->enctable.maxsym; ++s )
if ( s > 1 && IHWT->rank(s,IHWT->getN()-1) )
{
assert ( C[s].get() );
C[s]->serialize(out);
}
out.flush();
}
/// Constructor
connection(
server& parent,
tcp::endpoint const& ep,
tcp::socket&& sock)
: log_(parent.log_)
, ep_(ep)
, ws_(std::move(sock))
, timer_(ws_.get_io_service(), (clock_type::time_point::max)())
, strand_(ws_.get_io_service())
, id_([]
{
static std::atomic<std::size_t> n{0};
return ++n;
}())
{
// Invoke the callback for new connections if set.
// This allows the settings on the websocket stream
// to be adjusted. For example to turn compression
// on or off or adjust the read and write buffer sizes.
//
if(parent.mod_)
parent.mod_(ws_);
}
result_type operator() (stream_type& strm, value_type const& value) const
{
if (value.type == attributes::named_scope_entry::function)
{
const char* begin = value.scope_name.c_str();
const char* end = begin + value.scope_name.size();
if (parse_function_name(begin, end, m_include_scope))
{
strm.write(begin, end - begin);
return;
}
}
strm << value.scope_name;
}
result_type operator() (stream_type& strm, value_type const& value) const
{
std::size_t n = value.file_name.size(), i = n;
for (; i > 0; --i)
{
const char c = value.file_name[i - 1];
#if defined(BOOST_WINDOWS)
if (c == '\\')
break;
#endif
if (c == '/')
break;
}
strm.write(value.file_name.c_str() + i, n - i);
}
uint64_t createFinalStream(stream_type & out)
{
flush();
uint64_t p = 0;
p += ::libmaus::util::NumberSerialisation::serialiseNumber(out,symbols); // n
p += root->serialize(out); // huffman code tree
p += ::libmaus::util::NumberSerialisation::serialiseNumber(out,contexts.size()); // number of bit vectors
std::vector<uint64_t> nodeposvec;
for ( uint64_t i = 0; i < contexts.size(); ++i )
{
nodeposvec.push_back(p);
uint64_t const blockswritten = contexts[i]->blockswritten;
uint64_t const datawordswritten = 6*blockswritten;
uint64_t const allwordswritten = 8*blockswritten;
contexts[i].reset();
tmpcnt.closeOutputTempFile(i);
// bits written
p += ::libmaus::serialize::Serialize<uint64_t>::serialize(out,64*datawordswritten);
// auto array header (words written)
p += ::libmaus::serialize::Serialize<uint64_t>::serialize(out,allwordswritten);
//std::string const filename = outputfilenames[i];
//::libmaus::aio::CheckedInputStream istr(filename);
std::istream & istr = tmpcnt.openInputTempFile(i);
// std::ifstream istr(filename.c_str(),std::ios::binary);
// std::cerr << "Copying " << allwordswritten << " from stream " << filename << std::endl;
::libmaus::util::GetFileSize::copy (istr, out, allwordswritten, sizeof(uint64_t));
p += allwordswritten * sizeof(uint64_t);
tmpcnt.closeInputTempFile(i);
// remove(filename.c_str());
}
uint64_t const indexpos = p;
p += ::libmaus::util::NumberSerialisation::serialiseNumberVector(out,nodeposvec);
p += ::libmaus::util::NumberSerialisation::serialiseNumber(out,indexpos);
out.flush();
return p;
}
// Called immediately after the connection is created.
// We keep this separate from the constructor because
// shared_from_this may not be called from constructors.
void run()
{
// Run the timer
on_timer({});
// Put the handshake on the timer
timer_.expires_from_now(std::chrono::seconds(15));
// Read the websocket handshake and send the response
ws_.async_accept_ex(
[](websocket::response_type& res)
{
res.insert(http::field::server, "websocket-server-async");
},
strand_.wrap(std::bind(
&connection::on_accept,
shared_from_this(),
std::placeholders::_1)));
}
bool readBlock(stream_type & stream)
{
state = bgzfinflateblockstate_read_block;
if ( failed() )
return false;
try
{
std::pair<uint64_t,uint64_t> preblockinfo = BgzfInflateBase::readBlock(stream);
blockinfo = ::libmaus2::lz::BgzfInflateInfo(
preblockinfo.first,
preblockinfo.second,
preblockinfo.second ? false : (stream.peek() == stream_type::traits_type::eof())
);
return blockinfo.uncompressed;
}
catch(libmaus2::exception::LibMausException const & lex)
{
libmaus2::exception::LibMausException::unique_ptr_type tex(lex.uclone());
ex = UNIQUE_PTR_MOVE(tex);
return false;
}
catch(std::exception const & lex)
{
libmaus2::exception::LibMausException::unique_ptr_type tex(new libmaus2::exception::LibMausException);
ex = UNIQUE_PTR_MOVE(tex);
ex->getStream() << lex.what();
ex->finish(false);
return false;
}
catch(...)
{
libmaus2::exception::LibMausException::unique_ptr_type tex(new libmaus2::exception::LibMausException);
ex = UNIQUE_PTR_MOVE(tex);
ex->getStream() << "BgzfInflateBlock::readBlock(): unknown exception caught";
ex->finish(false);
return false;
}
}
void term()
{
genc.encode(0);
genc.encode(0);
genc.flush();
SGO.flush();
SGOout.flush();
indexout.clear();
indexout.seekg(0,std::ios::beg);
// uint64_t const indexpos = SGO.getWrittenBytes();
indexout.clear();
indexout.seekg(0,std::ios::beg);
libmaus2::util::GetFileSize::copy(indexout,SGOout,2*sizeof(uint64_t)*indexentries);
libmaus2::util::NumberSerialisation::serialiseNumber(SGOout,indexentries ? prevkey : 0); // highest key in file
libmaus2::util::NumberSerialisation::serialiseNumber(SGOout,indexentries);
SGOout.flush();
}
void init(stream_type & stream)
{
char magic[4];
stream.read(&magic[0],sizeof(magic));
if (
! stream
||
stream.gcount() != 4
||
magic[0] != 'B'
||
magic[1] != 'A'
||
magic[2] != 'I'
||
magic[3] != '\1'
)
{
libmaus2::exception::LibMausException ex;
ex.getStream() << "Failed to read BAI magic BAI\\1." << std::endl;
ex.finish();
throw ex;
}
uint32_t const numref = getLEInteger<stream_type,uint32_t,4>(stream);
refs = libmaus2::autoarray::AutoArray<libmaus2::bambam::BamIndexRef>(numref);
for ( uint64_t i = 0; i < numref; ++i )
{
uint32_t const distbins = getLEInteger<stream_type,uint32_t,4>(stream);
#if 0
std::cerr << "chr " << i << " distbins " << distbins << std::endl;
#endif
if ( distbins )
{
refs[i].bin = libmaus2::autoarray::AutoArray<libmaus2::bambam::BamIndexBin>(distbins,false);
libmaus2::autoarray::AutoArray< std::pair<uint64_t,uint64_t> > pi(distbins,false);
libmaus2::autoarray::AutoArray<libmaus2::bambam::BamIndexBin> prebins(distbins,false);
for ( uint64_t j = 0; j < distbins; ++j )
{
uint32_t const bin = getLEInteger<stream_type,uint32_t,4>(stream);
uint32_t const chunks = getLEInteger<stream_type,uint32_t,4>(stream);
// std::cerr << "chr " << i << " bin " << bin << " chunks " << chunks << std::endl;
prebins[j].bin = bin;
prebins[j].chunks = libmaus2::autoarray::AutoArray<libmaus2::bambam::BamIndexBin::Chunk>(chunks,false);
// read chunks
for ( uint64_t k = 0; k < chunks; ++k )
{
prebins[j].chunks[k].first = getLEInteger<stream_type,uint64_t,8>(stream);
prebins[j].chunks[k].second = getLEInteger<stream_type,uint64_t,8>(stream);
}
pi [ j ] = std::pair<uint64_t,uint64_t>(bin,j);
}
// sort by bin
std::sort(pi.begin(),pi.end());
// move
for ( uint64_t j = 0; j < distbins; ++j )
refs[i].bin[j] = prebins[pi[j].second];
}
uint32_t const lins = getLEInteger<stream_type,uint32_t,4>(stream);
if ( lins )
{
refs[i].lin.intervals = libmaus2::autoarray::AutoArray<uint64_t>(lins,false);
for ( uint64_t j = 0; j < lins; ++j )
refs[i].lin.intervals[j] = getLEInteger<stream_type,uint64_t,8>(stream);
}
}
}
local_precision(stream_type& stream) : pstream(&stream), saved_prec(stream.precision()) {}
~local_precision() { pstream->precision(saved_prec); }
