range.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 CGATOOLS_REFERENCE_RANGE_HPP_
#define CGATOOLS_REFERENCE_RANGE_HPP_ 1


#include "cgatools/core.hpp"
#include "cgatools/util/Exception.hpp"

namespace cgatools { namespace reference {

    class Location
    {
    public:
        Location()
            : chromosome_(0),
              offset_(0)
        {
        }

        Location(uint16_t chromosome, uint32_t offset)
            : chromosome_(chromosome),
              offset_(offset)
        {
        }

        int32_t distanceTo( const Location& other ) const;

        uint16_t chromosome_; 
        uint32_t offset_;     
    };

    inline int32_t Location::distanceTo( const Location& other ) const
    {
        if (chromosome_!=other.chromosome_)
            return std::numeric_limits<int32_t>::max();
        return other.offset_-offset_;
    }

    inline bool operator==(const Location& lhs, const Location& rhs)
    {
        return lhs.chromosome_ == rhs.chromosome_ &&
            lhs.offset_ == rhs.offset_;
    }

    inline bool operator!=(const Location& lhs, const Location& rhs)
    {
        return !(lhs == rhs);
    }

    inline bool operator<(const Location& lhs, const Location& rhs)
    {
        if (lhs.chromosome_ != rhs.chromosome_)
            return lhs.chromosome_ < rhs.chromosome_;
        return lhs.offset_ < rhs.offset_;
    }

    inline bool operator<=(const Location& lhs, const Location& rhs)
    {
        return !(rhs < lhs);
    }

    inline bool operator>(const Location& lhs, const Location& rhs)
    {
        return rhs < lhs;
    }

    inline bool operator>=(const Location& lhs, const Location& rhs)
    {
        return !(lhs < rhs);
    }

    inline std::ostream& operator<<(std::ostream& ostr, const Location& l)
    {
        return ostr << l.chromosome_<< "," << l.offset_;
    }

    class Range
    {
    public:
        Range()
            : chromosome_(0),
              begin_(0),
              end_(0)
        {
        }

        Range(uint16_t chromosome, uint32_t begin, uint32_t end)
            : chromosome_(chromosome),
              begin_(begin),
              end_(end)
        {
        }

        Range(const Location& beginLoc, const Location& endLoc)
            : chromosome_(beginLoc.chromosome_),
              begin_(beginLoc.offset_),
              end_(endLoc.offset_)
        {
            CGA_ASSERT_EQ(beginLoc.chromosome_, endLoc.chromosome_);
        }

        Location beginLocation() const
        {
            return Location(chromosome_, begin_);
        }

        Location endLocation() const
        {
            return Location(chromosome_, end_);
        }

        uint32_t length() const
        {
            return end_-begin_;
        }

        bool contains (const Location& loc) const
        {
            return chromosome_ == loc.chromosome_
                && loc.offset_ >= begin_ && loc.offset_ < end_;
        }

        bool intersects (const Range& r) const
        {
            return chromosome_ == r.chromosome_
                && ((r.begin_ < end_ && begin_ < r.end_)
                    || begin_ == r.begin_ || end_ == r.end_);
        }

        Range overlappingRange (const Range& rr) const
        {
            CGA_ASSERT(intersects(rr));
            return Range(chromosome_, std::max(begin_, rr.begin_), std::min(end_, rr.end_));
        }

        uint16_t chromosome_; 
        uint32_t begin_;      

        uint32_t end_;        

    };

    inline bool operator==(const Range& lhs, const Range& rhs)
    {
        return lhs.chromosome_ == rhs.chromosome_ &&
            lhs.begin_ == rhs.begin_ &&
            lhs.end_ == rhs.end_;
    }

    inline bool operator!=(const Range& lhs, const Range& rhs)
    {
        return !(lhs == rhs);
    }

    inline bool operator<(const Range& lhs, const Range& rhs)
    {
        if (lhs.chromosome_ != rhs.chromosome_)
            return lhs.chromosome_ < rhs.chromosome_;
        if (lhs.begin_ != rhs.begin_)
            return lhs.begin_ < rhs.begin_;
        return lhs.end_ < rhs.end_;
    }

    inline bool operator<=(const Range& lhs, const Range& rhs)
    {
        return !(rhs < lhs);
    }

    inline bool operator>(const Range& lhs, const Range& rhs)
    {
        return rhs < lhs;
    }

    inline bool operator>=(const Range& lhs, const Range& rhs)
    {
        return !(lhs < rhs);
    }

    struct RangeOverlap
    {
        bool operator()(const Range& a, const Range& b) const
        {
            return a.intersects(b);
        }
    };

    struct GetRangeBoundary
    {
        Location operator()(const Range& r, size_t side) const
        {
            if (0 == side)
                return r.beginLocation();
            else
                return r.endLocation();
        }
    };

} } // cgatools::reference

#endif // CGATOOLS_REFERENCE_RANGE_HPP_

---