Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,27 @@
|
||||
|
||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||
// 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.
|
||||
|
||||
#ifndef BOOST_TT_IS_SCALAR_HPP_INCLUDED
|
||||
#define BOOST_TT_IS_SCALAR_HPP_INCLUDED
|
||||
|
||||
#include <boost/type_traits/is_arithmetic.hpp>
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_member_pointer.hpp>
|
||||
#include <boost/config.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
template <typename T>
|
||||
struct is_scalar
|
||||
: public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_enum<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value>
|
||||
{};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_TT_IS_SCALAR_HPP_INCLUDED
|
||||
@@ -0,0 +1,13 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2007 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_INCLUDE_AS_LIST)
|
||||
#define FUSION_INCLUDE_AS_LIST
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/container/list/convert.hpp>
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,88 @@
|
||||
// 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) 2007-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_DETAIL_DIMENSIONLESS_UNIT_HPP
|
||||
#define BOOST_UNITS_DETAIL_DIMENSIONLESS_UNIT_HPP
|
||||
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/units/units_fwd.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace units {
|
||||
|
||||
template<class T>
|
||||
struct heterogeneous_system;
|
||||
|
||||
template<class T>
|
||||
struct homogeneous_system;
|
||||
|
||||
template<class T1, class T2, class Scale>
|
||||
struct heterogeneous_system_impl;
|
||||
|
||||
typedef boost::units::heterogeneous_system<
|
||||
boost::units::heterogeneous_system_impl<
|
||||
boost::units::dimensionless_type,
|
||||
boost::units::dimensionless_type,
|
||||
boost::units::dimensionless_type
|
||||
>
|
||||
> heterogeneous_dimensionless_system;
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class System>
|
||||
struct void_if_dimensionless {
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct void_if_dimensionless<boost::units::homogeneous_system<T> > {
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct void_if_dimensionless<heterogeneous_dimensionless_system> {
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<class System, class Test = void>
|
||||
struct void_if_heterogeneous {
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<class System>
|
||||
struct void_if_heterogeneous<System, typename void_if_dimensionless<System>::type> {
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<class System, class Enable=void>
|
||||
struct is_dimensionless_system : mpl::false_ {};
|
||||
|
||||
template<class System>
|
||||
struct is_dimensionless_system<System, typename void_if_dimensionless<System>::type> : mpl::true_ {};
|
||||
|
||||
#define BOOST_UNITS_DIMENSIONLESS_UNIT(T)\
|
||||
boost::units::unit<\
|
||||
boost::units::dimensionless_type,\
|
||||
T,\
|
||||
typename ::boost::units::detail::void_if_dimensionless<T>::type\
|
||||
>
|
||||
|
||||
#define BOOST_UNITS_HETEROGENEOUS_DIMENSIONLESS_UNIT(T)\
|
||||
boost::units::unit<\
|
||||
boost::units::dimensionless_type,\
|
||||
T,\
|
||||
typename ::boost::units::detail::void_if_heterogeneous<T>::type\
|
||||
>
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,34 @@
|
||||
// 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_SI_TORQUE_HPP
|
||||
#define BOOST_UNITS_SI_TORQUE_HPP
|
||||
|
||||
#include <boost/units/systems/si/base.hpp>
|
||||
#include <boost/units/physical_dimensions/torque.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace si {
|
||||
|
||||
typedef unit<torque_dimension,si::system> torque;
|
||||
|
||||
BOOST_UNITS_STATIC_CONSTANT(newton_meter,torque);
|
||||
BOOST_UNITS_STATIC_CONSTANT(newton_meters,torque);
|
||||
|
||||
} // namespace si
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNITS_SI_TORQUE_HPP
|
||||
@@ -0,0 +1,322 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2003 Joel de Guzman
|
||||
Copyright (c) 2001-2003 Daniel Nuffer
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
Use, modification and distribution is subject to the Boost Software
|
||||
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
=============================================================================*/
|
||||
#ifndef BOOST_SPIRIT_CHSET_IPP
|
||||
#define BOOST_SPIRIT_CHSET_IPP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/spirit/home/classic/utility/chset.hpp>
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// chset class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace utility { namespace impl {
|
||||
template <typename CharT>
|
||||
inline void
|
||||
detach(boost::shared_ptr<basic_chset<CharT> >& ptr)
|
||||
{
|
||||
if (!ptr.unique())
|
||||
ptr = boost::shared_ptr<basic_chset<CharT> >
|
||||
(new basic_chset<CharT>(*ptr));
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
detach_clear(boost::shared_ptr<basic_chset<CharT> >& ptr)
|
||||
{
|
||||
if (ptr.unique())
|
||||
ptr->clear();
|
||||
else
|
||||
ptr.reset(new basic_chset<CharT>());
|
||||
}
|
||||
|
||||
template <typename CharT, typename CharT2>
|
||||
void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
|
||||
CharT2 const* definition)
|
||||
{
|
||||
CharT2 ch = *definition++;
|
||||
while (ch)
|
||||
{
|
||||
CharT2 next = *definition++;
|
||||
if (next == '-')
|
||||
{
|
||||
next = *definition++;
|
||||
if (next == 0)
|
||||
{
|
||||
ptr->set(ch);
|
||||
ptr->set('-');
|
||||
break;
|
||||
}
|
||||
ptr->set(ch, next);
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr->set(ch);
|
||||
}
|
||||
ch = next;
|
||||
}
|
||||
}
|
||||
|
||||
}} // namespace utility::impl
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset()
|
||||
: ptr(new basic_chset<CharT>()) {}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(chset const& arg_)
|
||||
: ptr(new basic_chset<CharT>(*arg_.ptr)) {}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(CharT arg_)
|
||||
: ptr(new basic_chset<CharT>())
|
||||
{ ptr->set(arg_); }
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(anychar_parser /*arg*/)
|
||||
: ptr(new basic_chset<CharT>())
|
||||
{
|
||||
ptr->set(
|
||||
(std::numeric_limits<CharT>::min)(),
|
||||
(std::numeric_limits<CharT>::max)()
|
||||
);
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(nothing_parser /*arg_*/)
|
||||
: ptr(new basic_chset<CharT>()) {}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(chlit<CharT> const& arg_)
|
||||
: ptr(new basic_chset<CharT>())
|
||||
{ ptr->set(arg_.ch); }
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(range<CharT> const& arg_)
|
||||
: ptr(new basic_chset<CharT>())
|
||||
{ ptr->set(arg_.first, arg_.last); }
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(negated_char_parser<chlit<CharT> > const& arg_)
|
||||
: ptr(new basic_chset<CharT>())
|
||||
{
|
||||
set(arg_);
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::chset(negated_char_parser<range<CharT> > const& arg_)
|
||||
: ptr(new basic_chset<CharT>())
|
||||
{
|
||||
set(arg_);
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>::~chset() {}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(chset const& rhs)
|
||||
{
|
||||
ptr = rhs.ptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(CharT rhs)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
ptr->set(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(anychar_parser /*rhs*/)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
ptr->set(
|
||||
(std::numeric_limits<CharT>::min)(),
|
||||
(std::numeric_limits<CharT>::max)()
|
||||
);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(nothing_parser /*rhs*/)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(chlit<CharT> const& rhs)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
ptr->set(rhs.ch);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(range<CharT> const& rhs)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
ptr->set(rhs.first, rhs.last);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(negated_char_parser<chlit<CharT> > const& rhs)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
set(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator=(negated_char_parser<range<CharT> > const& rhs)
|
||||
{
|
||||
utility::impl::detach_clear(ptr);
|
||||
set(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
chset<CharT>::set(range<CharT> const& arg_)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
ptr->set(arg_.first, arg_.last);
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
chset<CharT>::set(negated_char_parser<chlit<CharT> > const& arg_)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
|
||||
if(arg_.positive.ch != (std::numeric_limits<CharT>::min)()) {
|
||||
ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.ch - 1);
|
||||
}
|
||||
if(arg_.positive.ch != (std::numeric_limits<CharT>::max)()) {
|
||||
ptr->set(arg_.positive.ch + 1, (std::numeric_limits<CharT>::max)());
|
||||
}
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
chset<CharT>::set(negated_char_parser<range<CharT> > const& arg_)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
|
||||
if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
|
||||
ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
|
||||
}
|
||||
if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
|
||||
ptr->set(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
|
||||
}
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
chset<CharT>::clear(range<CharT> const& arg_)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
ptr->clear(arg_.first, arg_.last);
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
chset<CharT>::clear(negated_char_parser<range<CharT> > const& arg_)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
|
||||
if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
|
||||
ptr->clear((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
|
||||
}
|
||||
if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
|
||||
ptr->clear(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
|
||||
}
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline bool
|
||||
chset<CharT>::test(CharT ch) const
|
||||
{ return ptr->test(ch); }
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::inverse()
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
ptr->inverse();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline void
|
||||
chset<CharT>::swap(chset& x)
|
||||
{ ptr.swap(x.ptr); }
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator|=(chset const& x)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
*ptr |= *x.ptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator&=(chset const& x)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
*ptr &= *x.ptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator-=(chset const& x)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
*ptr -= *x.ptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
inline chset<CharT>&
|
||||
chset<CharT>::operator^=(chset const& x)
|
||||
{
|
||||
utility::impl::detach(ptr);
|
||||
*ptr ^= *x.ptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace boost::spirit
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
// 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) 2007-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_ANGLE_RADIAN_BASE_UNIT_HPP
|
||||
#define BOOST_UNITS_ANGLE_RADIAN_BASE_UNIT_HPP
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <boost/units/config.hpp>
|
||||
#include <boost/units/base_unit.hpp>
|
||||
#include <boost/units/physical_dimensions/plane_angle.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace angle {
|
||||
|
||||
struct radian_base_unit : public base_unit<radian_base_unit, plane_angle_dimension, -2>
|
||||
{
|
||||
static std::string name() { return("radian"); }
|
||||
static std::string symbol() { return("rad"); }
|
||||
};
|
||||
|
||||
} // namespace angle
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#if BOOST_UNITS_HAS_BOOST_TYPEOF
|
||||
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::units::angle::radian_base_unit)
|
||||
|
||||
#endif
|
||||
|
||||
//#include <boost/units/base_units/angle/conversions.hpp>
|
||||
|
||||
#endif // BOOST_UNITS_ANGLE_RADIAN_BASE_UNIT_HPP
|
||||
@@ -0,0 +1,62 @@
|
||||
// -*- Mode: C++ -*-
|
||||
#ifndef LogQSO_H
|
||||
#define LogQSO_H
|
||||
|
||||
#ifdef QT5
|
||||
#include <QtWidgets>
|
||||
#else
|
||||
#include <QtGui>
|
||||
#endif
|
||||
|
||||
#include <QScopedPointer>
|
||||
|
||||
#include "Radio.hpp"
|
||||
|
||||
namespace Ui {
|
||||
class LogQSO;
|
||||
}
|
||||
|
||||
class QSettings;
|
||||
|
||||
class LogQSO : public QDialog
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
explicit LogQSO(QString const& programTitle, QSettings *, QWidget *parent = 0);
|
||||
~LogQSO();
|
||||
void initLogQSO(QString const& hisCall, QString const& hisGrid, QString mode,
|
||||
QString const& rptSent, QString const& rptRcvd, QDateTime const& dateTimeOn,
|
||||
QDateTime const& dateTimeOff,
|
||||
Radio::Frequency dialFreq, QString const& myCall, QString const& myGrid,
|
||||
bool noSuffix, bool toRTTY, bool dBtoComments);
|
||||
|
||||
public slots:
|
||||
void accept();
|
||||
|
||||
signals:
|
||||
void acceptQSO (QDateTime const& QSO_date_off, QString const& call, QString const& grid
|
||||
, Radio::Frequency dial_freq, QString const& mode
|
||||
, QString const& rpt_sent, QString const& rpt_received
|
||||
, QString const& tx_power, QString const& comments
|
||||
, QString const& name, QDateTime const& QSO_date_on);
|
||||
|
||||
protected:
|
||||
void hideEvent (QHideEvent *);
|
||||
|
||||
private:
|
||||
void loadSettings ();
|
||||
void storeSettings () const;
|
||||
|
||||
QScopedPointer<Ui::LogQSO> ui;
|
||||
QSettings * m_settings;
|
||||
QString m_txPower;
|
||||
QString m_comments;
|
||||
Radio::Frequency m_dialFreq;
|
||||
QString m_myCall;
|
||||
QString m_myGrid;
|
||||
QDateTime m_dateTimeOn;
|
||||
QDateTime m_dateTimeOff;
|
||||
};
|
||||
|
||||
#endif // LogQSO_H
|
||||
@@ -0,0 +1,178 @@
|
||||
/*==============================================================================
|
||||
Copyright (c) 2005-2010 Joel de Guzman
|
||||
Copyright (c) 2010 Thomas Heller
|
||||
|
||||
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_PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP
|
||||
#define BOOST_PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP
|
||||
|
||||
#include <boost/phoenix/core/limits.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/fusion/sequence/sequence_facade.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/begin.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/end.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/size.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/value_at.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/at.hpp>
|
||||
#include <boost/fusion/support/category_of.hpp>
|
||||
#include <boost/fusion/include/pop_front.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
namespace boost { namespace phoenix
|
||||
{
|
||||
template<typename Env, typename OuterEnv, typename Locals, typename Map>
|
||||
struct scoped_environment
|
||||
: fusion::sequence_facade<
|
||||
scoped_environment<Env, OuterEnv, Locals, Map>
|
||||
, fusion::random_access_traversal_tag
|
||||
>
|
||||
{
|
||||
typedef Env env_type;
|
||||
typedef OuterEnv outer_env_type;
|
||||
typedef Locals locals_type;
|
||||
typedef Map map_type;
|
||||
|
||||
scoped_environment(
|
||||
Env const & env_
|
||||
, OuterEnv const &outer_env_
|
||||
, Locals const &locals_
|
||||
)
|
||||
: env(env_)
|
||||
, outer_env(outer_env_)
|
||||
, locals(locals_)
|
||||
{}
|
||||
|
||||
scoped_environment(scoped_environment const & o)
|
||||
: env(o.env)
|
||||
, outer_env(o.outer_env)
|
||||
, locals(o.locals)
|
||||
{}
|
||||
|
||||
Env const & env;
|
||||
OuterEnv const & outer_env;
|
||||
Locals const & locals;
|
||||
|
||||
typedef typename
|
||||
fusion::result_of::pop_front<
|
||||
typename add_const<
|
||||
typename proto::detail::uncvref<Env>::type
|
||||
>::type
|
||||
>::type
|
||||
args_type;
|
||||
|
||||
args_type args() const
|
||||
{
|
||||
return fusion::pop_front(env);
|
||||
}
|
||||
|
||||
#define BOOST_PHOENIX_ADAPT_SCOPED_ENVIRONMENT(INTRINSIC) \
|
||||
template <typename Seq> \
|
||||
struct INTRINSIC \
|
||||
{ \
|
||||
typedef \
|
||||
typename fusion::result_of::INTRINSIC< \
|
||||
typename mpl::eval_if_c< \
|
||||
is_const< \
|
||||
typename remove_reference< \
|
||||
typename Seq::env_type \
|
||||
>::type \
|
||||
>::value \
|
||||
, add_const< \
|
||||
typename proto::detail::uncvref< \
|
||||
typename Seq::env_type \
|
||||
>::type \
|
||||
> \
|
||||
, proto::detail::uncvref< \
|
||||
typename Seq::env_type \
|
||||
> \
|
||||
>::type \
|
||||
>::type \
|
||||
type; \
|
||||
\
|
||||
static type call(Seq & seq) \
|
||||
{ \
|
||||
return fusion::INTRINSIC(seq.env); \
|
||||
} \
|
||||
} \
|
||||
/**/
|
||||
BOOST_PHOENIX_ADAPT_SCOPED_ENVIRONMENT(begin);
|
||||
BOOST_PHOENIX_ADAPT_SCOPED_ENVIRONMENT(end);
|
||||
BOOST_PHOENIX_ADAPT_SCOPED_ENVIRONMENT(size);
|
||||
#undef BOOST_PHOENIX_ADAPT_SCOPED_ENVIRONMENT
|
||||
|
||||
template <typename Seq, typename N>
|
||||
struct value_at
|
||||
{
|
||||
typedef
|
||||
typename fusion::result_of::value_at<
|
||||
typename mpl::eval_if_c<
|
||||
is_const<
|
||||
typename remove_reference<
|
||||
typename Seq::env_type
|
||||
>::type
|
||||
>::value
|
||||
, add_const<
|
||||
typename proto::detail::uncvref<
|
||||
typename Seq::env_type
|
||||
>::type
|
||||
>
|
||||
, proto::detail::uncvref<
|
||||
typename Seq::env_type
|
||||
>
|
||||
>::type
|
||||
, N
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename Seq, typename N>
|
||||
struct at
|
||||
{
|
||||
typedef
|
||||
typename fusion::result_of::at<
|
||||
typename mpl::eval_if_c<
|
||||
is_const<
|
||||
typename remove_reference<
|
||||
typename Seq::env_type
|
||||
>::type
|
||||
>::value
|
||||
, add_const<
|
||||
typename proto::detail::uncvref<
|
||||
typename Seq::env_type
|
||||
>::type
|
||||
>
|
||||
, proto::detail::uncvref<
|
||||
typename Seq::env_type
|
||||
>
|
||||
>::type
|
||||
, N
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type call(Seq & seq)
|
||||
{
|
||||
return fusion::at<N>(seq.env);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <typename Env, typename Dummy = void>
|
||||
struct is_scoped_environment : mpl::false_ {};
|
||||
|
||||
template <typename Env>
|
||||
struct is_scoped_environment<Env&> : is_scoped_environment<Env> {};
|
||||
|
||||
template <typename Env, typename OuterEnv, typename Locals, typename Map>
|
||||
struct is_scoped_environment<scoped_environment<Env, OuterEnv, Locals, Map> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template <typename Env, typename OuterEnv, typename Locals, typename Map>
|
||||
struct is_scoped_environment<scoped_environment<Env, OuterEnv, Locals, Map> const>
|
||||
: mpl::true_
|
||||
{};
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,113 @@
|
||||
#ifndef BOOST_THREAD_TSS_HPP
|
||||
#define BOOST_THREAD_TSS_HPP
|
||||
// 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)
|
||||
// (C) Copyright 2007-8 Anthony Williams
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/thread/detail/thread_heap_alloc.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
struct tss_cleanup_function
|
||||
{
|
||||
virtual ~tss_cleanup_function()
|
||||
{}
|
||||
|
||||
virtual void operator()(void* data)=0;
|
||||
};
|
||||
|
||||
BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
|
||||
BOOST_THREAD_DECL void* get_tss_data(void const* key);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class thread_specific_ptr
|
||||
{
|
||||
private:
|
||||
thread_specific_ptr(thread_specific_ptr&);
|
||||
thread_specific_ptr& operator=(thread_specific_ptr&);
|
||||
|
||||
struct delete_data:
|
||||
detail::tss_cleanup_function
|
||||
{
|
||||
void operator()(void* data)
|
||||
{
|
||||
delete static_cast<T*>(data);
|
||||
}
|
||||
};
|
||||
|
||||
struct run_custom_cleanup_function:
|
||||
detail::tss_cleanup_function
|
||||
{
|
||||
void (*cleanup_function)(T*);
|
||||
|
||||
explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
|
||||
cleanup_function(cleanup_function_)
|
||||
{}
|
||||
|
||||
void operator()(void* data)
|
||||
{
|
||||
cleanup_function(static_cast<T*>(data));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
boost::shared_ptr<detail::tss_cleanup_function> cleanup;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
thread_specific_ptr():
|
||||
cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
|
||||
{}
|
||||
explicit thread_specific_ptr(void (*func_)(T*))
|
||||
{
|
||||
if(func_)
|
||||
{
|
||||
cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
|
||||
}
|
||||
}
|
||||
~thread_specific_ptr()
|
||||
{
|
||||
detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
|
||||
}
|
||||
|
||||
T* get() const
|
||||
{
|
||||
return static_cast<T*>(detail::get_tss_data(this));
|
||||
}
|
||||
T* operator->() const
|
||||
{
|
||||
return get();
|
||||
}
|
||||
typename boost::detail::sp_dereference< T >::type operator*() const
|
||||
{
|
||||
return *get();
|
||||
}
|
||||
T* release()
|
||||
{
|
||||
T* const temp=get();
|
||||
detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
|
||||
return temp;
|
||||
}
|
||||
void reset(T* new_value=0)
|
||||
{
|
||||
T* const current_value=get();
|
||||
if(current_value!=new_value)
|
||||
{
|
||||
detail::set_tss_data(this,cleanup,new_value,true);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,112 @@
|
||||
program ft8d
|
||||
|
||||
! Decode FT8 data read from *.wav files.
|
||||
|
||||
! FT8 is a potential mode intended for use at 6m (and maybe HF). It uses an
|
||||
! LDPC (174,87) code, 8-FSK modulation, and 15 second T/R sequences. Otherwise
|
||||
! should behave like JT65 and JT9 as used on HF bands, except that QSOs are
|
||||
! 4 x faster.
|
||||
|
||||
! Reception and Demodulation algorithm:
|
||||
! ... tbd ...
|
||||
|
||||
include 'ft8_params.f90'
|
||||
parameter(NRECENT=10)
|
||||
character*12 recent_calls(NRECENT)
|
||||
character message*22,infile*80,datetime*13
|
||||
real s(NH1,NHSYM)
|
||||
real s1(0:7,ND)
|
||||
real ps(0:7)
|
||||
real rxdata(3*ND),llr(3*ND) !Soft symbols
|
||||
integer ihdr(11)
|
||||
integer*2 iwave(NMAX) !Generated full-length waveform
|
||||
! integer*1 idat(7)
|
||||
integer*1 decoded(KK),apmask(ND),cw(ND)
|
||||
|
||||
nargs=iargc()
|
||||
if(nargs.lt.1) then
|
||||
print*,'Usage: ft8d file1 [file2 ...]'
|
||||
go to 999
|
||||
endif
|
||||
|
||||
twopi=8.0*atan(1.0)
|
||||
fs=12000.0 !Sample rate
|
||||
dt=1.0/fs !Sample interval (s)
|
||||
tt=NSPS*dt !Duration of "itone" symbols (s)
|
||||
ts=2*NSPS*dt !Duration of OQPSK symbols (s)
|
||||
baud=1.0/tt !Keying rate (baud)
|
||||
txt=NZ*dt !Transmission length (s)
|
||||
|
||||
do ifile=1,nargs
|
||||
call getarg(ifile,infile)
|
||||
open(10,file=infile,status='old',access='stream')
|
||||
read(10,end=999) ihdr,iwave
|
||||
close(10)
|
||||
j2=index(infile,'.wav')
|
||||
read(infile(j2-6:j2-1),*) nutc
|
||||
datetime=infile(j2-13:j2-1)
|
||||
call sync8(iwave,xdt,f1,s)
|
||||
|
||||
xsnr=0.
|
||||
tstep=0.5*NSPS/12000.0
|
||||
df=12000.0/NFFT1
|
||||
i0=nint(f1/df)
|
||||
j0=nint(xdt/tstep)
|
||||
fac=20.0/maxval(s)
|
||||
s=fac*s
|
||||
|
||||
j=0
|
||||
ia=i0
|
||||
ib=i0+14
|
||||
do k=1,NN
|
||||
if(k.le.7) cycle
|
||||
if(k.ge.37 .and. k.le.43) cycle
|
||||
if(k.gt.72) cycle
|
||||
n=j0+2*(k-1)+1
|
||||
if(n.lt.1) cycle
|
||||
j=j+1
|
||||
s1(0:7,j)=s(ia:ib:2,n)
|
||||
enddo
|
||||
|
||||
do j=1,ND
|
||||
ps=s1(0:7,j)
|
||||
ps=log(ps)
|
||||
r1=max(ps(1),ps(3),ps(5),ps(7))-max(ps(0),ps(2),ps(4),ps(6))
|
||||
r2=max(ps(2),ps(3),ps(6),ps(7))-max(ps(0),ps(1),ps(4),ps(5))
|
||||
r4=max(ps(4),ps(5),ps(6),ps(7))-max(ps(0),ps(1),ps(2),ps(3))
|
||||
rxdata(3*j-2)=r4
|
||||
rxdata(3*j-1)=r2
|
||||
rxdata(3*j)=r1
|
||||
enddo
|
||||
rxav=sum(rxdata)/ND
|
||||
rx2av=sum(rxdata*rxdata)/ND
|
||||
rxsig=sqrt(rx2av-rxav*rxav)
|
||||
rxdata=rxdata/rxsig
|
||||
ss=0.84
|
||||
llr=2.0*rxdata/(ss*ss)
|
||||
apmask=0
|
||||
max_iterations=40
|
||||
ifer=0
|
||||
call bpdecode174(llr,apmask,max_iterations,decoded,niterations)
|
||||
if(niterations.lt.0) then
|
||||
write(41,*) llr,apmask,max_iterations,decoded,niterations
|
||||
call osd174(llr,2,decoded,niterations,cw)
|
||||
write(42,*) llr,apmask,max_iterations,decoded,niterations
|
||||
! if(niterations.lt.0) stop
|
||||
endif
|
||||
nbadcrc=0
|
||||
if(niterations.ge.0) call chkcrc12a(decoded,nbadcrc)
|
||||
if(niterations.lt.0 .or. nbadcrc.ne.0) ifer=1
|
||||
|
||||
message=' '
|
||||
if(ifer.eq.0) then
|
||||
call extractmessage174(decoded,message,ncrcflag,recent_calls,nrecent)
|
||||
endif
|
||||
nsnr=nint(xsnr)
|
||||
write(13,1110) datetime,0,nsnr,xdt,freq,message,nfdot
|
||||
1110 format(a11,2i4,f6.2,f12.7,2x,a22,i3)
|
||||
write(*,1112) datetime(8:13),nsnr,xdt,nint(f1),message
|
||||
1112 format(a6,i4,f5.1,i6,2x,a22)
|
||||
enddo ! ifile loop
|
||||
|
||||
999 end program ft8d
|
||||
@@ -0,0 +1,293 @@
|
||||
# /* **************************************************************************
|
||||
# * *
|
||||
# * (C) Copyright Paul Mensonides 2002.
|
||||
# * 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 most recent version. */
|
||||
#
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
#
|
||||
# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC()
|
||||
# include <boost/preprocessor/detail/dmc/auto_rec.hpp>
|
||||
# else
|
||||
#
|
||||
# ifndef BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
|
||||
# define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
|
||||
#
|
||||
# include <boost/preprocessor/control/iif.hpp>
|
||||
#
|
||||
# /* BOOST_PP_AUTO_REC */
|
||||
#
|
||||
# define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred)
|
||||
#
|
||||
# define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p)
|
||||
# define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p)
|
||||
#
|
||||
# define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
|
||||
# define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96)
|
||||
# define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48)
|
||||
# define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24)
|
||||
# define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12)
|
||||
# define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6)
|
||||
# define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3)
|
||||
# define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
|
||||
# define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4)
|
||||
# define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7)
|
||||
# define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6)
|
||||
# define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8)
|
||||
# define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14)
|
||||
# define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11)
|
||||
# define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10)
|
||||
# define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12)
|
||||
# define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15)
|
||||
# define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14)
|
||||
# define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16)
|
||||
# define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28)
|
||||
# define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22)
|
||||
# define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19)
|
||||
# define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18)
|
||||
# define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20)
|
||||
# define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23)
|
||||
# define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22)
|
||||
# define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24)
|
||||
# define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30)
|
||||
# define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27)
|
||||
# define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26)
|
||||
# define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28)
|
||||
# define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31)
|
||||
# define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30)
|
||||
# define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32)
|
||||
# define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56)
|
||||
# define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44)
|
||||
# define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38)
|
||||
# define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35)
|
||||
# define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34)
|
||||
# define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36)
|
||||
# define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39)
|
||||
# define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38)
|
||||
# define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40)
|
||||
# define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46)
|
||||
# define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43)
|
||||
# define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42)
|
||||
# define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44)
|
||||
# define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47)
|
||||
# define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46)
|
||||
# define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48)
|
||||
# define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60)
|
||||
# define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54)
|
||||
# define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51)
|
||||
# define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50)
|
||||
# define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52)
|
||||
# define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55)
|
||||
# define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54)
|
||||
# define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56)
|
||||
# define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62)
|
||||
# define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59)
|
||||
# define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58)
|
||||
# define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60)
|
||||
# define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63)
|
||||
# define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62)
|
||||
# define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64)
|
||||
# define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112)
|
||||
# define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88)
|
||||
# define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76)
|
||||
# define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70)
|
||||
# define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67)
|
||||
# define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66)
|
||||
# define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68)
|
||||
# define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71)
|
||||
# define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70)
|
||||
# define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72)
|
||||
# define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78)
|
||||
# define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75)
|
||||
# define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74)
|
||||
# define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76)
|
||||
# define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79)
|
||||
# define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78)
|
||||
# define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80)
|
||||
# define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92)
|
||||
# define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86)
|
||||
# define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83)
|
||||
# define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82)
|
||||
# define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84)
|
||||
# define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87)
|
||||
# define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86)
|
||||
# define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88)
|
||||
# define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94)
|
||||
# define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91)
|
||||
# define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90)
|
||||
# define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92)
|
||||
# define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95)
|
||||
# define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94)
|
||||
# define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96)
|
||||
# define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120)
|
||||
# define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108)
|
||||
# define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102)
|
||||
# define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99)
|
||||
# define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98)
|
||||
# define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100)
|
||||
# define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103)
|
||||
# define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102)
|
||||
# define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104)
|
||||
# define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110)
|
||||
# define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107)
|
||||
# define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106)
|
||||
# define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108)
|
||||
# define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111)
|
||||
# define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110)
|
||||
# define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112)
|
||||
# define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124)
|
||||
# define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118)
|
||||
# define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115)
|
||||
# define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114)
|
||||
# define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116)
|
||||
# define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119)
|
||||
# define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118)
|
||||
# define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120)
|
||||
# define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126)
|
||||
# define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123)
|
||||
# define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122)
|
||||
# define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124)
|
||||
# define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127)
|
||||
# define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126)
|
||||
# define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128)
|
||||
# define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224)
|
||||
# define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176)
|
||||
# define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152)
|
||||
# define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140)
|
||||
# define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134)
|
||||
# define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131)
|
||||
# define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130)
|
||||
# define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132)
|
||||
# define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135)
|
||||
# define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134)
|
||||
# define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136)
|
||||
# define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142)
|
||||
# define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139)
|
||||
# define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138)
|
||||
# define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140)
|
||||
# define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143)
|
||||
# define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142)
|
||||
# define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144)
|
||||
# define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156)
|
||||
# define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150)
|
||||
# define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147)
|
||||
# define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146)
|
||||
# define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148)
|
||||
# define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151)
|
||||
# define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150)
|
||||
# define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152)
|
||||
# define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158)
|
||||
# define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155)
|
||||
# define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154)
|
||||
# define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156)
|
||||
# define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159)
|
||||
# define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158)
|
||||
# define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160)
|
||||
# define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184)
|
||||
# define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172)
|
||||
# define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166)
|
||||
# define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163)
|
||||
# define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162)
|
||||
# define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164)
|
||||
# define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167)
|
||||
# define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166)
|
||||
# define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168)
|
||||
# define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174)
|
||||
# define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171)
|
||||
# define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170)
|
||||
# define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172)
|
||||
# define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175)
|
||||
# define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174)
|
||||
# define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176)
|
||||
# define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188)
|
||||
# define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182)
|
||||
# define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179)
|
||||
# define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178)
|
||||
# define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180)
|
||||
# define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183)
|
||||
# define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182)
|
||||
# define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184)
|
||||
# define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190)
|
||||
# define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187)
|
||||
# define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186)
|
||||
# define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188)
|
||||
# define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191)
|
||||
# define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190)
|
||||
# define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192)
|
||||
# define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240)
|
||||
# define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216)
|
||||
# define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204)
|
||||
# define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198)
|
||||
# define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195)
|
||||
# define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194)
|
||||
# define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196)
|
||||
# define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199)
|
||||
# define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198)
|
||||
# define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200)
|
||||
# define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206)
|
||||
# define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203)
|
||||
# define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202)
|
||||
# define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204)
|
||||
# define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207)
|
||||
# define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206)
|
||||
# define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208)
|
||||
# define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220)
|
||||
# define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214)
|
||||
# define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211)
|
||||
# define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210)
|
||||
# define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212)
|
||||
# define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215)
|
||||
# define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214)
|
||||
# define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216)
|
||||
# define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222)
|
||||
# define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219)
|
||||
# define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218)
|
||||
# define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220)
|
||||
# define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223)
|
||||
# define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222)
|
||||
# define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224)
|
||||
# define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248)
|
||||
# define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236)
|
||||
# define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230)
|
||||
# define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227)
|
||||
# define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226)
|
||||
# define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228)
|
||||
# define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231)
|
||||
# define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230)
|
||||
# define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232)
|
||||
# define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238)
|
||||
# define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235)
|
||||
# define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234)
|
||||
# define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236)
|
||||
# define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239)
|
||||
# define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238)
|
||||
# define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240)
|
||||
# define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252)
|
||||
# define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246)
|
||||
# define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243)
|
||||
# define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242)
|
||||
# define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244)
|
||||
# define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247)
|
||||
# define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246)
|
||||
# define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248)
|
||||
# define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254)
|
||||
# define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251)
|
||||
# define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250)
|
||||
# define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252)
|
||||
# define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255)
|
||||
# define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254)
|
||||
# define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256)
|
||||
#
|
||||
# endif
|
||||
# endif
|
||||
@@ -0,0 +1,225 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
// Copyright (C) 2007-9 Anthony Williams
|
||||
// (C) Copyright 2011-2012 Vicente J. Botet Escriba
|
||||
//
|
||||
// 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_THREAD_EXCEPTIONS_PDM070801_H
|
||||
#define BOOST_THREAD_EXCEPTIONS_PDM070801_H
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
// pdm: Sorry, but this class is used all over the place & I end up
|
||||
// with recursive headers if I don't separate it
|
||||
// wek: Not sure why recursive headers would cause compilation problems
|
||||
// given the include guards, but regardless it makes sense to
|
||||
// seperate this out any way.
|
||||
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <boost/system/system_error.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
|
||||
class BOOST_SYMBOL_VISIBLE thread_interrupted
|
||||
{};
|
||||
#endif
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE thread_exception:
|
||||
public system::system_error
|
||||
//public std::exception
|
||||
{
|
||||
typedef system::system_error base_type;
|
||||
public:
|
||||
thread_exception()
|
||||
: base_type(0,system::system_category())
|
||||
{}
|
||||
|
||||
thread_exception(int sys_error_code)
|
||||
: base_type(sys_error_code, system::system_category())
|
||||
{}
|
||||
|
||||
thread_exception( int ev, const char * what_arg )
|
||||
: base_type(system::error_code(ev, system::system_category()), what_arg)
|
||||
{
|
||||
}
|
||||
thread_exception( int ev, const std::string & what_arg )
|
||||
: base_type(system::error_code(ev, system::system_category()), what_arg)
|
||||
{
|
||||
}
|
||||
|
||||
~thread_exception() throw()
|
||||
{}
|
||||
|
||||
|
||||
int native_error() const
|
||||
{
|
||||
return code().value();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE condition_error:
|
||||
public system::system_error
|
||||
//public std::exception
|
||||
{
|
||||
typedef system::system_error base_type;
|
||||
public:
|
||||
condition_error()
|
||||
: base_type(system::error_code(0, system::system_category()), "Condition error")
|
||||
{}
|
||||
condition_error( int ev )
|
||||
: base_type(system::error_code(ev, system::system_category()), "Condition error")
|
||||
{
|
||||
}
|
||||
condition_error( int ev, const char * what_arg )
|
||||
: base_type(system::error_code(ev, system::system_category()), what_arg)
|
||||
{
|
||||
}
|
||||
condition_error( int ev, const std::string & what_arg )
|
||||
: base_type(system::error_code(ev, system::system_category()), what_arg)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE lock_error:
|
||||
public thread_exception
|
||||
{
|
||||
typedef thread_exception base_type;
|
||||
public:
|
||||
lock_error()
|
||||
: base_type(0, "boost::lock_error")
|
||||
{}
|
||||
|
||||
lock_error( int ev )
|
||||
: base_type(ev, "boost::lock_error")
|
||||
{
|
||||
}
|
||||
lock_error( int ev, const char * what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
lock_error( int ev, const std::string & what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
|
||||
~lock_error() throw()
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE thread_resource_error:
|
||||
public thread_exception
|
||||
{
|
||||
typedef thread_exception base_type;
|
||||
public:
|
||||
thread_resource_error()
|
||||
: base_type(static_cast<int>(system::errc::resource_unavailable_try_again), "boost::thread_resource_error")
|
||||
{}
|
||||
|
||||
thread_resource_error( int ev )
|
||||
: base_type(ev, "boost::thread_resource_error")
|
||||
{
|
||||
}
|
||||
thread_resource_error( int ev, const char * what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
thread_resource_error( int ev, const std::string & what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
~thread_resource_error() throw()
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE unsupported_thread_option:
|
||||
public thread_exception
|
||||
{
|
||||
typedef thread_exception base_type;
|
||||
public:
|
||||
unsupported_thread_option()
|
||||
: base_type(static_cast<int>(system::errc::invalid_argument), "boost::unsupported_thread_option")
|
||||
{}
|
||||
|
||||
unsupported_thread_option( int ev )
|
||||
: base_type(ev, "boost::unsupported_thread_option")
|
||||
{
|
||||
}
|
||||
unsupported_thread_option( int ev, const char * what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
unsupported_thread_option( int ev, const std::string & what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE invalid_thread_argument:
|
||||
public thread_exception
|
||||
{
|
||||
typedef thread_exception base_type;
|
||||
public:
|
||||
invalid_thread_argument()
|
||||
: base_type(static_cast<int>(system::errc::invalid_argument), "boost::invalid_thread_argument")
|
||||
{}
|
||||
|
||||
invalid_thread_argument( int ev )
|
||||
: base_type(ev, "boost::invalid_thread_argument")
|
||||
{
|
||||
}
|
||||
invalid_thread_argument( int ev, const char * what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
invalid_thread_argument( int ev, const std::string & what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE thread_permission_error:
|
||||
public thread_exception
|
||||
{
|
||||
typedef thread_exception base_type;
|
||||
public:
|
||||
thread_permission_error()
|
||||
: base_type(static_cast<int>(system::errc::permission_denied), "boost::thread_permission_error")
|
||||
{}
|
||||
|
||||
thread_permission_error( int ev )
|
||||
: base_type(ev, "boost::thread_permission_error")
|
||||
{
|
||||
}
|
||||
thread_permission_error( int ev, const char * what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
thread_permission_error( int ev, const std::string & what_arg )
|
||||
: base_type(ev, what_arg)
|
||||
{
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,41 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2011 Eric Niebler
|
||||
|
||||
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_FUSION_SEGMENTED_END_HPP_INCLUDED)
|
||||
#define BOOST_FUSION_SEGMENTED_END_HPP_INCLUDED
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp>
|
||||
#include <boost/fusion/iterator/segmented_iterator.hpp>
|
||||
#include <boost/fusion/container/list/cons.hpp>
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
//auto segmented_end( seq )
|
||||
//{
|
||||
// return make_segmented_iterator( segmented_end_impl( seq ) );
|
||||
//}
|
||||
|
||||
template <typename Sequence, typename Nil_ = fusion::nil_>
|
||||
struct segmented_end
|
||||
{
|
||||
typedef
|
||||
segmented_iterator<
|
||||
typename segmented_end_impl<Sequence, Nil_>::type
|
||||
>
|
||||
type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence & seq)
|
||||
{
|
||||
return type(
|
||||
segmented_end_impl<Sequence, Nil_>::call(seq, Nil_()));
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,13 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2005-2013. 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/container for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
#if defined BOOST_MSVC
|
||||
#pragma warning (pop)
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
// (C) Copyright John Maddock 2007.
|
||||
// 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)
|
||||
//
|
||||
// This file is machine generated, do not edit by hand
|
||||
|
||||
// Polynomial evaluation using Horners rule
|
||||
#ifndef BOOST_MATH_TOOLS_POLY_RAT_7_HPP
|
||||
#define BOOST_MATH_TOOLS_POLY_RAT_7_HPP
|
||||
|
||||
namespace boost{ namespace math{ namespace tools{ namespace detail{
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(0);
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[0]) / static_cast<V>(b[0]);
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>((a[0] * z + a[1]) / (b[0] * z + b[1]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>(((a[0] * z + a[1]) * z + a[2]) / ((b[0] * z + b[1]) * z + b[2]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>((((a[0] * z + a[1]) * z + a[2]) * z + a[3]) / (((b[0] * z + b[1]) * z + b[2]) * z + b[3]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>(((((a[0] * z + a[1]) * z + a[2]) * z + a[3]) * z + a[4]) / ((((b[0] * z + b[1]) * z + b[2]) * z + b[3]) * z + b[4]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>((((((a[0] * z + a[1]) * z + a[2]) * z + a[3]) * z + a[4]) * z + a[5]) / (((((b[0] * z + b[1]) * z + b[2]) * z + b[3]) * z + b[4]) * z + b[5]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>(((((((a[0] * z + a[1]) * z + a[2]) * z + a[3]) * z + a[4]) * z + a[5]) * z + a[6]) / ((((((b[0] * z + b[1]) * z + b[2]) * z + b[3]) * z + b[4]) * z + b[5]) * z + b[6]));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}}}} // namespaces
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -0,0 +1,516 @@
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1998-2002
|
||||
* John Maddock
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* LOCATION: see http://www.boost.org for most recent version.
|
||||
* FILE sub_match.cpp
|
||||
* VERSION see <boost/version.hpp>
|
||||
* DESCRIPTION: Declares template class sub_match.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_REGEX_V4_SUB_MATCH_HPP
|
||||
#define BOOST_REGEX_V4_SUB_MATCH_HPP
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable: 4103)
|
||||
#endif
|
||||
#ifdef BOOST_HAS_ABI_HEADERS
|
||||
# include BOOST_ABI_PREFIX
|
||||
#endif
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
template <class BidiIterator>
|
||||
struct sub_match : public std::pair<BidiIterator, BidiIterator>
|
||||
{
|
||||
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidiIterator>::value_type value_type;
|
||||
#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
#else
|
||||
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidiIterator>::difference_type difference_type;
|
||||
#endif
|
||||
typedef BidiIterator iterator_type;
|
||||
typedef BidiIterator iterator;
|
||||
typedef BidiIterator const_iterator;
|
||||
|
||||
bool matched;
|
||||
|
||||
sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}
|
||||
sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}
|
||||
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
|
||||
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\
|
||||
&& !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
|
||||
template <class T, class A>
|
||||
operator std::basic_string<value_type, T, A> ()const
|
||||
{
|
||||
return matched ? std::basic_string<value_type, T, A>(this->first, this->second) : std::basic_string<value_type, T, A>();
|
||||
}
|
||||
#else
|
||||
operator std::basic_string<value_type> ()const
|
||||
{
|
||||
return str();
|
||||
}
|
||||
#endif
|
||||
difference_type BOOST_REGEX_CALL length()const
|
||||
{
|
||||
difference_type n = matched ? ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
|
||||
return n;
|
||||
}
|
||||
std::basic_string<value_type> str()const
|
||||
{
|
||||
std::basic_string<value_type> result;
|
||||
if(matched)
|
||||
{
|
||||
std::size_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)this->first, (BidiIterator)this->second);
|
||||
result.reserve(len);
|
||||
BidiIterator i = this->first;
|
||||
while(i != this->second)
|
||||
{
|
||||
result.append(1, *i);
|
||||
++i;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
int compare(const sub_match& s)const
|
||||
{
|
||||
if(matched != s.matched)
|
||||
return static_cast<int>(matched) - static_cast<int>(s.matched);
|
||||
return str().compare(s.str());
|
||||
}
|
||||
int compare(const std::basic_string<value_type>& s)const
|
||||
{
|
||||
return str().compare(s);
|
||||
}
|
||||
int compare(const value_type* p)const
|
||||
{
|
||||
return str().compare(p);
|
||||
}
|
||||
|
||||
bool operator==(const sub_match& that)const
|
||||
{ return compare(that) == 0; }
|
||||
bool BOOST_REGEX_CALL operator !=(const sub_match& that)const
|
||||
{ return compare(that) != 0; }
|
||||
bool operator<(const sub_match& that)const
|
||||
{ return compare(that) < 0; }
|
||||
bool operator>(const sub_match& that)const
|
||||
{ return compare(that) > 0; }
|
||||
bool operator<=(const sub_match& that)const
|
||||
{ return compare(that) <= 0; }
|
||||
bool operator>=(const sub_match& that)const
|
||||
{ return compare(that) >= 0; }
|
||||
|
||||
#ifdef BOOST_REGEX_MATCH_EXTRA
|
||||
typedef std::vector<sub_match<BidiIterator> > capture_sequence_type;
|
||||
|
||||
const capture_sequence_type& captures()const
|
||||
{
|
||||
if(!m_captures)
|
||||
m_captures.reset(new capture_sequence_type());
|
||||
return *m_captures;
|
||||
}
|
||||
//
|
||||
// Private implementation API: DO NOT USE!
|
||||
//
|
||||
capture_sequence_type& get_captures()const
|
||||
{
|
||||
if(!m_captures)
|
||||
m_captures.reset(new capture_sequence_type());
|
||||
return *m_captures;
|
||||
}
|
||||
|
||||
private:
|
||||
mutable boost::scoped_ptr<capture_sequence_type> m_captures;
|
||||
public:
|
||||
|
||||
#endif
|
||||
sub_match(const sub_match& that, bool
|
||||
#ifdef BOOST_REGEX_MATCH_EXTRA
|
||||
deep_copy
|
||||
#endif
|
||||
= true
|
||||
)
|
||||
: std::pair<BidiIterator, BidiIterator>(that),
|
||||
matched(that.matched)
|
||||
{
|
||||
#ifdef BOOST_REGEX_MATCH_EXTRA
|
||||
if(that.m_captures)
|
||||
if(deep_copy)
|
||||
m_captures.reset(new capture_sequence_type(*(that.m_captures)));
|
||||
#endif
|
||||
}
|
||||
sub_match& operator=(const sub_match& that)
|
||||
{
|
||||
this->first = that.first;
|
||||
this->second = that.second;
|
||||
matched = that.matched;
|
||||
#ifdef BOOST_REGEX_MATCH_EXTRA
|
||||
if(that.m_captures)
|
||||
get_captures() = *(that.m_captures);
|
||||
#endif
|
||||
return *this;
|
||||
}
|
||||
//
|
||||
// Make this type a range, for both Boost.Range, and C++11:
|
||||
//
|
||||
BidiIterator begin()const { return this->first; }
|
||||
BidiIterator end()const { return this->second; }
|
||||
|
||||
|
||||
#ifdef BOOST_OLD_REGEX_H
|
||||
//
|
||||
// the following are deprecated, do not use!!
|
||||
//
|
||||
operator int()const;
|
||||
operator unsigned int()const;
|
||||
operator short()const
|
||||
{
|
||||
return (short)(int)(*this);
|
||||
}
|
||||
operator unsigned short()const
|
||||
{
|
||||
return (unsigned short)(unsigned int)(*this);
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
typedef sub_match<const char*> csub_match;
|
||||
typedef sub_match<std::string::const_iterator> ssub_match;
|
||||
#ifndef BOOST_NO_WREGEX
|
||||
typedef sub_match<const wchar_t*> wcsub_match;
|
||||
typedef sub_match<std::wstring::const_iterator> wssub_match;
|
||||
#endif
|
||||
|
||||
// comparison to std::basic_string<> part 1:
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator == (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return s.compare(m.str()) == 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator != (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return s.compare(m.str()) != 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator < (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return s.compare(m.str()) < 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator <= (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return s.compare(m.str()) <= 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator >= (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return s.compare(m.str()) >= 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator > (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return s.compare(m.str()) > 0; }
|
||||
// comparison to std::basic_string<> part 2:
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator == (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{ return m.str().compare(s) == 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator != (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{ return m.str().compare(s) != 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator < (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{ return m.str().compare(s) < 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator > (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{ return m.str().compare(s) > 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{ return m.str().compare(s) <= 0; }
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{ return m.str().compare(s) >= 0; }
|
||||
// comparison to const charT* part 1:
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator == (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
||||
{ return m.str().compare(s) == 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator != (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
||||
{ return m.str().compare(s) != 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator > (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
||||
{ return m.str().compare(s) > 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator < (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
||||
{ return m.str().compare(s) < 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
||||
{ return m.str().compare(s) >= 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
||||
{ return m.str().compare(s) <= 0; }
|
||||
// comparison to const charT* part 2:
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator == (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(s) == 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator != (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(s) != 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator < (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(s) > 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator > (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(s) < 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator <= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(s) >= 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator >= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(s) <= 0; }
|
||||
|
||||
// comparison to const charT& part 1:
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator == (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) == 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator != (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) != 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator > (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) > 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator < (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) < 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
|
||||
// comparison to const charT* part 2:
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator == (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) == 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator != (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) != 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator < (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) > 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator > (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) < 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator <= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
|
||||
template <class RandomAccessIterator>
|
||||
inline bool operator >= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
|
||||
|
||||
// addition operators:
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
|
||||
operator + (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
|
||||
result.reserve(s.size() + m.length() + 1);
|
||||
return result.append(s).append(m.first, m.second);
|
||||
}
|
||||
template <class RandomAccessIterator, class traits, class Allocator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
|
||||
operator + (const sub_match<RandomAccessIterator>& m,
|
||||
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
|
||||
result.reserve(s.size() + m.length() + 1);
|
||||
return result.append(m.first, m.second).append(s);
|
||||
}
|
||||
#if !(defined(__GNUC__) && defined(BOOST_NO_STD_LOCALE))
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
||||
result.reserve(std::char_traits<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
|
||||
return result.append(s).append(m.first, m.second);
|
||||
}
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
||||
result.reserve(std::char_traits<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
|
||||
return result.append(m.first, m.second).append(s);
|
||||
}
|
||||
#else
|
||||
// worwaround versions:
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{
|
||||
return s + m.str();
|
||||
}
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
|
||||
{
|
||||
return m.str() + s;
|
||||
}
|
||||
#endif
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
||||
const sub_match<RandomAccessIterator>& m)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
||||
result.reserve(m.length() + 2);
|
||||
return result.append(1, s).append(m.first, m.second);
|
||||
}
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (const sub_match<RandomAccessIterator>& m,
|
||||
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
||||
result.reserve(m.length() + 2);
|
||||
return result.append(m.first, m.second).append(1, s);
|
||||
}
|
||||
template <class RandomAccessIterator>
|
||||
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
|
||||
operator + (const sub_match<RandomAccessIterator>& m1,
|
||||
const sub_match<RandomAccessIterator>& m2)
|
||||
{
|
||||
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
||||
result.reserve(m1.length() + m2.length() + 1);
|
||||
return result.append(m1.first, m1.second).append(m2.first, m2.second);
|
||||
}
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
template <class charT, class traits, class RandomAccessIterator>
|
||||
std::basic_ostream<charT, traits>&
|
||||
operator << (std::basic_ostream<charT, traits>& os,
|
||||
const sub_match<RandomAccessIterator>& s)
|
||||
{
|
||||
return (os << s.str());
|
||||
}
|
||||
#else
|
||||
template <class RandomAccessIterator>
|
||||
std::ostream& operator << (std::ostream& os,
|
||||
const sub_match<RandomAccessIterator>& s)
|
||||
{
|
||||
return (os << s.str());
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_OLD_REGEX_H
|
||||
namespace BOOST_REGEX_DETAIL_NS{
|
||||
template <class BidiIterator, class charT>
|
||||
int do_toi(BidiIterator i, BidiIterator j, char c, int radix)
|
||||
{
|
||||
std::string s(i, j);
|
||||
char* p;
|
||||
int result = std::strtol(s.c_str(), &p, radix);
|
||||
if(*p)raise_regex_exception("Bad sub-expression");
|
||||
return result;
|
||||
}
|
||||
|
||||
//
|
||||
// helper:
|
||||
template <class I, class charT>
|
||||
int do_toi(I& i, I j, charT c)
|
||||
{
|
||||
int result = 0;
|
||||
while((i != j) && (isdigit(*i)))
|
||||
{
|
||||
result = result*10 + (*i - '0');
|
||||
++i;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <class BidiIterator>
|
||||
sub_match<BidiIterator>::operator int()const
|
||||
{
|
||||
BidiIterator i = first;
|
||||
BidiIterator j = second;
|
||||
if(i == j)raise_regex_exception("Bad sub-expression");
|
||||
int neg = 1;
|
||||
if((i != j) && (*i == '-'))
|
||||
{
|
||||
neg = -1;
|
||||
++i;
|
||||
}
|
||||
neg *= BOOST_REGEX_DETAIL_NS::do_toi(i, j, *i);
|
||||
if(i != j)raise_regex_exception("Bad sub-expression");
|
||||
return neg;
|
||||
}
|
||||
template <class BidiIterator>
|
||||
sub_match<BidiIterator>::operator unsigned int()const
|
||||
{
|
||||
BidiIterator i = first;
|
||||
BidiIterator j = second;
|
||||
if(i == j)
|
||||
raise_regex_exception("Bad sub-expression");
|
||||
return BOOST_REGEX_DETAIL_NS::do_toi(i, j, *first);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable: 4103)
|
||||
#endif
|
||||
#ifdef BOOST_HAS_ABI_HEADERS
|
||||
# include BOOST_ABI_SUFFIX
|
||||
#endif
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
/* BLOCKIO.C - Routines to read/write blocks of bits from/to a text file. */
|
||||
|
||||
/* Copyright (c) 1995-2012 by Radford M. Neal.
|
||||
*
|
||||
* Permission is granted for anyone to copy, use, modify, and distribute
|
||||
* these programs and accompanying documents for any purpose, provided
|
||||
* this copyright notice is retained and prominently displayed, and note
|
||||
* is made of any changes made to these programs. These programs and
|
||||
* documents are distributed without any warranty, express or implied.
|
||||
* As the programs were written for research purposes only, they have not
|
||||
* been tested to the degree that would be advisable in any important
|
||||
* application. All use of these programs is entirely at the user's own
|
||||
* risk.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "blockio.h"
|
||||
|
||||
|
||||
int blockio_flush = 0; /* Should blocks written be immediately flushed? */
|
||||
|
||||
|
||||
/* READ A BLOCK OF BITS. The bits must be given as '0' or '1' characters,
|
||||
with whitespace allowed (but not required) between bits. Returns 0 if
|
||||
a block is read successfully, and EOF if eof or an error occurs. If
|
||||
EOF is returned, a warning will be printed if a partial block had already
|
||||
been read. */
|
||||
|
||||
int blockio_read
|
||||
( FILE *f, /* File to read from */
|
||||
char *b, /* Place to store bits read */
|
||||
int l /* Length of block */
|
||||
)
|
||||
{
|
||||
int i, c;
|
||||
|
||||
for (i = 0; i<l; i++)
|
||||
{
|
||||
do
|
||||
{ c = getc(f);
|
||||
if (c==EOF)
|
||||
{ if (i>0)
|
||||
{ fprintf(stderr,
|
||||
"Warning: Short block (%d long) at end of input file ignored\n",i);
|
||||
}
|
||||
return EOF;
|
||||
}
|
||||
} while (c==' ' || c=='\t' || c=='\n' || c=='\r');
|
||||
|
||||
if (c!='0' && c!='1')
|
||||
{ fprintf(stderr,"Bad character in binary file (not '0' or '1')\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
b[i] = c=='1';
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* WRITE A BLOCK OF BITS. Bits are written as '0' and '1' characters, with
|
||||
no spaces between them, followed by a newline. */
|
||||
|
||||
void blockio_write
|
||||
( FILE *f, /* File to write to */
|
||||
char *b, /* Block of bits to write */
|
||||
int l /* Length of block */
|
||||
)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i<l; i++)
|
||||
{ if (b[i]!=0 && b[i]!=1) abort();
|
||||
putc("01"[b[i]],f);
|
||||
}
|
||||
|
||||
putc('\n',f);
|
||||
|
||||
if (blockio_flush)
|
||||
{ fflush(f);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
SNR Files Sync BM FT Hint Total False BadSync
|
||||
--------------------------------------------------------
|
||||
-18.0 1000 1000 1000 1000 1000 1000 0 0
|
||||
-18.5 1000 1000 1000 1000 1000 1000 0 0
|
||||
-19.0 1000 1000 1000 1000 1000 1000 0 0
|
||||
-19.5 1000 1000 1000 1000 1000 1000 0 0
|
||||
-20.0 1000 1000 1000 1000 1000 1000 0 0
|
||||
-20.5 1000 1000 1000 1000 1000 1000 0 0
|
||||
-21.0 1000 1000 1000 1000 1000 1000 0 0
|
||||
-21.5 1000 1000 991 1000 1000 1000 0 0
|
||||
-22.0 1000 1000 918 1000 1000 1000 0 0
|
||||
-22.5 1000 1000 631 1000 1000 1000 0 0
|
||||
-23.0 1000 1000 261 1000 1000 1000 0 0
|
||||
-23.5 1000 1000 57 990 1000 1000 0 0
|
||||
-24.0 1000 1000 0 925 1000 1000 0 0
|
||||
-24.5 1000 1000 0 737 1000 1000 0 0
|
||||
-25.0 1000 999 0 445 999 999 1 ?
|
||||
-25.5 1000 996 0 191 996 996 2 ?
|
||||
-26.0 1000 980 0 68 985 985 3 ?
|
||||
-26.5 1000 953 0 18 975 975 3 ?
|
||||
-27.0 1000 904 0 3 926 926 4 ?
|
||||
-27.5 1000 816 0 2 874 874 3 ?
|
||||
-28.0 1000 722 0 0 786 786 7 ?
|
||||
-28.5 1000 590 0 0 616 616 12 ?
|
||||
-29.0 1000 451 0 0 479 479 15 ?
|
||||
-29.5 1000 355 0 0 303 303 27 ?
|
||||
-30.0 1000 277 0 0 173 173 28 ?
|
||||
@@ -0,0 +1,38 @@
|
||||
// Boost.Range library
|
||||
//
|
||||
// Copyright Thorsten Ottosen 2006. 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_DETAIL_STR_TYPES_HPP
|
||||
#define BOOST_RANGE_DETAIL_STR_TYPES_HPP
|
||||
|
||||
#include <boost/range/size_type.hpp>
|
||||
#include <boost/range/iterator.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template< class T >
|
||||
struct range_mutable_iterator<T*>
|
||||
{
|
||||
typedef T* type;
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct range_const_iterator<T*>
|
||||
{
|
||||
typedef const T* type;
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct range_size<T*>
|
||||
{
|
||||
typedef std::size_t type;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,84 @@
|
||||
#ifndef REMOTE_FILE_HPP__
|
||||
#define REMOTE_FILE_HPP__
|
||||
|
||||
#include <QObject>
|
||||
#include <QString>
|
||||
#include <QUrl>
|
||||
#include <QFileInfo>
|
||||
#include <QSaveFile>
|
||||
#include <QPointer>
|
||||
|
||||
class QNetworkAccessManager;
|
||||
class QNetworkReply;
|
||||
|
||||
//
|
||||
// Synchronize an individual file specified by a URL to the local file
|
||||
// system
|
||||
//
|
||||
class RemoteFile final
|
||||
: public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
//
|
||||
// Clients of RemoteFile must provide an instance of this
|
||||
// interface. It may be used to receive information and requests
|
||||
// from the RemoteFile instance as it does its work.
|
||||
//
|
||||
class ListenerInterface
|
||||
{
|
||||
protected:
|
||||
ListenerInterface () {}
|
||||
|
||||
public:
|
||||
virtual void error (QString const& title, QString const& message) = 0;
|
||||
virtual bool redirect_request (QUrl const&) {return false;} // disallow
|
||||
virtual void download_progress (qint64 /* bytes_received */, qint64 /* total_bytes */) {}
|
||||
virtual void download_finished (bool /* success */) {}
|
||||
};
|
||||
|
||||
explicit RemoteFile (ListenerInterface * listener, QNetworkAccessManager * network_manager
|
||||
, QString const& local_file_path, bool http_only = false
|
||||
, QObject * parent = nullptr);
|
||||
|
||||
// true if local file exists or will do very soon
|
||||
bool local () const;
|
||||
|
||||
// download/remove the local file
|
||||
bool sync (QUrl const& url, bool local = true, bool force = false);
|
||||
|
||||
// abort an active download
|
||||
void abort ();
|
||||
|
||||
// change the local location, this will rename if the file exists locally
|
||||
void local_file_path (QString const&);
|
||||
|
||||
QString local_file_path () const {return local_file_.absoluteFilePath ();}
|
||||
QUrl url () const {return url_;}
|
||||
|
||||
// always use an http scheme for remote URLs
|
||||
void http_only (bool flag = true) {http_only_ = flag;}
|
||||
|
||||
private:
|
||||
void download (QUrl url);
|
||||
void reply_finished ();
|
||||
|
||||
Q_SLOT void store ();
|
||||
|
||||
Q_SIGNAL void redirect (QUrl const&, unsigned redirect_count);
|
||||
Q_SIGNAL void downloadProgress (qint64 bytes_received, qint64 total_bytes);
|
||||
Q_SIGNAL void finished ();
|
||||
|
||||
ListenerInterface * listener_;
|
||||
QNetworkAccessManager * network_manager_;
|
||||
QFileInfo local_file_;
|
||||
bool http_only_;
|
||||
QUrl url_;
|
||||
QPointer<QNetworkReply> reply_;
|
||||
bool is_valid_;
|
||||
unsigned redirect_count_;
|
||||
QSaveFile file_;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,643 @@
|
||||
// -*- Mode: C++ -*-
|
||||
#ifndef MAINWINDOW_H
|
||||
#define MAINWINDOW_H
|
||||
#ifdef QT5
|
||||
#include <QtWidgets>
|
||||
#else
|
||||
#include <QtGui>
|
||||
#endif
|
||||
#include <QThread>
|
||||
#include <QTimer>
|
||||
#include <QDateTime>
|
||||
#include <QList>
|
||||
#include <QAudioDeviceInfo>
|
||||
#include <QScopedPointer>
|
||||
#include <QDir>
|
||||
#include <QProgressDialog>
|
||||
#include <QAbstractSocket>
|
||||
#include <QHostAddress>
|
||||
#include <QPointer>
|
||||
#include <QSet>
|
||||
#include <QVector>
|
||||
#include <QFuture>
|
||||
#include <QFutureWatcher>
|
||||
|
||||
#include "AudioDevice.hpp"
|
||||
#include "commons.h"
|
||||
#include "Radio.hpp"
|
||||
#include "Modes.hpp"
|
||||
#include "FrequencyList.hpp"
|
||||
#include "Configuration.hpp"
|
||||
#include "WSPRBandHopping.hpp"
|
||||
#include "Transceiver.hpp"
|
||||
#include "DisplayManual.hpp"
|
||||
#include "psk_reporter.h"
|
||||
#include "logbook/logbook.h"
|
||||
#include "commons.h"
|
||||
#include "astro.h"
|
||||
#include "MessageBox.hpp"
|
||||
#include "NetworkAccessManager.hpp"
|
||||
|
||||
#define NUM_JT4_SYMBOLS 206 //(72+31)*2, embedded sync
|
||||
#define NUM_JT65_SYMBOLS 126 //63 data + 63 sync
|
||||
#define NUM_JT9_SYMBOLS 85 //69 data + 16 sync
|
||||
#define NUM_WSPR_SYMBOLS 162 //(50+31)*2, embedded sync
|
||||
#define NUM_WSPR_LF_SYMBOLS 412 //300 data + 109 sync + 3 ramp
|
||||
#define NUM_ISCAT_SYMBOLS 1291 //30*11025/256
|
||||
#define NUM_MSK144_SYMBOLS 144 //s8 + d48 + s8 + d80
|
||||
#define NUM_QRA64_SYMBOLS 84 //63 data + 21 sync
|
||||
#define NUM_FT8_SYMBOLS 79
|
||||
#define NUM_CW_SYMBOLS 250
|
||||
#define TX_SAMPLE_RATE 48000
|
||||
#define N_WIDGETS 24
|
||||
|
||||
extern int volatile itone[NUM_ISCAT_SYMBOLS]; //Audio tones for all Tx symbols
|
||||
extern int volatile icw[NUM_CW_SYMBOLS]; //Dits for CW ID
|
||||
|
||||
//--------------------------------------------------------------- MainWindow
|
||||
namespace Ui {
|
||||
class MainWindow;
|
||||
}
|
||||
|
||||
class QSettings;
|
||||
class QLineEdit;
|
||||
class QFont;
|
||||
class QHostInfo;
|
||||
class EchoGraph;
|
||||
class FastGraph;
|
||||
class WideGraph;
|
||||
class LogQSO;
|
||||
class Transceiver;
|
||||
class MessageAveraging;
|
||||
class MessageClient;
|
||||
class QTime;
|
||||
class WSPRBandHopping;
|
||||
class HelpTextWindow;
|
||||
class WSPRNet;
|
||||
class SoundOutput;
|
||||
class Modulator;
|
||||
class SoundInput;
|
||||
class Detector;
|
||||
class SampleDownloader;
|
||||
class MultiSettings;
|
||||
class EqualizationToolsDialog;
|
||||
class DecodedText;
|
||||
|
||||
class MainWindow : public QMainWindow
|
||||
{
|
||||
Q_OBJECT;
|
||||
|
||||
public:
|
||||
using Frequency = Radio::Frequency;
|
||||
using FrequencyDelta = Radio::FrequencyDelta;
|
||||
using Mode = Modes::Mode;
|
||||
|
||||
explicit MainWindow(QDir const& temp_directory, bool multiple, MultiSettings *,
|
||||
QSharedMemory *shdmem, unsigned downSampleFactor,
|
||||
QSplashScreen *,
|
||||
QWidget *parent = nullptr);
|
||||
~MainWindow();
|
||||
|
||||
public slots:
|
||||
void showSoundInError(const QString& errorMsg);
|
||||
void showSoundOutError(const QString& errorMsg);
|
||||
void showStatusMessage(const QString& statusMsg);
|
||||
void dataSink(qint64 frames);
|
||||
void fastSink(qint64 frames);
|
||||
void diskDat();
|
||||
void freezeDecode(int n);
|
||||
void guiUpdate();
|
||||
void doubleClickOnCall(bool shift, bool ctrl);
|
||||
void doubleClickOnCall2(bool shift, bool ctrl);
|
||||
void readFromStdout();
|
||||
void p1ReadFromStdout();
|
||||
void setXIT(int n, Frequency base = 0u);
|
||||
void setFreq4(int rxFreq, int txFreq);
|
||||
void msgAvgDecode2();
|
||||
void fastPick(int x0, int x1, int y);
|
||||
|
||||
protected:
|
||||
void keyPressEvent (QKeyEvent *) override;
|
||||
void closeEvent(QCloseEvent *) override;
|
||||
void childEvent(QChildEvent *) override;
|
||||
bool eventFilter(QObject *, QEvent *) override;
|
||||
|
||||
private slots:
|
||||
void on_tx1_editingFinished();
|
||||
void on_tx2_editingFinished();
|
||||
void on_tx3_editingFinished();
|
||||
void on_tx4_editingFinished();
|
||||
void on_tx5_currentTextChanged (QString const&);
|
||||
void on_tx6_editingFinished();
|
||||
void on_actionSettings_triggered();
|
||||
void on_monitorButton_clicked (bool);
|
||||
void on_actionAbout_triggered();
|
||||
void on_autoButton_clicked (bool);
|
||||
void on_stopTxButton_clicked();
|
||||
void on_stopButton_clicked();
|
||||
void on_actionRelease_Notes_triggered ();
|
||||
void on_actionOnline_User_Guide_triggered();
|
||||
void on_actionLocal_User_Guide_triggered();
|
||||
void on_actionWide_Waterfall_triggered();
|
||||
void on_actionOpen_triggered();
|
||||
void on_actionOpen_next_in_directory_triggered();
|
||||
void on_actionDecode_remaining_files_in_directory_triggered();
|
||||
void on_actionDelete_all_wav_files_in_SaveDir_triggered();
|
||||
void on_actionOpen_log_directory_triggered ();
|
||||
void on_actionNone_triggered();
|
||||
void on_actionSave_all_triggered();
|
||||
void on_actionKeyboard_shortcuts_triggered();
|
||||
void on_actionSpecial_mouse_commands_triggered();
|
||||
void on_DecodeButton_clicked (bool);
|
||||
void decode();
|
||||
void decodeBusy(bool b);
|
||||
void on_EraseButton_clicked();
|
||||
void on_txFirstCheckBox_stateChanged(int arg1);
|
||||
void set_dateTimeQSO(int m_ntx);
|
||||
void set_ntx(int n);
|
||||
void on_txrb1_toggled(bool status);
|
||||
void on_txrb1_doubleClicked ();
|
||||
void on_txrb2_toggled(bool status);
|
||||
void on_txrb3_toggled(bool status);
|
||||
void on_txrb4_toggled(bool status);
|
||||
void on_txrb4_doubleClicked ();
|
||||
void on_txrb5_toggled(bool status);
|
||||
void on_txrb5_doubleClicked ();
|
||||
void on_txrb6_toggled(bool status);
|
||||
void on_txb1_clicked();
|
||||
void on_txb1_doubleClicked ();
|
||||
void on_txb2_clicked();
|
||||
void on_txb3_clicked();
|
||||
void on_txb4_clicked();
|
||||
void on_txb4_doubleClicked ();
|
||||
void on_txb5_clicked();
|
||||
void on_txb5_doubleClicked ();
|
||||
void on_txb6_clicked();
|
||||
void on_lookupButton_clicked();
|
||||
void on_addButton_clicked();
|
||||
void on_dxCallEntry_textChanged (QString const&);
|
||||
void on_dxGridEntry_textChanged (QString const&);
|
||||
void on_dxCallEntry_returnPressed ();
|
||||
void on_genStdMsgsPushButton_clicked();
|
||||
void on_logQSOButton_clicked();
|
||||
void on_actionJT9_triggered();
|
||||
void on_actionJT65_triggered();
|
||||
void on_actionJT9_JT65_triggered();
|
||||
void on_actionJT4_triggered();
|
||||
void on_actionFT8_triggered();
|
||||
void on_TxFreqSpinBox_valueChanged(int arg1);
|
||||
void on_actionSave_decoded_triggered();
|
||||
void on_actionQuickDecode_toggled (bool);
|
||||
void on_actionMediumDecode_toggled (bool);
|
||||
void on_actionDeepestDecode_toggled (bool);
|
||||
void bumpFqso(int n);
|
||||
void on_actionErase_ALL_TXT_triggered();
|
||||
void on_actionErase_wsjtx_log_adi_triggered();
|
||||
void startTx2();
|
||||
void startP1();
|
||||
void stopTx();
|
||||
void stopTx2();
|
||||
void on_pbCallCQ_clicked();
|
||||
void on_pbAnswerCaller_clicked();
|
||||
void on_pbSendRRR_clicked();
|
||||
void on_pbAnswerCQ_clicked();
|
||||
void on_pbSendReport_clicked();
|
||||
void on_pbSend73_clicked();
|
||||
void on_rbGenMsg_clicked(bool checked);
|
||||
void on_rbFreeText_clicked(bool checked);
|
||||
void on_freeTextMsg_currentTextChanged (QString const&);
|
||||
void on_rptSpinBox_valueChanged(int n);
|
||||
void killFile();
|
||||
void on_tuneButton_clicked (bool);
|
||||
void on_pbR2T_clicked();
|
||||
void on_pbT2R_clicked();
|
||||
void acceptQSO2(QDateTime const&, QString const& call, QString const& grid
|
||||
, Frequency dial_freq, QString const& mode
|
||||
, QString const& rpt_sent, QString const& rpt_received
|
||||
, QString const& tx_power, QString const& comments
|
||||
, QString const& name, QDateTime const&);
|
||||
void on_bandComboBox_currentIndexChanged (int index);
|
||||
void on_bandComboBox_activated (int index);
|
||||
void on_readFreq_clicked();
|
||||
void on_pbTxMode_clicked();
|
||||
void on_RxFreqSpinBox_valueChanged(int n);
|
||||
void on_cbTxLock_clicked(bool checked);
|
||||
void on_outAttenuation_valueChanged (int);
|
||||
void rigOpen ();
|
||||
void handle_transceiver_update (Transceiver::TransceiverState const&);
|
||||
void handle_transceiver_failure (QString const& reason);
|
||||
void on_actionAstronomical_data_toggled (bool);
|
||||
void on_actionShort_list_of_add_on_prefixes_and_suffixes_triggered();
|
||||
void band_changed (Frequency);
|
||||
void monitor (bool);
|
||||
void stop_tuning ();
|
||||
void stopTuneATU();
|
||||
void auto_tx_mode(bool);
|
||||
void on_actionMessage_averaging_triggered();
|
||||
void on_actionInclude_averaging_toggled (bool);
|
||||
void on_actionInclude_correlation_toggled (bool);
|
||||
void on_actionEnable_AP_DXcall_toggled (bool);
|
||||
void VHF_features_enabled(bool b);
|
||||
void on_sbSubmode_valueChanged(int n);
|
||||
void on_cbShMsgs_toggled(bool b);
|
||||
void on_cbSWL_toggled(bool b);
|
||||
void on_cbTx6_toggled(bool b);
|
||||
void on_cbMenus_toggled(bool b);
|
||||
void on_cbFirst_toggled(bool b);
|
||||
void on_cbAutoSeq_toggled(bool b);
|
||||
void networkError (QString const&);
|
||||
void on_ClrAvgButton_clicked();
|
||||
void on_actionWSPR_triggered();
|
||||
void on_actionWSPR_LF_triggered();
|
||||
void on_syncSpinBox_valueChanged(int n);
|
||||
void on_TxPowerComboBox_currentIndexChanged(const QString &arg1);
|
||||
void on_sbTxPercent_valueChanged(int n);
|
||||
void on_cbUploadWSPR_Spots_toggled(bool b);
|
||||
void WSPR_config(bool b);
|
||||
void uploadSpots();
|
||||
void TxAgain();
|
||||
void uploadResponse(QString response);
|
||||
void on_WSPRfreqSpinBox_valueChanged(int n);
|
||||
void on_pbTxNext_clicked(bool b);
|
||||
void on_actionEcho_Graph_triggered();
|
||||
void on_actionEcho_triggered();
|
||||
void on_actionISCAT_triggered();
|
||||
void on_actionFast_Graph_triggered();
|
||||
void fast_decode_done();
|
||||
void on_actionMeasure_reference_spectrum_triggered();
|
||||
void on_actionErase_reference_spectrum_triggered();
|
||||
void on_actionMeasure_phase_response_triggered();
|
||||
void on_sbTR_valueChanged (int);
|
||||
void on_sbFtol_valueChanged (int);
|
||||
void on_cbFast9_clicked(bool b);
|
||||
void on_sbCQTxFreq_valueChanged(int n);
|
||||
void on_cbCQTx_toggled(bool b);
|
||||
void on_actionMSK144_triggered();
|
||||
void on_actionQRA64_triggered();
|
||||
void on_actionFreqCal_triggered();
|
||||
void splash_done ();
|
||||
|
||||
private:
|
||||
Q_SIGNAL void initializeAudioOutputStream (QAudioDeviceInfo,
|
||||
unsigned channels, unsigned msBuffered) const;
|
||||
Q_SIGNAL void stopAudioOutputStream () const;
|
||||
Q_SIGNAL void startAudioInputStream (QAudioDeviceInfo const&,
|
||||
int framesPerBuffer, AudioDevice * sink,
|
||||
unsigned downSampleFactor, AudioDevice::Channel) const;
|
||||
Q_SIGNAL void suspendAudioInputStream () const;
|
||||
Q_SIGNAL void resumeAudioInputStream () const;
|
||||
Q_SIGNAL void startDetector (AudioDevice::Channel) const;
|
||||
Q_SIGNAL void FFTSize (unsigned) const;
|
||||
Q_SIGNAL void detectorClose () const;
|
||||
Q_SIGNAL void finished () const;
|
||||
Q_SIGNAL void transmitFrequency (double) const;
|
||||
Q_SIGNAL void endTransmitMessage (bool quick = false) const;
|
||||
Q_SIGNAL void tune (bool = true) const;
|
||||
Q_SIGNAL void sendMessage (unsigned symbolsLength, double framesPerSymbol,
|
||||
double frequency, double toneSpacing,
|
||||
SoundOutput *, AudioDevice::Channel = AudioDevice::Mono,
|
||||
bool synchronize = true, bool fastMode = false, double dBSNR = 99.,
|
||||
int TRperiod=60) const;
|
||||
Q_SIGNAL void outAttenuationChanged (qreal) const;
|
||||
Q_SIGNAL void toggleShorthand () const;
|
||||
|
||||
private:
|
||||
void astroUpdate ();
|
||||
void writeAllTxt(QString message);
|
||||
void auto_sequence (DecodedText const& message, unsigned start_tolerance, unsigned stop_tolerance);
|
||||
void hideMenus(bool b);
|
||||
|
||||
NetworkAccessManager m_network_manager;
|
||||
bool m_valid;
|
||||
QSplashScreen * m_splash;
|
||||
QString m_revision;
|
||||
bool m_multiple;
|
||||
MultiSettings * m_multi_settings;
|
||||
QPushButton * m_configurations_button;
|
||||
QSettings * m_settings;
|
||||
QScopedPointer<Ui::MainWindow> ui;
|
||||
|
||||
// other windows
|
||||
Configuration m_config;
|
||||
WSPRBandHopping m_WSPR_band_hopping;
|
||||
bool m_WSPR_tx_next;
|
||||
MessageBox m_rigErrorMessageBox;
|
||||
QScopedPointer<SampleDownloader> m_sampleDownloader;
|
||||
QScopedPointer<EqualizationToolsDialog> m_equalizationToolsDialog;
|
||||
|
||||
QScopedPointer<WideGraph> m_wideGraph;
|
||||
QScopedPointer<EchoGraph> m_echoGraph;
|
||||
QScopedPointer<FastGraph> m_fastGraph;
|
||||
QScopedPointer<LogQSO> m_logDlg;
|
||||
QScopedPointer<Astro> m_astroWidget;
|
||||
QScopedPointer<HelpTextWindow> m_shortcuts;
|
||||
QScopedPointer<HelpTextWindow> m_prefixes;
|
||||
QScopedPointer<HelpTextWindow> m_mouseCmnds;
|
||||
QScopedPointer<MessageAveraging> m_msgAvgWidget;
|
||||
|
||||
Transceiver::TransceiverState m_rigState;
|
||||
Frequency m_lastDialFreq;
|
||||
QString m_lastBand;
|
||||
QString m_lastCallsign;
|
||||
Frequency m_dialFreqRxWSPR; // best guess at WSPR QRG
|
||||
|
||||
Detector * m_detector;
|
||||
unsigned m_FFTSize;
|
||||
SoundInput * m_soundInput;
|
||||
Modulator * m_modulator;
|
||||
SoundOutput * m_soundOutput;
|
||||
QThread m_audioThread;
|
||||
|
||||
qint64 m_msErase;
|
||||
qint64 m_secBandChanged;
|
||||
qint64 m_freqMoon;
|
||||
Frequency m_freqNominal;
|
||||
Frequency m_freqTxNominal;
|
||||
Astro::Correction m_astroCorrection;
|
||||
|
||||
double m_s6;
|
||||
double m_tRemaining;
|
||||
|
||||
float m_DTtol;
|
||||
float m_t0;
|
||||
float m_t1;
|
||||
float m_t0Pick;
|
||||
float m_t1Pick;
|
||||
float m_fCPUmskrtd;
|
||||
|
||||
qint32 m_waterfallAvg;
|
||||
qint32 m_ntx;
|
||||
bool m_gen_message_is_cq;
|
||||
bool m_send_RR73;
|
||||
qint32 m_timeout;
|
||||
qint32 m_XIT;
|
||||
qint32 m_setftx;
|
||||
qint32 m_ndepth;
|
||||
qint32 m_sec0;
|
||||
qint32 m_RxLog;
|
||||
qint32 m_nutc0;
|
||||
qint32 m_ntr;
|
||||
qint32 m_tx;
|
||||
qint32 m_hsym;
|
||||
qint32 m_TRperiod;
|
||||
qint32 m_nsps;
|
||||
qint32 m_hsymStop;
|
||||
qint32 m_inGain;
|
||||
qint32 m_ncw;
|
||||
qint32 m_secID;
|
||||
qint32 m_idleMinutes;
|
||||
qint32 m_nSubMode;
|
||||
qint32 m_nclearave;
|
||||
qint32 m_minSync;
|
||||
qint32 m_dBm;
|
||||
qint32 m_pctx;
|
||||
qint32 m_nseq;
|
||||
qint32 m_nWSPRdecodes;
|
||||
qint32 m_k0;
|
||||
qint32 m_kdone;
|
||||
qint32 m_nPick;
|
||||
FrequencyList_v2::const_iterator m_frequency_list_fcal_iter;
|
||||
qint32 m_nTx73;
|
||||
qint32 m_UTCdisk;
|
||||
qint32 m_wait;
|
||||
|
||||
bool m_btxok; //True if OK to transmit
|
||||
bool m_diskData;
|
||||
bool m_loopall;
|
||||
bool m_decoderBusy;
|
||||
bool m_txFirst;
|
||||
bool m_auto;
|
||||
bool m_restart;
|
||||
bool m_startAnother;
|
||||
bool m_saveDecoded;
|
||||
bool m_saveAll;
|
||||
bool m_widebandDecode;
|
||||
bool m_call3Modified;
|
||||
bool m_dataAvailable;
|
||||
bool m_bDecoded;
|
||||
bool m_noSuffix;
|
||||
bool m_blankLine;
|
||||
bool m_decodedText2;
|
||||
bool m_freeText;
|
||||
bool m_sentFirst73;
|
||||
int m_currentMessageType;
|
||||
QString m_currentMessage;
|
||||
int m_lastMessageType;
|
||||
QString m_lastMessageSent;
|
||||
bool m_lockTxFreq;
|
||||
bool m_bShMsgs;
|
||||
bool m_bSWL;
|
||||
bool m_uploadSpots;
|
||||
bool m_uploading;
|
||||
bool m_txNext;
|
||||
bool m_grid6;
|
||||
bool m_tuneup;
|
||||
bool m_bTxTime;
|
||||
bool m_rxDone;
|
||||
bool m_bSimplex; // not using split even if it is available
|
||||
bool m_bEchoTxOK;
|
||||
bool m_bTransmittedEcho;
|
||||
bool m_bEchoTxed;
|
||||
bool m_bFastMode;
|
||||
bool m_bFast9;
|
||||
bool m_bFastDecodeCalled;
|
||||
bool m_bDoubleClickAfterCQnnn;
|
||||
bool m_bRefSpec;
|
||||
bool m_bClearRefSpec;
|
||||
bool m_bTrain;
|
||||
bool m_bUseRef;
|
||||
bool m_bFastDone;
|
||||
bool m_bAltV;
|
||||
bool m_bNoMoreFiles;
|
||||
bool m_bQRAsyncWarned;
|
||||
bool m_bDoubleClicked;
|
||||
bool m_bCallingCQ;
|
||||
bool m_bAutoReply;
|
||||
enum
|
||||
{
|
||||
CALLING,
|
||||
REPLYING,
|
||||
REPORT,
|
||||
ROGER_REPORT,
|
||||
ROGERS,
|
||||
SIGNOFF
|
||||
}
|
||||
m_QSOProgress;
|
||||
|
||||
int m_ihsym;
|
||||
int m_nzap;
|
||||
int m_npts8;
|
||||
float m_px;
|
||||
float m_pxmax;
|
||||
float m_df3;
|
||||
int m_iptt0;
|
||||
bool m_btxok0;
|
||||
int m_nsendingsh;
|
||||
double m_onAirFreq0;
|
||||
bool m_first_error;
|
||||
|
||||
char m_msg[100][80];
|
||||
|
||||
// labels in status bar
|
||||
QLabel tx_status_label;
|
||||
QLabel config_label;
|
||||
QLabel mode_label;
|
||||
QLabel last_tx_label;
|
||||
QLabel auto_tx_label;
|
||||
QLabel band_hopping_label;
|
||||
QProgressBar progressBar;
|
||||
QLabel watchdog_label;
|
||||
|
||||
QFuture<void> m_wav_future;
|
||||
QFutureWatcher<void> m_wav_future_watcher;
|
||||
QFutureWatcher<void> watcher3;
|
||||
QFutureWatcher<QString> m_saveWAVWatcher;
|
||||
|
||||
QProcess proc_jt9;
|
||||
QProcess p1;
|
||||
QProcess p3;
|
||||
|
||||
WSPRNet *wsprNet;
|
||||
|
||||
QTimer m_guiTimer;
|
||||
QTimer ptt1Timer; //StartTx delay
|
||||
QTimer ptt0Timer; //StopTx delay
|
||||
QTimer logQSOTimer;
|
||||
QTimer killFileTimer;
|
||||
QTimer tuneButtonTimer;
|
||||
QTimer uploadTimer;
|
||||
QTimer tuneATU_Timer;
|
||||
QTimer TxAgainTimer;
|
||||
QTimer minuteTimer;
|
||||
QTimer splashTimer;
|
||||
QTimer p1Timer;
|
||||
|
||||
QString m_path;
|
||||
QString m_baseCall;
|
||||
QString m_hisCall;
|
||||
QString m_hisGrid;
|
||||
QString m_appDir;
|
||||
QString m_palette;
|
||||
QString m_dateTime;
|
||||
QString m_mode;
|
||||
QString m_modeTx;
|
||||
QString m_fnameWE; // save path without extension
|
||||
QString m_rpt;
|
||||
QString m_rptSent;
|
||||
QString m_rptRcvd;
|
||||
QString m_qsoStart;
|
||||
QString m_qsoStop;
|
||||
QString m_cmnd;
|
||||
QString m_cmndP1;
|
||||
QString m_msgSent0;
|
||||
QString m_fileToSave;
|
||||
QString m_calls;
|
||||
QString m_CQtype;
|
||||
|
||||
QSet<QString> m_pfx;
|
||||
QSet<QString> m_sfx;
|
||||
|
||||
QDateTime m_dateTimeQSOOn;
|
||||
|
||||
QSharedMemory *mem_jt9;
|
||||
LogBook m_logBook;
|
||||
QString m_QSOText;
|
||||
unsigned m_msAudioOutputBuffered;
|
||||
unsigned m_framesAudioInputBuffered;
|
||||
unsigned m_downSampleFactor;
|
||||
QThread::Priority m_audioThreadPriority;
|
||||
bool m_bandEdited;
|
||||
bool m_splitMode;
|
||||
bool m_monitoring;
|
||||
bool m_tx_when_ready;
|
||||
bool m_transmitting;
|
||||
bool m_tune;
|
||||
bool m_tx_watchdog; // true when watchdog triggered
|
||||
bool m_block_pwr_tooltip;
|
||||
bool m_PwrBandSetOK;
|
||||
bool m_bVHFwarned;
|
||||
Frequency m_lastMonitoredFrequency;
|
||||
double m_toneSpacing;
|
||||
int m_firstDecode;
|
||||
QProgressDialog m_optimizingProgress;
|
||||
QTimer m_heartbeat;
|
||||
MessageClient * m_messageClient;
|
||||
PSK_Reporter *psk_Reporter;
|
||||
DisplayManual m_manual;
|
||||
QHash<QString, QVariant> m_pwrBandTxMemory; // Remembers power level by band
|
||||
QHash<QString, QVariant> m_pwrBandTuneMemory; // Remembers power level by band for tuning
|
||||
QByteArray m_geometryNoControls;
|
||||
QVector<double> m_phaseEqCoefficients;
|
||||
|
||||
//---------------------------------------------------- private functions
|
||||
void readSettings();
|
||||
void setDecodedTextFont (QFont const&);
|
||||
void writeSettings();
|
||||
void createStatusBar();
|
||||
void updateStatusBar();
|
||||
void genStdMsgs(QString rpt, bool unconditional = false);
|
||||
void genCQMsg();
|
||||
void clearDX ();
|
||||
void lookup();
|
||||
void ba2msg(QByteArray ba, char* message);
|
||||
void msgtype(QString t, QLineEdit* tx);
|
||||
void stub();
|
||||
void statusChanged();
|
||||
void fixStop();
|
||||
bool shortList(QString callsign);
|
||||
void transmit (double snr = 99.);
|
||||
void rigFailure (QString const& reason);
|
||||
void pskSetLocal ();
|
||||
void pskPost(DecodedText const& decodedtext);
|
||||
void displayDialFrequency ();
|
||||
void transmitDisplay (bool);
|
||||
void processMessage(DecodedText const&, bool ctrl = false, bool alt = false);
|
||||
void replyToCQ (QTime, qint32 snr, float delta_time, quint32 delta_frequency, QString const& mode, QString const& message_text);
|
||||
void replayDecodes ();
|
||||
void postDecode (bool is_new, QString const& message);
|
||||
void postWSPRDecode (bool is_new, QStringList message_parts);
|
||||
void enable_DXCC_entity (bool on);
|
||||
void switch_mode (Mode);
|
||||
void WSPR_scheduling ();
|
||||
void freqCalStep();
|
||||
void setRig (Frequency = 0); // zero frequency means no change
|
||||
void WSPR_history(Frequency dialFreq, int ndecodes);
|
||||
QString WSPR_hhmm(int n);
|
||||
void fast_config(bool b);
|
||||
void CQTxFreq();
|
||||
QString save_wave_file (QString const& name
|
||||
, short const * data
|
||||
, int seconds
|
||||
, QString const& my_callsign
|
||||
, QString const& my_grid
|
||||
, QString const& mode
|
||||
, qint32 sub_mode
|
||||
, Frequency frequency
|
||||
, QString const& his_call
|
||||
, QString const& his_grid) const;
|
||||
void read_wav_file (QString const& fname);
|
||||
void decodeDone ();
|
||||
void subProcessFailed (QProcess *, int exit_code, QProcess::ExitStatus);
|
||||
void subProcessError (QProcess *, QProcess::ProcessError);
|
||||
void statusUpdate () const;
|
||||
void update_watchdog_label ();
|
||||
void on_the_minute ();
|
||||
void add_child_to_event_filter (QObject *);
|
||||
void remove_child_from_event_filter (QObject *);
|
||||
void setup_status_bar (bool vhf);
|
||||
void tx_watchdog (bool triggered);
|
||||
int nWidgets(QString t);
|
||||
void displayWidgets(int n);
|
||||
void vhfWarning();
|
||||
QChar current_submode () const; // returns QChar {0} if sub mode is
|
||||
// not appropriate
|
||||
void write_transmit_entry (QString const& file_name);
|
||||
};
|
||||
|
||||
extern int killbyname(const char* progName);
|
||||
extern void getDev(int* numDevices,char hostAPI_DeviceName[][50],
|
||||
int minChan[], int maxChan[],
|
||||
int minSpeed[], int maxSpeed[]);
|
||||
extern int next_tx_state(int pctx);
|
||||
|
||||
#endif // MAINWINDOW_H
|
||||
@@ -0,0 +1,20 @@
|
||||
// Copyright 2005 Alexander Nasonov.
|
||||
// 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 FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
|
||||
#define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
|
||||
|
||||
namespace boost {
|
||||
|
||||
template<class T> struct floating_point_promotion { typedef T type; };
|
||||
template<> struct floating_point_promotion<float> { typedef double type; };
|
||||
template<> struct floating_point_promotion<float const> { typedef double const type; };
|
||||
template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
|
||||
template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
|
||||
|
||||
}
|
||||
|
||||
#endif // #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
// Copyright David Abrahams 2002.
|
||||
// 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 OBJECT_ITEMS_DWA2002615_HPP
|
||||
# define OBJECT_ITEMS_DWA2002615_HPP
|
||||
|
||||
# include <boost/python/detail/prefix.hpp>
|
||||
|
||||
# include <boost/python/proxy.hpp>
|
||||
# include <boost/python/object_core.hpp>
|
||||
# include <boost/python/object_protocol.hpp>
|
||||
|
||||
namespace boost { namespace python { namespace api {
|
||||
|
||||
struct const_item_policies
|
||||
{
|
||||
typedef object key_type;
|
||||
static object get(object const& target, object const& key);
|
||||
};
|
||||
|
||||
struct item_policies : const_item_policies
|
||||
{
|
||||
static object const& set(object const& target, object const& key, object const& value);
|
||||
static void del(object const& target, object const& key);
|
||||
};
|
||||
|
||||
//
|
||||
// implementation
|
||||
//
|
||||
template <class U>
|
||||
inline object_item
|
||||
object_operators<U>::operator[](object_cref key)
|
||||
{
|
||||
object_cref2 x = *static_cast<U*>(this);
|
||||
return object_item(x, key);
|
||||
}
|
||||
|
||||
template <class U>
|
||||
inline const_object_item
|
||||
object_operators<U>::operator[](object_cref key) const
|
||||
{
|
||||
object_cref2 x = *static_cast<U const*>(this);
|
||||
return const_object_item(x, key);
|
||||
}
|
||||
|
||||
template <class U>
|
||||
template <class T>
|
||||
inline const_object_item
|
||||
object_operators<U>::operator[](T const& key) const
|
||||
{
|
||||
return (*this)[object(key)];
|
||||
}
|
||||
|
||||
template <class U>
|
||||
template <class T>
|
||||
inline object_item
|
||||
object_operators<U>::operator[](T const& key)
|
||||
{
|
||||
return (*this)[object(key)];
|
||||
}
|
||||
|
||||
inline object const_item_policies::get(object const& target, object const& key)
|
||||
{
|
||||
return getitem(target, key);
|
||||
}
|
||||
|
||||
inline object const& item_policies::set(
|
||||
object const& target
|
||||
, object const& key
|
||||
, object const& value)
|
||||
{
|
||||
setitem(target, key, value);
|
||||
return value;
|
||||
}
|
||||
|
||||
inline void item_policies::del(
|
||||
object const& target
|
||||
, object const& key)
|
||||
{
|
||||
delitem(target, key);
|
||||
}
|
||||
|
||||
}}} // namespace boost::python::api
|
||||
|
||||
#endif // OBJECT_ITEMS_DWA2002615_HPP
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,16 @@
|
||||
// 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_ITERATOR_RANGE_HPP_INCLUDED
|
||||
#define BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
|
||||
|
||||
#include "boost/range/iterator_range_core.hpp"
|
||||
#include "boost/range/iterator_range_io.hpp"
|
||||
|
||||
#endif // include guard
|
||||
Reference in New Issue
Block a user