ngs_server 0.1

data/ext/bamtools/src/api/SamProgramChain.cpp

@@ -0,0 +1,351 @@
+// ***************************************************************************
+// SamProgramChain.cpp (c) 2011 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 19 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides methods for operating on a SamProgram record "chain"
+// ***************************************************************************
+
+#include <api/SamProgramChain.h>
+using namespace BamTools;
+
+#include <algorithm>
+#include <iostream>
+#include <cstdlib>
+using namespace std;
+
+/*! \class BamTools::SamProgramChain
+    \brief Sorted container "chain" of SamProgram records.
+
+    Provides methods for operating on a collection of SamProgram records.
+
+    N.B. - Underlying container is *NOT* ordered by linkage, but by order of
+    appearance in SamHeader and subsequent Add() calls. Using the current
+    iterators will not allow you to step through the header's program history.
+    Instead use First()/Last() to access oldest/newest records, respectively.
+*/
+
+/*! \fn SamProgramChain::SamProgramChain(void)
+    \brief constructor
+*/
+SamProgramChain::SamProgramChain(void) { }
+
+/*! \fn SamProgramChain::SamProgramChain(const SamProgramChain& other)
+    \brief copy constructor
+*/
+SamProgramChain::SamProgramChain(const SamProgramChain& other)
+    : m_data(other.m_data)
+{ }
+
+/*! \fn SamProgramChain::~SamProgramChain(void)
+    \brief destructor
+*/
+SamProgramChain::~SamProgramChain(void) { }
+
+/*! \fn void SamProgramChain::Add(SamProgram& program)
+    \brief Appends a program to program chain.
+
+    Duplicate entries are silently discarded.
+
+    N.B. - Underlying container is *NOT* ordered by linkage, but by order of
+    appearance in SamHeader and subsequent Add() calls. Using the current
+    iterators will not allow you to step through the header's program history.
+    Instead use First()/Last() to access oldest/newest records, respectively.
+
+    \param program entry to be appended
+*/
+void SamProgramChain::Add(SamProgram& program) {
+
+    // ignore duplicated records
+    if ( Contains(program) )
+        return;
+
+    // if other programs already in chain, try to find the "next" record
+    // tries to match another record's PPID with @program's ID
+    if ( !IsEmpty() )
+        program.NextProgramID = NextIdFor(program.ID);
+
+    // store program record
+    m_data.push_back(program);
+}
+
+/*! \fn void SamProgramChain::Add(const std::vector<SamProgram>& programs)
+    \brief Appends a batch of programs to the end of the chain.
+
+    This is an overloaded function.
+
+    \param programs batch of program records to append
+    \sa Add()
+*/
+void SamProgramChain::Add(std::vector<SamProgram>& programs) {
+    vector<SamProgram>::iterator pgIter = programs.begin();
+    vector<SamProgram>::iterator pgEnd  = programs.end();
+    for ( ; pgIter != pgEnd; ++pgIter )
+        Add(*pgIter);
+}
+
+/*! \fn SamProgramIterator SamProgramChain::Begin(void)
+    \return an STL iterator pointing to the first (oldest) program record
+    \sa ConstBegin(), End(), First()
+*/
+SamProgramIterator SamProgramChain::Begin(void) {
+    return m_data.begin();
+}
+
+/*! \fn SamProgramConstIterator SamProgramChain::Begin(void) const
+    \return an STL const_iterator pointing to the first (oldest) program record
+
+    This is an overloaded function.
+
+    \sa ConstBegin(), End(), First()
+*/
+SamProgramConstIterator SamProgramChain::Begin(void) const {
+    return m_data.begin();
+}
+
+/*! \fn void SamProgramChain::Clear(void)
+    \brief Clears all program records.
+*/
+void SamProgramChain::Clear(void) {
+    m_data.clear();
+}
+
+/*! \fn SamProgramConstIterator SamProgramChain::ConstBegin(void) const
+    \return an STL const_iterator pointing to the first (oldest) program record
+    \sa Begin(), ConstEnd(), First()
+*/
+SamProgramConstIterator SamProgramChain::ConstBegin(void) const {
+    return m_data.begin();
+}
+
+/*! \fn SamProgramConstIterator SamProgramChain::ConstEnd(void) const
+    \return an STL const_iterator pointing to the imaginary entry after the last (newest) program record
+    \sa ConstBegin(), End(), Last()
+*/
+SamProgramConstIterator SamProgramChain::ConstEnd(void) const {
+    return m_data.end();
+}
+
+/*! \fn bool SamProgramChain::Contains(const SamProgram& program) const
+    \brief Returns true if chains has this program record (matching on ID).
+
+    This is an overloaded function.
+
+    \param program SamProgram to search for
+    \return \c true if chain contains program (matching on ID)
+*/
+bool SamProgramChain::Contains(const SamProgram& program) const {
+    return Contains(program.ID);
+}
+
+/*! \fn bool SamProgramChain::Contains(const std::string& programId) const
+    \brief Returns true if chains has a program record with this ID
+    \param programId search for program matching this ID
+    \return \c true if chain contains a program record with this ID
+*/
+bool SamProgramChain::Contains(const std::string& programId) const {
+    return ( IndexOf(programId) != (int)m_data.size() );
+}
+
+/*! \fn SamProgramIterator SamProgramChain::End(void)
+    \return an STL iterator pointing to the imaginary entry after the last (newest) program record
+    \sa Begin(), ConstEnd(), Last()
+*/
+SamProgramIterator SamProgramChain::End(void) {
+    return m_data.end();
+}
+
+/*! \fn SamProgramConstIterator SamProgramChain::End(void) const
+    \return an STL const_iterator pointing to the imaginary entry after the last (newest) program record
+
+    This is an overloaded function.
+
+    \sa Begin(), ConstEnd(), Last()
+*/
+SamProgramConstIterator SamProgramChain::End(void) const {
+    return m_data.end();
+}
+
+/*! \fn SamProgram& SamProgramChain::First(void)
+    \brief Fetches first (oldest) record in the chain.
+
+    N.B. - This function will fail if the chain is empty. If this is possible,
+    check the result of IsEmpty() before calling this function.
+
+    \return a modifiable reference to the first (oldest) program entry
+    \sa Begin(), Last()
+*/
+SamProgram& SamProgramChain::First(void) {
+
+    // find first record in container that has no PreviousProgramID entry
+    SamProgramIterator iter = Begin();
+    SamProgramIterator end  = End();
+    for ( ; iter != end; ++iter ) {
+        SamProgram& current = (*iter);
+        if ( !current.HasPreviousProgramID() )
+            return current;
+    }
+
+    // otherwise error
+    cerr << "SamProgramChain ERROR - could not find any record without a PP tag" << endl;
+    exit(1);
+}
+
+/*! \fn const SamProgram& SamProgramChain::First(void) const
+    \brief Fetches first (oldest) record in the chain.
+
+    This is an overloaded function.
+
+    N.B. - This function will fail if the chain is empty. If this is possible,
+    check the result of IsEmpty() before calling this function.
+
+    \return a read-only reference to the first (oldest) program entry
+    \sa Begin(), ConstBegin(), Last()
+*/
+const SamProgram& SamProgramChain::First(void) const {
+
+    // find first record in container that has no PreviousProgramID entry
+    SamProgramConstIterator iter = ConstBegin();
+    SamProgramConstIterator end  = ConstEnd();
+    for ( ; iter != end; ++iter ) {
+        const SamProgram& current = (*iter);
+        if ( !current.HasPreviousProgramID() )
+            return current;
+    }
+
+    // otherwise error
+    cerr << "SamProgramChain ERROR - could not find any record without a PP tag" << endl;
+    exit(1);
+}
+
+/*! \fn int SamProgramChain::IndexOf(const std::string& programId) const
+    \internal
+    \return index of program record if found.
+    Otherwise, returns vector::size() (invalid index).
+*/
+int SamProgramChain::IndexOf(const std::string& programId) const {
+    SamProgramConstIterator begin = ConstBegin();
+    SamProgramConstIterator iter  = begin;
+    SamProgramConstIterator end   = ConstEnd();
+    for ( ; iter != end; ++iter ) {
+        const SamProgram& current = (*iter);
+        if ( current.ID == programId )
+            break;
+    }
+    return distance( begin, iter );
+}
+
+/*! \fn bool SamProgramChain::IsEmpty(void) const
+    \brief Returns \c true if chain contains no records
+    \sa Size()
+*/
+bool SamProgramChain::IsEmpty(void) const {
+    return m_data.empty();
+}
+
+/*! \fn SamProgram& SamProgramChain::Last(void)
+    \brief Fetches last (newest) record in the chain.
+
+    N.B. - This function will fail if the chain is empty. If this is possible,
+    check the result of IsEmpty() before calling this function.
+
+    \return a modifiable reference to the last (newest) program entry
+    \sa End(), First()
+*/
+SamProgram& SamProgramChain::Last(void) {
+    // find first record in container that has no NextProgramID entry
+    SamProgramIterator iter = Begin();
+    SamProgramIterator end  = End();
+    for ( ; iter != end; ++iter ) {
+        SamProgram& current = (*iter);
+        if ( !current.HasNextProgramID() )
+            return current;
+    }
+
+    // otherwise error
+    cerr << "SamProgramChain ERROR - could not determine last record" << endl;
+    exit(1);
+}
+
+/*! \fn const SamProgram& SamProgramChain::Last(void) const
+    \brief Fetches last (newest) record in the chain.
+
+    This is an overloaded function.
+
+    N.B. - This function will fail if the chain is empty. If this is possible,
+    check the result of IsEmpty() before calling this function.
+
+    \return a read-only reference to the last (newest) program entry
+    \sa End(), ConstEnd(), First()
+*/
+const SamProgram& SamProgramChain::Last(void) const {
+    // find first record in container that has no NextProgramID entry
+    SamProgramConstIterator iter = ConstBegin();
+    SamProgramConstIterator end  = ConstEnd();
+    for ( ; iter != end; ++iter ) {
+        const SamProgram& current = (*iter);
+        if ( !current.HasNextProgramID() )
+            return current;
+    }
+
+    // otherwise error
+    cerr << "SamProgramChain ERROR - could not determine last record" << endl;
+    exit(1);
+}
+
+/*! \fn const std::string SamProgramChain::NextIdFor(const std::string& programId) const
+    \internal
+    \return ID of program record, whose PreviousProgramID matches \a programId.
+    Otherwise, returns empty string if none found.
+*/
+const std::string SamProgramChain::NextIdFor(const std::string& programId) const {
+
+    // find first record in container whose PreviousProgramID matches @programId
+    SamProgramConstIterator iter = ConstBegin();
+    SamProgramConstIterator end  = ConstEnd();
+    for ( ; iter != end; ++iter ) {
+        const SamProgram& current = (*iter);
+        if ( !current.HasPreviousProgramID() &&
+              current.PreviousProgramID == programId
+           )
+        {
+            return current.ID;
+        }
+    }
+
+    // none found
+    return string();
+}
+
+/*! \fn int SamProgramChain::Size(void) const
+    \brief Returns number of program records in the chain.
+    \sa IsEmpty()
+*/
+int SamProgramChain::Size(void) const {
+    return m_data.size();
+}
+
+/*! \fn SamProgram& SamProgramChain::operator[](const std::string& programId)
+    \brief Retrieves the modifiable SamProgram record that matches \a programId.
+
+    NOTE - If the chain contains no read group matching this ID, this function will
+    print an error and terminate.
+
+    \param programId ID of program record to retrieve
+    \return a modifiable reference to the SamProgram associated with the ID
+*/
+SamProgram& SamProgramChain::operator[](const std::string& programId) {
+
+    // look up program record matching this ID
+    int index = IndexOf(programId);
+
+    // if record not found
+    if ( index == (int)m_data.size() ) {
+        cerr << "SamProgramChain ERROR - unknown programId: " << programId << endl;
+        exit(1);
+    }
+
+    // otherwise return program record at index
+    return m_data.at(index);
+}

data/ext/bamtools/src/api/SamProgramChain.h

@@ -0,0 +1,85 @@
+// ***************************************************************************
+// SamProgramChain.h (c) 2011 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 19 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides methods for operating on a SamProgram record "chain"
+// ***************************************************************************
+
+#ifndef SAM_PROGRAMCHAIN_H
+#define SAM_PROGRAMCHAIN_H
+
+#include <api/api_global.h>
+#include <api/SamProgram.h>
+#include <string>
+#include <vector>
+
+namespace BamTools {
+
+// chain is *NOT* sorted in any order
+// use First()/Last() to retrieve oldest/newest programs, respectively
+typedef std::vector<SamProgram>             SamProgramContainer;
+typedef SamProgramContainer::iterator       SamProgramIterator;
+typedef SamProgramContainer::const_iterator SamProgramConstIterator;
+
+class API_EXPORT SamProgramChain {
+
+    // ctor & dtor
+    public:
+        SamProgramChain(void);
+        SamProgramChain(const SamProgramChain& other);
+        ~SamProgramChain(void);
+
+    // query/modify program data
+    public:
+        // appends a program record to the chain
+        void Add(SamProgram& program);
+        void Add(std::vector<SamProgram>& programs);
+
+        // clears all read group entries
+        void Clear(void);
+
+        // returns true if chain contains this program record (matches on ID)
+        bool Contains(const SamProgram& program) const;
+        bool Contains(const std::string& programId) const;
+
+        // returns the first (oldest) program in the chain
+        SamProgram& First(void);
+        const SamProgram& First(void) const;
+
+        // returns true if chain is empty
+        bool IsEmpty(void) const;
+
+        // returns last (most recent) program in the chain
+        SamProgram& Last(void);
+        const SamProgram& Last(void) const;
+
+        // returns number of program records in the chain
+        int Size(void) const;
+
+        // retrieves a modifiable reference to the SamProgram object associated with this ID
+        SamProgram& operator[](const std::string& programId);
+
+    // retrieve STL-compatible iterators
+    public:
+        SamProgramIterator      Begin(void);              // returns iterator to begin()
+        SamProgramConstIterator Begin(void) const;        // returns const_iterator to begin()
+        SamProgramConstIterator ConstBegin(void) const;   // returns const_iterator to begin()
+        SamProgramIterator      End(void);                // returns iterator to end()
+        SamProgramConstIterator End(void) const;          // returns const_iterator to end()
+        SamProgramConstIterator ConstEnd(void) const;     // returns const_iterator to end()
+
+    // internal methods
+    private:
+        int IndexOf(const std::string& programId) const;
+        const std::string NextIdFor(const std::string& programId) const;
+
+    // data members
+    private:
+        SamProgramContainer m_data;
+};
+
+} // namespace BamTools
+
+#endif // SAM_PROGRAMCHAIN_H

data/ext/bamtools/src/api/SamReadGroup.cpp

@@ -0,0 +1,221 @@
+// ***************************************************************************
+// SamReadGroup.cpp (c) 2010 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 18 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides direct read/write access to the SAM read group data fields.
+// ***************************************************************************
+
+#include <api/SamReadGroup.h>
+using namespace BamTools;
+using namespace std;
+
+/*! \struct BamTools::SamReadGroup
+    \brief Represents a SAM read group entry.
+
+    Provides direct read/write access to the SAM read group data fields.
+
+    \sa \samSpecURL
+*/
+/*! \var SamReadGroup::Description
+    \brief corresponds to \@RG DS:\<Description\>
+*/
+/*! \var SamReadGroup::FlowOrder
+    \brief corresponds to \@RG FO:\<FlowOrder\>
+*/
+/*! \var SamReadGroup::ID
+    \brief corresponds to \@RG ID:\<ID\>
+
+    Required for valid SAM header.
+*/
+/*! \var SamReadGroup::KeySequence
+    \brief corresponds to \@RG KS:\<KeySequence\>
+*/
+/*! \var SamReadGroup::Library
+    \brief corresponds to \@RG LB:\<Library\>
+*/
+/*! \var SamReadGroup::PlatformUnit
+    \brief corresponds to \@RG PU:\<PlatformUnit\>
+*/
+/*! \var SamReadGroup::PredictedInsertSize
+    \brief corresponds to \@RG PI:\<PredictedInsertSize\>
+*/
+/*! \var SamReadGroup::ProductionDate
+    \brief corresponds to \@RG DT:\<ProductionDate\>
+*/
+/*! \var SamReadGroup::Program
+    \brief corresponds to \@RG PG:\<Program\>
+*/
+/*! \var SamReadGroup::Sample
+    \brief corresponds to \@RG SM:\<Sample\>
+*/
+/*! \var SamReadGroup::SequencingCenter
+    \brief corresponds to \@RG CN:\<SequencingCenter\>
+*/
+/*! \var SamReadGroup::SequencingTechnology
+    \brief corresponds to \@RG PL:\<SequencingTechnology\>
+*/
+
+/*! \fn SamReadGroup::SamReadGroup(void)
+    \brief default constructor
+*/
+SamReadGroup::SamReadGroup(void)
+    : Description("")
+    , FlowOrder("")
+    , ID("")
+    , KeySequence("")
+    , Library("")
+    , PlatformUnit("")
+    , PredictedInsertSize("")
+    , ProductionDate("")
+    , Program("")
+    , Sample("")
+    , SequencingCenter("")
+    , SequencingTechnology("")
+{ }
+
+/*! \fn SamReadGroup::SamReadGroup(const std::string& id)
+    \brief constructs read group with \a id
+
+    \param id desired read group ID
+*/
+SamReadGroup::SamReadGroup(const std::string& id)
+    : Description("")
+    , FlowOrder("")
+    , ID(id)
+    , KeySequence("")
+    , Library("")
+    , PlatformUnit("")
+    , PredictedInsertSize("")
+    , ProductionDate("")
+    , Program("")
+    , Sample("")
+    , SequencingCenter("")
+    , SequencingTechnology("")
+{ }
+
+/*! \fn SamReadGroup::SamReadGroup(const SamReadGroup& other)
+    \brief copy constructor
+*/
+SamReadGroup::SamReadGroup(const SamReadGroup& other)
+    : Description(other.Description)
+    , FlowOrder(other.FlowOrder)
+    , ID(other.ID)
+    , KeySequence(other.KeySequence)
+    , Library(other.Library)
+    , PlatformUnit(other.PlatformUnit)
+    , PredictedInsertSize(other.PredictedInsertSize)
+    , ProductionDate(other.ProductionDate)
+    , Program(other.Program)
+    , Sample(other.Sample)
+    , SequencingCenter(other.SequencingCenter)
+    , SequencingTechnology(other.SequencingTechnology)
+{ }
+
+/*! \fn SamReadGroup::~SamReadGroup(void)
+    \brief destructor
+*/
+SamReadGroup::~SamReadGroup(void) { }
+
+/*! \fn void SamReadGroup::Clear(void)
+    \brief Clears all data fields.
+*/
+void SamReadGroup::Clear(void) {
+    Description.clear();
+    FlowOrder.clear();
+    ID.clear();
+    KeySequence.clear();
+    Library.clear();
+    PlatformUnit.clear();
+    PredictedInsertSize.clear();
+    ProductionDate.clear();
+    Program.clear();
+    Sample.clear();
+    SequencingCenter.clear();
+    SequencingTechnology.clear();
+}
+
+/*! \fn bool SamReadGroup::HasDescription(void) const
+    \brief Returns \c true if read group contains \@RG DS:\<Description\>
+*/
+bool SamReadGroup::HasDescription(void) const {
+    return (!Description.empty());
+}
+
+/*! \fn bool SamReadGroup::HasFlowOrder(void) const
+    \brief Returns \c true if read group contains \@RG FO:\<FlowOrder\>
+*/
+bool SamReadGroup::HasFlowOrder(void) const {
+    return (!FlowOrder.empty());
+}
+
+/*! \fn bool SamReadGroup::HasID(void) const
+    \brief Returns \c true if read group contains \@RG: ID:\<ID\>
+*/
+bool SamReadGroup::HasID(void) const {
+    return (!ID.empty());
+}
+
+/*! \fn bool SamReadGroup::HasKeySequence(void) const
+    \brief Returns \c true if read group contains \@RG KS:\<KeySequence\>
+*/
+bool SamReadGroup::HasKeySequence(void) const {
+    return (!KeySequence.empty());
+}
+
+/*! \fn bool SamReadGroup::HasLibrary(void) const
+    \brief Returns \c true if read group contains \@RG LB:\<Library\>
+*/
+bool SamReadGroup::HasLibrary(void) const {
+    return (!Library.empty());
+}
+
+/*! \fn bool SamReadGroup::HasPlatformUnit(void) const
+    \brief Returns \c true if read group contains \@RG PU:\<PlatformUnit\>
+*/
+bool SamReadGroup::HasPlatformUnit(void) const {
+    return (!PlatformUnit.empty());
+}
+
+/*! \fn bool SamReadGroup::HasPredictedInsertSize(void) const
+    \brief Returns \c true if read group contains \@RG PI:\<PredictedInsertSize\>
+*/
+bool SamReadGroup::HasPredictedInsertSize(void) const {
+    return (!PredictedInsertSize.empty());
+}
+
+/*! \fn bool SamReadGroup::HasProductionDate(void) const
+    \brief Returns \c true if read group contains \@RG DT:\<ProductionDate\>
+*/
+bool SamReadGroup::HasProductionDate(void) const {
+    return (!ProductionDate.empty());
+}
+
+/*! \fn bool SamReadGroup::HasProgram(void) const
+    \brief Returns \c true if read group contains \@RG PG:\<Program\>
+*/
+bool SamReadGroup::HasProgram(void) const {
+    return (!Program.empty());
+}
+
+/*! \fn bool SamReadGroup::HasSample(void) const
+    \brief Returns \c true if read group contains \@RG SM:\<Sample\>
+*/
+bool SamReadGroup::HasSample(void) const {
+    return (!Sample.empty());
+}
+
+/*! \fn bool SamReadGroup::HasSequencingCenter(void) const
+    \brief Returns \c true if read group contains \@RG CN:\<SequencingCenter\>
+*/
+bool SamReadGroup::HasSequencingCenter(void) const {
+    return (!SequencingCenter.empty());
+}
+
+/*! \fn bool SamReadGroup::HasSequencingTechnology(void) const
+    \brief Returns \c true if read group contains \@RG PL:\<SequencingTechnology\>
+*/
+bool SamReadGroup::HasSequencingTechnology(void) const {
+    return (!SequencingTechnology.empty());
+}