ngs_server 0.1

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

@@ -0,0 +1,68 @@
+// ***************************************************************************
+// SamReadGroup.h (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.
+// ***************************************************************************
+
+#ifndef SAM_READGROUP_H
+#define SAM_READGROUP_H
+
+#include "api/api_global.h"
+#include <string>
+
+namespace BamTools {
+
+struct API_EXPORT SamReadGroup {
+
+    // ctor & dtor
+    SamReadGroup(void);
+    SamReadGroup(const std::string& id);
+    SamReadGroup(const SamReadGroup& other);
+    ~SamReadGroup(void);
+
+    // query/modify entire read group
+    void Clear(void);                           // clears all data fields
+
+    // convenience query methods
+    bool HasDescription(void) const;            // returns true if read group has a description
+    bool HasFlowOrder(void) const;              // returns true if read group has a flow order entry
+    bool HasID(void) const;                     // returns true if read group has a group ID
+    bool HasKeySequence(void) const;            // returns true if read group has a key sequence
+    bool HasLibrary(void) const;                // returns true if read group has a library name
+    bool HasPlatformUnit(void) const;           // returns true if read group has a platform unit ID
+    bool HasPredictedInsertSize(void) const;    // returns true if read group has a predicted insert size
+    bool HasProductionDate(void) const;         // returns true if read group has a production date
+    bool HasProgram(void) const;                // returns true if read group has a program entry
+    bool HasSample(void) const;                 // returns true if read group has a sample name
+    bool HasSequencingCenter(void) const;       // returns true if read group has a sequencing center ID
+    bool HasSequencingTechnology(void) const;   // returns true if read group has a sequencing technology ID
+
+
+    // data fields
+    std::string Description;                    // DS:<Description>
+    std::string FlowOrder;                      // FO:<FlowOrder>
+    std::string ID;                             // ID:<ID>              *Required for valid SAM header*
+    std::string KeySequence;                    // KS:<KeySequence>
+    std::string Library;                        // LB:<Library>
+    std::string PlatformUnit;                   // PU:<PlatformUnit>
+    std::string PredictedInsertSize;            // PI:<PredictedInsertSize>
+    std::string ProductionDate;                 // DT:<ProductionDate>
+    std::string Program;                        // PG:<Program>
+    std::string Sample;                         // SM:<Sample>
+    std::string SequencingCenter;               // CN:<SequencingCenter>
+    std::string SequencingTechnology;           // PL:<SequencingTechnology>
+};
+
+/*! \fn bool operator==(const SamReadGroup& lhs, const SamReadGroup& rhs)
+    \brief tests equality by comparing read group IDs
+*/
+API_EXPORT inline bool operator==(const SamReadGroup& lhs, const SamReadGroup& rhs) {
+    return lhs.ID == rhs.ID;
+}
+
+} // namespace BamTools
+
+#endif // SAM_READGROUP_H

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

@@ -0,0 +1,289 @@
+// ***************************************************************************
+// SamReadGroupDictionary.cpp (c) 2010 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 18 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides methods for operating on a collection of SamReadGroup entries.
+// ***************************************************************************
+
+#include <api/SamReadGroupDictionary.h>
+using namespace BamTools;
+
+#include <algorithm>
+#include <iostream>
+using namespace std;
+
+/*! \class BamTools::SamReadGroupDictionary
+    \brief Container of SamReadGroup entries.
+
+    Provides methods for operating on a collection of SamReadGroup entries.
+*/
+
+/*! \fn SamReadGroupDictionary::SamReadGroupDictionary(void)
+    \brief constructor
+*/
+SamReadGroupDictionary::SamReadGroupDictionary(void) { }
+
+/*! \fn SamReadGroupDictionary::SamReadGroupDictionary(const SamReadGroupDictionary& other)
+    \brief copy constructor
+*/
+SamReadGroupDictionary::SamReadGroupDictionary(const SamReadGroupDictionary& other)
+    : m_data(other.m_data)
+{ }
+
+/*! \fn SamReadGroupDictionary::~SamReadGroupDictionary(void)
+    \brief destructor
+*/
+SamReadGroupDictionary::~SamReadGroupDictionary(void) { }
+
+/*! \fn void SamReadGroupDictionary::Add(const SamReadGroup& readGroup)
+    \brief Adds a read group to the dictionary.
+
+    Duplicate entries are silently discarded.
+
+    \param readGroup entry to be added
+*/
+void SamReadGroupDictionary::Add(const SamReadGroup& readGroup) {
+
+    // TODO: report error on attempted duplicate?
+
+    if ( IsEmpty() || !Contains(readGroup) )
+        m_data.push_back(readGroup);
+}
+
+/*! \fn void SamReadGroupDictionary::Add(const std::string& readGroupId)
+    \brief Adds a read group to the dictionary.
+
+    This is an overloaded function.
+
+    \param readGroupId ID of read group to be added
+    \sa Add()
+*/
+void SamReadGroupDictionary::Add(const std::string& readGroupId) {
+    Add( SamReadGroup(readGroupId) );
+}
+
+/*! \fn void SamReadGroupDictionary::Add(const std::vector<SamReadGroup>& readGroups)
+    \brief Adds multiple read groups to the dictionary.
+
+    This is an overloaded function.
+
+    \param readGroups entries to be added
+    \sa Add()
+*/
+void SamReadGroupDictionary::Add(const std::vector<SamReadGroup>& readGroups) {
+    vector<SamReadGroup>::const_iterator rgIter = readGroups.begin();
+    vector<SamReadGroup>::const_iterator rgEnd  = readGroups.end();
+    for ( ; rgIter!= rgEnd; ++rgIter )
+        Add(*rgIter);
+}
+
+/*! \fn void SamReadGroupDictionary::Add(const std::vector<std::string>& readGroupIds)
+    \brief Adds multiple read groups to the dictionary.
+
+    This is an overloaded function.
+
+    \param readGroupIds IDs of read groups to be added
+    \sa Add()
+*/
+void SamReadGroupDictionary::Add(const std::vector<std::string>& readGroupIds) {
+    vector<string>::const_iterator rgIter = readGroupIds.begin();
+    vector<string>::const_iterator rgEnd  = readGroupIds.end();
+    for ( ; rgIter!= rgEnd; ++rgIter )
+        Add(*rgIter);
+}
+
+/*! \fn SamReadGroupIterator SamReadGroupDictionary::Begin(void)
+    \return an STL iterator pointing to the first read group
+    \sa ConstBegin(), End()
+*/
+SamReadGroupIterator SamReadGroupDictionary::Begin(void) {
+    return m_data.begin();
+}
+
+/*! \fn SamReadGroupConstIterator SamReadGroupDictionary::Begin(void) const
+    \return an STL const_iterator pointing to the first read group
+
+    This is an overloaded function.
+
+    \sa ConstBegin(), End()
+*/
+SamReadGroupConstIterator SamReadGroupDictionary::Begin(void) const {
+    return m_data.begin();
+}
+
+/*! \fn void SamReadGroupDictionary::Clear(void)
+    \brief Clears all read group entries.
+*/
+void SamReadGroupDictionary::Clear(void) {
+    m_data.clear();
+}
+
+/*! \fn SamReadGroupConstIterator SamReadGroupDictionary::ConstBegin(void) const
+    \return an STL const_iterator pointing to the first read group
+    \sa Begin(), ConstEnd()
+*/
+SamReadGroupConstIterator SamReadGroupDictionary::ConstBegin(void) const {
+    return m_data.begin();
+}
+
+/*! \fn SamReadGroupConstIterator SamReadGroupDictionary::ConstEnd(void) const
+    \return an STL const_iterator pointing to the imaginary entry after the last read group
+    \sa ConstBegin(), End()
+*/
+SamReadGroupConstIterator SamReadGroupDictionary::ConstEnd(void) const {
+    return m_data.end();
+}
+
+/*! \fn bool SamReadGroupDictionary::Contains(const std::string& readGroupId) const
+    \brief Returns true if dictionary contains read group.
+    \param readGroupId search for read group matching this ID
+    \return \c true if dictionary contains a read group with this ID
+*/
+bool SamReadGroupDictionary::Contains(const std::string& readGroupId) const {
+    return ( IndexOf(readGroupId) != (int)m_data.size() );
+}
+
+/*! \fn bool SamReadGroupDictionary::Contains(const SamReadGroup& readGroup) const
+    \brief Returns true if dictionary contains read group (matching on ID).
+
+    This is an overloaded function.
+
+    \param readGroup search for this read group
+    \return \c true if dictionary contains read group (matching on ID).
+*/
+bool SamReadGroupDictionary::Contains(const SamReadGroup& readGroup) const {
+    return Contains( readGroup.ID );
+}
+
+/*! \fn SamReadGroupIterator SamReadGroupDictionary::End(void)
+    \return an STL iterator pointing to the imaginary entry after the last read group
+    \sa Begin(), ConstEnd()
+*/
+SamReadGroupIterator SamReadGroupDictionary::End(void) {
+    return m_data.end();
+}
+
+/*! \fn SamReadGroupConstIterator SamReadGroupDictionary::End(void) const
+    \return an STL const_iterator pointing to the imaginary entry after the last read group
+
+    This is an overloaded function.
+
+    \sa Begin(), ConstEnd()
+*/
+SamReadGroupConstIterator SamReadGroupDictionary::End(void) const {
+    return m_data.end();
+}
+
+/*! \fn int SamReadGroupDictionary::IndexOf(const std::string& readGroupId) const
+    \internal
+    \return index of read group if found.  Otherwise, returns vector::size() (invalid index).
+*/
+int SamReadGroupDictionary::IndexOf(const std::string& readGroupId) const {
+    SamReadGroupConstIterator begin = ConstBegin();
+    SamReadGroupConstIterator iter  = begin;
+    SamReadGroupConstIterator end   = ConstEnd();
+    for ( ; iter != end; ++iter ) {
+        const SamReadGroup& current = (*iter);
+        if ( current.ID == readGroupId )
+            break;
+    }
+    return distance( begin, iter );
+}
+
+/*! \fn bool SamReadGroupDictionary::IsEmpty(void) const
+    \brief Returns \c true if dictionary contains no read groups
+    \sa Size()
+*/
+bool SamReadGroupDictionary::IsEmpty(void) const {
+    return m_data.empty();
+}
+
+/*! \fn void SamReadGroupDictionary::Remove(const SamReadGroup& readGroup)
+    \brief Removes read group from dictionary, if found (matching on ID).
+
+    This is an overloaded function.
+
+    \param readGroup read group to remove (matches on ID)
+*/
+void SamReadGroupDictionary::Remove(const SamReadGroup& readGroup) {
+    Remove( readGroup.ID );
+}
+
+/*! \fn void SamReadGroupDictionary::Remove(const std::string& readGroupId)
+    \brief Removes read group from dictionary, if found.
+    \param readGroupId ID of read group to remove
+    \sa Remove()
+*/
+void SamReadGroupDictionary::Remove(const std::string& readGroupId) {
+    if ( Contains(readGroupId) )
+        m_data.erase( m_data.begin() + IndexOf(readGroupId) );
+}
+
+/*! \fn void SamReadGroupDictionary::Remove(const std::vector<SamReadGroup>& readGroups)
+    \brief Removes multiple read groups from dictionary (matching on ID).
+
+    This is an overloaded function.
+
+    \param readGroups read groups to remove
+    \sa Remove()
+*/
+void SamReadGroupDictionary::Remove(const std::vector<SamReadGroup>& readGroups) {
+    vector<SamReadGroup>::const_iterator rgIter = readGroups.begin();
+    vector<SamReadGroup>::const_iterator rgEnd  = readGroups.end();
+    for ( ; rgIter!= rgEnd; ++rgIter )
+        Remove(*rgIter);
+}
+
+/*! \fn void SamReadGroupDictionary::Remove(const std::vector<std::string>& readGroupIds)
+    \brief Removes multiple read groups from dictionary.
+
+    This is an overloaded function.
+
+    \param readGroupIds IDs of the read groups to remove
+    \sa Remove()
+*/
+void SamReadGroupDictionary::Remove(const std::vector<std::string>& readGroupIds) {
+    vector<string>::const_iterator rgIter = readGroupIds.begin();
+    vector<string>::const_iterator rgEnd  = readGroupIds.end();
+    for ( ; rgIter!= rgEnd; ++rgIter )
+        Remove(*rgIter);
+}
+
+/*! \fn int SamReadGroupDictionary::Size(void) const
+    \brief Returns number of read groups in dictionary.
+    \sa IsEmpty()
+*/
+int SamReadGroupDictionary::Size(void) const {
+    return m_data.size();
+}
+
+/*! \fn SamReadGroup& SamReadGroupDictionary::operator[](const std::string& readGroupId)
+    \brief Retrieves the modifiable SamReadGroup that matches \a readGroupId.
+
+    NOTE - If the dictionary contains no read group matching this ID, this function inserts
+    a new one with this ID, and returns a reference to it.
+
+    If you want to avoid this insertion behavior, check the result of Contains() before
+    using this operator.
+
+    \param readGroupId ID of read group to retrieve
+    \return a modifiable reference to the SamReadGroup associated with the ID
+*/
+SamReadGroup& SamReadGroupDictionary::operator[](const std::string& readGroupId) {
+
+    // look up read group ID
+    int index = IndexOf(readGroupId);
+
+    // if found, return read group at index
+    if ( index != (int)m_data.size() )
+        return m_data[index];
+
+    // otherwise, append new read group and return reference
+    else {
+        SamReadGroup rg(readGroupId);
+        m_data.push_back(rg);
+        return m_data.back();
+    }
+}

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

@@ -0,0 +1,86 @@
+// ***************************************************************************
+// SamReadGroupDictionary.h (c) 2010 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 18 April 2011 (DB)
+// ---------------------------------------------------------------------------
+// Provides methods for operating on a collection of SamReadGroup entries.
+// ***************************************************************************
+
+#ifndef SAM_READGROUP_DICTIONARY_H
+#define SAM_READGROUP_DICTIONARY_H
+
+#include <api/api_global.h>
+#include <api/SamReadGroup.h>
+#include <string>
+#include <vector>
+
+namespace BamTools {
+
+typedef std::vector<SamReadGroup>             SamReadGroupContainer;
+typedef SamReadGroupContainer::iterator       SamReadGroupIterator;
+typedef SamReadGroupContainer::const_iterator SamReadGroupConstIterator;
+
+class API_EXPORT SamReadGroupDictionary {
+
+    // ctor & dtor
+    public:
+        SamReadGroupDictionary(void);
+        SamReadGroupDictionary(const SamReadGroupDictionary& other);
+        ~SamReadGroupDictionary(void);
+
+    // query/modify read group data
+    public:
+        // adds a read group
+        void Add(const SamReadGroup& readGroup);
+        void Add(const std::string& readGroupId);
+
+        // adds multiple read groups
+        void Add(const std::vector<SamReadGroup>& readGroups);
+        void Add(const std::vector<std::string>& readGroupIds);
+
+        // clears all read group entries
+        void Clear(void);
+
+        // returns true if dictionary contains this read group
+        bool Contains(const SamReadGroup& readGroup) const;
+        bool Contains(const std::string& readGroupId) const;
+
+        // returns true if dictionary is empty
+        bool IsEmpty(void) const;
+
+        // removes read group, if found
+        void Remove(const SamReadGroup& readGroup);
+        void Remove(const std::string& readGroupId);
+
+        // removes multiple read groups
+        void Remove(const std::vector<SamReadGroup>& readGroups);
+        void Remove(const std::vector<std::string>& readGroupIds);
+
+        // returns number of read groups in dictionary
+        int Size(void) const;
+
+        // retrieves a modifiable reference to the SamReadGroup object associated with this ID
+        SamReadGroup& operator[](const std::string& readGroupId);
+
+    // retrieve STL-compatible iterators
+    public:
+        SamReadGroupIterator      Begin(void);              // returns iterator to begin()
+        SamReadGroupConstIterator Begin(void) const;        // returns const_iterator to begin()
+        SamReadGroupConstIterator ConstBegin(void) const;   // returns const_iterator to begin()
+        SamReadGroupIterator      End(void);                // returns iterator to end()
+        SamReadGroupConstIterator End(void) const;          // returns const_iterator to end()
+        SamReadGroupConstIterator ConstEnd(void) const;     // returns const_iterator to end()
+
+    // internal methods
+    private:
+        int IndexOf(const std::string& readGroupId) const;
+
+    // data members
+    private:
+        SamReadGroupContainer m_data;
+};
+
+} // namespace BamTools
+
+#endif // SAM_READGROUP_DICTIONARY_H

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

@@ -0,0 +1,161 @@
+// ***************************************************************************
+// SamSequence.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 sequence data fields.
+// ***************************************************************************
+
+#include <api/SamSequence.h>
+#include <sstream>
+using namespace BamTools;
+using namespace std;
+
+/*! \struct BamTools::SamSequence
+    \brief Represents a SAM sequence entry.
+
+    Provides direct read/write access to the SAM sequence data fields.
+
+    \sa \samSpecURL
+*/
+/*! \var SamSequence::AssemblyID
+    \brief corresponds to \@SQ AS:\<AssemblyID\>
+*/
+/*! \var SamSequence::Checksum
+    \brief corresponds to \@SQ M5:\<Checksum\>
+*/
+/*! \var SamSequence::Length
+    \brief corresponds to \@SQ LN:\<Length\>
+
+    Required for valid SAM header.
+*/
+/*! \var SamSequence::Name
+    \brief corresponds to \@SQ SN:\<Name\>
+
+    Required for valid SAM header.
+*/
+/*! \var SamSequence::Species
+    \brief corresponds to \@SQ SP:\<Species\>
+*/
+/*! \var SamSequence::URI
+    \brief corresponds to \@SQ UR:\<URI\>
+*/
+
+/*! \fn SamSequence::SamSequence(void)
+    \brief default constructor
+*/
+SamSequence::SamSequence(void)
+    : AssemblyID("")
+    , Checksum("")
+    , Length("")
+    , Name("")
+    , Species("")
+    , URI("")
+{ }
+
+/*! \fn SamSequence::SamSequence(const std::string& name, const int& length)
+    \brief constructs sequence with \a name and \a length
+
+    \param name   desired sequence name
+    \param length desired sequence length (numeric value)
+*/
+SamSequence::SamSequence(const std::string& name,
+                         const int& length)
+    : AssemblyID("")
+    , Checksum("")
+    , Name(name)
+    , Species("")
+    , URI("")
+{
+    stringstream s("");
+    s << length;
+    Length = s.str();
+}
+
+/*! \fn SamSequence::SamSequence(const std::string& name, const std::string& length)
+    \brief constructs sequence with \a name and \a length
+
+    \param name   desired sequence name
+    \param length desired sequence length (string value)
+*/
+SamSequence::SamSequence(const std::string& name,
+                         const std::string& length)
+    : AssemblyID("")
+    , Checksum("")
+    , Length(length)
+    , Name(name)
+    , Species("")
+    , URI("")
+{ }
+
+/*! \fn SamSequence::SamSequence(const SamSequence& other)
+    \brief copy constructor
+*/
+SamSequence::SamSequence(const SamSequence& other)
+    : AssemblyID(other.AssemblyID)
+    , Checksum(other.Checksum)
+    , Length(other.Length)
+    , Name(other.Name)
+    , Species(other.Species)
+    , URI(other.URI)
+{ }
+
+/*! \fn SamSequence::~SamSequence(void)
+    \brief destructor
+*/
+SamSequence::~SamSequence(void) { }
+
+/*! \fn void SamSequence::Clear(void)
+    \brief Clears all data fields.
+*/
+void SamSequence::Clear(void) {
+    AssemblyID.clear();
+    Checksum.clear();
+    Length.clear();
+    Name.clear();
+    Species.clear();
+    URI.clear();
+}
+
+/*! \fn bool SamSequence::HasAssemblyID(void) const
+    \brief Returns \c true if sequence contains \@SQ AS:\<AssemblyID\>
+*/
+bool SamSequence::HasAssemblyID(void) const {
+    return (!AssemblyID.empty());
+}
+
+/*! \fn bool SamSequence::HasChecksum(void) const
+    \brief Returns \c true if sequence contains \@SQ M5:\<Checksum\>
+*/
+bool SamSequence::HasChecksum(void) const {
+    return (!Checksum.empty());
+}
+
+/*! \fn bool SamSequence::HasLength(void) const
+    \brief Returns \c true if sequence contains \@SQ LN:\<Length\>
+*/
+bool SamSequence::HasLength(void) const {
+    return (!Length.empty());
+}
+
+/*! \fn bool SamSequence::HasName(void) const
+    \brief Returns \c true if sequence contains \@SQ SN:\<Name\>
+*/
+bool SamSequence::HasName(void) const {
+    return (!Name.empty());
+}
+
+/*! \fn bool SamSequence::HasSpecies(void) const
+    \brief Returns \c true if sequence contains \@SQ SP:\<Species\>
+*/
+bool SamSequence::HasSpecies(void) const {
+    return (!Species.empty());
+}
+
+/*! \fn bool SamSequence::HasURI(void) const
+    \brief Returns \c true if sequence contains \@SQ UR:\<URI\>
+*/
+bool SamSequence::HasURI(void) const {
+    return (!URI.empty());
+}

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

@@ -0,0 +1,60 @@
+// ***************************************************************************
+// SamSequence.h (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 sequence data fields.
+// ***************************************************************************
+
+#ifndef SAM_SEQUENCE_H
+#define SAM_SEQUENCE_H
+
+#include <api/api_global.h>
+#include <string>
+
+namespace BamTools {
+
+struct API_EXPORT SamSequence {
+
+    // ctor & dtor
+    SamSequence(void);
+    SamSequence(const std::string& name, const int& length);
+    SamSequence(const std::string& name, const std::string& length);
+    SamSequence(const SamSequence& other);
+    ~SamSequence(void);
+
+    // query/modify entire sequence
+    void Clear(void);                   // clears all contents
+
+    // convenience query methods
+    bool HasAssemblyID(void) const;     // returns true if sequence has an assembly ID
+    bool HasChecksum(void) const;       // returns true if sequence has an MD5 checksum
+    bool HasLength(void) const;         // returns true if sequence has a length
+    bool HasName(void) const;           // returns true if sequence has a name
+    bool HasSpecies(void) const;        // returns true if sequence has a species ID
+    bool HasURI(void) const;            // returns true if sequence has a URI
+
+    // data members
+    std::string AssemblyID;             // AS:<AssemblyID>
+    std::string Checksum;               // M5:<Checksum>
+    std::string Length;                 // LN:<Length>      *Required for valid SAM header*
+    std::string Name;                   // SN:<Name>        *Required for valid SAM header*
+    std::string Species;                // SP:<Species>
+    std::string URI;                    // UR:<URI>
+};
+
+/*! \fn bool operator==(const SamSequence& lhs, const SamSequence& rhs)
+    \brief tests equality by comparing sequence names, lengths, & checksums (if available)
+*/
+API_EXPORT inline bool operator==(const SamSequence& lhs, const SamSequence& rhs) {
+    if ( lhs.Name   != rhs.Name   ) return false;
+    if ( lhs.Length != rhs.Length ) return false;
+    if ( lhs.HasChecksum() && rhs.HasChecksum() )
+        return (lhs.Checksum == rhs.Checksum);
+    else return true;
+}
+
+} // namespace BamTools
+
+#endif // SAM_SEQUENCE_H