Boost-Geometry-Utils
view release on metacpan or search on metacpan
src/boost/detail/allocator_utilities.hppsrc/boost/detail/atomic_count.hppsrc/boost/detail/binary_search.hppsrc/boost/detail/call_traits.hppsrc/boost/detail/compressed_pair.hppsrc/boost/detail/container_fwd.hppsrc/boost/detail/dynamic_bitset.hppsrc/boost/detail/endian.hppsrc/boost/detail/fenv.hppsrc/boost/detail/indirect_traits.hppsrc/boost/detail/interlocked.hppsrc/boost/detail/is_function_ref_tester.hppsrc/boost/detail/is_incrementable.hppsrc/boost/detail/is_xxx.hppsrc/boost/detail/iterator.hppsrc/boost/detail/lcast_precision.hppsrc/boost/detail/lightweight_mutex.hppsrc/boost/detail/limits.hppsrc/boost/detail/no_exceptions_support.hppsrc/boost/detail/numeric_traits.hppsrc/boost/detail/ob_call_traits.hpp
src/boost/detail/interlocked.hpp view on Meta::CPAN
#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED#define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED// MS compatible compilers support#pragma once#if defined(_MSC_VER) && (_MSC_VER >= 1020)# pragma once#endif//// boost/detail/interlocked.hpp//// Copyright 2005 Peter Dimov//// Distributed under the Boost Software License, Version 1.0. (See// accompanying file LICENSE_1_0.txt or copy at//#include <boost/config.hpp>#if defined( BOOST_USE_WINDOWS_H )# include <windows.h># define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer# define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer#elif defined(_WIN32_WCE)#if _WIN32_WCE >= 0x600extern"C"long __cdecl _InterlockedIncrement( long volatile * );extern"C"long __cdecl _InterlockedDecrement( long volatile * );extern"C"long __cdecl _InterlockedCompareExchange( long volatile *, long, long );extern"C"long __cdecl _InterlockedExchange( long volatile *, long );extern"C"long __cdecl _InterlockedExchangeAdd( long volatile *, long );# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd#else// under Windows CE we still have old-style Interlocked* functionsextern"C"long __cdecl InterlockedIncrement( long* );extern"C"long __cdecl InterlockedDecrement( long* );extern"C"long __cdecl InterlockedCompareExchange( long*, long, long );extern"C"long __cdecl InterlockedExchange( long*, long );extern"C"long __cdecl InterlockedExchangeAdd( long*, long );# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd#endif# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare)))# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \((void*)BOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange)))#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600#include <intrin.h>#elif defined( __CLRCALL_PURE_OR_CDECL )extern"C"long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * );extern"C"long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * );extern"C"long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long );extern"C"long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long );extern"C"long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long );#elseextern"C"long __cdecl _InterlockedIncrement( long volatile * );extern"C"long __cdecl _InterlockedDecrement( long volatile * );extern"C"long __cdecl _InterlockedCompareExchange( long volatile *, long, long );extern"C"long __cdecl _InterlockedExchange( long volatile *, long );extern"C"long __cdecl _InterlockedExchangeAdd( long volatile *, long );#endif# pragma intrinsic( _InterlockedIncrement )# pragma intrinsic( _InterlockedDecrement )# pragma intrinsic( _InterlockedCompareExchange )# pragma intrinsic( _InterlockedExchange )# pragma intrinsic( _InterlockedExchangeAdd )# if defined(_M_IA64) || defined(_M_AMD64)extern"C"void* __cdecl _InterlockedCompareExchangePointer( void* volatile *, void*, void* );extern"C"void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );# pragma intrinsic( _InterlockedCompareExchangePointer )# pragma intrinsic( _InterlockedExchangePointer )# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer# define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer# else# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))# endif# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )#if defined(__MINGW64__)#define BOOST_INTERLOCKED_IMPORT#else#define BOOST_INTERLOCKED_IMPORT __declspec(dllimport)#endifnamespace boost{namespace detail{extern"C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * );extern"C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * );extern"C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long );extern"C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long );extern"C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long );# if defined(_M_IA64) || defined(_M_AMD64)extern"C"BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );extern"C"BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* );# endif} // namespace detail} // namespace boost# define BOOST_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement# define BOOST_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement# define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange# define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange# define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd# if defined(_M_IA64) || defined(_M_AMD64)# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::boost::detail::InterlockedCompareExchangePointer# define BOOST_INTERLOCKED_EXCHANGE_POINTER ::boost::detail::InterlockedExchangePointer# else# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))# endif#else# error "Interlocked intrinsics not available"#endif#endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
src/boost/geometry/algorithms/detail/overlay/check_enrich.hpp view on Meta::CPAN
{meta_turns.push_back(meta_turn<turn_point_type>(index,*it));}intcycle = 0;for(typename boost::range_iterator<std::vector<meta_turn<turn_point_type> > > ::typeit = boost::begin(meta_turns);it != boost::end(meta_turns);++it){if(! (it->turn->blocked() || it->turn->is_discarded())){for(inti = 0 ; i < 2; i++){if(! it->handled[i]&& it->turn->operations[i].operation == for_operation){#ifdef BOOST_GEOMETRY_DEBUG_ENRICHstd::cout <<"CYCLE "<< cycle << std::endl;#endifit->handled[i] = true;
src/boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp view on Meta::CPAN
}inline char operation_char(detail::overlay::operation_type const& operation){using namespace detail::overlay;switch(operation){case operation_none :return'-';case operation_union :return'u';case operation_intersection :return'i';case operation_blocked :return'x';case operation_continue :return'c';case operation_opposite :return'o';default:return'?';}}inline char visited_char(detail::overlay::visit_info const& v){if(v.rejected())return'R';if(v.started())return's';
src/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp view on Meta::CPAN
{// Add operations on this ring, but skip discarded onesif(! it->discarded){intop_index = 0;for(typename boost::range_iterator<container_type const>::typeop_it = boost::begin(it->operations);op_it != boost::end(it->operations);++op_it, ++op_index){// We should NOT skip blocked operations here// because they can be relevantfor"the other side"// NOTif(op_it->operation != operation_blocked)ring_identifier ring_id(op_it->seg_id.source_index,op_it->seg_id.multi_index,op_it->seg_id.ring_index);mapped_vector[ring_id].push_back(IndexedType(index, op_index,*op_it)
src/boost/geometry/algorithms/detail/overlay/follow.hpp view on Meta::CPAN
#ifndef DOXYGEN_NO_DETAILnamespace detail { namespace overlay{namespace following{template <typename Turn, typename Operation>static inline bool is_entering(Turn const& /* TODO remove this parameter */, Operation const& op){// (Blocked means: blockedforpolygon/polygon intersection, because// they are reversed. Butforpolygon/line it is similar tocontinue)returnop.operation == operation_intersection|| op.operation == operation_continue|| op.operation == operation_blocked;}template<typename Turn,typename Operation,typename LineString,typename Polygon>
src/boost/geometry/algorithms/detail/overlay/follow.hpp view on Meta::CPAN
typename LineString,typename Polygon,overlay_type OverlayType>class follow{template<typename Turn>struct sort_on_segment{// In case of turn point at the same location, we want to havecontinue/blocked LAST// because that should be followed (intersection) or skipped (difference).inlineintoperation_order(Turn const& turn) const{operation_type const& operation = turn.operations[0].operation;switch(operation){case operation_opposite :return0;case operation_none :return0;case operation_union :return1;case operation_intersection :return2;case operation_blocked :return3;case operation_continue :return4;}return-1;};inline bool use_operation(Turn const& left, Turn const& right) const{// If they are the same, OK.returnoperation_order(left) < operation_order(right);}
src/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp view on Meta::CPAN
both(ti, operation_continue);}else{// Opposite direction, which is never travelled.// If Q turns left, P continuesforintersection// If Q turns right, P continuesforunionti.operations[Index].operation = side_qk_q == 1? operation_intersection: operation_union;ti.operations[1 - Index].operation = operation_blocked;}}else{// Should not occur!ti.method = method_error;}}};
src/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp view on Meta::CPAN
{static inline bool between(intside1,intside2,intturn){returnside1 == side2 && ! opposite(side1, turn);}/*staticinline void block_second(bool block, TurnInfo& ti){if(block){ti.operations[1].operation = operation_blocked;}}*/template<typename Point1,typename Point2,typename IntersectionInfo,typename DirInfo
src/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp view on Meta::CPAN
return;}intconst side_pk_q1 = SideStrategy::apply(qi, qj, pk);// Collinear opposite case -> block P// (#BRL4, #BLR8)if(side_pk_q1 == 0){ti.operations[0].operation = operation_blocked;// Q turns right -> union (both independent),// Q turns left -> intersectionti.operations[1].operation = block_q ? operation_blocked: q_turns_left ? operation_intersection: operation_union;return;}// Pk between Qi and Qk// (#BRL3, #BRL7)if(between(side_pk_q1, side_pk_q2, side_qk_q)){ui_else_iu(q_turns_left, ti);if(block_q){ti.operations[1].operation = operation_blocked;}//block_second(block_q, ti);return;}// Pk between Qk and P, so left of Qk (ifQ turns right) and vv// (#BRL1)if(side_pk_q2 == -side_qk_q){ui_else_iu(! q_turns_left, ti);return;}//// (#BRL5, #BRL9)if(side_pk_q1 == -side_qk_q){uu_else_ii(! q_turns_left, ti);if(block_q){ti.operations[1].operation = operation_blocked;}//block_second(block_q, ti);return;}}else{// Pk at other side than Qi/Pkintconst side_qk_q = SideStrategy::apply(qi, qj, qk);bool const q_turns_left = side_qk_q == 1;ti.operations[0].operation = q_turns_left? operation_intersection: operation_union;ti.operations[1].operation = block_q? operation_blocked: side_qi_p1 == 1 || side_qk_p1 == 1? operation_union: operation_intersection;return;}}else{// From left to right or from right to left
src/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp view on Meta::CPAN
bool const right_to_left = side_qk_p1 == 1;// If p turns into direction of qi (1,2)if(side_pk_p == side_qi_p1){intconst side_pk_q1 = SideStrategy::apply(qi, qj, pk);// Collinear opposite case -> block Pif(side_pk_q1 == 0){ti.operations[0].operation = operation_blocked;ti.operations[1].operation = right_to_left? operation_union : operation_intersection;return;}if(side_pk_q1 == side_qk_p1){uu_else_ii(right_to_left, ti);return;}
src/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp view on Meta::CPAN
template<intIndex,typename Point,typename IntersectionInfo>static inline bool set_tp(Point const& ri, Point const& rj, Point const& rk,TurnInfo& tp, IntersectionInfo const& intersection_info){intconst side_rk_r = SideStrategy::apply(ri, rj, rk);operation_type blocked = operation_blocked;switch(side_rk_r){case 1 :// Turning left on opposite collinear: intersectiontp.operations[Index].operation = operation_intersection;break;case -1 :// Turning right on opposite collinear: uniontp.operations[Index].operation = operation_union;break;case 0 :// No turn on opposite collinear: block,donot traverse// But this"xx"is usually ignored, it is useless to include// two operations blocked, so the whole point does not need// to be generated.// Soreturnfalse to indicate nothing is to be done.if(AssignPolicy::include_opposite){tp.operations[Index].operation = operation_opposite;blocked = operation_opposite;}else{returnfalse;}break;}// The other direction is always blockedwhencollinear oppositetp.operations[1 - Index].operation = blocked;// If P arrives within Q, set info on P (which is done above,index=0),// this turn-info belongs to the second intersection point,index=1// (see e.g. figure CLO1)geometry::convert(intersection_info.intersections[1 - Index], tp.point);returntrue;}public:template
src/boost/geometry/algorithms/detail/overlay/handle_tangencies.hpp view on Meta::CPAN
// ux/uxinline bool consider_ux_ux(Indexed const& left,Indexed const& right, std::string const& // header) const{bool ret = left.index< right.index;// In combination of u/x, x/u: take first union, then blocked.// Solves#88, #61, #56, #80if(left.subject.operation == operation_union&& right.subject.operation == operation_blocked){ret = true;}elseif(left.subject.operation == operation_blocked&& right.subject.operation == operation_union){ret = false;}else{#ifdef BOOST_GEOMETRY_DEBUG_ENRICHstd::cout <<"ux/ux unhandled"<< std::endl;#endif}
src/boost/geometry/algorithms/detail/overlay/handle_tangencies.hpp view on Meta::CPAN
) const{bool ret = false;if(left.subject.operation == operation_union&& right.subject.operation == operation_union){ret = order == 1;}elseif(left.subject.operation == operation_union&& right.subject.operation == operation_blocked){ret = true;}elseif(right.subject.operation == operation_union&& left.subject.operation == operation_blocked){ret = false;}elseif(left.subject.operation == operation_union){ret = true;}elseif(right.subject.operation == operation_union){ret = false;
src/boost/geometry/algorithms/detail/overlay/handle_tangencies.hpp view on Meta::CPAN
&& right.subject.operation == operation_intersection ? order == 1: left.subject.operation == operation_intersection ? false: right.subject.operation == operation_intersection ? true: order == 1;}inline bool consider_ix_ix(Indexed const& left, Indexed const& right, std::string const& // header) const{// Take first intersection, then blocked.if(left.subject.operation == operation_intersection&& right.subject.operation == operation_blocked){returntrue;}elseif(left.subject.operation == operation_blocked&& right.subject.operation == operation_intersection){returnfalse;}// Default case, should not occur#ifdef BOOST_GEOMETRY_DEBUG_ENRICHstd::cout <<"ix/ix unhandled"<< std::endl;#endif
src/boost/geometry/algorithms/detail/overlay/handle_tangencies.hpp view on Meta::CPAN
{// Be careful tosortdiscarded first, then all othersreturntrue;}elseif(m_turn_points[right.index].discarded || right.discarded){// See above soreturnfalse here such that right (discarded)// is sortedbeforeleft (not discarded)returnfalse;}elseif(m_turn_points[left.index].combination(operation_blocked, operation_union)&& m_turn_points[right.index].combination(operation_blocked, operation_union)){// ux/uxreturnconsider_ux_ux(left, right,"ux/ux");}elseif(m_turn_points[left.index].both(operation_union)&& m_turn_points[right.index].both(operation_union)){// uu/uu, Order is arbitrary// Note: uu/uu is discarded nowbeforeso this point will// not be reached.returndefault_order;}elseif(m_turn_points[left.index].combination(operation_intersection, operation_union)&& m_turn_points[right.index].combination(operation_intersection, operation_union)){returnconsider_iu_iu(left, right,"iu/iu");}elseif(m_turn_points[left.index].combination(operation_intersection, operation_blocked)&& m_turn_points[right.index].combination(operation_intersection, operation_blocked)){returnconsider_ix_ix(left, right,"ix/ix");}elseif(m_turn_points[left.index].both(operation_intersection)&& m_turn_points[right.index].both(operation_intersection)){returnconsider_ii(left, right,"ii/ii");}elseif(m_turn_points[left.index].combination(operation_union, operation_blocked)&& m_turn_points[right.index].combination(operation_intersection, operation_union)){returnconsider_iu_ux(left, right, -1,"ux/iu");}elseif(m_turn_points[left.index].combination(operation_intersection, operation_union)&& m_turn_points[right.index].combination(operation_union, operation_blocked)){returnconsider_iu_ux(left, right, 1,"iu/ux");}elseif(m_turn_points[left.index].combination(operation_intersection, operation_blocked)&& m_turn_points[right.index].combination(operation_intersection, operation_union)){returnconsider_iu_ix(left, right, 1,"ix/iu");}elseif(m_turn_points[left.index].combination(operation_intersection, operation_union)&& m_turn_points[right.index].combination(operation_intersection, operation_blocked)){returnconsider_iu_ix(left, right, -1,"iu/ix");}elseif(m_turn_points[left.index].method != method_equal&& m_turn_points[right.index].method == method_equal){// If one of them was EQUAL or CONTINUES, it should always come firstreturnfalse;}
src/boost/geometry/algorithms/detail/overlay/overlay.hpp view on Meta::CPAN
#ifndef DOXYGEN_NO_DETAILnamespace detail { namespace overlay{// Skipforassemble processtemplate <typename TurnInfo>inline bool skip(TurnInfo const& turn_info){return(turn_info.discarded || turn_info.both(operation_union))&& ! turn_info.any_blocked()&& ! turn_info.both(operation_intersection);}template <typename TurnPoints, typename Map>inline void map_turns(Map&map, TurnPoints const& turn_points){typedef typename boost::range_value<TurnPoints>::type turn_point_type;typedef typename turn_point_type::container_type container_type;
src/boost/geometry/algorithms/detail/overlay/traverse.hpp view on Meta::CPAN
do{state.reset();// Iterate through all unvisited pointsfor(turn_iterator it = boost::begin(turns);state.good() && it != boost::end(turns);++it){// Skip discarded onesif(! (it->is_discarded() || it->blocked())){for(turn_operation_iterator_type iit = boost::begin(it->operations);state.good() && iit != boost::end(it->operations);++iit){if(iit->visited.none()&& ! iit->visited.rejected()&& (iit->operation == operation|| iit->operation == detail::overlay::operation_continue))
src/boost/geometry/algorithms/detail/overlay/turn_info.hpp view on Meta::CPAN
#ifndef DOXYGEN_NO_DETAILnamespace detail { namespace overlay{enum operation_type{operation_none,operation_union,operation_intersection,operation_blocked,operation_continue,operation_opposite};enum method_type{method_none,method_disjoint,method_crosses,
src/boost/geometry/algorithms/detail/overlay/turn_info.hpp view on Meta::CPAN
|| this->operations[1].operation == type;}inline bool combination(operation_type type1, operation_type type2) const{returnhas12(type1, type2) || has12(type2, type1);}inline bool is_discarded() const {returndiscarded; }inline bool blocked() const{returnboth(operation_blocked);}inline bool opposite() const{returnboth(operation_opposite);}inline bool any_blocked() const{returnhas(operation_blocked);}private :inline bool has12(operation_type type1, operation_type type2) const{returnthis->operations[0].operation == type1&& this->operations[1].operation == type2;}
src/boost/geometry/algorithms/touches.hpp view on Meta::CPAN
namespace boost { namespace geometry{namespace detail { namespace touches{template <typename Turn>inline bool ok_for_touch(Turn const& turn){returnturn.both(detail::overlay::operation_union)|| turn.both(detail::overlay::operation_blocked)|| turn.combination(detail::overlay::operation_union, detail::overlay::operation_blocked);}template <typename Turns>inline bool has_only_turns(Turns const& turns){bool has_touch = false;typedef typename boost::range_iterator<Turns const>::type iterator_type;for(iterator_type it = boost::begin(turns); it != boost::end(turns); ++it){
src/boost/lexical_cast.hpp view on Meta::CPAN
// String representation of Sourcehasan upper limit.template< class CharT // a result of widest_char transformation, class Traits // usually char_traits<CharT>, bool RequiresStringbuffer>class lexical_stream_limited_src{#if defined(BOOST_NO_STRINGSTREAM)typedef std::ostrstream out_stream_t;typedef stl_buf_unlocker<std::strstreambuf, char> unlocked_but_t;#elif defined(BOOST_NO_STD_LOCALE)typedef std::ostringstream out_stream_t;typedef stl_buf_unlocker<std::stringbuf, char> unlocked_but_t;#elsetypedef std::basic_ostringstream<CharT, Traits> out_stream_t;typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT> unlocked_but_t;#endiftypedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<RequiresStringbuffer,out_stream_t,do_not_construct_out_stream_t>::type deduced_out_stream_t;// A string representation of Source is written to [start, finish).CharT* start;CharT* finish;
src/boost/lexical_cast.hpp view on Meta::CPAN
template<typename InputStreamable>bool shl_input_streamable(InputStreamable& input){#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)// If you have compilation error at this point, than your STL library// does not support such conversions. Try updating it.BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));#endifbool const result = !(out_stream << input).fail();const unlocked_but_t* const p= static_cast<unlocked_but_t*>(out_stream.rdbuf()) ;start = p->pbase();finish = p->pptr();returnresult;}template <class T>inline bool shl_signed(T n){start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);if(n < 0)
src/boost/lexical_cast.hpp view on Meta::CPAN
BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));#endif#if defined(BOOST_NO_STRINGSTREAM)std::istrstream stream(start, finish - start);#elif defined(BOOST_NO_STD_LOCALE)std::istringstream stream;#elsestd::basic_istringstream<CharT, Traits> stream;#endifstatic_cast<unlocked_but_t*>(stream.rdbuf())->setg(start, start, finish);stream.unsetf(std::ios::skipws);lcast_set_precision(stream, static_cast<InputStreamable*>(0));#if (defined _MSC_VER)# pragma warning( pop )#endifreturnstream >> output &&stream.get() ==#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
src/boost/serialization/singleton.hpp view on Meta::CPAN
// turns out to be necessary and sufficient to implement the tables// used by serialization library.// Second, it provides a mechanism to detectwhena non-const function// is calledafterinitialization.// make a singleton tolock/unlock all singletonsforalteration.// The intent is that all singletons created/used by this code// are to be initializedbeforemain is called. A test program// canlockall the singletonswhenmain is entereed. This any// attempt to retieve a mutable instanceswhilelocked will// generate a assertionifcompiledfordebug.class singleton_module :public boost::noncopyable{private:static bool & get_lock(){static boollock= false;returnlock;}public:// static const void * get_module_handle(){//returnstatic_cast<const void *>(get_module_handle);// }static voidlock(){get_lock() = true;}static void unlock(){get_lock() = false;}static bool is_locked() {returnget_lock();}};namespace detail {template<class T>class singleton_wrapper : public T{public:
src/boost/serialization/singleton.hpp view on Meta::CPAN
BOOST_DLLEXPORT static T & get_instance() {static detail::singleton_wrapper< T > t;// refer to instance, causing it to be instantiated (and// initialized at startup on working compilers)BOOST_ASSERT(! detail::singleton_wrapper< T >::m_is_destroyed);use(instance);returnstatic_cast<T &>(t);}public:BOOST_DLLEXPORT static T & get_mutable_instance(){BOOST_ASSERT(! is_locked());returnget_instance();}BOOST_DLLEXPORT static const T & get_const_instance(){returnget_instance();}BOOST_DLLEXPORT static bool is_destroyed(){returndetail::singleton_wrapper< T >::m_is_destroyed;}};
src/boost/smart_ptr/detail/atomic_count_win32.hpp view on Meta::CPAN
//// boost/detail/atomic_count_win32.hpp//// Copyright (c) 2001-2005 Peter Dimov//// Distributed under the Boost Software License, Version 1.0. (See// accompanying file LICENSE_1_0.txt or copy at//#include <boost/detail/interlocked.hpp>namespace boost{namespace detail{class atomic_count{public:
src/boost/smart_ptr/detail/sp_counted_base_w32.hpp view on Meta::CPAN
// accompanying file LICENSE_1_0.txt or copy at////// Lock-free algorithm by Alexander Terekhov//// Thanks to Ben Hitchingsforthe#weak + (#shared != 0)// formulation//#include <boost/detail/interlocked.hpp>#include <boost/detail/workaround.hpp>#include <boost/detail/sp_typeinfo.hpp>namespace boost{namespace detail{class sp_counted_base
src/boost/smart_ptr/detail/spinlock_nt.hpp view on Meta::CPAN
namespace boost{namespace detail{class spinlock{public:bool locked_;public:inline bool try_lock(){if( locked_ ){returnfalse;}else{locked_ = true;returntrue;}}inline voidlock(){BOOST_ASSERT( !locked_ );locked_ = true;}inline void unlock(){BOOST_ASSERT( locked_ );locked_ = false;}public:class scoped_lock{private:spinlock & sp_;
src/boost/smart_ptr/detail/spinlock_w32.hpp view on Meta::CPAN
#endif//// Copyright (c) 2008 Peter Dimov//// Distributed under the Boost Software License, Version 1.0.// See accompanying file LICENSE_1_0.txt or copy at//#include <boost/detail/interlocked.hpp>#include <boost/smart_ptr/detail/yield_k.hpp>// BOOST_COMPILER_FENCE#if defined(__INTEL_COMPILER)#define BOOST_COMPILER_FENCE __memory_barrier();#elif defined( _MSC_VER ) && _MSC_VER >= 1310
( run in 0.524 second using v1.01-cache-2.11-cpan-87723dcf8b7 )