datatypes.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 *
 * This file is part of SHORE.
 *
 * SHORE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SHORE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef DATATYPES_HPP__
#define DATATYPES_HPP__

#include <string>
#include <vector>
#include <map>

#include <boost/shared_ptr.hpp>

#include "shore/datatype/dna_iterator.hpp"
#include "shore/container/intpack.hpp"
#include "shore/base/memops.hpp"
#include "shore/datatype/coor.hpp"

namespace shore {

struct read
{
        static const int ASCIIENC_ILLUMINA=64;
        static const int ASCIIENC_SANGER=33;
        static const int ASCIIENC_CHASTITY=-10;

        enum InsertState
        {
                PE_UNSPECIFIED,
                PE_FILTER_ORPHAN,
                PE_TECHNICAL,
                PE_PAIRED
        };

        static const char insstate_enc[5];

        enum PeOrientation
        {
                ORI_UNSPECIFIED,
                ORI_TOWARDS,
                ORI_AWAY,
                ORI_SAME
        };

        static const char *ori_conv[4];

        std::string id;

        std::string sequence;

        std::string qual_std;

        int index;
        InsertState pe_state;

        std::string qual_aux;

        struct accessory
        {
                static const uint16_t CLIP_RIGHT_NA;
                static const int EDIT_DISTANCE_NA;

                int badqual_flags;
                int edit_distance_hint;

                uint16_t clip_left;
                uint16_t clip_right;
                std::string barcode;
                std::string readgroup;

                int num_reads;

                PeOrientation ori;

                accessory();

                void reset();

                bool empty() const;

                void write(std::ostream &str,const char *const sep) const;
        };

        accessory tags;

        read();

        bool is_firstread() const;
        bool is_lastread() const;

        int get_qual_std(const size_t pos) const;

        void get_part(shore::read &buf,size_t left,size_t right,bool set_tags) const;

        void get_clipped_read(shore::read &buf,bool set_tags=false) const;

        void get_read_prefix(shore::read &buf,bool set_tags=false) const;

        void get_read_suffix(shore::read &buf,bool set_tags=false) const;

        typedef bool(*compare_type)(const read &,const read &);

        static bool cmp_id(const read &r1,const read &r2);

        static bool cmp_seq(const read &r1,const read &r2);

        static bool cmp_id_str(const std::string &id1,const std::string &id2);

        static void qual_sanger2illumina(std::string &qual);
        static void qual_illumina2sanger(std::string &qual);
        static void qual_solexa2sanger(std::string &qual);

        static char enc_qual_sanger(const int q);
        static int dec_qual_sanger(const char q);
};

S_MAKE_ENUM_TRAITS(read::PeOrientation)


struct alignment
{
        static const char strandconv_dp[5];
        //static const bool peconv_legacy[9];

        enum InsertState
        {
                PE_UNSPECIFIED,
                PE_FILTER_ORPHAN,
                PE_TECHNICAL,
                PE_PAIRED,
                //          size distribution
                PE_CONCORDANT,
                PE_DISCORDANT,
                // \brief   Partner is unmapped.
                PE_MAPPING_ORPHAN,
                PE_ACCESSORY,
                // \brief   Concordant, but another mapping has a more likely pairing
                PE_SUBOPTIMAL
        };

        static const read::InsertState insstate_flatten[9];
        static const char insstate_enc[10];

        std::string id;

        shore::refseq_coor coor;

        size_t readlength;

        shore::Strand strand;

        int hits;

        std::string alignment_string;

        int mismatches;

        size_t offset;

        int index;
        InsertState pe_state;

        std::string qual_std;

        std::string qual_aux;

        std::string qual_raw;

        struct accessory
        {
                static const int MAP_QUAL_NA=255;

                int map_qual;

                std::string readgroup;

                int num_reads;

                read::PeOrientation ori;

                size_t ori_readlength;

                shore::refseq_coor nextread_coor;
                shore::Strand nextread_strand;

                accessory();
                explicit accessory(const shore::read::accessory &read_tags);

                accessory & operator=(const shore::read::accessory &read_tags);

                void write(std::ostream &os,const char *const sep) const;
                void reset();
                bool empty() const;
        };

        accessory tags;

        alignment();

        // convenience functions ///////////////////////////////////////////////////

        char get_qual_std_char(const size_t pos) const;
        char get_qual_aux_char(const size_t pos) const;

        int get_qual_std(const size_t pos) const;
        int get_qual_aux(const size_t pos) const;

        //static int plain_peflag(const int pairing);

        //static bool is_first(const int pairing);

        bool is_firstread() const;
        bool is_lastread() const;

        bool is_fwd_frag() const;
        bool is_rev_frag() const;

        bool partner_mapped() const;


        typedef bool(*cmp_type)(const alignment &,const alignment &);

        static bool cmp_coor(const alignment &f1,const alignment &f2);
        static bool cmp_id(const alignment &f1,const alignment &f2);
        static bool cmp_null(const alignment &f1,const alignment &f2);
};


class fasta_reader;

class sequence_record
{
 private:

        friend class fasta_reader;

        long m_enumerated;
        std::string m_header;
        std::string m_id;
        std::string m_supplement;
        std::string m_md5sum;

        std::string m_sequence_str;
        intpack m_sequence_pack;
        boost::shared_ptr<shore::mmapping> m_sequence_mmpp;
        std::streamoff m_mmpp_off;
        std::streamsize m_mmpp_size;


        size_t m_size;
        const char *m_cbegin;
        const char *m_cend;
        dna_iterator m_seqbegin;
        dna_iterator m_seqend;
        chardna_iterator m_seqbegin_c;
        chardna_iterator m_seqend_c;


        void init();

 public:

        sequence_record();
        sequence_record(const sequence_record &other);
        sequence_record &operator=(const sequence_record &other);

        const std::string &get_header() const;
        const std::string &get_id() const;
        const std::string &get_supplement() const;

        long enumerated() const;

        dna_iterator seqbegin() const;
        dna_iterator seqend() const;
        chardna_iterator seqbegin_c() const;
        chardna_iterator seqend_c() const;

        void substr(std::string &res,const size_t ofs,size_t size=0) const;
        std::string substr(const size_t ofs,const size_t size=0) const;
        char operator[](const size_t i) const;
        bool compare(const size_t ofs,const size_t size,const std::string &str) const;
        bool empty() const;

        size_t size() const;

        std::string md5sum() const;

        void write_sequence(std::ostream &out) const;
};


struct sff_read
{
        struct commonhead
        {
                uint32_t magic;

                char version[4];

                uint64_t index_offset;
                uint32_t index_length;

                uint32_t number_of_reads;

                uint16_t header_length;

                uint16_t key_length;

                uint16_t number_of_flows_per_read;

                uint8_t flowgram_format_code;

                std::string flow_chars;

                std::string key_sequence;

                // uint8_t* eight_byte_padding (omitted)
        };

        /*
         * If an index is included in the file, the index_offset and index_length values in the common
         * header should point to the section of the file containing the index. To support different
         * indexing methods, the index section should begin with the following two fields:
         *
         * - index_magic_number                uint32_t
         * - index_version                     char[4]
         *
         * ... and should end with an eight_byte_padding field, so that the length of the index section
         * is divisible by 8. The format of the rest of the index section is specific to the indexing
         * method used. The index_length given in the common header should include the bytes of
         * these fields and the padding.
         */

        struct readhead
        {
                uint16_t read_header_length;

                uint16_t name_length;

                uint32_t number_of_bases;

                uint16_t clip_qual_left;
                uint16_t clip_qual_right;
                uint16_t clip_adapter_left;
                uint16_t clip_adapter_right;

                std::string name;

                //uint8_t[*]
                //eight_byte_padding
        };

        struct readdata
        {
                std::vector<uint16_t> flowgram_values;

                std::vector<uint8_t> flow_index_per_base;

                std::string bases;

                std::string quality_scores;

                //uint8_t[*] eight_byte_padding
        };

        commonhead *chead;
        readhead rhead;
        readdata rdata;

        sff_read()
        :chead(0)
        {}

        typedef bool(*compare_type)(const sff_read &,const sff_read &);

        static bool cmp_id(const sff_read &r1,const sff_read &r2);

        static bool cmp_seq(const sff_read &r1,const sff_read &r2);
};


struct annotation_entry
{
        std::string seqid;

        std::string source;

        std::string type;

        long pos;
        long end;

        double score;
        static const double SCORE_NA;
        static bool is_score_NA(const double& score);

        shore::ExtendedStrand strand;

        enum Phase
        {
                PHASE_NA=-1,
                PHASE_0=0,
                PHASE_1=1,
                PHASE_2=2
        };

        Phase phase;

        std::vector<std::string> other_attributes;

        static const std::string ATTR_ID;
        static const std::string ATTR_NAME;
        static const std::string ATTR_ALIAS;
        static const std::string ATTR_PARENT;
        static const std::string ATTR_TARGET;
        static const std::string ATTR_GAP;
        static const std::string ATTR_DERIVES_FROM;
        static const std::string ATTR_NOTE;
        static const std::string ATTR_DBXREF;
        static const std::string ATTR_ONTOLOGY_TERM;
        static const std::string ATTR_IS_CIRCULAR;

        std::string id;

        std::string name;

        std::string alias;

        std::string parent;

        std::string target;

        std::string gap;

        std::string derives_from;

        std::string note;

        std::string dbxref;

        std::string ontology_term;

        bool is_circular;
};

std::istream &operator>>(std::istream &is,annotation_entry::Phase &phase);
std::ostream &operator<<(std::ostream &os,const annotation_entry::Phase &phase);


struct delta_record
{
        std::string files;
        std::string delta_type;

        std::string ref_seqid;
        std::string qry_seqid;
        size_t ref_seqsize;
        size_t qry_seqsize;

        size_t ref_start;
        size_t ref_end;

        size_t qry_start;

        size_t qry_end;

        int err_edit;
        int err_similarity;

        int nstop;

        std::vector<int> deltas;
};


struct coverage
:public shore::refseq_region
{
        shore::OptionalStrand strand;

        double score;

        coverage()
        :refseq_region(refseq_coor(1,1),0),
         strand(shore::STR_NA_OPT),score(0.0)
        {}
};


struct segment
:public shore::refseq_region
{
        std::string id;

        shore::OptionalStrand strand;

        double min_coverage;
        double max_coverage;
        double p;

        segment()
        :refseq_region(refseq_coor(1,1),0),
         strand(shore::STR_NA_OPT),
         min_coverage(-1),max_coverage(-1),p(-1)
        {}

        typedef bool(*cmp_type)(const segment &,const segment &);

        static bool cmp_coor(const segment &f1,const segment &f2);
};


struct refdict_entry
{
        int num_id;
        std::string str_id;
        size_t size;
        std::string md5;
        std::string supplement;

        operator shore::refseq_region() const;
};


struct local_variant
{
        std::string ecotype;
        std::string chromosome;
        long position;
        char ref_base;
        char new_base;
        int quality;
        unsigned int support;
        double concordance;
        double repetitiveness;
};


struct wga_record
{
        size_t id;

        std::string ref_seqid;
        std::string qry_seqid;
        long ref_pos;
        long qry_pos;
        int ref_size;
        int qry_size;

        shore::Strand strand;

        std::string aln;

        int nsubst;
        int nins;
        int ndel;
        int nmatch;

        wga_record();
        void init(const int idnum,const std::string &refid,const std::string &qryid);
};

} // namespace shore

#endif /* DATATYPES_HPP__ */