JunctionVcfWriter.hpp

Go to the documentation of this file.

// Copyright 2012 Complete Genomics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you
// may not use this file except in compliance with the License. You
// may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.

#ifndef CGA_TOOLS_JUNCTION_VCF_WRITER_HPP_
#define CGA_TOOLS_JUNCTION_VCF_WRITER_HPP_



// Complete Genomics.
#include "cgatools/core.hpp"
#include "cgatools/junctions/Junction.hpp"
#include "cgatools/junctions/JunctionCompare.hpp"

// Standard library.
#include <string>
#include <vector>
#include <map>
#include <set>

// Boost
#include <boost/shared_ptr.hpp>

namespace cgatools { namespace junctions {

    typedef std::map<std::string, junctions::JunctionRefs> JunctionCompatMap;

typedef std::vector<JunctionCompatMap> JunctionCompatMapPerFile;

typedef std::set<JunctionRef> JunctionRefSet;

struct JunctionRefSide
{
    JunctionRef jr_;
    size_t side_;

    JunctionRefSide(const JunctionRef& jr, size_t side)
        :   jr_(jr), side_(side)
    {}

    bool operator<(const JunctionRefSide& b) const
    {
        reference::Location
            apos = jr_.it_->sideSections_  [  side_].getBasePos(side_),
            bpos = b.jr_.it_->sideSections_[b.side_].getBasePos(b.side_);
        if (apos != bpos)
            return apos < bpos;
        else
            return side_ < b.side_;
    }
};


class JunctionVcfWriter
{
    public:

        JunctionVcfWriter ( boost::shared_ptr<reference::CrrFile> ref, 
                            boost::shared_ptr<junctions::JunctionFiles> junctionFiles );

        std::string  fileFieldSeparator_;
        size_t  filterScoreThreshold_;
        size_t  filterSideLength_;


        void writeJunctionVcfHeaders(std::ostream& out) const;

        std::string createJunctionVcfId( const JunctionRef& jref, size_t side) const;


        std::string formatPositionForVcf( reference::Location pos, const std::string& sep ) const;

        void writeJunctionPositionToVcf( const junctions::JunctionSideSection& jss, 
                                         size_t side, std::ostream& out) const;


        void writeJunctionAltFieldToVcf(const JunctionRef& jref,
            size_t side, std::ostream& out, bool suppressChrom=false) const;

        std::string convertMobileElementToVcf(const std::string& med) const;

        void writeJunctionInfoFieldToVcf(const JunctionRef& jref,
            size_t side, std::ostream& out) const;

        void addFilterFlag( std::ostream& out, const std::string& flag, bool& filtered) const;

        void writeJunctionFilterFieldToVcf( const JunctionRef& jref, std::ostream& out) const;

        void writeJunctionComparisonField( const JunctionRef& jref, size_t side, 
                                           std::ostream& out) const;

        void writeJunctionToVcf(  const JunctionRef& jref, size_t side,
                                  const JunctionCompatMapPerFile& compat,
                                  std::ostream& out) const;

protected:

        JunctionVcfWriter();

        void init();

        boost::shared_ptr<reference::CrrFile>       reference_;
        boost::shared_ptr<junctions::JunctionFiles> junctionFiles_;
        std::vector<std::string>                    sampleIds_;
};

}}


#endif //CGA_TOOLS_JUNCTION_VCF_WRITER_HPP_

---