Junction.hpp

Go to the documentation of this file.

// Copyright 2010 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_HPP_
#define CGA_TOOLS_JUNCTION_HPP_


// Complete Genomics.
#include "cgatools/core.hpp"
#include "cgatools/reference/CrrFile.hpp"
#include "cgatools/util/DelimitedFile.hpp"

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

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


namespace cgatools { namespace junctions {

    // Constants for the two possible sides of a Junction.
    const int JUNCTION_LEFT_SIDE = 0;
    const int JUNCTION_RIGHT_SIDE = 1;
    const int JUNCTION_BOTH_SIDES = 2;

    // The two possible strands of a Junction.
    enum JunctionStrand {
        JUNCTION_MINUS_STRAND = -1,
        JUNCTION_UNKNOWN_STRAND = 0,
        JUNCTION_PLUS_STRAND = +1
    };

    class JunctionSideSection {
    public:

        // Strand of the reference that this junction side maps to.
        JunctionStrand strand_;

        // Position of the base closest to the transition section.
        reference::Location position_;

        // Number of bases in this side of the junction, or -1 if unknown.
        int length_;

        //list of the intersecting repeats
        std::string repeatClassification_;

        //list of the intersecting genes
        std::string genes_;

        JunctionSideSection();

        JunctionSideSection(JunctionStrand, const reference::Location& position, int length, 
                    const std::string& repeatClassification,
                    const std::string& genes
                    );

        void write(std::ostream&, const reference::CrrFile&) const;
    };



    class Junction {
    public:
        std::string id_;

        // The three sections that make up this junction.
        boost::array<JunctionSideSection,2> sideSections_;

        std::string transitionSequence_;

        size_t transitionLength_;

        bool            transitionIsKnown_;

        uint32_t        score_;

        std::string     xRef_;
        std::string     deletedTransposableElement_;
        std::string     knownUnderrepresentedRepeat_;
        double          frequencyInBaselineGenomeSet_;

        std::string     assembledSequence_;

        std::vector<std::string> annotations_;

        Junction();

        Junction(
            const std::string& junctionId,
            const JunctionSideSection& leftSection,
            const JunctionSideSection& rightSection,
            const std::string& transitionSequence,
            size_t transitionLength,
            bool transitionIsKnown,
            uint32_t score,
            const std::string& xRef,
            const std::string& deletedTransposableElement,
            const std::string& knownUnderrepresentedRepeat,
            double frequencyInBaselineGenomeSet,
            const std::string& assembledSequence
            );

        const reference::Location &getLocation(int side) const {
            return sideSections_[side].position_;
        }

        size_t getDistance() const;

        void write(std::ostream&, const reference::CrrFile&,
                   size_t expectedAnnotationCount) const;
    };

    typedef std::vector<Junction> Junctions;

    class CompareJunctionsBySide {
    public:
        CompareJunctionsBySide(int side=JUNCTION_LEFT_SIDE) 
            :side_(side), otherSide_(JUNCTION_RIGHT_SIDE-side)
        { 
            CGA_ASSERT_MSG(side==JUNCTION_LEFT_SIDE || side>=JUNCTION_RIGHT_SIDE, 
                "wrong junction side: " << side);
        }

        static const reference::Location &getLocation(const Junction& j, int side) {
            return j.sideSections_[side].position_;
        }

        bool operator() (const Junction& j1,const Junction& j2) const {
            const reference::Location &f1 = j1.getLocation(side_);
            const reference::Location &f2 = j2.getLocation(side_);
            if (f1!=f2)
                return f1<f2;
            const reference::Location &s1 = j1.getLocation(otherSide_);
            const reference::Location &s2 = j2.getLocation(otherSide_);
            if (s1!=s2)
                return s1<s2;
            return j1.id_ < j2.id_; //compare by id to guarantee the sort order
        }

    protected:
        int side_;
        int otherSide_;
    };

    class JunctionFile {
    public:

        JunctionFile() {}

        JunctionFile(const std::string& name, const reference::CrrFile&);

        void read(const std::string& name, const reference::CrrFile& reference);

        void write(const std::string& name, const reference::CrrFile&);

        void add(const Junction&);

        Junctions junctions_;

        static const std::string header_;

        util::DelimitedFile::Metadata metadata_;

        std::string fileName_;

        std::vector<std::string> annotationHeaders_;
    };

    typedef std::vector<JunctionFile> JunctionFiles;
}}


#endif //CGA_TOOLS_JUNCTION_HPP_

---