serialization.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 SHORE_SERIALIZATION_HPP__
#define SHORE_SERIALIZATION_HPP__

#include "shore/datatype/coor.hpp"
#include "shore/datatype/alignment_processing.hpp"
#include "shore/algo/align.hpp"

namespace shore {

class serialization_core_access
{
 private:

        serialization_core_access();

 public:

        template<typename Archive>
        static void serialize(Archive &ar,shore::alignment_statistic &c,
                              const unsigned int version)
        {
                ar&c.m_stats;
        }
};

template<typename Archive>
void serialize(Archive &ar,shore::refseq_coor &c,const unsigned int version)
{
        ar&c.chromosome;
        ar&c.position;
}

template<typename Archive>
void serialize(Archive &ar,shore::refseq_region &c,const unsigned int version)
{
        ar&c.coor;
        ar&c.size;
}

template<typename Archive>
void serialize(Archive &ar,shore::refseq_range &c,const unsigned int version)
{
        ar&c.start;
        ar&c.end;
}

template<typename Archive>
void serialize(Archive &ar,shore::genomic_coor &c,const unsigned int version)
{
        ar&c.sequence;
        ar&c.position;
}

template<typename Archive>
void serialize(Archive &ar,shore::genomic_region &c,const unsigned int version)
{
        ar&c.coor;
        ar&c.size;
}

template<typename Archive>
void serialize(Archive &ar,shore::genomic_range &c,const unsigned int version)
{
        ar&c.start;
        ar&c.end;
}

template<typename Archive>
void serialize(Archive & ar,shore::read::accessory & r,
               const unsigned int version)
{
        ar&r.badqual_flags;
        ar&r.edit_distance_hint;
        ar&r.clip_left;
        ar&r.clip_right;
        ar&r.barcode;
        ar&r.readgroup;
        ar&r.num_reads;
        ar&r.ori;
}

template<typename Archive>
void serialize(Archive & ar,shore::read & r,const unsigned int version)
{
        ar&r.id;
        ar&r.sequence;
        ar&r.qual_std;
        ar&r.index;
        ar&r.pe_state;
        ar&r.qual_aux;
        ar&r.tags;
}

template<typename Archive>
void serialize(Archive & ar,shore::alignment::accessory & a,
               const unsigned int version)
{
        ar&a.map_qual;
        ar&a.readgroup;
        ar&a.num_reads;
        ar&a.ori;
        ar&a.ori_readlength;
        ar&a.nextread_coor;
        ar&a.nextread_strand;
}

template<typename Archive>
void serialize(Archive & ar,shore::alignment & a,const unsigned int version)
{
        ar&a.id;
        ar&a.coor;
        ar&a.readlength;
        ar&a.strand;
        ar&a.hits;
        ar&a.alignment_string;
        ar&a.mismatches;
        ar&a.offset;
        ar&a.index;
        ar&a.pe_state;
        ar&a.qual_std;
        ar&a.qual_aux;
        ar&a.qual_raw;
        ar&a.tags;
}

template<typename Archive>
void serialize(Archive & ar,shore::dp_trace & t,const unsigned int version)
{
        ar&t.alignment_id;
        ar&t.left_ends;
        ar&t.right_ends;
        ar&t.alignment_string;
        ar&t.score;
        ar&t.ref_id;
        ar&t.ref_hits;
        ar&t.ref_totalsize;
        ar&t.qry_totalsize;
        ar&t.ref_pos;
        ar&t.ref_end;
        ar&t.qry_pos;
        ar&t.qry_end;
        ar&t.soft_clipped;
        ar&t.unique_alignment;
        ar&t.unique_mapping;
}

template<typename Archive>
void serialize(Archive & ar,shore::dp_mapping & m,const unsigned int version)
{
        ar&const_cast<shore::read * &>(m.read);
        ar&const_cast<shore::dp_trace * &>(m.trace);
}

template<typename Archive>
void serialize(Archive &ar,shore::alignment_statistic &c,
               const unsigned int version)
{
        serialization_core_access::serialize(ar,c,version);
}

} // namespace

#endif // SHORE_SERIALIZATION_HPP__