chris/js8call
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial Commit

Browse Source
This commit is contained in:
Jordan Sherer
2018-02-08 21:28:33 -05:00
commit 678c1d3966
14352 changed files with 3176737 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.svn/pristine/08/0803f1624a0a41bb428db5e088157989ba15386a.svn-base
+66
View File
@@ -0,0 +1,66 @@
/* Copyright 2003-2013 Joaquin M Lopez Munoz.
* Distributed under 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)
*
* See http://www.boost.org/libs/multi_index for library home page.
*/
#ifndef BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
#define BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <boost/detail/workaround.hpp>
namespace boost{
namespace multi_index{
/* dummy type and variable for use in ordered_index::range() */
/* ODR-abiding technique shown at the example attached to
* http://lists.boost.org/Archives/boost/2006/07/108355.php
*/
namespace detail{class unbounded_helper;}
detail::unbounded_helper unbounded(detail::unbounded_helper);
namespace detail{
class unbounded_helper
{
unbounded_helper(){}
unbounded_helper(const unbounded_helper&){}
friend unbounded_helper multi_index::unbounded(unbounded_helper);
};
typedef unbounded_helper (*unbounded_type)(unbounded_helper);
} /* namespace multi_index::detail */
inline detail::unbounded_helper unbounded(detail::unbounded_helper)
{
return detail::unbounded_helper();
}
/* tags used in the implementation of range */
namespace detail{
struct none_unbounded_tag{};
struct lower_unbounded_tag{};
struct upper_unbounded_tag{};
struct both_unbounded_tag{};
} /* namespace multi_index::detail */
} /* namespace multi_index */
} /* namespace boost */
#endif
.svn/pristine/08/08053e66691ead1da47bb0568fa97eb781393f98.svn-base
+180
View File
@@ -0,0 +1,180 @@
48 128
12 4
11 11 11 11 11 11 11 11 11 11 11 11 11 10 11 11 11 10 10 11 10 11 10 11 10 10 10 10 10 11 10 12 11 11 10 11 11 11 11 11 10 10 11 10 10 11 11 10
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4
1 13 26 38 51 62 75 86 99 111 124 0
2 13 27 39 49 63 76 87 100 112 121 0
3 14 27 40 52 64 74 88 101 104 123 0
2 15 28 41 53 65 77 89 102 113 125 0
4 16 26 41 54 66 71 90 101 114 122 0
5 15 29 40 55 67 78 91 98 110 126 0
6 17 30 42 56 63 79 90 103 115 124 0
7 18 25 43 56 68 80 87 104 113 122 0
7 13 29 44 52 69 81 92 102 114 127 0
8 14 29 42 57 66 77 86 97 116 119 0
9 19 26 45 56 69 76 93 97 110 128 0
9 14 28 46 54 68 82 91 99 112 118 0
8 20 31 47 49 69 78 88 105 109 124 0
1 20 32 42 52 70 76 94 106 117 0 0
10 15 33 48 52 62 80 93 100 118 119 0
11 18 31 39 48 67 83 94 97 114 125 0
12 15 34 37 49 64 73 85 99 116 127 0
2 21 25 45 55 64 83 92 103 119 0 0
4 22 33 46 55 65 84 86 107 108 0 0
11 16 27 45 53 70 79 95 107 111 126 0
6 13 33 45 57 68 85 96 101 120 0 0
12 17 25 38 58 67 76 96 107 118 123 0
5 18 30 44 59 71 77 93 106 120 0 0
6 20 28 43 50 72 83 86 95 121 127 0
11 23 28 38 59 73 81 88 108 115 0 0
10 19 32 49 60 67 75 89 101 108 0 0
5 22 27 48 54 69 73 96 103 113 0 0
12 23 35 47 50 62 79 97 106 122 0 0
3 18 26 47 53 61 82 85 98 108 0 0
9 22 31 41 58 60 72 87 106 115 116 0
10 16 30 50 58 65 73 91 104 109 0 0
10 24 36 41 57 61 78 94 103 111 123 127
4 17 29 43 59 74 85 89 109 112 128 0
3 21 34 38 60 63 77 95 105 114 128 0
7 24 37 46 53 71 74 96 105 110 0 0
6 19 34 47 51 70 81 91 100 123 125 0
2 24 31 40 56 66 81 84 95 118 120 0
1 14 30 37 48 72 78 92 107 122 128 0
3 23 24 42 55 68 75 93 109 121 125 0
12 22 32 43 51 71 82 88 102 119 126 0
1 23 36 44 58 64 80 90 110 112 0 0
7 19 35 40 59 65 82 90 111 117 0 0
9 17 36 39 50 66 75 92 105 117 126 0
4 21 35 39 57 70 80 98 99 115 0 0
8 25 33 37 54 60 79 94 98 121 0 0
8 16 34 46 61 62 83 87 102 117 120 0
11 21 32 44 61 72 74 84 100 113 124 0
5 20 35 36 51 63 84 89 104 116 0 0
1 14 38 41
2 4 18 37
3 29 34 39
5 19 33 44
6 23 27 48
7 21 24 36
8 9 35 42
10 13 45 46
11 12 30 43
15 26 31 32
16 20 25 47
17 22 28 40
1 2 9 21
3 10 12 38
4 6 15 17
5 20 31 46
7 22 33 43
8 16 23 29
11 26 36 42
13 14 24 48
18 34 44 47
19 27 30 40
25 28 39 41
32 35 37 39
8 18 22 45
1 5 11 29
2 3 20 27
4 12 24 25
6 9 10 33
7 23 31 38
13 16 30 37
14 26 40 47
15 19 21 45
17 34 36 46
28 42 44 48
32 41 43 48
17 35 38 45
1 22 25 34
2 16 43 44
3 6 37 42
4 5 30 32
7 10 14 39
8 24 33 40
9 23 41 47
11 18 20 21
12 19 35 46
13 28 29 36
15 16 27 38
2 13 17 26
24 28 31 43
1 36 40 48
3 9 14 15
4 20 29 35
5 12 27 45
6 18 19 39
7 8 11 37
10 21 32 44
22 30 31 41
23 25 33 42
26 30 34 45
29 32 46 47
1 15 28 46
2 7 34 48
3 17 18 41
4 19 31 42
5 10 37 43
6 16 22 26
8 12 21 39
9 11 13 27
14 20 36 44
5 23 35 40
24 30 38 47
17 25 27 31
3 33 35 47
1 26 39 43
2 11 14 22
4 10 23 34
6 13 32 38
7 20 28 45
8 15 41 44
9 25 36 37
12 29 40 42
16 18 24 46
19 37 47 48
17 21 29 33
1 10 19 24
2 8 30 46
3 13 25 40
4 26 33 48
5 7 41 42
6 12 31 36
9 18 38 43
11 15 23 39
14 16 32 45
20 24 34 37
21 22 27 35
10 11 16 28
6 29 44 45
1 12 17 44
2 15 36 47
3 5 21 26
4 9 40 46
7 18 27 32
3 8 31 48
13 34 35 43
14 23 28 30
19 20 22 38
19 25 26 29
13 31 33 39
6 11 35 41
1 20 32 42
2 12 33 41
4 8 27 47
5 9 16 34
7 25 30 44
10 17 30 48
14 42 43 46
12 15 22 37
10 15 18 40
21 23 37 46
2 24 39 45
5 8 28 38
3 22 32 36
1 7 13 47
4 16 36 39
6 20 40 43
9 17 24 32
11 33 34 38
.svn/pristine/08/081ec218492ba87ec82d1ea0bb40ce98d60012fa.svn-base
BIN
View File
Binary file not shown.
.svn/pristine/08/082673a1343079b57b1e2a6e99d799ea80c55316.svn-base
+128
View File
@@ -0,0 +1,128 @@
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// text_iarchive_impl.ipp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Distributed under 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)
// See http://www.boost.org for updates, documentation, and revision history.
//////////////////////////////////////////////////////////////////////
// implementation of basic_text_iprimitive overrides for the combination
// of template parameters used to implement a text_iprimitive
#include <cstddef> // size_t, NULL
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
using ::size_t;
} // namespace std
#endif
#include <boost/detail/workaround.hpp> // RogueWave
#include <boost/archive/text_iarchive.hpp>
namespace boost {
namespace archive {
template<class Archive>
BOOST_ARCHIVE_DECL void
text_iarchive_impl<Archive>::load(char *s)
{
std::size_t size;
* this->This() >> size;
// skip separating space
is.get();
// Works on all tested platforms
is.read(s, size);
s[size] = '\0';
}
template<class Archive>
BOOST_ARCHIVE_DECL void
text_iarchive_impl<Archive>::load(std::string &s)
{
std::size_t size;
* this->This() >> size;
// skip separating space
is.get();
// borland de-allocator fixup
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
if(NULL != s.data())
#endif
s.resize(size);
if(0 < size)
is.read(&(*s.begin()), size);
}
#ifndef BOOST_NO_CWCHAR
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
template<class Archive>
BOOST_ARCHIVE_DECL void
text_iarchive_impl<Archive>::load(wchar_t *ws)
{
std::size_t size;
* this->This() >> size;
// skip separating space
is.get();
is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
ws[size] = L'\0';
}
#endif // BOOST_NO_INTRINSIC_WCHAR_T
#ifndef BOOST_NO_STD_WSTRING
template<class Archive>
BOOST_ARCHIVE_DECL void
text_iarchive_impl<Archive>::load(std::wstring &ws)
{
std::size_t size;
* this->This() >> size;
// borland de-allocator fixup
#if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
if(NULL != ws.data())
#endif
ws.resize(size);
// skip separating space
is.get();
is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
}
#endif // BOOST_NO_STD_WSTRING
#endif // BOOST_NO_CWCHAR
template<class Archive>
BOOST_ARCHIVE_DECL void
text_iarchive_impl<Archive>::load_override(class_name_type & t){
basic_text_iarchive<Archive>::load_override(t);
}
template<class Archive>
BOOST_ARCHIVE_DECL void
text_iarchive_impl<Archive>::init(){
basic_text_iarchive<Archive>::init();
}
template<class Archive>
BOOST_ARCHIVE_DECL
text_iarchive_impl<Archive>::text_iarchive_impl(
std::istream & is,
unsigned int flags
) :
basic_text_iprimitive<std::istream>(
is,
0 != (flags & no_codecvt)
),
basic_text_iarchive<Archive>(flags)
{
if(0 == (flags & no_header))
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
this->init();
#else
this->basic_text_iarchive<Archive>::init();
#endif
}
} // namespace archive
} // namespace boost
.svn/pristine/08/082dcee202f57d68aa42b902120eafbac73211af.svn-base
+126
View File
@@ -0,0 +1,126 @@
// Boost integer/integer_mask.hpp header file ------------------------------//
// (C) Copyright Daryle Walker 2001.
// Distributed under 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)
// See http://www.boost.org for updates, documentation, and revision history.
#ifndef BOOST_INTEGER_INTEGER_MASK_HPP
#define BOOST_INTEGER_INTEGER_MASK_HPP
#include <boost/integer_fwd.hpp> // self include
#include <boost/config.hpp> // for BOOST_STATIC_CONSTANT
#include <boost/integer.hpp> // for boost::uint_t
#include <climits> // for UCHAR_MAX, etc.
#include <cstddef> // for std::size_t
#include <boost/limits.hpp> // for std::numeric_limits
//
// We simply cannot include this header on gcc without getting copious warnings of the kind:
//
// boost/integer/integer_mask.hpp:93:35: warning: use of C99 long long integer constant
//
// And yet there is no other reasonable implementation, so we declare this a system header
// to suppress these warnings.
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif
namespace boost
{
// Specified single-bit mask class declaration -----------------------------//
// (Lowest bit starts counting at 0.)
template < std::size_t Bit >
struct high_bit_mask_t
{
typedef typename uint_t<(Bit + 1)>::least least;
typedef typename uint_t<(Bit + 1)>::fast fast;
BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
}; // boost::high_bit_mask_t
// Specified bit-block mask class declaration ------------------------------//
// Makes masks for the lowest N bits
// (Specializations are needed when N fills up a type.)
template < std::size_t Bits >
struct low_bits_mask_t
{
typedef typename uint_t<Bits>::least least;
typedef typename uint_t<Bits>::fast fast;
BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
}; // boost::low_bits_mask_t
#define BOOST_LOW_BITS_MASK_SPECIALIZE( Type ) \
template < > struct low_bits_mask_t< std::numeric_limits<Type>::digits > { \
typedef std::numeric_limits<Type> limits_type; \
typedef uint_t<limits_type::digits>::least least; \
typedef uint_t<limits_type::digits>::fast fast; \
BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) ); \
BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); \
BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits ); \
}
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4245) // 'initializing' : conversion from 'int' to 'const boost::low_bits_mask_t<8>::least', signed/unsigned mismatch
#endif
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );
#if USHRT_MAX > UCHAR_MAX
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned short );
#endif
#if UINT_MAX > USHRT_MAX
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
#endif
#if ULONG_MAX > UINT_MAX
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
#endif
#if defined(BOOST_HAS_LONG_LONG)
#if ((defined(ULLONG_MAX) && (ULLONG_MAX > ULONG_MAX)) ||\
(defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX > ULONG_MAX)) ||\
(defined(ULONGLONG_MAX) && (ULONGLONG_MAX > ULONG_MAX)) ||\
(defined(_ULLONG_MAX) && (_ULLONG_MAX > ULONG_MAX)))
BOOST_LOW_BITS_MASK_SPECIALIZE( boost::ulong_long_type );
#endif
#elif defined(BOOST_HAS_MS_INT64)
#if 18446744073709551615ui64 > ULONG_MAX
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned __int64 );
#endif
#endif
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#undef BOOST_LOW_BITS_MASK_SPECIALIZE
} // namespace boost
#endif // BOOST_INTEGER_INTEGER_MASK_HPP
.svn/pristine/08/082e0c83b5c62cde2a1710e02b73889813b407f0.svn-base
+98
View File
@@ -0,0 +1,98 @@
#ifndef BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED
#define BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2003-2007
// Copyright David Abrahams 2003-2004
//
// Distributed under 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/set/aux_/set0.hpp>
#include <boost/mpl/has_key.hpp>
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
// used by 's_iter_get'
template< typename Set, typename Tail > struct s_iter;
template< typename Set, typename Tail > struct s_iter_get
: eval_if<
has_key< Set,typename Tail::item_type_ >
, identity< s_iter<Set,Tail> >
, next< s_iter<Set,Tail> >
>
{
};
template< typename Set, typename Tail > struct s_iter_impl
{
typedef Tail tail_;
typedef forward_iterator_tag category;
typedef typename Tail::item_type_ type;
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
typedef typename s_iter_get< Set,typename Tail::base >::type next;
#endif
};
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< typename Set, typename Tail >
struct next< s_iter<Set,Tail> >
: s_iter_get< Set,typename Tail::base >
{
};
template< typename Set >
struct next< s_iter<Set,set0<> > >
{
typedef s_iter<Set,set0<> > type;
};
template< typename Set, typename Tail > struct s_iter
: s_iter_impl<Set,Tail>
{
};
template< typename Set > struct s_iter<Set, set0<> >
{
typedef forward_iterator_tag category;
};
#else
template< typename Set >
struct s_end_iter
{
typedef forward_iterator_tag category;
typedef s_iter<Set,set0<> > next;
};
template< typename Set, typename Tail > struct s_iter
: if_<
is_same< Tail,set0<> >
, s_end_iter<Set>
, s_iter_impl<Set,Tail>
>::type
{
};
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
}}
#endif // BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED
.svn/pristine/08/083683e3d59058bfb1e653d5f1355d97e27d5be4.svn-base
+188
View File
@@ -0,0 +1,188 @@
/*=============================================================================
Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2001-2011 Joel de Guzman
Distributed under 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)
This is an auto-generated file. Do not edit!
==============================================================================*/
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
# else
# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
# endif
namespace boost { namespace fusion
{
namespace detail
{
template<int SeqSize, typename It, typename State, typename F, typename = void
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
, bool = SeqSize == 0
# endif
>
struct result_of_it_reverse_iter_fold
{};
template<typename It, typename State, typename F>
struct result_of_it_reverse_iter_fold<0,It,State,F
, typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
, true
# endif
>
{
typedef typename State::type type;
};
template<int SeqSize, typename It, typename State, typename F>
struct result_of_it_reverse_iter_fold<SeqSize,It,State,F
, typename boost::enable_if_has_type<
# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
typename boost::disable_if_c<SeqSize == 0, State>::type::type
# else
BOOST_FUSION_FOLD_IMPL_ENABLER(State)
# endif
>::type
# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
, false
# endif
>
: result_of_it_reverse_iter_fold<
SeqSize-1
, typename result_of::prior<It>::type
, boost::result_of<
F(
typename add_reference<typename State::type>::type,
It const&
)
>
, F
>
{};
template<typename It, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of_it_reverse_iter_fold<
0
, It
, State
, F
>::type
it_reverse_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
{
return state;
}
template<typename It, typename State, typename F, int SeqSize>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename lazy_enable_if_c<
SeqSize != 0
, result_of_it_reverse_iter_fold<
SeqSize
, It
, State
, F
>
>::type
it_reverse_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
{
return it_reverse_iter_fold<
typename result_of::prior<It>::type
, boost::result_of<
F(
typename add_reference<typename State::type>::type,
It const&
)
>
, F
>(
mpl::int_<SeqSize-1>()
, fusion::prior(it)
, f(state, it)
, f
);
}
template<typename Seq, typename State, typename F
, bool = traits::is_sequence<Seq>::value
, bool = traits::is_segmented<Seq>::value>
struct result_of_reverse_iter_fold
{};
template<typename Seq, typename State, typename F>
struct result_of_reverse_iter_fold<Seq, State, F, true, false>
: result_of_it_reverse_iter_fold<
result_of::size<Seq>::value
, typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
, add_reference<State>
, F
>
{};
template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of_reverse_iter_fold<Seq, State, F>::type
reverse_iter_fold(Seq& seq, State& state, F& f)
{
return it_reverse_iter_fold<
typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
, add_reference<State>
, F
>(
typename result_of::size<Seq>::type()
, fusion::prior( fusion::end(seq) )
, state
, f
);
}
}
namespace result_of
{
template<typename Seq, typename State, typename F>
struct reverse_iter_fold
: detail::result_of_reverse_iter_fold<Seq, State, F>
{};
}
template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq
, State const
, F
>::type
reverse_iter_fold(Seq& seq, State const& state, F f)
{
return detail::reverse_iter_fold<Seq, State const, F>(seq, state, f);
}
template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq const
, State const
, F
>::type
reverse_iter_fold(Seq const& seq, State const& state, F f)
{
return detail::reverse_iter_fold<Seq const, State const, F>(seq, state, f);
}
template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq
, State
, F
>::type
reverse_iter_fold(Seq& seq, State& state, F f)
{
return detail::reverse_iter_fold<Seq, State, F>(seq, state, f);
}
template<typename Seq, typename State, typename F>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::reverse_iter_fold<
Seq const
, State
, F
>::type
reverse_iter_fold(Seq const& seq, State& state, F f)
{
return detail::reverse_iter_fold<Seq const, State, F>(seq, state, f);
}
}}
.svn/pristine/08/083c4591c10e44860bfdafc1f625033f7b7ec720.svn-base
+436
View File
@@ -0,0 +1,436 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2006 Dan Marsden
Distributed under 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)
This is an auto-generated file. Do not edit!
==============================================================================*/
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template<typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ , typename T10 = fusion::void_ , typename T11 = fusion::void_ , typename T12 = fusion::void_ , typename T13 = fusion::void_ , typename T14 = fusion::void_ , typename T15 = fusion::void_ , typename T16 = fusion::void_ , typename T17 = fusion::void_ , typename T18 = fusion::void_ , typename T19 = fusion::void_ , typename T20 = fusion::void_>
struct zip;
}
namespace result_of
{
template< typename T0 , typename T1 >
struct zip< T0 , T1
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1>::type
zip(T0 const& t0 , T1 const& t1)
{
fusion::vector<const T0& , const T1&> seqs(
t0 , t1);
return typename result_of::zip<const T0 , const T1>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 >
struct zip< T0 , T1 , T2
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2)
{
fusion::vector<const T0& , const T1& , const T2&> seqs(
t0 , t1 , t2);
return typename result_of::zip<const T0 , const T1 , const T2>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 >
struct zip< T0 , T1 , T2 , T3
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3)
{
fusion::vector<const T0& , const T1& , const T2& , const T3&> seqs(
t0 , t1 , t2 , t3);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct zip< T0 , T1 , T2 , T3 , T4
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4&> seqs(
t0 , t1 , t2 , t3 , t4);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5&> seqs(
t0 , t1 , t2 , t3 , t4 , t5);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
, void_ , void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
, void_ , void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
, void_ , void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16
, void_ , void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17
, void_ , void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18
, void_ , void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type(
seqs);
}
namespace result_of
{
template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
, void_
>
{
typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > sequences;
typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
};
}
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type
zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19)
{
fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19&> seqs(
t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19);
return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type(
seqs);
}
}}
.svn/pristine/08/0851ed82b420569a609d46fb03017205df5764d0.svn-base
+47
View File
@@ -0,0 +1,47 @@
// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes,
// Howard Hinnant and John Maddock 2000.
// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001
// Use, modification and distribution are 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
// Fixed is_pointer, is_reference, is_const, is_volatile, is_same,
// is_member_pointer based on the Simulated Partial Specialization work
// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or
// http://groups.yahoo.com/group/boost/message/5441
// Some workarounds in here use ideas suggested from "Generic<Programming>:
// Mappings between Types and Values"
// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED
#define BOOST_TT_IS_CONST_HPP_INCLUDED
#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
#if defined( __CODEGEARC__ )
template <class T>
struct is_const : public integral_constant<bool, __is_const(T)> {};
#else
template <class T>
struct is_const : public false_type {};
template <class T> struct is_const<T const> : public true_type{};
template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
template <class T> struct is_const<T const[]> : public true_type{};
#endif
} // namespace boost
#endif // BOOST_TT_IS_CONST_HPP_INCLUDED
.svn/pristine/08/085832eb2eb6aa9576f4df85a213bc7afc4cd058.svn-base
+138
View File
@@ -0,0 +1,138 @@
//
//! Copyright (c) 2011-2012
//! Brandon Kohn
//
// Distributed under 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)
//
#if !defined(BOOST_NUMERIC_CONVERSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp>
#if !defined(BOOST_NO_LONG_LONG)
#include <boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp>
#endif
#else
#if !BOOST_PP_IS_ITERATING
#include <boost/preprocessor/seq/elem.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#if defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/numeric_cast_traits_common.hpp")
#endif
//
//! Copyright (c) 2011-2012
//! Brandon Kohn
//
// Distributed under 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)
//
#if defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
//! These are the assumed common built in fundamental types (not typedefs/macros.)
#define BOOST_NUMERIC_CONVERSION_BASE_BUILTIN_TYPES() \
(char) \
(signed char) \
(unsigned char) \
(short) \
(unsigned short) \
(int) \
(unsigned int) \
(long) \
(unsigned long) \
(float) \
(double) \
(long double) \
/***/
#define BOOST_NUMERIC_CONVERSION_SEQ_A() BOOST_NUMERIC_CONVERSION_BASE_BUILTIN_TYPES()
#define BOOST_NUMERIC_CONVERSION_SEQ_B() BOOST_NUMERIC_CONVERSION_BASE_BUILTIN_TYPES()
namespace boost { namespace numeric {
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_NUMERIC_CONVERSION_SEQ_A())), <boost/numeric/conversion/detail/numeric_cast_traits.hpp>))
#include BOOST_PP_ITERATE()
}}//namespace boost::numeric;
#if defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#if ( defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES) ) || !defined(BOOST_NO_LONG_LONG)
#undef BOOST_NUMERIC_CONVERSION_SEQ_A
#undef BOOST_NUMERIC_CONVERSION_SEQ_B
#if defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/numeric_cast_traits_long_long.hpp")
#endif
//
//! Copyright (c) 2011-2012
//! Brandon Kohn
//
// Distributed under 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)
//
#if defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace numeric {
#define BOOST_NUMERIC_CONVERSION_SEQ_A() BOOST_NUMERIC_CONVERSION_BASE_BUILTIN_TYPES()(boost::long_long_type)(boost::ulong_long_type)
#define BOOST_NUMERIC_CONVERSION_SEQ_B() (boost::long_long_type)(boost::ulong_long_type)
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_NUMERIC_CONVERSION_SEQ_A())), <boost/numeric/conversion/detail/numeric_cast_traits.hpp>))
#include BOOST_PP_ITERATE()
}}//namespace boost::numeric;
#if defined(__WAVE__) && defined(BOOST_NUMERIC_CONVERSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif
#undef BOOST_NUMERIC_CONVERSION_BASE_BUILTIN_TYPES
#undef BOOST_NUMERIC_CONVERSION_SEQ_A
#undef BOOST_NUMERIC_CONVERSION_SEQ_B
#elif BOOST_PP_ITERATION_DEPTH() == 1
#define BOOST_PP_ITERATION_PARAMS_2 (3, (0, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_NUMERIC_CONVERSION_SEQ_B())), <boost/numeric/conversion/detail/numeric_cast_traits.hpp>))
#include BOOST_PP_ITERATE()
#elif BOOST_PP_ITERATION_DEPTH() == 2
//! Generate default traits for the specified source and target.
#define BOOST_NUMERIC_CONVERSION_A BOOST_PP_FRAME_ITERATION(1)
#define BOOST_NUMERIC_CONVERSION_B BOOST_PP_FRAME_ITERATION(2)
template <>
struct numeric_cast_traits
<
BOOST_PP_SEQ_ELEM(BOOST_NUMERIC_CONVERSION_A, BOOST_NUMERIC_CONVERSION_SEQ_A())
, BOOST_PP_SEQ_ELEM(BOOST_NUMERIC_CONVERSION_B, BOOST_NUMERIC_CONVERSION_SEQ_B())
>
{
typedef def_overflow_handler overflow_policy;
typedef UseInternalRangeChecker range_checking_policy;
typedef Trunc<BOOST_PP_SEQ_ELEM(BOOST_NUMERIC_CONVERSION_B, BOOST_NUMERIC_CONVERSION_SEQ_B())> rounding_policy;
};
#undef BOOST_NUMERIC_CONVERSION_A
#undef BOOST_NUMERIC_CONVERSION_B
#endif//! Depth 2.
#endif// BOOST_NUMERIC_CONVERSION_DONT_USE_PREPROCESSED_FILES
.svn/pristine/08/0864c4c94e29553184cb2bb4f8ca68c1b217946e.svn-base
+69
View File
@@ -0,0 +1,69 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Distributed under 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)
==============================================================================*/
#if !defined(FUSION_INSERT_07222005_0730)
#define FUSION_INSERT_07222005_0730
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/iterator/mpl/convert_iterator.hpp>
#include <boost/fusion/view/joint_view/joint_view.hpp>
#include <boost/fusion/view/single_view/single_view.hpp>
#include <boost/fusion/view/iterator_range/iterator_range.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
namespace result_of
{
template <typename Sequence, typename Position, typename T>
struct insert
{
typedef typename detail::as_fusion_element<T>::type element_type;
typedef typename convert_iterator<Position>::type pos_type;
typedef typename result_of::begin<Sequence>::type first_type;
typedef typename result_of::end<Sequence>::type last_type;
typedef iterator_range<first_type, pos_type> left_type;
typedef iterator_range<pos_type, last_type> right_type;
typedef fusion::single_view<element_type> single_view;
typedef joint_view<left_type, single_view const> left_insert_type;
typedef joint_view<left_insert_type, right_type> type;
};
}
template <typename Sequence, typename Position, typename T>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::insert<Sequence const, Position, T>
>::type
insert(Sequence const& seq, Position const& pos, T const& x)
{
typedef result_of::insert<
Sequence const, Position, T>
result_of;
typedef typename result_of::left_type left_type;
typedef typename result_of::right_type right_type;
typedef typename result_of::single_view single_view;
typedef typename result_of::left_insert_type left_insert_type;
typedef typename result_of::type result;
left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos));
right_type right(convert_iterator<Position>::call(pos), fusion::end(seq));
single_view insert(x);
left_insert_type left_insert(left, insert);
return result(left_insert, right);
}
}}
#endif
.svn/pristine/08/086ee50896825b2f32c243fb7250f6450346857f.svn-base
+27
View File
@@ -0,0 +1,27 @@
//-----------------------------------------------------------------------------
// boost variant.hpp header file
// See http://www.boost.org/libs/variant for documentation.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2003
// Eric Friedman, Itay Maman
//
// Distributed under 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_VARIANT_HPP
#define BOOST_VARIANT_HPP
// variant "main"
#include <boost/variant/variant.hpp>
#include <boost/variant/recursive_variant.hpp>
#include <boost/variant/recursive_wrapper.hpp>
// common applications
#include <boost/variant/get.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/static_visitor.hpp>
#include <boost/variant/visitor_ptr.hpp>
#endif // BOOST_VARIANT_HPP
.svn/pristine/08/08731ff6a4efe2aaac89f0828dea0be704f33b13.svn-base
+13
View File
@@ -0,0 +1,13 @@
// Copyright David Abrahams 2004. Distributed under 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 SFINAE_DWA2004723_HPP
# define SFINAE_DWA2004723_HPP
# include <boost/python/detail/prefix.hpp>
# if defined(BOOST_NO_SFINAE) && !defined(BOOST_MSVC)
# define BOOST_PYTHON_NO_SFINAE
# endif
#endif // SFINAE_DWA2004723_HPP
.svn/pristine/08/087a158493c11aa363b5581a9e030f31a5eacada.svn-base
+55
View File
@@ -0,0 +1,55 @@
# /* Copyright (C) 2001
# * Housemarque Oy
# * http://www.housemarque.com
# *
# * Distributed under 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)
# */
#
# /* Revised by Paul Mensonides (2002) */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_LIST_REST_N_HPP
# define BOOST_PREPROCESSOR_LIST_REST_N_HPP
#
# include <boost/preprocessor/arithmetic/dec.hpp>
# include <boost/preprocessor/config/config.hpp>
# include <boost/preprocessor/control/while.hpp>
# include <boost/preprocessor/list/adt.hpp>
# include <boost/preprocessor/tuple/elem.hpp>
#
# /* BOOST_PP_LIST_REST_N */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_LIST_REST_N(count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count)))
# else
# define BOOST_PP_LIST_REST_N(count, list) BOOST_PP_LIST_REST_N_I(count, list)
# define BOOST_PP_LIST_REST_N_I(count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count)))
# endif
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_LIST_REST_N_P(d, lc) BOOST_PP_TUPLE_ELEM(2, 1, lc)
# else
# define BOOST_PP_LIST_REST_N_P(d, lc) BOOST_PP_LIST_REST_N_P_I lc
# define BOOST_PP_LIST_REST_N_P_I(list, count) count
# endif
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_LIST_REST_N_O(d, lc) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(2, 0, lc)), BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2, 1, lc)))
# else
# define BOOST_PP_LIST_REST_N_O(d, lc) BOOST_PP_LIST_REST_N_O_I lc
# define BOOST_PP_LIST_REST_N_O_I(list, count) (BOOST_PP_LIST_REST(list), BOOST_PP_DEC(count))
# endif
#
# /* BOOST_PP_LIST_REST_N_D */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_LIST_REST_N_D(d, count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count)))
# else
# define BOOST_PP_LIST_REST_N_D(d, count, list) BOOST_PP_LIST_REST_N_D_I(d, count, list)
# define BOOST_PP_LIST_REST_N_D_I(d, count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count)))
# endif
#
# endif
.svn/pristine/08/088acbd5a258ad357cbf8e6af1307a7dbf773fba.svn-base
+147
View File
@@ -0,0 +1,147 @@
// (C) Copyright 2005 Matthias Troyer
// (C) Copyright 2006 Douglas Gregor <doug.gregor -at- gmail.com>
// 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)
// Authors: Matthias Troyer
// Douglas Gregor
/** @file packed_oarchive.hpp
*
* This header provides the facilities for unpacking Serializable
* data types from a buffer using @c MPI_Unpack. The buffers are
* typically received via MPI and have been packed either by via the
* facilities in @c packed_iarchive.hpp or @c MPI_Pack.
*/
#ifndef BOOST_MPI_PACKED_OARCHIVE_HPP
#define BOOST_MPI_PACKED_OARCHIVE_HPP
#include <boost/mpi/datatype.hpp>
#include <boost/archive/basic_archive.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/common_oarchive.hpp>
#include <boost/mpi/detail/packed_oprimitive.hpp>
#include <boost/mpi/detail/binary_buffer_oprimitive.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/item_version_type.hpp>
namespace boost { namespace mpi {
#ifdef BOOST_MPI_HOMOGENEOUS
typedef binary_buffer_oprimitive oprimitive;
#else
typedef packed_oprimitive oprimitive;
#endif
/** @brief An archive that packs binary data into an MPI buffer.
*
* The @c packed_iarchive class is an Archiver (as in the
* Boost.Serialization library) that packs binary data into a buffer
* for transmission via MPI. It can operate on any Serializable data
* type and will use the @c MPI_Pack function of the underlying MPI
* implementation to perform serialization.
*/
class BOOST_MPI_DECL packed_oarchive
: public oprimitive
, public archive::detail::common_oarchive<packed_oarchive>
{
public:
/**
* Construct a @c packed_oarchive for transmission over the given
* MPI communicator and with an initial buffer.
*
* @param comm The communicator over which this archive will be
* sent.
*
* @param b A user-defined buffer that will be filled with the
* binary representation of serialized objects.
*
* @param flags Control the serialization of the data types. Refer
* to the Boost.Serialization documentation before changing the
* default flags.
*
* @param position Set the offset into buffer @p b at which
* deserialization will begin.
*/
packed_oarchive( MPI_Comm const & comm, buffer_type & b, unsigned int flags = boost::archive::no_header)
: oprimitive(b,comm),
archive::detail::common_oarchive<packed_oarchive>(flags)
{}
/**
* Construct a @c packed_oarchive for transmission over the given
* MPI communicator.
*
* @param comm The communicator over which this archive will be
* sent.
*
* @param s The size of the buffer to be received.
*
* @param flags Control the serialization of the data types. Refer
* to the Boost.Serialization documentation before changing the
* default flags.
*/
packed_oarchive ( MPI_Comm const & comm, unsigned int flags = boost::archive::no_header)
: oprimitive(internal_buffer_,comm),
archive::detail::common_oarchive<packed_oarchive>(flags)
{}
// Save everything else in the usual way, forwarding on to the Base class
template<class T>
void save_override(T const& x, mpl::false_)
{
archive::detail::common_oarchive<packed_oarchive>::save_override(x);
}
// Save it directly using the primitives
template<class T>
void save_override(T const& x, mpl::true_)
{
oprimitive::save(x);
}
// Save all supported datatypes directly
template<class T>
void save_override(T const& x)
{
typedef typename mpl::apply1<use_array_optimization,T>::type use_optimized;
save_override(x, use_optimized());
}
// output archives need to ignore the optional information
void save_override(const archive::class_id_optional_type & ){}
// explicitly convert to char * to avoid compile ambiguities
void save_override(const archive::class_name_type & t){
const std::string s(t);
* this->This() << s;
}
void save_override(const archive::class_id_type & t){
const boost::int_least16_t x = t;
* this->This() << x;
}
void save_override(const archive::version_type & t){
const boost::int_least8_t x = t;
* this->This() << x;
}
private:
/// An internal buffer to be used when the user does not supply his
/// own buffer.
buffer_type internal_buffer_;
};
} } // end namespace boost::mpi
// required by export
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::mpi::packed_oarchive)
BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::mpi::packed_oarchive)
#endif // BOOST_MPI_PACKED_OARCHIVE_HPP
.svn/pristine/08/08a4c84b29a5ea9bf6d92e6ea4ef032a62d27c94.svn-base
+28
View File
@@ -0,0 +1,28 @@
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2008 Steven Watanabe
//
// Distributed under 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_UNITS_ACTIVITY_DERIVED_DIMENSION_HPP
#define BOOST_UNITS_ACTIVITY_DERIVED_DIMENSION_HPP
#include <boost/units/derived_dimension.hpp>
#include <boost/units/physical_dimensions/time.hpp>
namespace boost {
namespace units {
/// derived dimension for activity : T^-1
typedef derived_dimension<time_base_dimension,-1>::type activity_dimension;
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_ACTIVITY_DERIVED_DIMENSION_HPP
.svn/pristine/08/08aba1de6b4aad6e0a8b58bfd9ffb6bce6cd4ff5.svn-base
+48
View File
@@ -0,0 +1,48 @@
#ifndef BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED
#define BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/aux_/config/gcc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x530)) \
|| BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
: T::type
{
};
}}}
#if BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \
aux::nested_type_wknd<T> \
/**/
#else
# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \
::boost::mpl::aux::nested_type_wknd<T> \
/**/
#endif
#else // !BOOST_MPL_CFG_GCC et al.
# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) T::type
#endif
#endif // BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED
.svn/pristine/08/08c4cde3701358646c35ff76acfa15ba80221e9c.svn-base
+40
View File
@@ -0,0 +1,40 @@
// Copyright Aleksey Gurtovoy 2001-2004
//
// Distributed under 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)
//
// *Preprocessed* version of the main "template_arity.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl { namespace aux {
template< bool >
struct template_arity_impl
{
template< typename F > struct result_
: mpl::int_< -1 >
{
};
};
template<>
struct template_arity_impl<true>
{
template< typename F > struct result_
: F::arity
{
};
};
template< typename F >
struct template_arity
: template_arity_impl< ::boost::mpl::aux::has_rebind<F>::value >
::template result_<F>
{
};
}}}
.svn/pristine/08/08c65d5f44b5775460c61d11033cb1c8b5019199.svn-base
+25
View File
@@ -0,0 +1,25 @@
#ifndef RESTRICTED_SPIN_BOX_HPP_
#define RESTRICTED_SPIN_BOX_HPP_
#include "HintedSpinBox.hpp"
class QString;
//
// RestrictedSpinBox - select only from a sequence of values
//
class RestrictedSpinBox final
: public HintedSpinBox
{
public:
RestrictedSpinBox (QWidget * parent = nullptr)
: HintedSpinBox {parent}
{
}
protected:
// override the base class validation
QValidator::State validate (QString& input, int& pos) const override;
};
#endif
.svn/pristine/08/08cbdf518ce3e5041caf19c956d2070c8624fc46.svn-base
+242
View File
@@ -0,0 +1,242 @@
// This is a comment line, anything with // is ignored at process time.
= WSJT-X User Guide
Joseph H Taylor, Jr, K1JT
:revnumber: {VERSION}
// For web-pages, adding :badges: is ok, but is a security issue for
// package building .deb, .rpm, etc as it exposes the IP address and the images
// are non-free, so can't be included as part of the Debian package.
// :badges:
:docinfo1:
:imagesdir: {docdir}/images
:icons: font
:numbered:
:keywords: amateur radio weak signal communication K1JT WSJT JT65 JT9
:description: Software for Amateur Radio Weak-Signal Communication
:prog: WSJT-X
// use global link file
include::../../common/links.adoc[]
// These [[xxxx]] labels are HTML anchors, and can be used to
// navigate though the document easily: <<INTRO,See Introduction>> will
// place a hyper-link in your text to take you too the anchored section.
// All major sections or points of interest should have one.
// == is level (2), section 1.0, === would mean section 1.1, === would
// be section 1.1.1. This method is used throughout the document.
[[INTRO]]
== Introduction
include::introduction.adoc[]
[[NEW_FEATURES]]
include::new_features.adoc[]
[[SYSREQ]]
== System Requirements
include::system-requirements.adoc[]
[[INSTALL]]
== Installation
Installation packages for released versions on Windows, Linux, and OS
X are found on the {homepage}. Click on the _WSJT-X_ link at the
left margin and select the appropriate package for your operating
system.
[[INSTALL_WIN]]
=== Windows
include::install-windows.adoc[]
[[INSTALL_LINUX]]
=== Linux
include::install-linux.adoc[]
[[INSTALL_OSX]]
=== OS X and macOS
include::install-mac.adoc[]
////
[[SRC_CODE]]
=== Source Code
include::install-from-source.adoc[]
////
[[CONFIG]]
== Settings
Select *Settings* from the *File* menu or by typing *F2*. (On
Macintosh select *Preferences* from the _WSJT-X_ menu, or use the
keyboard shortcut *Cmd+,*). The following sections describe setup
options available on each of seven tabs selectable near the top of the
window.
[[GENERAL]]
=== General
include::settings-general.adoc[]
[[RADIO]]
=== Radio
include::settings-radio.adoc[]
[[AUDIO]]
=== Audio
include::settings-audio.adoc[]
[[TXMACROS]]
=== Tx Macros
include::settings-txmacros.adoc[]
[[REPORTING]]
=== Reporting
include::settings-reporting.adoc[]
[[BAND_SETTINGS]]
=== Frequencies
include::settings-frequencies.adoc[]
[[COLORS]]
=== Colors
include::settings-colors.adoc[]
[[ADVANCED]]
=== Advanced
include::settings-advanced.adoc[]
[[TRANSCEIVER]]
== Transceiver Setup
include::transceiver-setup.adoc[]
[[TUTORIAL]]
== Basic Operating Tutorial
<<TUT_MAIN,Sections 6.1>> through <<TUT_EX2,6.4>> introduce basic user
controls and program behavior of _WSJT-X_. We suggest that new users
should go through the full HF-oriented tutorial, preferably while at
your radio. Subsequent sections cover additional details on
<<MAKE_QSOS,Making QSOs>>, <<WSPR,WSPR mode>> and <<VHF_AND_UP,VHF+
Features>>.
[[TUT_MAIN]]
=== Main Window Settings
include::tutorial-main-window.adoc[]
[[TUT_WIDE_GRAPH]]
=== Wide Graph Settings
include::tutorial-wide-graph-settings.adoc[]
[[TUT_EX1]]
=== JT9
include::tutorial-example1.adoc[]
[[TUT_EX2]]
=== JT9+JT65
include::tutorial-example2.adoc[]
[[TUT_EX3]]
=== FT8
include::tutorial-example3.adoc[]
[[MAKE_QSOS]]
== Making QSOs
include::make-qso.adoc[]
[[VHF_AND_UP]]
== VHF+ Features
include::vhf-features.adoc[]
[[WSPR]]
== WSPR Mode
include::wspr.adoc[]
[[COMMAND_REF]]
== On-Screen Controls
[[MENUS]]
=== Menus
include::controls-functions-menus.adoc[]
[[CONTROLS_MAIN]]
=== Button Row
include::controls-functions-main-window.adoc[]
[[CONTROLS_LEFT]]
=== Left
include::controls-functions-left.adoc[]
[[CONTROLS_CENTER]]
=== Center
include::controls-functions-center.adoc[]
[[CONTROLS_MSGS]]
=== Tx Messages
include::controls-functions-messages.adoc[]
[[STATUS_BAR]]
=== Status Bar
include::controls-functions-status-bar.adoc[]
[[CONTROLS_WIDE]]
=== Wide Graph
include::controls-functions-wide-graph.adoc[]
[[LOGGING]]
== Logging
include::logging.adoc[]
[[ODDS_AND_ENDS]]
== Odds and Ends
include::odds_and_ends.adoc[]
[[COOP_PGMS]]
== Cooperating Programs
include::cooperating-programs.adoc[]
[[PLATFORM]]
== Platform Dependencies
include::platform-dependencies.adoc[]
[[FAQ]]
== Frequently Asked Questions
include::faq.adoc[]
[[PROTOCOLS]]
== Protocol Specifications
include::protocols.adoc[]
[[ASTRODATA]]
== Astronomical Data
include::astro_data.adoc[]
[[UTIL]]
== Utility Programs
include::utilities.adoc[]
////
[[TXRX]]
== Implementation Details
include::implementation.adoc[]
[[TROUBLE_SHOOTING]]
== Troubleshooting
To be added (?) ...
////
[[SUPPORT]]
== Support
include::support.adoc[]
[[ACK]]
== Acknowledgements
include::acknowledgements.adoc[]
[[LICENSE]]
== License
include::../../common/license.adoc[]
ifeval::["{backend}" != "html5"]
[index]
== Index
endif::[]
.svn/pristine/08/08de0c9ff8f5361ffa065866b8685d088f725a18.svn-base
+29
View File
@@ -0,0 +1,29 @@
// Copyright David Abrahams 2004. Distributed under 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 IS_WRAPPER_DWA2004723_HPP
# define IS_WRAPPER_DWA2004723_HPP
# include <boost/python/detail/prefix.hpp>
# include <boost/mpl/bool.hpp>
namespace boost { namespace python {
template <class T> class wrapper;
namespace detail
{
typedef char (&is_not_wrapper)[2];
is_not_wrapper is_wrapper_helper(...);
template <class T>
char is_wrapper_helper(wrapper<T> const volatile*);
// A metafunction returning true iff T is [derived from] wrapper<U>
template <class T>
struct is_wrapper
: mpl::bool_<(sizeof(detail::is_wrapper_helper((T*)0)) == 1)>
{};
}}} // namespace boost::python::detail
#endif // IS_WRAPPER_DWA2004723_HPP
.svn/pristine/08/08dfb631845b61db89b409d05750e085aa1f5e96.svn-base
+29
View File
@@ -0,0 +1,29 @@
// (C) Copyright John Maddock 2001 - 2002.
// Use, modification and distribution are 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)
// See http://www.boost.org for most recent version.
// SGI C++ compiler setup:
#define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION)
#include <boost/config/compiler/common_edg.hpp>
//
// Threading support:
// Turn this on unconditionally here, it will get turned off again later
// if no threading API is detected.
//
#define BOOST_HAS_THREADS
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#undef BOOST_NO_SWPRINTF
#undef BOOST_DEDUCED_TYPENAME
//
// version check:
// probably nothing to do here?
.svn/pristine/08/08e5a3356ed636791804cb9306c81badca3b50e4.svn-base
+337
View File
@@ -0,0 +1,337 @@
module options
!
! Source code copied from:
! http://fortranwiki.org/fortran/show/Command-line+arguments
!
implicit none
type option
!> Long name.
character(len=100) :: name
!> Does the option require an argument?
logical :: has_arg
!> Corresponding short name.
character :: chr
!> Description.
character(len=500) :: descr
!> Argument name, if required.
character(len=20) :: argname
contains
procedure :: print => print_opt
end type option
contains
!> Parse command line options. Options and their arguments must come before
!> all non-option arguments. Short options have the form "-X", long options
!> have the form "--XXXX..." where "X" is any character. Parsing can be
!> stopped with the option '--'.
!> The following code snippet illustrates the intended use:
!> \code
!> do
!> call getopt (..., optchar=c, ...)
!> if (stat /= 0) then
!> ! optional error handling
!> exit
!> end if
!> select case (c)
!> ! process options
!> end select
!> end do
!> \endcode
subroutine getopt (options, longopts, optchar, optarg, arglen, stat, &
offset, remain, err)
use iso_fortran_env, only: error_unit
!> String containing the characters that are valid short options. If
!> present, command line arguments are scanned for those options.
!> If a character is followed by a colon (:) its corresponding option
!> requires an argument. E.g. "vn:" defines two options -v and -n with -n
!> requiring an argument.
character(len=*), intent(in), optional :: options
!> Array of long options. If present, options of the form '--XXXX...' are
!> recognised. Each option has an associated option character. This can be
!> any character of default kind, it is just an identifier. It can, but
!> doesn't have to, match any character in the options argument. In fact it
!> is possible to only pass long options and no short options at all.
!> Only name, has_arg and chr need to be set.
type(option), intent(in), optional :: longopts(:)
!> If stat is not 1, optchar contains the option character that was parsed.
!> Otherwise its value is undefined.
character, intent(out), optional :: optchar
!> If stat is 0 and the parsed option requires an argument, optarg contains
!> the first len(optarg) (but at most 500) characters of that argument.
!> Otherwise its value is undefined. If the arguments length exceeds 500
!> characters and err is .true., a warning is issued.
character(len=*), intent(out), optional :: optarg
!> If stat is 0 and the parsed option requires an argument, arglen contains
!> the actual length of that argument. Otherwise its value is undefined.
!> This can be used to make sure the argument was not truncated by the
!> limited length of optarg.
integer, intent(out), optional :: arglen
!> Status indicator. Can have the following values:
!> - 0: An option was successfully parsed.
!> - 1: Parsing stopped successfully because a non-option or '--' was
!> encountered.
!> - -1: An unrecognised option was encountered.
!> - -2: A required argument was missing.
!> .
!> Its value is never undefined.
integer, intent(out), optional :: stat
!> If stat is 1, offset contains the number of the argument before the
!> first non-option argument, i.e. offset+n is the nth non-option argument.
!> If stat is not 1, offset contains the number of the argument that would
!> be parsed in the next call to getopt. This number can be greater than
!> the actual number of arguments.
integer, intent(out), optional :: offset
!> If stat is 1, remain contains the number of remaining non-option
!> arguments, i.e. the non-option arguments are in the range
!> (offset+1:offset+remain). If stat is not 1, remain is undefined.
integer, intent(out), optional :: remain
!> If err is present and .true., getopt prints messages to the standard
!> error unit if an error is encountered (i.e. whenever stat would be set
!> to a negative value).
logical, intent(in), optional :: err
integer, save :: pos = 1, cnt = 0
character(len=500), save :: arg
integer :: chrpos, length, st, id = 0
character :: chr
logical :: long
if (cnt == 0) cnt = command_argument_count()
long = .false.
! no more arguments left
if (pos > cnt) then
pos = pos - 1
st = 1
goto 10
end if
call get_command_argument (pos, arg, length)
! is argument an option?
if (arg(1:1) == '-') then
chr = arg(2:2)
! too long ('-xxxx...') for one dash?
if (chr /= '-' .and. len_trim(arg) > 2) then
st = -1
goto 10
end if
! forced stop ('--')
if (chr == '-' .and. arg(3:3) == ' ') then
st = 1
goto 10
end if
! long option ('--xxx...')
if (chr == '-') then
long = .true.
! check if valid
id = lookup(arg(3:))
! option is invalid, stop
if (id == 0) then
st = -1
goto 10
end if
chr = longopts(id)%chr
! check if option requires an argument
if (.not. longopts(id)%has_arg) then
st = 0
goto 10
end if
! check if there are still arguments left
if (pos == cnt) then
st = -2
goto 10
end if
! go to next position
pos = pos + 1
! get argument
call get_command_argument (pos, arg, length)
! make sure it is not an option
if (arg(1:1) == '-') then
st = -2
pos = pos - 1
goto 10
end if
end if
! short option
! check if valid
if (present(options)) then
chrpos = scan(options, chr)
else
chrpos = 0
end if
! option is invalid, stop
if (chrpos == 0) then
st = -1
goto 10
end if
! look for argument requirement
if (chrpos < len_trim(options)) then
if (options(chrpos+1:chrpos+1) == ':') then
! check if there are still arguments left
if (pos == cnt) then
st = -2
goto 10
end if
! go to next position
pos = pos + 1
! get argument
call get_command_argument (pos, arg, length)
! make sure it is not an option
if (arg(1:1) == '-') then
st = -2
pos = pos - 1
goto 10
end if
end if
end if
! if we get to this point, no error happened
! return option and the argument (if there is one)
st = 0
goto 10
end if
! not an option, parsing stops
st = 1
! we are already at the first non-option argument
! go one step back to the last option or option argument
pos = pos - 1
! error handling and setting of return values
10 continue
if (present(err)) then
if (err) then
select case (st)
case (-1)
write (error_unit, *) "error: unrecognised option: " // trim(arg)
case (-2)
if (.not. long) then
write (error_unit, *) "error: option -" // chr &
// " requires an argument"
else
write (error_unit, *) "error: option --" &
// trim(longopts(id)%name) // " requires an argument"
end if
end select
end if
end if
if (present(optchar)) optchar = chr
if (present(optarg)) optarg = arg
if (present(arglen)) arglen = length
if (present(stat)) stat = st
if (present(offset)) offset = pos
if (present(remain)) remain = cnt-pos
! setup pos for next call to getopt
pos = pos + 1
contains
integer function lookup (name)
character(len=*), intent(in) :: name
integer :: i
! if there are no long options, skip the loop
if (.not. present(longopts)) goto 10
do i = 1, size(longopts)
if (name == longopts(i)%name) then
lookup = i
return
end if
end do
! if we get to this point, the option was not found
10 lookup = 0
end function lookup
end subroutine getopt
!============================================================================
!> Print an option in the style of a man page. I.e.
!> \code
!> -o arg
!> --option arg
!> description.................................................................
!> ............................................................................
!> \endcode
subroutine print_opt (opt, unit)
!> the option
class(option), intent(in) :: opt
!> logical unit number
integer, intent(in) :: unit
integer :: l, c1, c2
if (opt%has_arg) then
write (unit, '(1x,"-",a,1x,a)') opt%chr, trim(opt%argname)
write (unit, '(1x,"--",a,1x,a)') trim(opt%name), trim(opt%argname)
else
write (unit, '(1x,"-",a)') opt%chr
write (unit, '(1x,"--",a)') trim(opt%name)
end if
l = len_trim(opt%descr)
! c1 is the first character of the line
! c2 is one past the last character of the line
c1 = 1
do
if (c1 > l) exit
! print at maximum 4+76 = 80 characters
c2 = min(c1 + 76, 500)
! if not at the end of the whole string
if (c2 /= 500) then
! find the end of a word
do
if (opt%descr(c2:c2) == ' ') exit
c2 = c2-1
end do
end if
write (unit, '(4x,a)') opt%descr(c1:c2-1)
c1 = c2+1
end do
end subroutine print_opt
end module options
.svn/pristine/08/08f63d5cf38767b039bd14219ee6ddba36c7a425.svn-base
+61
View File
@@ -0,0 +1,61 @@
// Boost.Range library
//
// Copyright Neil Groves 2009. 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_ALGORITHM_EXT_ERASE_HPP_INCLUDED
#define BOOST_RANGE_ALGORITHM_EXT_ERASE_HPP_INCLUDED
#include <boost/range/config.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/assert.hpp>
namespace boost
{
namespace range
{
template< class Container >
inline Container& erase( Container& on,
iterator_range<BOOST_DEDUCED_TYPENAME Container::iterator> to_erase )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
on.erase( boost::begin(to_erase), boost::end(to_erase) );
return on;
}
template< class Container, class T >
inline Container& remove_erase( Container& on, const T& val )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
on.erase(
std::remove(boost::begin(on), boost::end(on), val),
boost::end(on));
return on;
}
template< class Container, class Pred >
inline Container& remove_erase_if( Container& on, Pred pred )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
on.erase(
std::remove_if(boost::begin(on), boost::end(on), pred),
boost::end(on));
return on;
}
} // namespace range
using range::erase;
using range::remove_erase;
using range::remove_erase_if;
} // namespace boost
#endif // include guard
.svn/pristine/08/08fbaebcc77a3e8f1b053a71f2e6fce7b0be483e.svn-base
+70
View File
@@ -0,0 +1,70 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under 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_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP
#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/iterator/basic_iterator.hpp>
namespace boost { namespace fusion { namespace extension
{
template <typename>
struct end_impl;
template <>
struct end_impl<struct_tag>
{
template <typename Seq>
struct apply
{
typedef
basic_iterator<
struct_iterator_tag
, random_access_traversal_tag
, Seq
, struct_size<typename remove_const<Seq>::type>::value
>
type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type
call(Seq& seq)
{
return type(seq,0);
}
};
};
template <>
struct end_impl<assoc_struct_tag>
{
template <typename Seq>
struct apply
{
typedef
basic_iterator<
struct_iterator_tag
, assoc_struct_category
, Seq
, struct_size<typename remove_const<Seq>::type>::value
>
type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type
call(Seq& seq)
{
return type(seq,0);
}
};
};
}}}
#endif