thin-provisioning-tools/persistent-data/run_list.tcc
2013-01-02 12:55:41 +00:00

180 lines
3.8 KiB
C++

// Copyright (C) 2011 Red Hat, Inc. All rights reserved.
//
// This file is part of the thin-provisioning-tools source.
//
// thin-provisioning-tools 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.
//
// thin-provisioning-tools 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 thin-provisioning-tools. If not, see
// <http://www.gnu.org/licenses/>.
#include <iostream> // FIXME: remove
#include <boost/optional.hpp>
//----------------------------------------------------------------
namespace {
using namespace base;
using namespace boost;
using namespace std;
template <typename T>
bool overlaps_ordered(run<T> const &lhs, run<T> const &rhs) {
return rhs.b_ < lhs.e_;
}
template <typename T>
bool overlaps(run<T> const &lhs, run<T> const &rhs) {
if (lhs.b_ <= rhs.b_)
return overlaps_ordered(lhs, rhs);
else
return overlaps_ordered(rhs, lhs);
}
template <typename T>
boost::optional<run<T> >
merge_ordered_runs_if_overlapping(run<T> const &lhs, run<T> const &rhs) {
typedef optional<run<T> > result;
if (lhs.e_ < rhs.e_)
return result(run<T>(lhs.b_, rhs.e_));
if (lhs.e_ <= rhs.e_)
return result(lhs);
return result();
}
template <typename T>
boost::optional<run<T> >
merge_if_overlapping(run<T> const &lhs, run<T> const &rhs) {
if (lhs.b_ <= rhs.b_)
return merge_ordered_runs_if_overlapping(lhs, rhs);
else
return merge_ordered_runs_if_overlapping(rhs, lhs);
}
template <typename T>
pair<typename set<run<T> >::const_iterator,
typename set<run<T> >::const_iterator>
overlapping_range(set<run<T> > const &runs, run<T> const &r) {
// FIXME: slow, but correct implementation first
typedef typename set<run<T> >::const_iterator cit;
for (cit b = runs.begin(); b != runs.end(); ++b) {
if (overlaps(*b, r)) {
cit e = b;
++e;
while (overlaps(*e, r))
++e;
return make_pair(b, e);
}
}
return make_pair(runs.end(), runs.end());
}
}
//----------------------------------------------------------------
template <typename T>
void
run_list<T>::add_run(T const &b, T const &e)
{
using namespace std;
typedef typename set<run<T> >::const_iterator cit;
run<T> r(b, e);
pair<cit, cit> range = overlapping_range(runs_, r);
for (cit it = range.first; it != range.second; ++it) {
optional<run<T> > mr = merge_if_overlapping(r, *it);
if (mr)
r = *mr;
}
runs_.erase(range.first, range.second);
runs_.insert(r);
}
template <typename T>
void
run_list<T>::sub_run(T const &b, T const &e)
{
// FIXME: finish
}
template <typename T>
bool
run_list<T>::in_run_(T const &key) const
{
using namespace std;
run<T> r(key, key + 1);
typename set<run<T> >::const_iterator it = runs_.lower_bound(r);
if (it != runs_.end() && it->b_ == key)
return true;
--it;
if (it == runs_.end())
return false;
return it->b_ <= key && it->e_ > key;
}
template <typename T>
bool
run_list<T>::in_run(T const &key) const
{
if (invert_)
return !in_run_(key);
else
return in_run_(key);
}
template <typename T>
void
run_list<T>::invert()
{
invert_ = !invert_;
}
template <typename T>
void
run_list<T>::add(run_list<T> const &rl)
{
// FIXME: finish
}
template <typename T>
void
run_list<T>::sub(run_list<T> const &rl)
{
// FIXME: finish
}
template <typename T>
const_iterator
run_list<T>::begin() const
{
return runs_.begin();
}
const_iterator
run_list<T>::end() const
{
return runs_.end();
}
//----------------------------------------------------------------