mirror of
https://github.com/boostorg/geometry.git
synced 2026-02-13 12:32:09 +00:00
377 lines
10 KiB
C++
377 lines
10 KiB
C++
// Boost.Geometry Index
|
|
//
|
|
// Throwing objects implementation
|
|
//
|
|
// Copyright (c) 2011-2012 Adam Wulkiewicz, Lodz, Poland.
|
|
//
|
|
// Use, modification and distribution is subject to the Boost Software License,
|
|
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#ifndef BOOST_GEOMETRY_EXTENSIONS_INDEX_TEST_THROWING_HPP
|
|
#define BOOST_GEOMETRY_EXTENSIONS_INDEX_TEST_THROWING_HPP
|
|
|
|
// value
|
|
|
|
struct throwing_value_copy_exception : public std::exception
|
|
{
|
|
const char * what() const throw() { return "value copy failed."; }
|
|
};
|
|
|
|
struct throwing_value
|
|
{
|
|
explicit throwing_value(int v = 0)
|
|
: value(v)
|
|
{}
|
|
|
|
bool operator==(throwing_value const& v) const
|
|
{
|
|
return value == v.value;
|
|
}
|
|
|
|
throwing_value(throwing_value const& v)
|
|
{
|
|
throw_if_required();
|
|
|
|
value = v.value;
|
|
}
|
|
|
|
throwing_value & operator=(throwing_value const& v)
|
|
{
|
|
throw_if_required();
|
|
|
|
value = v.value;
|
|
return *this;
|
|
}
|
|
|
|
void throw_if_required()
|
|
{
|
|
// throw if counter meets max count
|
|
if ( get_max_calls_ref() <= get_calls_counter_ref() )
|
|
throw throwing_value_copy_exception();
|
|
else
|
|
++get_calls_counter_ref();
|
|
}
|
|
|
|
static void reset_calls_counter() { get_calls_counter_ref() = 0; }
|
|
static void set_max_calls(size_t mc) { get_max_calls_ref() = mc; }
|
|
|
|
static size_t & get_calls_counter_ref() { static size_t cc = 0; return cc; }
|
|
static size_t & get_max_calls_ref() { static size_t mc = (std::numeric_limits<size_t>::max)(); return mc; }
|
|
|
|
int value;
|
|
};
|
|
|
|
template <typename T, typename C>
|
|
struct generate_value< std::pair<bg::model::point<T, 2, C>, throwing_value> >
|
|
{
|
|
typedef bg::model::point<T, 2, C> P;
|
|
typedef std::pair<P, throwing_value> R;
|
|
static R apply(int x, int y)
|
|
{
|
|
return std::make_pair(P(x, y), throwing_value(x + y * 100));
|
|
}
|
|
};
|
|
|
|
// box
|
|
//
|
|
//#include <boost/geometry/geometries/register/box.hpp>
|
|
//
|
|
//struct throwing_box_copy_exception : public std::exception
|
|
//{
|
|
// const char * what() const throw() { return "box copy failed."; }
|
|
//};
|
|
//
|
|
//template <typename Point>
|
|
//struct throwing_box
|
|
//{
|
|
// throwing_box(){}
|
|
//
|
|
// throwing_box(Point const& m, Point const& mm)
|
|
// : min_p(m), max_p(mm)
|
|
// {}
|
|
//
|
|
// throwing_box(throwing_box const& o)
|
|
// {
|
|
// throw_if_required();
|
|
//
|
|
// min_p = o.min_p;
|
|
// max_p = o.max_p;
|
|
// }
|
|
//
|
|
// throwing_box & operator=(throwing_box const& o)
|
|
// {
|
|
// throw_if_required();
|
|
//
|
|
// min_p = o.min_p;
|
|
// max_p = o.max_p;
|
|
// return *this;
|
|
// }
|
|
//
|
|
// void throw_if_required()
|
|
// {
|
|
// // throw if counter meets max count
|
|
// if ( get_max_calls_ref() <= get_calls_counter_ref() )
|
|
// throw throwing_box_copy_exception();
|
|
// else
|
|
// ++get_calls_counter_ref();
|
|
// }
|
|
//
|
|
// static void reset_calls_counter() { get_calls_counter_ref() = 0; }
|
|
// static void set_max_calls(size_t mc) { get_max_calls_ref() = mc; }
|
|
//
|
|
// static size_t & get_calls_counter_ref() { static size_t cc = 0; return cc; }
|
|
// static size_t & get_max_calls_ref() { static size_t mc = (std::numeric_limits<size_t>::max)(); return mc; }
|
|
//
|
|
// Point min_p;
|
|
// Point max_p;
|
|
//};
|
|
//
|
|
//BOOST_GEOMETRY_REGISTER_BOX_TEMPLATED(throwing_box, min_p, max_p)
|
|
//
|
|
//namespace boost { namespace geometry { namespace index {
|
|
//
|
|
//template <typename CT, size_t D, typename CS>
|
|
//struct default_box_type< bg::model::point<CT, D, CS> >
|
|
//{
|
|
// typedef throwing_box<
|
|
// bg::model::point<CT, D, CS>
|
|
// > type;
|
|
//};
|
|
//
|
|
//}}} // namespace boost::geometry::index
|
|
|
|
#include <boost/geometry/extensions/index/pushable_array.hpp>
|
|
|
|
struct throwing_pushable_array_exception : public std::exception
|
|
{
|
|
const char * what() const throw() { return "pushable array exception."; }
|
|
};
|
|
|
|
struct throwing_pushable_array_settings
|
|
{
|
|
static void throw_if_required()
|
|
{
|
|
// throw if counter meets max count
|
|
if ( get_max_calls_ref() <= get_calls_counter_ref() )
|
|
throw throwing_pushable_array_exception();
|
|
else
|
|
++get_calls_counter_ref();
|
|
}
|
|
|
|
static void reset_calls_counter() { get_calls_counter_ref() = 0; }
|
|
static void set_max_calls(size_t mc) { get_max_calls_ref() = mc; }
|
|
|
|
static size_t & get_calls_counter_ref() { static size_t cc = 0; return cc; }
|
|
static size_t & get_max_calls_ref() { static size_t mc = (std::numeric_limits<size_t>::max)(); return mc; }
|
|
};
|
|
|
|
template <typename Element, size_t Capacity>
|
|
class throwing_pushable_array
|
|
{
|
|
typedef typename boost::array<Element, Capacity> array_type;
|
|
|
|
public:
|
|
typedef typename array_type::value_type value_type;
|
|
typedef typename array_type::size_type size_type;
|
|
typedef typename array_type::iterator iterator;
|
|
typedef typename array_type::const_iterator const_iterator;
|
|
typedef typename array_type::reverse_iterator reverse_iterator;
|
|
typedef typename array_type::const_reverse_iterator const_reverse_iterator;
|
|
typedef typename array_type::reference reference;
|
|
typedef typename array_type::const_reference const_reference;
|
|
|
|
inline throwing_pushable_array()
|
|
: m_size(0)
|
|
{}
|
|
|
|
//inline explicit throwing_pushable_array(size_type s)
|
|
// : m_size(s)
|
|
//{
|
|
// BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big");
|
|
//}
|
|
|
|
inline void resize(size_type s)
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big");
|
|
throwing_pushable_array_settings::throw_if_required();
|
|
m_size = s;
|
|
}
|
|
|
|
inline void reserve(size_type /*s*/)
|
|
{
|
|
//BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big");
|
|
// do nothing
|
|
}
|
|
|
|
inline Element & operator[](size_type i)
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(i < m_size, "index of the element outside the container");
|
|
return m_array[i];
|
|
}
|
|
|
|
inline Element const& operator[](size_type i) const
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(i < m_size, "index of the element outside the container");
|
|
return m_array[i];
|
|
}
|
|
|
|
inline Element const& front() const
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container");
|
|
return m_array.front();
|
|
}
|
|
|
|
inline Element & front()
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container");
|
|
return m_array.front();
|
|
}
|
|
|
|
inline Element const& back() const
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container");
|
|
return *(begin() + (m_size - 1));
|
|
}
|
|
|
|
inline Element & back()
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container");
|
|
return *(begin() + (m_size - 1));
|
|
}
|
|
|
|
inline iterator begin()
|
|
{
|
|
return m_array.begin();
|
|
}
|
|
|
|
inline iterator end()
|
|
{
|
|
return m_array.begin() + m_size;
|
|
}
|
|
|
|
inline const_iterator begin() const
|
|
{
|
|
return m_array.begin();
|
|
}
|
|
|
|
inline const_iterator end() const
|
|
{
|
|
return m_array.begin() + m_size;
|
|
}
|
|
|
|
inline reverse_iterator rbegin()
|
|
{
|
|
return reverse_iterator(end());
|
|
}
|
|
|
|
inline reverse_iterator rend()
|
|
{
|
|
return reverse_iterator(begin());
|
|
}
|
|
|
|
inline const_reverse_iterator rbegin() const
|
|
{
|
|
return const_reverse_iterator(end());
|
|
}
|
|
|
|
inline const_reverse_iterator rend() const
|
|
{
|
|
return const_reverse_iterator(begin());
|
|
}
|
|
|
|
inline void clear()
|
|
{
|
|
m_size = 0;
|
|
}
|
|
|
|
void push_back(Element const& v)
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(m_size < Capacity, "can't further increase the size of the container");
|
|
throwing_pushable_array_settings::throw_if_required();
|
|
m_array[m_size] = v;
|
|
++m_size;
|
|
}
|
|
|
|
inline void pop_back()
|
|
{
|
|
BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container");
|
|
--m_size;
|
|
}
|
|
|
|
inline bool empty() const
|
|
{
|
|
return m_size == 0;
|
|
}
|
|
|
|
inline size_t size() const
|
|
{
|
|
return m_size;
|
|
}
|
|
|
|
inline size_t capacity() const
|
|
{
|
|
return Capacity;
|
|
}
|
|
|
|
private:
|
|
boost::array<Element, Capacity> m_array;
|
|
size_type m_size;
|
|
};
|
|
|
|
#include <boost/geometry/extensions/index/static_vector.hpp>
|
|
|
|
struct throwing_static_vector_exception : public std::exception
|
|
{
|
|
const char * what() const throw() { return "static vector exception."; }
|
|
};
|
|
|
|
struct throwing_static_vector_settings
|
|
{
|
|
static void throw_if_required()
|
|
{
|
|
// throw if counter meets max count
|
|
if ( get_max_calls_ref() <= get_calls_counter_ref() )
|
|
throw throwing_pushable_array_exception();
|
|
else
|
|
++get_calls_counter_ref();
|
|
}
|
|
|
|
static void reset_calls_counter() { get_calls_counter_ref() = 0; }
|
|
static void set_max_calls(size_t mc) { get_max_calls_ref() = mc; }
|
|
|
|
static size_t & get_calls_counter_ref() { static size_t cc = 0; return cc; }
|
|
static size_t & get_max_calls_ref() { static size_t mc = (std::numeric_limits<size_t>::max)(); return mc; }
|
|
};
|
|
|
|
template <typename Element, size_t Capacity>
|
|
class throwing_static_vector
|
|
: public boost::geometry::index::static_vector<Element, Capacity>
|
|
{
|
|
typedef boost::geometry::index::static_vector<Element, Capacity> container;
|
|
|
|
public:
|
|
typedef typename container::value_type value_type;
|
|
typedef typename container::size_type size_type;
|
|
typedef typename container::iterator iterator;
|
|
typedef typename container::const_iterator const_iterator;
|
|
typedef typename container::reverse_iterator reverse_iterator;
|
|
typedef typename container::const_reverse_iterator const_reverse_iterator;
|
|
typedef typename container::reference reference;
|
|
typedef typename container::const_reference const_reference;
|
|
|
|
inline void resize(size_type s)
|
|
{
|
|
throwing_pushable_array_settings::throw_if_required();
|
|
container::resize(s);
|
|
}
|
|
|
|
void push_back(Element const& v)
|
|
{
|
|
throwing_pushable_array_settings::throw_if_required();
|
|
container::push_back(v);
|
|
}
|
|
};
|
|
|
|
#endif // BOOST_GEOMETRY_EXTENSIONS_INDEX_TEST_THROWING_HPP
|