ngs_server 0.1

data/ext/bamtools/src/api/internal/BamHeader_p.h

@@ -0,0 +1,71 @@
+// ***************************************************************************
+// BamHeader_p.h (c) 2010 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 26 January 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides the basic functionality for handling BAM headers.
+// ***************************************************************************
+
+#ifndef BAMHEADER_P_H
+#define BAMHEADER_P_H
+
+//  -------------
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the BamTools API.  It exists purely as an
+// implementation detail. This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+
+#include <api/SamHeader.h>
+#include <string>
+
+namespace BamTools {
+namespace Internal {
+
+class BgzfStream;
+
+class BamHeader {
+
+    // ctor & dtor
+    public:
+        BamHeader(void);
+        ~BamHeader(void);
+
+    // BamHeader interface
+    public:
+        // clear SamHeader data
+        void Clear(void);
+        // return true if SamHeader data is valid
+        bool IsValid(void) const;
+        // load BAM header ('magic number' and SAM header text) from BGZF stream
+        // returns true if all OK
+        bool Load(BgzfStream* stream);
+        // returns (editable) copy of SamHeader data object
+        SamHeader ToSamHeader(void) const;
+        // returns SAM-formatted string of header data
+        std::string ToString(void) const;
+
+    // internal methods
+    private:
+        // reads magic number from BGZF stream, returns true if valid
+        bool CheckMagicNumber(BgzfStream* stream);
+        // reads SAM header length from BGZF stream, stores it in @length
+        // returns read success/fail status
+        bool ReadHeaderLength(BgzfStream* stream, uint32_t& length);
+        // reads SAM header text from BGZF stream, stores in SamHeader object
+        // returns read success/fail status
+        bool ReadHeaderText(BgzfStream* stream, const uint32_t& length);
+
+    // data members
+    private:
+        SamHeader m_header;
+};
+
+} // namespace Internal
+} // namespace BamTools
+
+#endif // BAMHEADER_P_H

data/ext/bamtools/src/api/internal/BamIndexFactory_p.cpp

@@ -0,0 +1,112 @@
+// ***************************************************************************
+// BamIndexFactory_p.cpp (c) 2011 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 5 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides interface for generating BamIndex implementations
+// ***************************************************************************
+
+#include <api/BamAux.h>
+#include <api/internal/BamIndexFactory_p.h>
+#include <api/internal/BamStandardIndex_p.h>
+#include <api/internal/BamToolsIndex_p.h>
+using namespace BamTools;
+using namespace BamTools::Internal;
+
+#include <cstdio>
+using namespace std;
+
+// generates index filename from BAM filename (depending on requested type)
+// if type is unknown, returns empty string
+const string BamIndexFactory::CreateIndexFilename(const string& bamFilename,
+                                                  const BamIndex::IndexType& type)
+{
+    switch ( type ) {
+        case ( BamIndex::STANDARD ) : return ( bamFilename + BamStandardIndex::Extension() );
+        case ( BamIndex::BAMTOOLS ) : return ( bamFilename + BamToolsIndex::Extension() );
+        default :
+            cerr << "BamIndexFactory ERROR: unknown index type" << type << endl;
+            return string();
+    }
+}
+
+// creates a new BamIndex object, depending on extension of @indexFilename
+BamIndex* BamIndexFactory::CreateIndexFromFilename(const string& indexFilename, BamReaderPrivate* reader) {
+
+    // if file doesn't exist, return null index
+    if ( !BamTools::FileExists(indexFilename) )
+        return 0;
+
+    // get file extension from index filename, including dot (".EXT")
+    // if can't get file extension, return null index
+    const string extension = FileExtension(indexFilename);
+    if ( extension.empty() )
+        return 0;
+
+    // create index based on extension
+    if      ( extension == BamStandardIndex::Extension() ) return new BamStandardIndex(reader);
+    else if ( extension == BamToolsIndex::Extension()    ) return new BamToolsIndex(reader);
+    else
+        return 0;
+}
+
+// creates a new BamIndex, object of requested @type
+BamIndex* BamIndexFactory::CreateIndexOfType(const BamIndex::IndexType& type,
+                                             BamReaderPrivate* reader)
+{
+    switch ( type ) {
+        case ( BamIndex::STANDARD ) : return new BamStandardIndex(reader);
+        case ( BamIndex::BAMTOOLS ) : return new BamToolsIndex(reader);
+        default :
+            cerr << "BamIndexFactory ERROR: unknown index type " << type << endl;
+            return 0;
+    }
+}
+
+// retrieves file extension (including '.')
+const string BamIndexFactory::FileExtension(const string& filename) {
+
+    // if filename cannot contain valid path + extension, return empty string
+    if ( filename.empty() || filename.length() <= 4 )
+        return string();
+
+    // look for last dot in filename
+    size_t lastDotPosition = filename.find_last_of('.');
+
+    // if none found, return empty string
+    if ( lastDotPosition == string::npos )
+        return string();
+
+    // return substring from last dot position
+    return filename.substr(lastDotPosition);
+}
+
+// returns name of existing index file that corresponds to @bamFilename
+// will defer to @preferredType if possible, if not will attempt to load any supported type
+// returns empty string if not found
+const string BamIndexFactory::FindIndexFilename(const string& bamFilename,
+                                                const BamIndex::IndexType& preferredType)
+{
+    // try to find index of preferred type first
+    // return index filename if found
+    string indexFilename = CreateIndexFilename(bamFilename, preferredType);
+    if ( !indexFilename.empty() && BamTools::FileExists(indexFilename) )
+        return indexFilename;
+
+    // couldn't find preferred type, try the other supported types
+    // return index filename if found
+    if ( preferredType != BamIndex::STANDARD ) {
+        indexFilename = CreateIndexFilename(bamFilename, BamIndex::STANDARD);
+        if ( !indexFilename.empty() && BamTools::FileExists(indexFilename) )
+            return indexFilename;
+    }
+    if ( preferredType != BamIndex::BAMTOOLS ) {
+        indexFilename = CreateIndexFilename(bamFilename, BamIndex::BAMTOOLS);
+        if ( !indexFilename.empty() && BamTools::FileExists(indexFilename) )
+            return indexFilename;
+    }
+
+    // otherwise couldn't find any index matching this filename
+    return string();
+}

data/ext/bamtools/src/api/internal/BamIndexFactory_p.h

@@ -0,0 +1,49 @@
+// ***************************************************************************
+// BamIndexFactory_p.h (c) 2011 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 5 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides interface for generating BamIndex implementations
+// ***************************************************************************
+
+#ifndef BAMINDEX_FACTORY_P_H
+#define BAMINDEX_FACTORY_P_H
+
+#include <api/BamIndex.h>
+#include <string>
+
+namespace BamTools {
+namespace Internal {
+
+class BamIndexFactory {
+
+    // static interface methods
+    public:
+        // creates a new BamIndex object, depending on extension of @indexFilename
+        static BamIndex* CreateIndexFromFilename(const std::string& indexFilename,
+                                                 BamReaderPrivate* reader);
+        // creates a new BamIndex object, of requested @type
+        static BamIndex* CreateIndexOfType(const BamIndex::IndexType& type,
+                                           BamReaderPrivate* reader);
+        // returns name of existing index file that corresponds to @bamFilename
+        // will defer to @preferredType if possible
+        // if @preferredType not found, will attempt to load any supported index type
+        // returns empty string if no index file (of any type) is found
+        static const std::string FindIndexFilename(const std::string& bamFilename,
+                                                   const BamIndex::IndexType& preferredType);
+
+    // internal methods
+    public:
+        // generates index filename from BAM filename (depending on requested type)
+        // if type is unknown, returns empty string
+        static const std::string CreateIndexFilename(const std::string& bamFilename,
+                                                     const BamIndex::IndexType& type);
+        // retrieves file extension (including '.')
+        static const std::string FileExtension(const std::string& filename);
+};
+
+} // namespace Internal
+} // namespace BamTools
+
+#endif // BAMINDEX_FACTORY_P_H

data/ext/bamtools/src/api/internal/BamMultiMerger_p.h

@@ -0,0 +1,297 @@
+// ***************************************************************************
+// BamMultiMerger_p.h (c) 2010 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 9 September 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides merging functionality for BamMultiReader.  At this point, supports
+// sorting results by (refId, position) or by read name.
+// ***************************************************************************
+
+#ifndef BAMMULTIMERGER_P_H
+#define BAMMULTIMERGER_P_H
+
+//  -------------
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the BamTools API.  It exists purely as an
+// implementation detail. This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+
+#include <api/BamAlignment.h>
+#include <api/BamReader.h>
+#include <map>
+#include <queue>
+#include <string>
+#include <utility>
+
+namespace BamTools {
+namespace Internal {
+
+typedef std::pair<BamReader*, BamAlignment*> ReaderAlignment;
+
+// generic MultiMerger interface
+class IBamMultiMerger {
+
+    public:
+        IBamMultiMerger(void) { }
+        virtual ~IBamMultiMerger(void) { }
+
+    public:
+        virtual void Add(ReaderAlignment value) =0;
+        virtual void Clear(void) =0;
+        virtual const ReaderAlignment& First(void) const =0;
+        virtual bool IsEmpty(void) const =0;
+        virtual void Remove(BamReader* reader) =0;
+        virtual int Size(void) const =0;
+        virtual ReaderAlignment TakeFirst(void) =0;
+};
+
+// IBamMultiMerger implementation - sorted on BamAlignment: (RefId, Position)
+class PositionMultiMerger : public IBamMultiMerger {
+
+    public:
+        PositionMultiMerger(void) : IBamMultiMerger() { }
+        ~PositionMultiMerger(void) { }
+
+    public:
+        void Add(ReaderAlignment value);
+        void Clear(void);
+        const ReaderAlignment& First(void) const;
+        bool IsEmpty(void) const;
+        void Remove(BamReader* reader);
+        int Size(void) const;
+        ReaderAlignment TakeFirst(void);
+
+    private:
+        typedef std::pair<int, int>           KeyType;
+        typedef ReaderAlignment               ValueType;
+        typedef std::pair<KeyType, ValueType> ElementType;
+
+        typedef std::multimap<KeyType, ValueType> ContainerType;
+        typedef ContainerType::iterator           DataIterator;
+        typedef ContainerType::const_iterator     DataConstIterator;
+
+        ContainerType m_data;
+};
+
+// IBamMultiMerger implementation - sorted on BamAlignment: Name
+class ReadNameMultiMerger : public IBamMultiMerger {
+
+    public:
+        ReadNameMultiMerger(void) : IBamMultiMerger() { }
+        ~ReadNameMultiMerger(void) { }
+
+    public:
+        void Add(ReaderAlignment value);
+        void Clear(void);
+        const ReaderAlignment& First(void) const;
+        bool IsEmpty(void) const;
+        void Remove(BamReader* reader);
+        int Size(void) const;
+        ReaderAlignment TakeFirst(void);
+
+    private:
+        typedef std::string                   KeyType;
+        typedef ReaderAlignment               ValueType;
+        typedef std::pair<KeyType, ValueType> ElementType;
+
+        typedef std::multimap<KeyType, ValueType> ContainerType;
+        typedef ContainerType::iterator           DataIterator;
+        typedef ContainerType::const_iterator     DataConstIterator;
+
+        ContainerType m_data;
+};
+
+// IBamMultiMerger implementation - unsorted BAM file(s)
+class UnsortedMultiMerger : public IBamMultiMerger {
+
+    public:
+        UnsortedMultiMerger(void) : IBamMultiMerger() { }
+        ~UnsortedMultiMerger(void) { }
+
+    public:
+        void Add(ReaderAlignment value);
+        void Clear(void);
+        const ReaderAlignment& First(void) const;
+        bool IsEmpty(void) const;
+        void Remove(BamReader* reader);
+        int Size(void) const;
+        ReaderAlignment TakeFirst(void);
+
+    private:
+        typedef ReaderAlignment ElementType;
+        typedef std::vector<ReaderAlignment>  ContainerType;
+        typedef ContainerType::iterator       DataIterator;
+        typedef ContainerType::const_iterator DataConstIterator;
+
+        ContainerType m_data;
+};
+
+// ------------------------------------------
+// PositionMultiMerger implementation
+
+inline void PositionMultiMerger::Add(ReaderAlignment value) {
+    const KeyType key( value.second->RefID, value.second->Position );
+    m_data.insert( ElementType(key, value) );
+}
+
+inline void PositionMultiMerger::Clear(void) {
+    m_data.clear();
+}
+
+inline const ReaderAlignment& PositionMultiMerger::First(void) const {
+    const ElementType& entry = (*m_data.begin());
+    return entry.second;
+}
+
+inline bool PositionMultiMerger::IsEmpty(void) const {
+    return m_data.empty();
+}
+
+inline void PositionMultiMerger::Remove(BamReader* reader) {
+
+    if ( reader == 0 ) return;
+    const std::string filenameToRemove = reader->GetFilename();
+
+    // iterate over readers in cache
+    DataIterator dataIter = m_data.begin();
+    DataIterator dataEnd  = m_data.end();
+    for ( ; dataIter != dataEnd; ++dataIter ) {
+        const ValueType& entry = (*dataIter).second;
+        const BamReader* entryReader = entry.first;
+        if ( entryReader == 0 ) continue;
+
+        // remove iterator on match
+        if ( entryReader->GetFilename() == filenameToRemove ) {
+            m_data.erase(dataIter);
+            return;
+        }
+    }
+}
+
+inline int PositionMultiMerger::Size(void) const {
+    return m_data.size();
+}
+
+inline ReaderAlignment PositionMultiMerger::TakeFirst(void) {
+    DataIterator first = m_data.begin();
+    ReaderAlignment next = (*first).second;
+    m_data.erase(first);
+    return next;
+}
+
+// ------------------------------------------
+// ReadNameMultiMerger implementation
+
+inline void ReadNameMultiMerger::Add(ReaderAlignment value) {
+    BamAlignment* al = value.second;
+    if ( al->BuildCharData() ) {
+        const KeyType key(al->Name);
+        m_data.insert( ElementType(key, value) );
+    }
+}
+
+inline void ReadNameMultiMerger::Clear(void) {
+    m_data.clear();
+}
+
+inline const ReaderAlignment& ReadNameMultiMerger::First(void) const {
+    const ElementType& entry = (*m_data.begin());
+    return entry.second;
+}
+
+inline bool ReadNameMultiMerger::IsEmpty(void) const {
+    return m_data.empty();
+}
+
+inline void ReadNameMultiMerger::Remove(BamReader* reader) {
+
+    if ( reader == 0 ) return;
+    const std::string filenameToRemove = reader->GetFilename();
+
+    // iterate over readers in cache
+    DataIterator dataIter = m_data.begin();
+    DataIterator dataEnd  = m_data.end();
+    for ( ; dataIter != dataEnd; ++dataIter ) {
+        const ValueType& entry = (*dataIter).second;
+        const BamReader* entryReader = entry.first;
+        if ( entryReader == 0 ) continue;
+
+        // remove iterator on match
+        if ( entryReader->GetFilename() == filenameToRemove ) {
+            m_data.erase(dataIter);
+            return;
+        }
+    }
+
+}
+
+inline int ReadNameMultiMerger::Size(void) const {
+    return m_data.size();
+}
+
+inline ReaderAlignment ReadNameMultiMerger::TakeFirst(void) {
+    DataIterator first = m_data.begin();
+    ReaderAlignment next = (*first).second;
+    m_data.erase(first);
+    return next;
+}
+
+// ------------------------------------------
+// UnsortedMultiMerger implementation
+
+inline void UnsortedMultiMerger::Add(ReaderAlignment value) {
+    m_data.push_back(value);
+}
+
+inline void UnsortedMultiMerger::Clear(void) {
+    for (size_t i = 0; i < m_data.size(); ++i )
+        m_data.pop_back();
+}
+
+inline const ReaderAlignment& UnsortedMultiMerger::First(void) const {
+    return m_data.front();
+}
+
+inline bool UnsortedMultiMerger::IsEmpty(void) const {
+    return m_data.empty();
+}
+
+inline void UnsortedMultiMerger::Remove(BamReader* reader) {
+
+    if ( reader == 0 ) return;
+    const std::string filenameToRemove = reader->GetFilename();
+
+    // iterate over readers in cache
+    DataIterator dataIter = m_data.begin();
+    DataIterator dataEnd  = m_data.end();
+    for ( ; dataIter != dataEnd; ++dataIter ) {
+        const BamReader* entryReader = (*dataIter).first;
+        if ( entryReader == 0 ) continue;
+
+        // remove iterator on match
+        if ( entryReader->GetFilename() == filenameToRemove ) {
+            m_data.erase(dataIter);
+            return;
+        }
+    }
+}
+
+inline int UnsortedMultiMerger::Size(void) const {
+    return m_data.size();
+}
+
+inline ReaderAlignment UnsortedMultiMerger::TakeFirst(void) {
+    ReaderAlignment first = m_data.front();
+    m_data.erase( m_data.begin() );
+    return first;
+}
+
+} // namespace Internal
+} // namespace BamTools
+
+#endif // BAMMULTIMERGER_P_H