Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,4 @@
|
||||
gcc -c gran.c
|
||||
gfortran -c four2a.f90
|
||||
gfortran -c f77_wisdom.f90
|
||||
gfortran -o chkfft chkfft.f90 four2a.o f77_wisdom.o gran.o /JTSDK-QT/appsupport/runtime/libfftw3f-3.dll
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* -*- c++ -*-
|
||||
*
|
||||
* \file c_array.hpp
|
||||
*
|
||||
* \brief provides specializations of matrix and vector operations for c arrays and c matrices.
|
||||
*
|
||||
* Copyright (c) 2009, Gunter Winkler
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
* \author Gunter Winkler (guwi17 at gmx dot de)
|
||||
*/
|
||||
|
||||
#ifndef BOOST_NUMERIC_UBLAS_OPERATION_C_ARRAY_HPP
|
||||
#define BOOST_NUMERIC_UBLAS_OPERATION_C_ARRAY_HPP
|
||||
|
||||
#include <boost/numeric/ublas/traits/c_array.hpp>
|
||||
|
||||
namespace boost { namespace numeric { namespace ublas {
|
||||
|
||||
namespace detail {
|
||||
|
||||
|
||||
|
||||
} // namespace boost::numeric::ublas::detail
|
||||
|
||||
|
||||
template <typename T>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename ExprT::const_iterator begin(vector_expression<ExprT> const& e)
|
||||
{
|
||||
return detail::begin_impl<typename ExprT::type_category>::apply(e());
|
||||
}
|
||||
|
||||
|
||||
}}} // Namespace boost::numeric::ublas
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,85 @@
|
||||
#ifndef WSJTX_UDP_CLIENT_WIDGET_MODEL_HPP__
|
||||
#define WSJTX_UDP_CLIENT_WIDGET_MODEL_HPP__
|
||||
|
||||
#include <QObject>
|
||||
#include <QSortFilterProxyModel>
|
||||
#include <QString>
|
||||
#include <QRegularExpression>
|
||||
#include <QtWidgets>
|
||||
|
||||
#include "MessageServer.hpp"
|
||||
|
||||
class QAbstractItemModel;
|
||||
class QModelIndex;
|
||||
|
||||
using Frequency = MessageServer::Frequency;
|
||||
|
||||
class ClientWidget
|
||||
: public QDockWidget
|
||||
{
|
||||
Q_OBJECT;
|
||||
|
||||
public:
|
||||
explicit ClientWidget (QAbstractItemModel * decodes_model, QAbstractItemModel * beacons_model
|
||||
, QString const& id, QString const& version, QString const& revision
|
||||
, QWidget * parent = nullptr);
|
||||
|
||||
bool fast_mode () const {return fast_mode_;}
|
||||
|
||||
Q_SLOT void update_status (QString const& id, Frequency f, QString const& mode, QString const& dx_call
|
||||
, QString const& report, QString const& tx_mode, bool tx_enabled
|
||||
, bool transmitting, bool decoding, qint32 rx_df, qint32 tx_df
|
||||
, QString const& de_call, QString const& de_grid, QString const& dx_grid
|
||||
, bool watchdog_timeout, QString const& sub_mode, bool fast_mode);
|
||||
Q_SLOT void decode_added (bool is_new, QString const& client_id, QTime, qint32 snr
|
||||
, float delta_time, quint32 delta_frequency, QString const& mode
|
||||
, QString const& message, bool low_confidence, bool off_air);
|
||||
Q_SLOT void beacon_spot_added (bool is_new, QString const& client_id, QTime, qint32 snr
|
||||
, float delta_time, Frequency delta_frequency, qint32 drift
|
||||
, QString const& callsign, QString const& grid, qint32 power
|
||||
, bool off_air);
|
||||
Q_SLOT void clear_decodes (QString const& client_id);
|
||||
|
||||
Q_SIGNAL void do_reply (QModelIndex const&, quint8 modifier);
|
||||
Q_SIGNAL void do_halt_tx (QString const& id, bool auto_only);
|
||||
Q_SIGNAL void do_free_text (QString const& id, QString const& text, bool);
|
||||
|
||||
private:
|
||||
QString id_;
|
||||
class IdFilterModel final
|
||||
: public QSortFilterProxyModel
|
||||
{
|
||||
public:
|
||||
IdFilterModel (QString const& client_id);
|
||||
|
||||
void de_call (QString const&);
|
||||
void rx_df (int);
|
||||
|
||||
QVariant data (QModelIndex const& proxy_index, int role = Qt::DisplayRole) const override;
|
||||
|
||||
protected:
|
||||
bool filterAcceptsRow (int source_row, QModelIndex const& source_parent) const override;
|
||||
|
||||
private:
|
||||
QString client_id_;
|
||||
QString call_;
|
||||
QRegularExpression base_call_re_;
|
||||
int rx_df_;
|
||||
} decodes_proxy_model_;
|
||||
QTableView * decodes_table_view_;
|
||||
QTableView * beacons_table_view_;
|
||||
QLineEdit * message_line_edit_;
|
||||
QStackedLayout * decodes_stack_;
|
||||
QAbstractButton * auto_off_button_;
|
||||
QAbstractButton * halt_tx_button_;
|
||||
QLabel * mode_label_;
|
||||
bool fast_mode_;
|
||||
QLabel * frequency_label_;
|
||||
QLabel * dx_label_;
|
||||
QLabel * rx_df_label_;
|
||||
QLabel * tx_df_label_;
|
||||
QLabel * report_label_;
|
||||
bool columns_resized_;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,46 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
// Preprocessed version of "boost/mpl/apply_fwd.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename F
|
||||
>
|
||||
struct apply0;
|
||||
|
||||
template<
|
||||
typename F, typename T1
|
||||
>
|
||||
struct apply1;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2
|
||||
>
|
||||
struct apply2;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3
|
||||
>
|
||||
struct apply3;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3, typename T4
|
||||
>
|
||||
struct apply4;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5
|
||||
>
|
||||
struct apply5;
|
||||
|
||||
}}
|
||||
|
||||
@@ -0,0 +1,187 @@
|
||||
// (C) Copyright Antony Polukhin 2013.
|
||||
//
|
||||
// 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_COPY_CONSTRUCTIBLE_HPP_INCLUDED
|
||||
#define BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40900)
|
||||
|
||||
#include <boost/type_traits/is_constructible.hpp>
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1800)
|
||||
|
||||
namespace boost {
|
||||
|
||||
template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};
|
||||
|
||||
template <> struct is_copy_constructible<void> : public false_type{};
|
||||
template <> struct is_copy_constructible<void const> : public false_type{};
|
||||
template <> struct is_copy_constructible<void const volatile> : public false_type{};
|
||||
template <> struct is_copy_constructible<void volatile> : public false_type{};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#else
|
||||
//
|
||||
// Special version for VC12 which has a problem when a base class (such as non_copyable) has a deleted
|
||||
// copy constructor. In this case the compiler thinks there really is a copy-constructor and tries to
|
||||
// instantiate the deleted member. std::is_copy_constructible has the same issue (or at least returns
|
||||
// an incorrect value, which just defers the issue into the users code) as well. We can at least fix
|
||||
// boost::non_copyable as a base class as a special case:
|
||||
//
|
||||
#include <boost/type_traits/is_base_and_derived.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template <class T, bool b> struct is_copy_constructible_imp : public boost::is_constructible<T, const T&>{};
|
||||
template <class T> struct is_copy_constructible_imp<T, true> : public false_type{};
|
||||
|
||||
}
|
||||
|
||||
template <class T> struct is_copy_constructible : public detail::is_copy_constructible_imp<T, is_base_and_derived<boost::noncopyable, T>::value>{};
|
||||
|
||||
template <> struct is_copy_constructible<void> : public false_type{};
|
||||
template <> struct is_copy_constructible<void const> : public false_type{};
|
||||
template <> struct is_copy_constructible<void const volatile> : public false_type{};
|
||||
template <> struct is_copy_constructible<void volatile> : public false_type{};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#include <boost/type_traits/detail/yes_no_type.hpp>
|
||||
#include <boost/type_traits/is_base_and_derived.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <boost/type_traits/is_rvalue_reference.hpp>
|
||||
#include <boost/type_traits/declval.hpp>
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
#include <boost/type_traits/declval.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4181)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <bool DerivedFromNoncopyable, class T>
|
||||
struct is_copy_constructible_impl2 {
|
||||
|
||||
// Intel compiler has problems with SFINAE for copy constructors and deleted functions:
|
||||
//
|
||||
// error: function *function_name* cannot be referenced -- it is a deleted function
|
||||
// static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0);
|
||||
// ^
|
||||
//
|
||||
// MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
|
||||
// https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
|
||||
#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_INTEL_CXX_VERSION) && !(defined(BOOST_MSVC) && _MSC_VER == 1800)
|
||||
|
||||
#ifdef BOOST_NO_CXX11_DECLTYPE
|
||||
template <class T1>
|
||||
static boost::type_traits::yes_type test(const T1&, boost::mpl::int_<sizeof(T1(boost::declval<const T1&>()))>* = 0);
|
||||
#else
|
||||
template <class T1>
|
||||
static boost::type_traits::yes_type test(const T1&, decltype(T1(boost::declval<const T1&>()))* = 0);
|
||||
#endif
|
||||
|
||||
static boost::type_traits::no_type test(...);
|
||||
#else
|
||||
template <class T1>
|
||||
static boost::type_traits::no_type test(const T1&, typename T1::boost_move_no_copy_constructor_or_assign* = 0);
|
||||
static boost::type_traits::yes_type test(...);
|
||||
#endif
|
||||
|
||||
// If you see errors like this:
|
||||
//
|
||||
// `'T::T(const T&)' is private`
|
||||
// `boost/type_traits/is_copy_constructible.hpp:68:5: error: within this context`
|
||||
//
|
||||
// then you are trying to call that macro for a structure defined like that:
|
||||
//
|
||||
// struct T {
|
||||
// ...
|
||||
// private:
|
||||
// T(const T &);
|
||||
// ...
|
||||
// };
|
||||
//
|
||||
// To fix that you must modify your structure:
|
||||
//
|
||||
// // C++03 and C++11 version
|
||||
// struct T: private boost::noncopyable {
|
||||
// ...
|
||||
// private:
|
||||
// T(const T &);
|
||||
// ...
|
||||
// };
|
||||
//
|
||||
// // C++11 version
|
||||
// struct T {
|
||||
// ...
|
||||
// private:
|
||||
// T(const T &) = delete;
|
||||
// ...
|
||||
// };
|
||||
BOOST_STATIC_CONSTANT(bool, value = (
|
||||
sizeof(test(
|
||||
boost::declval<BOOST_DEDUCED_TYPENAME boost::add_reference<T const>::type>()
|
||||
)) == sizeof(boost::type_traits::yes_type)
|
||||
&&
|
||||
!boost::is_rvalue_reference<T>::value
|
||||
&& !boost::is_array<T>::value
|
||||
));
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_copy_constructible_impl2<true, T> {
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_copy_constructible_impl {
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, value = (
|
||||
boost::detail::is_copy_constructible_impl2<
|
||||
boost::is_base_and_derived<boost::noncopyable, T>::value,
|
||||
T
|
||||
>::value
|
||||
));
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T> struct is_copy_constructible : public integral_constant<bool, ::boost::detail::is_copy_constructible_impl<T>::value>{};
|
||||
template <> struct is_copy_constructible<void> : public false_type{};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <> struct is_copy_constructible<void const> : public false_type{};
|
||||
template <> struct is_copy_constructible<void volatile> : public false_type{};
|
||||
template <> struct is_copy_constructible<void const volatile> : public false_type{};
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif // BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED
|
||||
@@ -0,0 +1,34 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
// See http://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_COMPUTE_FUNCTIONAL_HPP
|
||||
#define BOOST_COMPUTE_FUNCTIONAL_HPP
|
||||
|
||||
/// \file
|
||||
///
|
||||
/// Meta-header to include all Boost.Compute functional headers.
|
||||
|
||||
#include <boost/compute/functional/as.hpp>
|
||||
#include <boost/compute/functional/atomic.hpp>
|
||||
#include <boost/compute/functional/common.hpp>
|
||||
#include <boost/compute/functional/convert.hpp>
|
||||
#include <boost/compute/functional/field.hpp>
|
||||
#include <boost/compute/functional/geometry.hpp>
|
||||
#include <boost/compute/functional/get.hpp>
|
||||
#include <boost/compute/functional/hash.hpp>
|
||||
#include <boost/compute/functional/identity.hpp>
|
||||
#include <boost/compute/functional/integer.hpp>
|
||||
#include <boost/compute/functional/logical.hpp>
|
||||
#include <boost/compute/functional/math.hpp>
|
||||
#include <boost/compute/functional/operator.hpp>
|
||||
#include <boost/compute/functional/popcount.hpp>
|
||||
#include <boost/compute/functional/relational.hpp>
|
||||
|
||||
#endif // BOOST_COMPUTE_FUNCTIONAL_HPP
|
||||
@@ -0,0 +1,19 @@
|
||||
|
||||
#ifndef BOOST_MPL_END_HPP_INCLUDED
|
||||
#define BOOST_MPL_END_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
#include <boost/mpl/begin_end.hpp>
|
||||
|
||||
#endif // BOOST_MPL_END_HPP_INCLUDED
|
||||
@@ -0,0 +1,424 @@
|
||||
#include "MessageClient.hpp"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
#include <QUdpSocket>
|
||||
#include <QHostInfo>
|
||||
#include <QTimer>
|
||||
#include <QQueue>
|
||||
#include <QByteArray>
|
||||
#include <QHostAddress>
|
||||
|
||||
#include "NetworkMessage.hpp"
|
||||
|
||||
#include "pimpl_impl.hpp"
|
||||
|
||||
#include "moc_MessageClient.cpp"
|
||||
|
||||
class MessageClient::impl
|
||||
: public QUdpSocket
|
||||
{
|
||||
Q_OBJECT;
|
||||
|
||||
public:
|
||||
impl (QString const& id, QString const& version, QString const& revision,
|
||||
port_type server_port, MessageClient * self)
|
||||
: self_ {self}
|
||||
, id_ {id}
|
||||
, version_ {version}
|
||||
, revision_ {revision}
|
||||
, server_port_ {server_port}
|
||||
, schema_ {2} // use 2 prior to negotiation not 1 which is broken
|
||||
, heartbeat_timer_ {new QTimer {this}}
|
||||
{
|
||||
connect (heartbeat_timer_, &QTimer::timeout, this, &impl::heartbeat);
|
||||
connect (this, &QIODevice::readyRead, this, &impl::pending_datagrams);
|
||||
|
||||
heartbeat_timer_->start (NetworkMessage::pulse * 1000);
|
||||
|
||||
// bind to an ephemeral port
|
||||
bind ();
|
||||
}
|
||||
|
||||
~impl ()
|
||||
{
|
||||
closedown ();
|
||||
}
|
||||
|
||||
enum StreamStatus {Fail, Short, OK};
|
||||
|
||||
void parse_message (QByteArray const& msg);
|
||||
void pending_datagrams ();
|
||||
void heartbeat ();
|
||||
void closedown ();
|
||||
StreamStatus check_status (QDataStream const&) const;
|
||||
void send_message (QByteArray const&);
|
||||
void send_message (QDataStream const& out, QByteArray const& message)
|
||||
{
|
||||
if (OK == check_status (out))
|
||||
{
|
||||
send_message (message);
|
||||
}
|
||||
else
|
||||
{
|
||||
Q_EMIT self_->error ("Error creating UDP message");
|
||||
}
|
||||
}
|
||||
|
||||
Q_SLOT void host_info_results (QHostInfo);
|
||||
|
||||
MessageClient * self_;
|
||||
QString id_;
|
||||
QString version_;
|
||||
QString revision_;
|
||||
QString server_string_;
|
||||
port_type server_port_;
|
||||
QHostAddress server_;
|
||||
quint32 schema_;
|
||||
QTimer * heartbeat_timer_;
|
||||
|
||||
// hold messages sent before host lookup completes asynchronously
|
||||
QQueue<QByteArray> pending_messages_;
|
||||
QByteArray last_message_;
|
||||
};
|
||||
|
||||
#include "MessageClient.moc"
|
||||
|
||||
void MessageClient::impl::host_info_results (QHostInfo host_info)
|
||||
{
|
||||
if (QHostInfo::NoError != host_info.error ())
|
||||
{
|
||||
Q_EMIT self_->error ("UDP server lookup failed:\n" + host_info.errorString ());
|
||||
pending_messages_.clear (); // discard
|
||||
}
|
||||
else if (host_info.addresses ().size ())
|
||||
{
|
||||
server_ = host_info.addresses ()[0];
|
||||
|
||||
// send initial heartbeat which allows schema negotiation
|
||||
heartbeat ();
|
||||
|
||||
// clear any backlog
|
||||
while (pending_messages_.size ())
|
||||
{
|
||||
send_message (pending_messages_.dequeue ());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::impl::pending_datagrams ()
|
||||
{
|
||||
while (hasPendingDatagrams ())
|
||||
{
|
||||
QByteArray datagram;
|
||||
datagram.resize (pendingDatagramSize ());
|
||||
QHostAddress sender_address;
|
||||
port_type sender_port;
|
||||
if (0 <= readDatagram (datagram.data (), datagram.size (), &sender_address, &sender_port))
|
||||
{
|
||||
parse_message (datagram);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::impl::parse_message (QByteArray const& msg)
|
||||
{
|
||||
try
|
||||
{
|
||||
//
|
||||
// message format is described in NetworkMessage.hpp
|
||||
//
|
||||
NetworkMessage::Reader in {msg};
|
||||
if (OK == check_status (in) && id_ == in.id ()) // OK and for us
|
||||
{
|
||||
if (schema_ < in.schema ()) // one time record of server's
|
||||
// negotiated schema
|
||||
{
|
||||
schema_ = in.schema ();
|
||||
}
|
||||
|
||||
//
|
||||
// message format is described in NetworkMessage.hpp
|
||||
//
|
||||
switch (in.type ())
|
||||
{
|
||||
case NetworkMessage::Reply:
|
||||
{
|
||||
// unpack message
|
||||
QTime time;
|
||||
qint32 snr;
|
||||
float delta_time;
|
||||
quint32 delta_frequency;
|
||||
QByteArray mode;
|
||||
QByteArray message;
|
||||
bool low_confidence {false};
|
||||
quint8 modifiers {0};
|
||||
in >> time >> snr >> delta_time >> delta_frequency >> mode >> message
|
||||
>> low_confidence >> modifiers;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->reply (time, snr, delta_time, delta_frequency
|
||||
, QString::fromUtf8 (mode), QString::fromUtf8 (message)
|
||||
, low_confidence, modifiers);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::Replay:
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
last_message_.clear ();
|
||||
Q_EMIT self_->replay ();
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::HaltTx:
|
||||
{
|
||||
bool auto_only {false};
|
||||
in >> auto_only;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->halt_tx (auto_only);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::FreeText:
|
||||
{
|
||||
QByteArray message;
|
||||
bool send {true};
|
||||
in >> message >> send;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->free_text (QString::fromUtf8 (message), send);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
// Ignore
|
||||
//
|
||||
// Note that although server heartbeat messages are not
|
||||
// parsed here they are still partially parsed in the
|
||||
// message reader class to negotiate the maximum schema
|
||||
// number being used on the network.
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (std::exception const& e)
|
||||
{
|
||||
Q_EMIT self_->error (QString {"MessageClient exception: %1"}.arg (e.what ()));
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
Q_EMIT self_->error ("Unexpected exception in MessageClient");
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::impl::heartbeat ()
|
||||
{
|
||||
if (server_port_ && !server_.isNull ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder hb {&message, NetworkMessage::Heartbeat, id_, schema_};
|
||||
hb << NetworkMessage::Builder::schema_number // maximum schema number accepted
|
||||
<< version_.toUtf8 () << revision_.toUtf8 ();
|
||||
if (OK == check_status (hb))
|
||||
{
|
||||
writeDatagram (message, server_, server_port_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::impl::closedown ()
|
||||
{
|
||||
if (server_port_ && !server_.isNull ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::Close, id_, schema_};
|
||||
if (OK == check_status (out))
|
||||
{
|
||||
writeDatagram (message, server_, server_port_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::impl::send_message (QByteArray const& message)
|
||||
{
|
||||
if (server_port_)
|
||||
{
|
||||
if (!server_.isNull ())
|
||||
{
|
||||
if (message != last_message_) // avoid duplicates
|
||||
{
|
||||
writeDatagram (message, server_, server_port_);
|
||||
last_message_ = message;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pending_messages_.enqueue (message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto MessageClient::impl::check_status (QDataStream const& stream) const -> StreamStatus
|
||||
{
|
||||
auto stat = stream.status ();
|
||||
StreamStatus result {Fail};
|
||||
switch (stat)
|
||||
{
|
||||
case QDataStream::ReadPastEnd:
|
||||
result = Short;
|
||||
break;
|
||||
|
||||
case QDataStream::ReadCorruptData:
|
||||
Q_EMIT self_->error ("Message serialization error: read corrupt data");
|
||||
break;
|
||||
|
||||
case QDataStream::WriteFailed:
|
||||
Q_EMIT self_->error ("Message serialization error: write error");
|
||||
break;
|
||||
|
||||
default:
|
||||
result = OK;
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
MessageClient::MessageClient (QString const& id, QString const& version, QString const& revision,
|
||||
QString const& server, port_type server_port, QObject * self)
|
||||
: QObject {self}
|
||||
, m_ {id, version, revision, server_port, this}
|
||||
{
|
||||
connect (&*m_, static_cast<void (impl::*) (impl::SocketError)> (&impl::error)
|
||||
, [this] (impl::SocketError e)
|
||||
{
|
||||
#if defined (Q_OS_WIN) && QT_VERSION >= 0x050500
|
||||
if (e != impl::NetworkError // take this out when Qt 5.5
|
||||
// stops doing this
|
||||
// spuriously
|
||||
&& e != impl::ConnectionRefusedError) // not
|
||||
// interested
|
||||
// in this with
|
||||
// UDP socket
|
||||
#else
|
||||
Q_UNUSED (e);
|
||||
#endif
|
||||
{
|
||||
Q_EMIT error (m_->errorString ());
|
||||
}
|
||||
});
|
||||
set_server (server);
|
||||
}
|
||||
|
||||
QHostAddress MessageClient::server_address () const
|
||||
{
|
||||
return m_->server_;
|
||||
}
|
||||
|
||||
auto MessageClient::server_port () const -> port_type
|
||||
{
|
||||
return m_->server_port_;
|
||||
}
|
||||
|
||||
void MessageClient::set_server (QString const& server)
|
||||
{
|
||||
m_->server_.clear ();
|
||||
m_->server_string_ = server;
|
||||
if (!server.isEmpty ())
|
||||
{
|
||||
// queue a host address lookup
|
||||
QHostInfo::lookupHost (server, &*m_, SLOT (host_info_results (QHostInfo)));
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::set_server_port (port_type server_port)
|
||||
{
|
||||
m_->server_port_ = server_port;
|
||||
}
|
||||
|
||||
void MessageClient::send_raw_datagram (QByteArray const& message, QHostAddress const& dest_address
|
||||
, port_type dest_port)
|
||||
{
|
||||
if (dest_port && !dest_address.isNull ())
|
||||
{
|
||||
m_->writeDatagram (message, dest_address, dest_port);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::status_update (Frequency f, QString const& mode, QString const& dx_call
|
||||
, QString const& report, QString const& tx_mode
|
||||
, bool tx_enabled, bool transmitting, bool decoding
|
||||
, qint32 rx_df, qint32 tx_df, QString const& de_call
|
||||
, QString const& de_grid, QString const& dx_grid
|
||||
, bool watchdog_timeout, QString const& sub_mode
|
||||
, bool fast_mode)
|
||||
{
|
||||
if (m_->server_port_ && !m_->server_string_.isEmpty ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::Status, m_->id_, m_->schema_};
|
||||
out << f << mode.toUtf8 () << dx_call.toUtf8 () << report.toUtf8 () << tx_mode.toUtf8 ()
|
||||
<< tx_enabled << transmitting << decoding << rx_df << tx_df << de_call.toUtf8 ()
|
||||
<< de_grid.toUtf8 () << dx_grid.toUtf8 () << watchdog_timeout << sub_mode.toUtf8 ()
|
||||
<< fast_mode;
|
||||
m_->send_message (out, message);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::decode (bool is_new, QTime time, qint32 snr, float delta_time, quint32 delta_frequency
|
||||
, QString const& mode, QString const& message_text, bool low_confidence
|
||||
, bool off_air)
|
||||
{
|
||||
if (m_->server_port_ && !m_->server_string_.isEmpty ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::Decode, m_->id_, m_->schema_};
|
||||
out << is_new << time << snr << delta_time << delta_frequency << mode.toUtf8 ()
|
||||
<< message_text.toUtf8 () << low_confidence << off_air;
|
||||
m_->send_message (out, message);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::WSPR_decode (bool is_new, QTime time, qint32 snr, float delta_time, Frequency frequency
|
||||
, qint32 drift, QString const& callsign, QString const& grid, qint32 power
|
||||
, bool off_air)
|
||||
{
|
||||
if (m_->server_port_ && !m_->server_string_.isEmpty ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::WSPRDecode, m_->id_, m_->schema_};
|
||||
out << is_new << time << snr << delta_time << frequency << drift << callsign.toUtf8 ()
|
||||
<< grid.toUtf8 () << power << off_air;
|
||||
m_->send_message (out, message);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::clear_decodes ()
|
||||
{
|
||||
if (m_->server_port_ && !m_->server_string_.isEmpty ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::Clear, m_->id_, m_->schema_};
|
||||
m_->send_message (out, message);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageClient::qso_logged (QDateTime time_off, QString const& dx_call, QString const& dx_grid
|
||||
, Frequency dial_frequency, QString const& mode, QString const& report_sent
|
||||
, QString const& report_received, QString const& tx_power
|
||||
, QString const& comments, QString const& name, QDateTime time_on)
|
||||
{
|
||||
if (m_->server_port_ && !m_->server_string_.isEmpty ())
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::QSOLogged, m_->id_, m_->schema_};
|
||||
out << time_off << dx_call.toUtf8 () << dx_grid.toUtf8 () << dial_frequency << mode.toUtf8 ()
|
||||
<< report_sent.toUtf8 () << report_received.toUtf8 () << tx_power.toUtf8 () << comments.toUtf8 ()
|
||||
<< name.toUtf8 () << time_on;
|
||||
m_->send_message (out, message);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
|
||||
|
||||
[begin_description]
|
||||
Specialization of the controller factory for the controlled_runge_kutta class.
|
||||
[end_description]
|
||||
|
||||
Copyright 2011-2012 Karsten Ahnert
|
||||
Copyright 2011-2012 Mario Mulansky
|
||||
|
||||
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_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
|
||||
|
||||
#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
|
||||
#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
|
||||
// controller factory for controlled_runge_kutta
|
||||
template< class Stepper >
|
||||
struct controller_factory< Stepper , controlled_runge_kutta< Stepper > >
|
||||
{
|
||||
typedef Stepper stepper_type;
|
||||
typedef controlled_runge_kutta< stepper_type > controller_type;
|
||||
typedef typename controller_type::error_checker_type error_checker_type;
|
||||
typedef typename controller_type::step_adjuster_type step_adjuster_type;
|
||||
typedef typename stepper_type::value_type value_type;
|
||||
typedef typename stepper_type::value_type time_type;
|
||||
|
||||
controller_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper )
|
||||
{
|
||||
return controller_type( error_checker_type( abs_error , rel_error ) ,
|
||||
step_adjuster_type() , stepper );
|
||||
}
|
||||
|
||||
controller_type operator()( value_type abs_error , value_type rel_error ,
|
||||
time_type max_dt, const stepper_type &stepper )
|
||||
{
|
||||
return controller_type( error_checker_type( abs_error , rel_error ) ,
|
||||
step_adjuster_type(max_dt) , stepper );
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // odeint
|
||||
} // numeric
|
||||
} // boost
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
|
||||
@@ -0,0 +1,142 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/algebra/range_algebra.hpp
|
||||
|
||||
[begin_description]
|
||||
Default algebra, which works with the most state types, like vector< double >, boost::array< double >, boost::range.
|
||||
Internally is uses boost::range to obtain the begin and end iterator of the according sequence.
|
||||
[end_description]
|
||||
|
||||
Copyright 2010-2013 Karsten Ahnert
|
||||
Copyright 2010-2013 Mario Mulansky
|
||||
|
||||
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_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED
|
||||
|
||||
#include <boost/range.hpp>
|
||||
#include <boost/mpl/size_t.hpp>
|
||||
|
||||
#include <boost/numeric/odeint/algebra/detail/macros.hpp>
|
||||
#include <boost/numeric/odeint/algebra/detail/for_each.hpp>
|
||||
#include <boost/numeric/odeint/algebra/detail/norm_inf.hpp>
|
||||
#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
struct range_algebra
|
||||
{
|
||||
template< class S1 , class Op >
|
||||
static void for_each1( S1 &s1 , Op op )
|
||||
{
|
||||
detail::for_each1( boost::begin( s1 ) , boost::end( s1 ) ,
|
||||
op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class Op >
|
||||
static void for_each2( S1 &s1 , S2 &s2 , Op op )
|
||||
{
|
||||
detail::for_each2( boost::begin( s1 ) , boost::end( s1 ) ,
|
||||
boost::begin( s2 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class Op >
|
||||
static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op )
|
||||
{
|
||||
detail::for_each3( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class Op >
|
||||
static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op )
|
||||
{
|
||||
detail::for_each4( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op >
|
||||
static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op )
|
||||
{
|
||||
detail::for_each5( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op >
|
||||
static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op )
|
||||
{
|
||||
detail::for_each6( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op >
|
||||
static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op )
|
||||
{
|
||||
detail::for_each7( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op >
|
||||
static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op )
|
||||
{
|
||||
detail::for_each8( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op >
|
||||
static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op )
|
||||
{
|
||||
detail::for_each9( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op >
|
||||
static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op )
|
||||
{
|
||||
detail::for_each10( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op >
|
||||
static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op )
|
||||
{
|
||||
detail::for_each11( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op >
|
||||
static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op )
|
||||
{
|
||||
detail::for_each12( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op >
|
||||
static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op )
|
||||
{
|
||||
detail::for_each13( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op >
|
||||
static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op )
|
||||
{
|
||||
detail::for_each14( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , boost::begin( s14 ) , op );
|
||||
}
|
||||
|
||||
template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op >
|
||||
static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op )
|
||||
{
|
||||
detail::for_each15( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , boost::begin( s14 ) , boost::begin( s15 ) , op );
|
||||
}
|
||||
|
||||
template< typename S >
|
||||
static typename norm_result_type<S>::type norm_inf( const S &s )
|
||||
{
|
||||
return detail::norm_inf( boost::begin( s ) , boost::end( s ) ,
|
||||
static_cast< typename norm_result_type<S>::type >( 0 ) );
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // odeint
|
||||
} // numeric
|
||||
} // boost
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED
|
||||
@@ -0,0 +1,298 @@
|
||||
#ifndef BOOST_SERIALIZATION_VOID_CAST_HPP
|
||||
#define BOOST_SERIALIZATION_VOID_CAST_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// void_cast.hpp: interface for run-time casting of void pointers.
|
||||
|
||||
// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// gennadiy.rozental@tfn.com
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <cstddef> // for ptrdiff_t
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/serialization/smart_cast.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/force_include.hpp>
|
||||
#include <boost/serialization/type_info_implementation.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
#include <boost/type_traits/is_virtual_base_of.hpp>
|
||||
#include <boost/serialization/void_cast_fwd.hpp>
|
||||
|
||||
#include <boost/serialization/config.hpp>
|
||||
#include <boost/config/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4251 4231 4660 4275)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
|
||||
class extended_type_info;
|
||||
|
||||
// Given a void *, assume that it really points to an instance of one type
|
||||
// and alter it so that it would point to an instance of a related type.
|
||||
// Return the altered pointer. If there exists no sequence of casts that
|
||||
// can transform from_type to to_type, return a NULL.
|
||||
|
||||
BOOST_SERIALIZATION_DECL void const *
|
||||
void_upcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const t
|
||||
);
|
||||
|
||||
inline void *
|
||||
void_upcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void * const t
|
||||
){
|
||||
return const_cast<void*>(void_upcast(
|
||||
derived,
|
||||
base,
|
||||
const_cast<void const *>(t)
|
||||
));
|
||||
}
|
||||
|
||||
BOOST_SERIALIZATION_DECL void const *
|
||||
void_downcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const t
|
||||
);
|
||||
|
||||
inline void *
|
||||
void_downcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void * const t
|
||||
){
|
||||
return const_cast<void*>(void_downcast(
|
||||
derived,
|
||||
base,
|
||||
const_cast<void const *>(t)
|
||||
));
|
||||
}
|
||||
|
||||
namespace void_cast_detail {
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE void_caster :
|
||||
private boost::noncopyable
|
||||
{
|
||||
friend
|
||||
BOOST_SERIALIZATION_DECL void const *
|
||||
boost::serialization::void_upcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const
|
||||
);
|
||||
friend
|
||||
BOOST_SERIALIZATION_DECL void const *
|
||||
boost::serialization::void_downcast(
|
||||
extended_type_info const & derived,
|
||||
extended_type_info const & base,
|
||||
void const * const
|
||||
);
|
||||
protected:
|
||||
BOOST_SERIALIZATION_DECL void recursive_register(bool includes_virtual_base = false) const;
|
||||
BOOST_SERIALIZATION_DECL void recursive_unregister() const;
|
||||
virtual bool has_virtual_base() const = 0;
|
||||
public:
|
||||
// Data members
|
||||
const extended_type_info * m_derived;
|
||||
const extended_type_info * m_base;
|
||||
/*const*/ std::ptrdiff_t m_difference;
|
||||
void_caster const * const m_parent;
|
||||
|
||||
// note that void_casters are keyed on value of
|
||||
// member extended type info records - NOT their
|
||||
// addresses. This is necessary in order for the
|
||||
// void cast operations to work across dll and exe
|
||||
// module boundries.
|
||||
bool operator<(const void_caster & rhs) const;
|
||||
|
||||
const void_caster & operator*(){
|
||||
return *this;
|
||||
}
|
||||
// each derived class must re-implement these;
|
||||
virtual void const * upcast(void const * const t) const = 0;
|
||||
virtual void const * downcast(void const * const t) const = 0;
|
||||
// Constructor
|
||||
void_caster(
|
||||
extended_type_info const * derived,
|
||||
extended_type_info const * base,
|
||||
std::ptrdiff_t difference = 0,
|
||||
void_caster const * const parent = 0
|
||||
) :
|
||||
m_derived(derived),
|
||||
m_base(base),
|
||||
m_difference(difference),
|
||||
m_parent(parent)
|
||||
{}
|
||||
virtual ~void_caster(){}
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4251 4231 4660 4275 4511 4512)
|
||||
#endif
|
||||
|
||||
template <class Derived, class Base>
|
||||
class BOOST_SYMBOL_VISIBLE void_caster_primitive :
|
||||
public void_caster
|
||||
{
|
||||
virtual void const * downcast(void const * const t) const {
|
||||
const Derived * d =
|
||||
boost::serialization::smart_cast<const Derived *, const Base *>(
|
||||
static_cast<const Base *>(t)
|
||||
);
|
||||
return d;
|
||||
}
|
||||
virtual void const * upcast(void const * const t) const {
|
||||
const Base * b =
|
||||
boost::serialization::smart_cast<const Base *, const Derived *>(
|
||||
static_cast<const Derived *>(t)
|
||||
);
|
||||
return b;
|
||||
}
|
||||
virtual bool has_virtual_base() const {
|
||||
return false;
|
||||
}
|
||||
public:
|
||||
void_caster_primitive();
|
||||
virtual ~void_caster_primitive();
|
||||
};
|
||||
|
||||
template <class Derived, class Base>
|
||||
void_caster_primitive<Derived, Base>::void_caster_primitive() :
|
||||
void_caster(
|
||||
& type_info_implementation<Derived>::type::get_const_instance(),
|
||||
& type_info_implementation<Base>::type::get_const_instance(),
|
||||
// note:I wanted to displace from 0 here, but at least one compiler
|
||||
// treated 0 by not shifting it at all.
|
||||
reinterpret_cast<std::ptrdiff_t>(
|
||||
static_cast<Derived *>(
|
||||
reinterpret_cast<Base *>(8)
|
||||
)
|
||||
) - 8
|
||||
)
|
||||
{
|
||||
recursive_register();
|
||||
}
|
||||
|
||||
template <class Derived, class Base>
|
||||
void_caster_primitive<Derived, Base>::~void_caster_primitive(){
|
||||
recursive_unregister();
|
||||
}
|
||||
|
||||
template <class Derived, class Base>
|
||||
class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
|
||||
public void_caster
|
||||
{
|
||||
virtual bool has_virtual_base() const {
|
||||
return true;
|
||||
}
|
||||
public:
|
||||
virtual void const * downcast(void const * const t) const {
|
||||
const Derived * d =
|
||||
dynamic_cast<const Derived *>(
|
||||
static_cast<const Base *>(t)
|
||||
);
|
||||
return d;
|
||||
}
|
||||
virtual void const * upcast(void const * const t) const {
|
||||
const Base * b =
|
||||
dynamic_cast<const Base *>(
|
||||
static_cast<const Derived *>(t)
|
||||
);
|
||||
return b;
|
||||
}
|
||||
void_caster_virtual_base();
|
||||
virtual ~void_caster_virtual_base();
|
||||
};
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template <class Derived, class Base>
|
||||
void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() :
|
||||
void_caster(
|
||||
& (type_info_implementation<Derived>::type::get_const_instance()),
|
||||
& (type_info_implementation<Base>::type::get_const_instance())
|
||||
)
|
||||
{
|
||||
recursive_register(true);
|
||||
}
|
||||
|
||||
template <class Derived, class Base>
|
||||
void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){
|
||||
recursive_unregister();
|
||||
}
|
||||
|
||||
template <class Derived, class Base>
|
||||
struct BOOST_SYMBOL_VISIBLE void_caster_base :
|
||||
public void_caster
|
||||
{
|
||||
typedef
|
||||
typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
|
||||
mpl::identity<
|
||||
void_cast_detail::void_caster_virtual_base<Derived, Base>
|
||||
>
|
||||
,// else
|
||||
mpl::identity<
|
||||
void_cast_detail::void_caster_primitive<Derived, Base>
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
} // void_cast_detail
|
||||
|
||||
template<class Derived, class Base>
|
||||
BOOST_DLLEXPORT
|
||||
inline const void_cast_detail::void_caster & void_cast_register(
|
||||
Derived const * /* dnull = NULL */,
|
||||
Base const * /* bnull = NULL */
|
||||
){
|
||||
typedef
|
||||
typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
|
||||
mpl::identity<
|
||||
void_cast_detail::void_caster_virtual_base<Derived, Base>
|
||||
>
|
||||
,// else
|
||||
mpl::identity<
|
||||
void_cast_detail::void_caster_primitive<Derived, Base>
|
||||
>
|
||||
>::type typex;
|
||||
return singleton<typex>::get_const_instance();
|
||||
}
|
||||
|
||||
template<class Derived, class Base>
|
||||
class BOOST_SYMBOL_VISIBLE void_caster :
|
||||
public void_cast_detail::void_caster_base<Derived, Base>::type
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
|
||||
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
Copyright (c) Microsoft Corporation 2014
|
||||
Copyright Rene Rivera 2015
|
||||
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_PREDEF_PLAT_WINDOWS_RUNTIME_H
|
||||
#define BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H
|
||||
|
||||
#include <boost/predef/version_number.h>
|
||||
#include <boost/predef/make.h>
|
||||
#include <boost/predef/os/windows.h>
|
||||
|
||||
/*`
|
||||
[heading `BOOST_PLAT_WINDOWS_RUNTIME`]
|
||||
|
||||
[table
|
||||
[[__predef_symbol__] [__predef_version__]]
|
||||
|
||||
[[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]]
|
||||
[[`WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP`] [__predef_detection__]]
|
||||
]
|
||||
*/
|
||||
|
||||
#define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_NOT_AVAILABLE
|
||||
|
||||
#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && \
|
||||
( WINAPI_FAMILY == WINAPI_FAMILY_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP )
|
||||
# undef BOOST_PLAT_WINDOWS_RUNTIME
|
||||
# define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_AVAILABLE
|
||||
#endif
|
||||
|
||||
#if BOOST_PLAT_WINDOWS_RUNTIME
|
||||
# define BOOST_PLAT_WINDOWS_RUNTIME_AVAILABLE
|
||||
# include <boost/predef/detail/platform_detected.h>
|
||||
#endif
|
||||
|
||||
#define BOOST_PLAT_WINDOWS_RUNTIME_NAME "Windows Runtime"
|
||||
|
||||
#endif
|
||||
|
||||
#include <boost/predef/detail/test.h>
|
||||
BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_RUNTIME,BOOST_PLAT_WINDOWS_RUNTIME_NAME)
|
||||
@@ -0,0 +1,90 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2014-2014.
|
||||
//
|
||||
// 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/intrusive for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_DETAIL_ALGORITHM_HPP
|
||||
#define BOOST_INTRUSIVE_DETAIL_ALGORITHM_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
# include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace intrusive {
|
||||
|
||||
struct algo_pred_equal
|
||||
{
|
||||
template<class T>
|
||||
bool operator()(const T &x, const T &y) const
|
||||
{ return x == y; }
|
||||
};
|
||||
|
||||
struct algo_pred_less
|
||||
{
|
||||
template<class T>
|
||||
bool operator()(const T &x, const T &y) const
|
||||
{ return x < y; }
|
||||
};
|
||||
|
||||
template<class InputIt1, class InputIt2, class BinaryPredicate>
|
||||
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
|
||||
{
|
||||
for (; first1 != last1; ++first1, ++first2) {
|
||||
if (!p(*first1, *first2)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<class InputIt1, class InputIt2>
|
||||
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
|
||||
{ return (algo_equal)(first1, last1, first2, algo_pred_equal()); }
|
||||
|
||||
template<class InputIt1, class InputIt2, class BinaryPredicate>
|
||||
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate pred)
|
||||
{
|
||||
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
|
||||
if (!pred(*first1, *first2))
|
||||
return false;
|
||||
return first1 == last1 && first2 == last2;
|
||||
}
|
||||
|
||||
template<class InputIt1, class InputIt2>
|
||||
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
|
||||
{ return (algo_equal)(first1, last1, first2, last2, algo_pred_equal()); }
|
||||
|
||||
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
|
||||
bool algo_lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
|
||||
InputIterator2 first2, InputIterator2 last2,
|
||||
BinaryPredicate pred)
|
||||
{
|
||||
while (first1 != last1){
|
||||
if (first2 == last2 || *first2 < *first1) return false;
|
||||
else if (pred(*first1, *first2)) return true;
|
||||
++first1; ++first2;
|
||||
}
|
||||
return (first2 != last2);
|
||||
}
|
||||
|
||||
template <class InputIterator1, class InputIterator2>
|
||||
bool algo_lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
|
||||
InputIterator2 first2, InputIterator2 last2)
|
||||
{ return (algo_lexicographical_compare)(first1, last1, first2, last2, algo_pred_less()); }
|
||||
|
||||
} //namespace intrusive {
|
||||
} //namespace boost {
|
||||
|
||||
#endif //#ifndef BOOST_INTRUSIVE_DETAIL_ALGORITHM_HPP
|
||||
@@ -0,0 +1,106 @@
|
||||
#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
#define BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// codecvt_null.hpp:
|
||||
|
||||
// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <locale>
|
||||
#include <cstddef> // NULL, size_t
|
||||
#include <cwchar> // for mbstate_t
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/archive/detail/auto_link_archive.hpp>
|
||||
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std {
|
||||
// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
|
||||
// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
|
||||
# if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
|
||||
using ::codecvt;
|
||||
# endif
|
||||
using ::mbstate_t;
|
||||
using ::size_t;
|
||||
} // namespace
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4511 4512)
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
template<class Ch>
|
||||
class codecvt_null;
|
||||
|
||||
template<>
|
||||
class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
|
||||
{
|
||||
virtual bool do_always_noconv() const throw() {
|
||||
return true;
|
||||
}
|
||||
public:
|
||||
explicit codecvt_null(std::size_t no_locale_manage = 0) :
|
||||
std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
|
||||
{}
|
||||
virtual ~codecvt_null(){};
|
||||
};
|
||||
|
||||
template<>
|
||||
class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
|
||||
{
|
||||
virtual BOOST_WARCHIVE_DECL std::codecvt_base::result
|
||||
do_out(
|
||||
std::mbstate_t & state,
|
||||
const wchar_t * first1,
|
||||
const wchar_t * last1,
|
||||
const wchar_t * & next1,
|
||||
char * first2,
|
||||
char * last2,
|
||||
char * & next2
|
||||
) const;
|
||||
virtual BOOST_WARCHIVE_DECL std::codecvt_base::result
|
||||
do_in(
|
||||
std::mbstate_t & state,
|
||||
const char * first1,
|
||||
const char * last1,
|
||||
const char * & next1,
|
||||
wchar_t * first2,
|
||||
wchar_t * last2,
|
||||
wchar_t * & next2
|
||||
) const;
|
||||
virtual int do_encoding( ) const throw( ){
|
||||
return sizeof(wchar_t) / sizeof(char);
|
||||
}
|
||||
virtual int do_max_length( ) const throw( ){
|
||||
return do_encoding();
|
||||
}
|
||||
public:
|
||||
explicit codecvt_null(std::size_t no_locale_manage = 0) :
|
||||
std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
|
||||
{}
|
||||
virtual ~codecvt_null(){};
|
||||
};
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
|
||||
|
||||
#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
|
||||
@@ -0,0 +1,40 @@
|
||||
// (C) Copyright 2009-2011 Frederic Bron.
|
||||
//
|
||||
// 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_HAS_LOGICAL_OR_HPP_INCLUDED
|
||||
#define BOOST_TT_HAS_LOGICAL_OR_HPP_INCLUDED
|
||||
|
||||
#define BOOST_TT_TRAIT_NAME has_logical_or
|
||||
#define BOOST_TT_TRAIT_OP ||
|
||||
#define BOOST_TT_FORBIDDEN_IF\
|
||||
/* pointer with fundamental non convertible to bool */\
|
||||
(\
|
||||
(\
|
||||
::boost::is_pointer< Lhs_noref >::value && \
|
||||
(\
|
||||
::boost::is_fundamental< Rhs_nocv >::value && \
|
||||
(! ::boost::is_convertible< Rhs_nocv, bool >::value )\
|
||||
)\
|
||||
)||\
|
||||
(\
|
||||
::boost::is_pointer< Rhs_noref >::value && \
|
||||
(\
|
||||
::boost::is_fundamental< Lhs_nocv >::value && \
|
||||
(! ::boost::is_convertible< Lhs_nocv, bool >::value )\
|
||||
)\
|
||||
)\
|
||||
)
|
||||
|
||||
|
||||
#include <boost/type_traits/detail/has_binary_operator.hpp>
|
||||
|
||||
#undef BOOST_TT_TRAIT_NAME
|
||||
#undef BOOST_TT_TRAIT_OP
|
||||
#undef BOOST_TT_FORBIDDEN_IF
|
||||
|
||||
#endif
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
@@ -0,0 +1,22 @@
|
||||
// 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 SHARED_PTR_DELETER_DWA2002121_HPP
|
||||
# define SHARED_PTR_DELETER_DWA2002121_HPP
|
||||
|
||||
namespace boost { namespace python { namespace converter {
|
||||
|
||||
struct BOOST_PYTHON_DECL shared_ptr_deleter
|
||||
{
|
||||
shared_ptr_deleter(handle<> owner);
|
||||
~shared_ptr_deleter();
|
||||
|
||||
void operator()(void const*);
|
||||
|
||||
handle<> owner;
|
||||
};
|
||||
|
||||
}}} // namespace boost::python::converter
|
||||
|
||||
#endif // SHARED_PTR_DELETER_DWA2002121_HPP
|
||||
@@ -0,0 +1,343 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
// Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl { namespace aux {
|
||||
|
||||
/// forward declaration
|
||||
|
||||
template<
|
||||
long N
|
||||
, typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_impl;
|
||||
|
||||
template< long N >
|
||||
struct reverse_iter_fold_chunk;
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<0>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef fwd_state0 bkwd_state0;
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter0 iterator;
|
||||
};
|
||||
|
||||
/// ETI workaround
|
||||
template<> struct result_< int,int,int,int,int >
|
||||
{
|
||||
typedef int state;
|
||||
typedef int iterator;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<1>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
|
||||
|
||||
typedef fwd_state1 bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter1 iterator;
|
||||
};
|
||||
|
||||
/// ETI workaround
|
||||
template<> struct result_< int,int,int,int,int >
|
||||
{
|
||||
typedef int state;
|
||||
typedef int iterator;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<2>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
|
||||
|
||||
typedef fwd_state2 bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter2 iterator;
|
||||
};
|
||||
|
||||
/// ETI workaround
|
||||
template<> struct result_< int,int,int,int,int >
|
||||
{
|
||||
typedef int state;
|
||||
typedef int iterator;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<3>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
|
||||
typedef typename mpl::next<iter2>::type iter3;
|
||||
|
||||
|
||||
typedef fwd_state3 bkwd_state3;
|
||||
typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter3 iterator;
|
||||
};
|
||||
|
||||
/// ETI workaround
|
||||
template<> struct result_< int,int,int,int,int >
|
||||
{
|
||||
typedef int state;
|
||||
typedef int iterator;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<4>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
|
||||
typedef typename mpl::next<iter2>::type iter3;
|
||||
typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
|
||||
typedef typename mpl::next<iter3>::type iter4;
|
||||
|
||||
|
||||
typedef fwd_state4 bkwd_state4;
|
||||
typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
|
||||
typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter4 iterator;
|
||||
};
|
||||
|
||||
/// ETI workaround
|
||||
template<> struct result_< int,int,int,int,int >
|
||||
{
|
||||
typedef int state;
|
||||
typedef int iterator;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
template< long N >
|
||||
struct reverse_iter_fold_chunk
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
|
||||
typedef typename mpl::next<iter2>::type iter3;
|
||||
typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
|
||||
typedef typename mpl::next<iter3>::type iter4;
|
||||
|
||||
|
||||
typedef reverse_iter_fold_impl<
|
||||
( (N - 4) < 0 ? 0 : N - 4 )
|
||||
, iter4
|
||||
, Last
|
||||
, fwd_state4
|
||||
, BackwardOp
|
||||
, ForwardOp
|
||||
> nested_chunk;
|
||||
|
||||
typedef typename nested_chunk::state bkwd_state4;
|
||||
typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
|
||||
typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef typename nested_chunk::iterator iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_step;
|
||||
|
||||
template<
|
||||
typename Last
|
||||
, typename State
|
||||
>
|
||||
struct reverse_iter_fold_null_step
|
||||
{
|
||||
typedef Last iterator;
|
||||
typedef State state;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct reverse_iter_fold_chunk< -1 >
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef typename if_<
|
||||
typename is_same< First,Last >::type
|
||||
, reverse_iter_fold_null_step< Last,State >
|
||||
, reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp >
|
||||
>::type res_;
|
||||
|
||||
typedef typename res_::state state;
|
||||
typedef typename res_::iterator iterator;
|
||||
};
|
||||
|
||||
/// ETI workaround
|
||||
template<> struct result_< int,int,int,int,int >
|
||||
{
|
||||
typedef int state;
|
||||
typedef int iterator;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_step
|
||||
{
|
||||
typedef reverse_iter_fold_chunk< -1 >::template result_<
|
||||
typename mpl::next<First>::type
|
||||
, Last
|
||||
, typename apply2< ForwardOp,State,First >::type
|
||||
, BackwardOp
|
||||
, ForwardOp
|
||||
> nested_step;
|
||||
|
||||
typedef typename apply2<
|
||||
BackwardOp
|
||||
, typename nested_step::state
|
||||
, First
|
||||
>::type state;
|
||||
|
||||
typedef typename nested_step::iterator iterator;
|
||||
};
|
||||
|
||||
template<
|
||||
long N
|
||||
, typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_impl
|
||||
: reverse_iter_fold_chunk<N>
|
||||
::template result_< First,Last,State,BackwardOp,ForwardOp >
|
||||
{
|
||||
};
|
||||
|
||||
}}}
|
||||
@@ -0,0 +1,56 @@
|
||||
/*
|
||||
Copyright Rene Rivera 2008-2015
|
||||
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_PREDEF_ARCHITECTURE_RS6K_H
|
||||
#define BOOST_PREDEF_ARCHITECTURE_RS6K_H
|
||||
|
||||
#include <boost/predef/version_number.h>
|
||||
#include <boost/predef/make.h>
|
||||
|
||||
/*`
|
||||
[heading `BOOST_ARCH_RS6000`]
|
||||
|
||||
[@http://en.wikipedia.org/wiki/RS/6000 RS/6000] architecture.
|
||||
|
||||
[table
|
||||
[[__predef_symbol__] [__predef_version__]]
|
||||
|
||||
[[`__THW_RS6000`] [__predef_detection__]]
|
||||
[[`_IBMR2`] [__predef_detection__]]
|
||||
[[`_POWER`] [__predef_detection__]]
|
||||
[[`_ARCH_PWR`] [__predef_detection__]]
|
||||
[[`_ARCH_PWR2`] [__predef_detection__]]
|
||||
]
|
||||
*/
|
||||
|
||||
#define BOOST_ARCH_RS6000 BOOST_VERSION_NUMBER_NOT_AVAILABLE
|
||||
|
||||
#if defined(__THW_RS6000) || defined(_IBMR2) || \
|
||||
defined(_POWER) || defined(_ARCH_PWR) || \
|
||||
defined(_ARCH_PWR2)
|
||||
# undef BOOST_ARCH_RS6000
|
||||
# define BOOST_ARCH_RS6000 BOOST_VERSION_NUMBER_AVAILABLE
|
||||
#endif
|
||||
|
||||
#if BOOST_ARCH_RS6000
|
||||
# define BOOST_ARCH_RS6000_AVAILABLE
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCH_RS6000_NAME "RS/6000"
|
||||
|
||||
#define BOOST_ARCH_PWR BOOST_ARCH_RS6000
|
||||
|
||||
#if BOOST_ARCH_PWR
|
||||
# define BOOST_ARCH_PWR_AVAILABLE
|
||||
#endif
|
||||
|
||||
#define BOOST_ARCH_PWR_NAME BOOST_ARCH_RS6000_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#include <boost/predef/detail/test.h>
|
||||
BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_RS6000,BOOST_ARCH_RS6000_NAME)
|
||||
@@ -0,0 +1,71 @@
|
||||
Auto-Sequencing algorithm for DXpedition station:
|
||||
|
||||
Start:
|
||||
CQMsg = "CQ KH1DX" (or "CQ UP KH1DX", "CQ 116 KH1DX", etc.)
|
||||
TxMsg = CQMsg
|
||||
Ntry = 0
|
||||
QCALL = "" # Callsign of current QSO partner
|
||||
go to Transmit
|
||||
|
||||
Transmit:
|
||||
TX # (... takes 13.6 s)
|
||||
go to Receive
|
||||
|
||||
Receive:
|
||||
RX # (... takes ~14 s)
|
||||
N = number of decodes # RxMsg[i], i=1,N
|
||||
if(N == 0)
|
||||
go to Transmit
|
||||
J = index of a reply from current QCALL # RxMsg[J] = "KH1DX QCALL R<rpt>"
|
||||
|
||||
if(QCALL == "") # No QSO in progress
|
||||
Select new QCALL # Op chooses a caller
|
||||
if(QCALL == "")
|
||||
TxMsg = CQMsg # No callers, we'll CQ again
|
||||
else # QSO in progress
|
||||
if(J >= 1) # Expected message was received
|
||||
log the QSO with QCALL
|
||||
QCALL = ""
|
||||
Select new QCALL # Op chooses a new caller
|
||||
if(QCALL != "")
|
||||
TxMsg = "73 NOW QCALL <rpt>" # Start a new QSO
|
||||
else
|
||||
TxMsg = "73 " + CQMsg # No callers, we'll CQ again
|
||||
else
|
||||
Ntry = Ntry + 1 # Expected msg not received
|
||||
if(Ntry <= NtryMax)
|
||||
go to Transmit # Ask for a repeat
|
||||
else
|
||||
QCALL = "" # Max tries exceeded, abort this QSO
|
||||
Select new QCALL # Choose a new caller
|
||||
if(QCALL != "")
|
||||
TxMsg = "NIL NOW QCALL <rpt>" # Start a new QSO
|
||||
else
|
||||
TxMsg = "NIL " + CQMSG # No callers, we'll CQ again
|
||||
go to Transmit
|
||||
|
||||
|
||||
Auto-Sequencing algorithm for those calling the DXpedition:
|
||||
|
||||
Start:
|
||||
TxMsg = "KH1DX MyCall"
|
||||
InQSO = false
|
||||
|
||||
Transmit:
|
||||
TX # (... takes 13.6 s)
|
||||
go to Receive
|
||||
|
||||
Receive:
|
||||
RX # (... takes ~14 s)
|
||||
if(RxMsg[i] contains "MyCall <rpt>")
|
||||
InQSO = true
|
||||
TxMsg = "KH1DX MyCall R<rpt>"
|
||||
go to Transmit
|
||||
|
||||
if(RxMsg[i] contains "<rpt>")
|
||||
TxEnable = false
|
||||
go to Receive
|
||||
|
||||
if(RxMsg[i] contains "CQ KH1DX")
|
||||
TxEnable = true
|
||||
go to Transmit
|
||||
@@ -0,0 +1,30 @@
|
||||
# /* **************************************************************************
|
||||
# * *
|
||||
# * (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. */
|
||||
#
|
||||
# ifndef BOOST_PREPROCESSOR_SEQ_FIRST_N_HPP
|
||||
# define BOOST_PREPROCESSOR_SEQ_FIRST_N_HPP
|
||||
#
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
# include <boost/preprocessor/control/if.hpp>
|
||||
# include <boost/preprocessor/seq/detail/split.hpp>
|
||||
# include <boost/preprocessor/tuple/eat.hpp>
|
||||
# include <boost/preprocessor/tuple/elem.hpp>
|
||||
#
|
||||
# /* BOOST_PP_SEQ_FIRST_N */
|
||||
#
|
||||
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
|
||||
# define BOOST_PP_SEQ_FIRST_N(n, seq) BOOST_PP_IF(n, BOOST_PP_TUPLE_ELEM, BOOST_PP_TUPLE_EAT_3)(2, 0, BOOST_PP_SEQ_SPLIT(n, seq (nil)))
|
||||
# else
|
||||
# define BOOST_PP_SEQ_FIRST_N(n, seq) BOOST_PP_SEQ_FIRST_N_I(n, seq)
|
||||
# define BOOST_PP_SEQ_FIRST_N_I(n, seq) BOOST_PP_IF(n, BOOST_PP_TUPLE_ELEM, BOOST_PP_TUPLE_EAT_3)(2, 0, BOOST_PP_SEQ_SPLIT(n, seq (nil)))
|
||||
# endif
|
||||
#
|
||||
# endif
|
||||
@@ -0,0 +1,138 @@
|
||||
/* Boost interval/compare/tribool.hpp template implementation file
|
||||
*
|
||||
* Copyright 2002-2003 Guillaume Melquiond
|
||||
*
|
||||
* 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_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP
|
||||
#define BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP
|
||||
|
||||
#include <boost/numeric/interval/detail/interval_prototype.hpp>
|
||||
#include <boost/numeric/interval/detail/test_input.hpp>
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace interval_lib {
|
||||
namespace compare {
|
||||
namespace tribool {
|
||||
|
||||
template<class T, class Policies1, class Policies2> inline
|
||||
logic::tribool operator<(const interval<T, Policies1>& x, const interval<T, Policies2>& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() < y.lower()) return true;
|
||||
if (x.lower() >= y.upper()) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
logic::tribool operator<(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() < y) return true;
|
||||
if (x.lower() >= y) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies1, class Policies2> inline
|
||||
logic::tribool operator<=(const interval<T, Policies1>& x, const interval<T, Policies2>& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() <= y.lower()) return true;
|
||||
if (x.lower() > y.upper()) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
logic::tribool operator<=(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() <= y) return true;
|
||||
if (x.lower() > y) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies1, class Policies2> inline
|
||||
logic::tribool operator>(const interval<T, Policies1>& x, const interval<T, Policies2>& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.lower() > y.upper()) return true;
|
||||
if (x.upper() <= y.lower()) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
logic::tribool operator>(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.lower() > y) return true;
|
||||
if (x.upper() <= y) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies1, class Policies2> inline
|
||||
logic::tribool operator>=(const interval<T, Policies1>& x, const interval<T, Policies2>& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.lower() >= y.upper()) return true;
|
||||
if (x.upper() < y.lower()) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
logic::tribool operator>=(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.lower() >= y) return true;
|
||||
if (x.upper() < y) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies1, class Policies2> inline
|
||||
logic::tribool operator==(const interval<T, Policies1>& x, const interval<T, Policies2>& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() == y.lower() && x.lower() == y.upper()) return true;
|
||||
if (x.upper() < y.lower() || x.lower() > y.upper()) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
logic::tribool operator==(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() == y && x.lower() == y) return true;
|
||||
if (x.upper() < y || x.lower() > y) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies1, class Policies2> inline
|
||||
logic::tribool operator!=(const interval<T, Policies1>& x, const interval<T, Policies2>& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() < y.lower() || x.lower() > y.upper()) return true;
|
||||
if (x.upper() == y.lower() && x.lower() == y.upper()) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
logic::tribool operator!=(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (detail::test_input(x, y)) throw comparison_error();
|
||||
if (x.upper() < y || x.lower() > y) return true;
|
||||
if (x.upper() == y && x.lower() == y) return false;
|
||||
return logic::indeterminate;
|
||||
}
|
||||
|
||||
} // namespace tribool
|
||||
} // namespace compare
|
||||
} // namespace interval_lib
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_INTERVAL_COMPARE_TRIBOOL_HPP
|
||||
Reference in New Issue
Block a user