RangeAnnotationStore.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_RANGEANNOTATIONSTORE_HPP_
#define CGATOOLS_REFERENCE_RANGEANNOTATIONSTORE_HPP_ 1


#include "cgatools/core.hpp"

#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>

#include "cgatools/util/Streams.hpp"
#include "cgatools/util/DelimitedFile.hpp"
#include "cgatools/util/DelimitedLineParser.hpp"
#include "cgatools/util/RangeIntersector.hpp"
#include "cgatools/reference/CrrFile.hpp"
#include "cgatools/reference/ChromosomeIdField.hpp"

using cgatools::util::InputStream;

namespace cgatools { namespace reference {


template <typename Derived, typename TValue>
class RangeAnnotationStore
{
private:
public:
    typedef util::IntervalTree<reference::Range,
                               reference::Location,
                               TValue,
                               reference::RangeOverlap,
                               reference::GetRangeBoundary > DataStore;
    typedef typename DataStore::QueryResultType QueryResultType;

    RangeAnnotationStore(const reference::CrrFile& crr)
        : crr_(crr)
    {}

    const util::DelimitedFileMetadata& getMetadata() const
    {
        return metadata_;
    }

    void intersect(const reference::Range& range,
                   std::vector<QueryResultType>& result) const
    {
        data_.intersect(range, result);
    }

#if 0
    void bindColumns(util::DelimitedFile& df, reference::Range& range, TValue& data)
#endif

protected:
    const reference::CrrFile& crr_;
    DataStore data_;

    typedef RangeAnnotationStore<Derived, TValue> Base;

    void load(const std::string& fn, char delimiter = '\t')
    {
        boost::shared_ptr<std::istream> in =
                InputStream::openCompressedInputStreamByExtension(fn);
        util::DelimitedFile df(*in, fn, delimiter);
        metadata_ = df.getMetadata();

        reference::Range range;
        TValue payload;
        static_cast<Derived*>(this)->bindColumns(df, range, payload);

        while (df.next())
            data_.put(range, payload);
    }


    void bindRangeColumns(util::DelimitedFile& df,
                          reference::Range& range,
                          const std::string& chrColName = "chromosome",
                          const std::string& begColName = "begin",
                          const std::string& endColName = "end")
    {
        df.addField(ChromosomeIdField(chrColName, &range.chromosome_, crr_));
        df.addField(util::ValueField<uint32_t>(begColName, &range.begin_));
        df.addField(util::ValueField<uint32_t>(endColName, &range.end_));
    }


    template <typename Value>
    class MidpointField : public util::DelimitedFieldParser
    {
    public:
        MidpointField(const std::string& name, Value* begin, Value* end)
            : DelimitedFieldParser(name),
              begin_(begin),
              end_(end)
            {
            }

        void parse(const char* first, const char* last)
            {
                *begin_ = util::parseValue<Value>(first, last);
                *end_ = *begin_;
            }

    private:
        uint32_t* begin_;
        uint32_t* end_;
    };

    void bindRangeMidpointColumns(util::DelimitedFile& df,
                          reference::Range& range,
                          const std::string& chrColName = "chromosome",
                          const std::string& midpointColName = "position")
    {
        df.addField(ChromosomeIdField(chrColName, &range.chromosome_, crr_));
        df.addField(MidpointField<uint32_t>(midpointColName, &range.begin_, &range.end_));
    }


private:
    util::DelimitedFileMetadata metadata_;
};

}}

#endif

---