Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,448 @@
|
||||
#include "MessageServer.hpp"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
#include <QUdpSocket>
|
||||
#include <QString>
|
||||
#include <QTimer>
|
||||
#include <QHash>
|
||||
|
||||
#include "Radio.hpp"
|
||||
#include "NetworkMessage.hpp"
|
||||
#include "qt_helpers.hpp"
|
||||
|
||||
#include "pimpl_impl.hpp"
|
||||
|
||||
#include "moc_MessageServer.cpp"
|
||||
|
||||
class MessageServer::impl
|
||||
: public QUdpSocket
|
||||
{
|
||||
Q_OBJECT;
|
||||
|
||||
public:
|
||||
impl (MessageServer * self, QString const& version, QString const& revision)
|
||||
: self_ {self}
|
||||
, version_ {version}
|
||||
, revision_ {revision}
|
||||
, port_ {0u}
|
||||
, clock_ {new QTimer {this}}
|
||||
{
|
||||
// register the required types with Qt
|
||||
Radio::register_types ();
|
||||
|
||||
connect (this, &QIODevice::readyRead, this, &MessageServer::impl::pending_datagrams);
|
||||
connect (this, static_cast<void (impl::*) (SocketError)> (&impl::error)
|
||||
, [this] (SocketError /* e */)
|
||||
{
|
||||
Q_EMIT self_->error (errorString ());
|
||||
});
|
||||
connect (clock_, &QTimer::timeout, this, &impl::tick);
|
||||
clock_->start (NetworkMessage::pulse * 1000);
|
||||
}
|
||||
|
||||
enum StreamStatus {Fail, Short, OK};
|
||||
|
||||
void leave_multicast_group ();
|
||||
void join_multicast_group ();
|
||||
void parse_message (QHostAddress const& sender, port_type sender_port, QByteArray const& msg);
|
||||
void tick ();
|
||||
void pending_datagrams ();
|
||||
StreamStatus check_status (QDataStream const&) const;
|
||||
void send_message (QDataStream const& out, QByteArray const& message, QHostAddress const& address, port_type port)
|
||||
{
|
||||
if (OK == check_status (out))
|
||||
{
|
||||
writeDatagram (message, address, port);
|
||||
}
|
||||
else
|
||||
{
|
||||
Q_EMIT self_->error ("Error creating UDP message");
|
||||
}
|
||||
}
|
||||
|
||||
MessageServer * self_;
|
||||
QString version_;
|
||||
QString revision_;
|
||||
port_type port_;
|
||||
QHostAddress multicast_group_address_;
|
||||
static BindMode constexpr bind_mode_ = ShareAddress | ReuseAddressHint;
|
||||
struct Client
|
||||
{
|
||||
Client () = default;
|
||||
Client (QHostAddress const& sender_address, port_type const& sender_port)
|
||||
: sender_address_ {sender_address}
|
||||
, sender_port_ {sender_port}
|
||||
, negotiated_schema_number_ {2} // not 1 because it's broken
|
||||
, last_activity_ {QDateTime::currentDateTime ()}
|
||||
{
|
||||
}
|
||||
Client (Client const&) = default;
|
||||
Client& operator= (Client const&) = default;
|
||||
|
||||
QHostAddress sender_address_;
|
||||
port_type sender_port_;
|
||||
quint32 negotiated_schema_number_;
|
||||
QDateTime last_activity_;
|
||||
};
|
||||
QHash<QString, Client> clients_; // maps id to Client
|
||||
QTimer * clock_;
|
||||
};
|
||||
|
||||
MessageServer::impl::BindMode constexpr MessageServer::impl::bind_mode_;
|
||||
|
||||
#include "MessageServer.moc"
|
||||
|
||||
void MessageServer::impl::leave_multicast_group ()
|
||||
{
|
||||
if (!multicast_group_address_.isNull () && BoundState == state ())
|
||||
{
|
||||
leaveMulticastGroup (multicast_group_address_);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::impl::join_multicast_group ()
|
||||
{
|
||||
if (BoundState == state ()
|
||||
&& !multicast_group_address_.isNull ())
|
||||
{
|
||||
if (IPv4Protocol == multicast_group_address_.protocol ()
|
||||
&& IPv4Protocol != localAddress ().protocol ())
|
||||
{
|
||||
close ();
|
||||
bind (QHostAddress::AnyIPv4, port_, bind_mode_);
|
||||
}
|
||||
if (!joinMulticastGroup (multicast_group_address_))
|
||||
{
|
||||
multicast_group_address_.clear ();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::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 (sender_address, sender_port, datagram);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::impl::parse_message (QHostAddress const& sender, port_type sender_port, QByteArray const& msg)
|
||||
{
|
||||
try
|
||||
{
|
||||
//
|
||||
// message format is described in NetworkMessage.hpp
|
||||
//
|
||||
NetworkMessage::Reader in {msg};
|
||||
|
||||
auto id = in.id ();
|
||||
if (OK == check_status (in))
|
||||
{
|
||||
if (!clients_.contains (id))
|
||||
{
|
||||
auto& client = (clients_[id] = {sender, sender_port});
|
||||
QByteArray client_version;
|
||||
QByteArray client_revision;
|
||||
|
||||
if (NetworkMessage::Heartbeat == in.type ())
|
||||
{
|
||||
// negotiate a working schema number
|
||||
in >> client.negotiated_schema_number_;
|
||||
if (OK == check_status (in))
|
||||
{
|
||||
auto sn = NetworkMessage::Builder::schema_number;
|
||||
client.negotiated_schema_number_ = std::min (sn, client.negotiated_schema_number_);
|
||||
|
||||
// reply to the new client informing it of the
|
||||
// negotiated schema number
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder hb {&message, NetworkMessage::Heartbeat, id, client.negotiated_schema_number_};
|
||||
hb << NetworkMessage::Builder::schema_number // maximum schema number accepted
|
||||
<< version_.toUtf8 () << revision_.toUtf8 ();
|
||||
if (impl::OK == check_status (hb))
|
||||
{
|
||||
writeDatagram (message, client.sender_address_, client.sender_port_);
|
||||
}
|
||||
else
|
||||
{
|
||||
Q_EMIT self_->error ("Error creating UDP message");
|
||||
}
|
||||
}
|
||||
// we don't care if this fails to read
|
||||
in >> client_version >> client_revision;
|
||||
}
|
||||
Q_EMIT self_->client_opened (id, QString::fromUtf8 (client_version),
|
||||
QString::fromUtf8 (client_revision));
|
||||
}
|
||||
clients_[id].last_activity_ = QDateTime::currentDateTime ();
|
||||
|
||||
//
|
||||
// message format is described in NetworkMessage.hpp
|
||||
//
|
||||
switch (in.type ())
|
||||
{
|
||||
case NetworkMessage::Heartbeat:
|
||||
//nothing to do here as time out handling deals with lifetime
|
||||
break;
|
||||
|
||||
case NetworkMessage::Clear:
|
||||
Q_EMIT self_->clear_decodes (id);
|
||||
break;
|
||||
|
||||
case NetworkMessage::Status:
|
||||
{
|
||||
// unpack message
|
||||
Frequency f;
|
||||
QByteArray mode;
|
||||
QByteArray dx_call;
|
||||
QByteArray report;
|
||||
QByteArray tx_mode;
|
||||
bool tx_enabled {false};
|
||||
bool transmitting {false};
|
||||
bool decoding {false};
|
||||
qint32 rx_df {-1};
|
||||
qint32 tx_df {-1};
|
||||
QByteArray de_call;
|
||||
QByteArray de_grid;
|
||||
QByteArray dx_grid;
|
||||
bool watchdog_timeout {false};
|
||||
QByteArray sub_mode;
|
||||
bool fast_mode {false};
|
||||
in >> f >> mode >> dx_call >> report >> tx_mode >> tx_enabled >> transmitting >> decoding
|
||||
>> rx_df >> tx_df >> de_call >> de_grid >> dx_grid >> watchdog_timeout >> sub_mode
|
||||
>> fast_mode;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->status_update (id, f, QString::fromUtf8 (mode), QString::fromUtf8 (dx_call)
|
||||
, QString::fromUtf8 (report), QString::fromUtf8 (tx_mode)
|
||||
, tx_enabled, transmitting, decoding, rx_df, tx_df
|
||||
, QString::fromUtf8 (de_call), QString::fromUtf8 (de_grid)
|
||||
, QString::fromUtf8 (dx_grid), watchdog_timeout
|
||||
, QString::fromUtf8 (sub_mode), fast_mode);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::Decode:
|
||||
{
|
||||
// unpack message
|
||||
bool is_new {true};
|
||||
QTime time;
|
||||
qint32 snr;
|
||||
float delta_time;
|
||||
quint32 delta_frequency;
|
||||
QByteArray mode;
|
||||
QByteArray message;
|
||||
bool low_confidence;
|
||||
in >> is_new >> time >> snr >> delta_time >> delta_frequency >> mode
|
||||
>> message >> low_confidence;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->decode (is_new, id, time, snr, delta_time, delta_frequency
|
||||
, QString::fromUtf8 (mode), QString::fromUtf8 (message)
|
||||
, low_confidence);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::WSPRDecode:
|
||||
{
|
||||
// unpack message
|
||||
bool is_new {true};
|
||||
QTime time;
|
||||
qint32 snr;
|
||||
float delta_time;
|
||||
Frequency frequency;
|
||||
qint32 drift;
|
||||
QByteArray callsign;
|
||||
QByteArray grid;
|
||||
qint32 power;
|
||||
in >> is_new >> time >> snr >> delta_time >> frequency >> drift >> callsign >> grid >> power;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->WSPR_decode (is_new, id, time, snr, delta_time, frequency, drift
|
||||
, QString::fromUtf8 (callsign), QString::fromUtf8 (grid), power);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::QSOLogged:
|
||||
{
|
||||
QDateTime timeOff;
|
||||
QByteArray dx_call;
|
||||
QByteArray dx_grid;
|
||||
Frequency dial_frequency;
|
||||
QByteArray mode;
|
||||
QByteArray report_sent;
|
||||
QByteArray report_received;
|
||||
QByteArray tx_power;
|
||||
QByteArray comments;
|
||||
QByteArray name;
|
||||
QDateTime timeOn; // Note: LOTW uses TIME_ON for their +/- 30-minute time window
|
||||
in >> timeOff >> dx_call >> dx_grid >> dial_frequency >> mode >> report_sent >> report_received
|
||||
>> tx_power >> comments >> name >> timeOn;
|
||||
if (check_status (in) != Fail)
|
||||
{
|
||||
Q_EMIT self_->qso_logged (id, timeOff, QString::fromUtf8 (dx_call), QString::fromUtf8 (dx_grid)
|
||||
, dial_frequency, QString::fromUtf8 (mode), QString::fromUtf8 (report_sent)
|
||||
, QString::fromUtf8 (report_received), QString::fromUtf8 (tx_power)
|
||||
, QString::fromUtf8 (comments), QString::fromUtf8 (name), timeOn);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case NetworkMessage::Close:
|
||||
Q_EMIT self_->client_closed (id);
|
||||
clients_.remove (id);
|
||||
break;
|
||||
|
||||
default:
|
||||
// Ignore
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Q_EMIT self_->error ("MessageServer warning: invalid UDP message received");
|
||||
}
|
||||
}
|
||||
catch (std::exception const& e)
|
||||
{
|
||||
Q_EMIT self_->error (QString {"MessageServer exception: %1"}.arg (e.what ()));
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
Q_EMIT self_->error ("Unexpected exception in MessageServer");
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::impl::tick ()
|
||||
{
|
||||
auto now = QDateTime::currentDateTime ();
|
||||
auto iter = std::begin (clients_);
|
||||
while (iter != std::end (clients_))
|
||||
{
|
||||
if (now > (*iter).last_activity_.addSecs (NetworkMessage::pulse))
|
||||
{
|
||||
Q_EMIT self_->clear_decodes (iter.key ());
|
||||
Q_EMIT self_->client_closed (iter.key ());
|
||||
iter = clients_.erase (iter); // safe while iterating as doesn't rehash
|
||||
}
|
||||
else
|
||||
{
|
||||
++iter;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto MessageServer::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;
|
||||
}
|
||||
|
||||
MessageServer::MessageServer (QObject * parent, QString const& version, QString const& revision)
|
||||
: QObject {parent}
|
||||
, m_ {this, version, revision}
|
||||
{
|
||||
}
|
||||
|
||||
void MessageServer::start (port_type port, QHostAddress const& multicast_group_address)
|
||||
{
|
||||
if (port != m_->port_
|
||||
|| multicast_group_address != m_->multicast_group_address_)
|
||||
{
|
||||
m_->leave_multicast_group ();
|
||||
if (impl::BoundState == m_->state ())
|
||||
{
|
||||
m_->close ();
|
||||
}
|
||||
m_->multicast_group_address_ = multicast_group_address;
|
||||
auto address = m_->multicast_group_address_.isNull ()
|
||||
|| impl::IPv4Protocol != m_->multicast_group_address_.protocol () ? QHostAddress::Any : QHostAddress::AnyIPv4;
|
||||
if (port && m_->bind (address, port, m_->bind_mode_))
|
||||
{
|
||||
m_->port_ = port;
|
||||
m_->join_multicast_group ();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_->port_ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::reply (QString const& id, QTime time, qint32 snr, float delta_time, quint32 delta_frequency, QString const& mode, QString const& message_text, bool low_confidence)
|
||||
{
|
||||
auto iter = m_->clients_.find (id);
|
||||
if (iter != std::end (m_->clients_))
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::Reply, id, (*iter).negotiated_schema_number_};
|
||||
out << time << snr << delta_time << delta_frequency << mode.toUtf8 ()
|
||||
<< message_text.toUtf8 () << low_confidence;
|
||||
m_->send_message (out, message, iter.value ().sender_address_, (*iter).sender_port_);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::replay (QString const& id)
|
||||
{
|
||||
auto iter = m_->clients_.find (id);
|
||||
if (iter != std::end (m_->clients_))
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::Replay, id, (*iter).negotiated_schema_number_};
|
||||
m_->send_message (out, message, iter.value ().sender_address_, (*iter).sender_port_);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::halt_tx (QString const& id, bool auto_only)
|
||||
{
|
||||
auto iter = m_->clients_.find (id);
|
||||
if (iter != std::end (m_->clients_))
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::HaltTx, id, (*iter).negotiated_schema_number_};
|
||||
out << auto_only;
|
||||
m_->send_message (out, message, iter.value ().sender_address_, (*iter).sender_port_);
|
||||
}
|
||||
}
|
||||
|
||||
void MessageServer::free_text (QString const& id, QString const& text, bool send)
|
||||
{
|
||||
auto iter = m_->clients_.find (id);
|
||||
if (iter != std::end (m_->clients_))
|
||||
{
|
||||
QByteArray message;
|
||||
NetworkMessage::Builder out {&message, NetworkMessage::FreeText, id, (*iter).negotiated_schema_number_};
|
||||
out << text.toUtf8 () << send;
|
||||
m_->send_message (out, message, iter.value ().sender_address_, (*iter).sender_port_);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
#ifndef BOOST_PP_IS_ITERATING
|
||||
#if !defined(FUSION_PP_MAKE_LIST_07192005_1239)
|
||||
#define FUSION_PP_MAKE_LIST_07192005_1239
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/fusion/container/list/list.hpp>
|
||||
#include <boost/fusion/support/detail/as_fusion_element.hpp>
|
||||
|
||||
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_list.hpp>
|
||||
#else
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_list" FUSION_MAX_LIST_SIZE_STR".hpp")
|
||||
#endif
|
||||
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <
|
||||
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
|
||||
FUSION_MAX_LIST_SIZE, typename T, void_)
|
||||
, typename Extra = void_
|
||||
>
|
||||
struct make_list;
|
||||
|
||||
template <>
|
||||
struct make_list<>
|
||||
{
|
||||
typedef list<> type;
|
||||
};
|
||||
}
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline list<>
|
||||
make_list()
|
||||
{
|
||||
return list<>();
|
||||
}
|
||||
|
||||
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
|
||||
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
|
||||
|
||||
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_list.hpp>
|
||||
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef BOOST_FUSION_AS_FUSION_ELEMENT
|
||||
|
||||
}}
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
|
||||
|
||||
#endif
|
||||
#else // defined(BOOST_PP_IS_ITERATING)
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Preprocessor vertical repetition code
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
|
||||
#define TEXT(z, n, text) , text
|
||||
struct make_list< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_LIST_SIZE, TEXT, void_) >
|
||||
#undef TEXT
|
||||
{
|
||||
typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
|
||||
};
|
||||
}
|
||||
|
||||
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
|
||||
make_list(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
|
||||
{
|
||||
return list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
|
||||
BOOST_PP_ENUM_PARAMS(N, arg));
|
||||
}
|
||||
|
||||
#undef N
|
||||
#endif // defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
// 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 DICT_20020706_HPP
|
||||
#define DICT_20020706_HPP
|
||||
|
||||
# include <boost/python/detail/prefix.hpp>
|
||||
|
||||
#include <boost/python/object.hpp>
|
||||
#include <boost/python/list.hpp>
|
||||
#include <boost/python/tuple.hpp>
|
||||
#include <boost/python/converter/pytype_object_mgr_traits.hpp>
|
||||
|
||||
namespace boost { namespace python {
|
||||
|
||||
class dict;
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct BOOST_PYTHON_DECL dict_base : object
|
||||
{
|
||||
// D.clear() -> None. Remove all items from D.
|
||||
void clear();
|
||||
|
||||
// D.copy() -> a shallow copy of D
|
||||
dict copy();
|
||||
|
||||
// D.get(k[,d]) -> D[k] if D.has_key(k), else d. d defaults to None.
|
||||
object get(object_cref k) const;
|
||||
|
||||
object get(object_cref k, object_cref d) const;
|
||||
|
||||
// D.has_key(k) -> 1 if D has a key k, else 0
|
||||
bool has_key(object_cref k) const;
|
||||
|
||||
// D.items() -> list of D's (key, value) pairs, as 2-tuples
|
||||
list items() const;
|
||||
|
||||
// D.iteritems() -> an iterator over the (key, value) items of D
|
||||
object iteritems() const;
|
||||
|
||||
// D.iterkeys() -> an iterator over the keys of D
|
||||
object iterkeys() const;
|
||||
|
||||
// D.itervalues() -> an iterator over the values of D
|
||||
object itervalues() const;
|
||||
|
||||
// D.keys() -> list of D's keys
|
||||
list keys() const;
|
||||
|
||||
// D.popitem() -> (k, v), remove and return some (key, value) pair as a
|
||||
// 2-tuple; but raise KeyError if D is empty
|
||||
tuple popitem();
|
||||
|
||||
// D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if not D.has_key(k)
|
||||
object setdefault(object_cref k);
|
||||
|
||||
object setdefault(object_cref k, object_cref d);
|
||||
|
||||
// D.update(E) -> None. Update D from E: for k in E.keys(): D[k] = E[k]
|
||||
void update(object_cref E);
|
||||
|
||||
// D.values() -> list of D's values
|
||||
list values() const;
|
||||
|
||||
protected:
|
||||
// dict() -> new empty dictionary.
|
||||
// dict(mapping) -> new dictionary initialized from a mapping object's
|
||||
// (key, value) pairs.
|
||||
// dict(seq) -> new dictionary initialized as if via:
|
||||
dict_base(); // new dict
|
||||
explicit dict_base(object_cref data);
|
||||
|
||||
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict_base, object)
|
||||
private:
|
||||
static detail::new_reference call(object const&);
|
||||
};
|
||||
}
|
||||
|
||||
class dict : public detail::dict_base
|
||||
{
|
||||
typedef detail::dict_base base;
|
||||
public:
|
||||
// dict() -> new empty dictionary.
|
||||
// dict(mapping) -> new dictionary initialized from a mapping object's
|
||||
// (key, value) pairs.
|
||||
// dict(seq) -> new dictionary initialized as if via:
|
||||
dict() {} // new dict
|
||||
|
||||
template <class T>
|
||||
explicit dict(T const& data)
|
||||
: base(object(data))
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
object get(T const& k) const
|
||||
{
|
||||
return base::get(object(k));
|
||||
}
|
||||
|
||||
template<class T1, class T2>
|
||||
object get(T1 const& k, T2 const& d) const
|
||||
{
|
||||
return base::get(object(k),object(d));
|
||||
}
|
||||
|
||||
template<class T>
|
||||
bool has_key(T const& k) const
|
||||
{
|
||||
return base::has_key(object(k));
|
||||
}
|
||||
|
||||
template<class T>
|
||||
object setdefault(T const& k)
|
||||
{
|
||||
return base::setdefault(object(k));
|
||||
}
|
||||
|
||||
template<class T1, class T2>
|
||||
object setdefault(T1 const& k, T2 const& d)
|
||||
{
|
||||
return base::setdefault(object(k),object(d));
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void update(T const& E)
|
||||
{
|
||||
base::update(object(E));
|
||||
}
|
||||
|
||||
public: // implementation detail -- for internal use only
|
||||
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict, base)
|
||||
};
|
||||
|
||||
//
|
||||
// Converter Specializations
|
||||
//
|
||||
namespace converter
|
||||
{
|
||||
template <>
|
||||
struct object_manager_traits<dict>
|
||||
: pytype_object_manager_traits<&PyDict_Type,dict>
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
}} // namespace boost::python
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,227 @@
|
||||
#ifndef BOOST_SERIALIZATION_VECTOR_HPP
|
||||
#define BOOST_SERIALIZATION_VECTOR_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// vector.hpp: serialization for stl vector templates
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// fast array serialization (C) Copyright 2005 Matthias Troyer
|
||||
// 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 <vector>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/archive/detail/basic_iarchive.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/collection_size_type.hpp>
|
||||
#include <boost/serialization/item_version_type.hpp>
|
||||
|
||||
#include <boost/serialization/collections_save_imp.hpp>
|
||||
#include <boost/serialization/collections_load_imp.hpp>
|
||||
#include <boost/serialization/split_free.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/serialization/detail/get_data.hpp>
|
||||
#include <boost/serialization/detail/stack_constructor.hpp>
|
||||
#include <boost/mpl/bool_fwd.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
|
||||
// default is being compatible with version 1.34.1 files, not 1.35 files
|
||||
#ifndef BOOST_SERIALIZATION_VECTOR_VERSIONED
|
||||
#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V==4 || V==5)
|
||||
#endif
|
||||
|
||||
// function specializations must be defined in the appropriate
|
||||
// namespace - boost::serialization
|
||||
#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
|
||||
#define STD _STLP_STD
|
||||
#else
|
||||
#define STD std
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// vector< T >
|
||||
|
||||
// the default versions
|
||||
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void save(
|
||||
Archive & ar,
|
||||
const std::vector<U, Allocator> &t,
|
||||
const unsigned int /* file_version */,
|
||||
mpl::false_
|
||||
){
|
||||
boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
|
||||
ar, t
|
||||
);
|
||||
}
|
||||
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void load(
|
||||
Archive & ar,
|
||||
std::vector<U, Allocator> &t,
|
||||
const unsigned int /* file_version */,
|
||||
mpl::false_
|
||||
){
|
||||
const boost::archive::library_version_type library_version(
|
||||
ar.get_library_version()
|
||||
);
|
||||
// retrieve number of elements
|
||||
item_version_type item_version(0);
|
||||
collection_size_type count;
|
||||
ar >> BOOST_SERIALIZATION_NVP(count);
|
||||
if(boost::archive::library_version_type(3) < library_version){
|
||||
ar >> BOOST_SERIALIZATION_NVP(item_version);
|
||||
}
|
||||
t.reserve(count);
|
||||
stl::collection_load_impl(ar, t, count, item_version);
|
||||
}
|
||||
|
||||
// the optimized versions
|
||||
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void save(
|
||||
Archive & ar,
|
||||
const std::vector<U, Allocator> &t,
|
||||
const unsigned int /* file_version */,
|
||||
mpl::true_
|
||||
){
|
||||
const collection_size_type count(t.size());
|
||||
ar << BOOST_SERIALIZATION_NVP(count);
|
||||
if (!t.empty())
|
||||
ar << boost::serialization::make_array(detail::get_data(t),t.size());
|
||||
}
|
||||
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void load(
|
||||
Archive & ar,
|
||||
std::vector<U, Allocator> &t,
|
||||
const unsigned int /* file_version */,
|
||||
mpl::true_
|
||||
){
|
||||
collection_size_type count(t.size());
|
||||
ar >> BOOST_SERIALIZATION_NVP(count);
|
||||
t.resize(count);
|
||||
unsigned int item_version=0;
|
||||
if(BOOST_SERIALIZATION_VECTOR_VERSIONED(ar.get_library_version())) {
|
||||
ar >> BOOST_SERIALIZATION_NVP(item_version);
|
||||
}
|
||||
if (!t.empty())
|
||||
ar >> boost::serialization::make_array(detail::get_data(t),t.size());
|
||||
}
|
||||
|
||||
// dispatch to either default or optimized versions
|
||||
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void save(
|
||||
Archive & ar,
|
||||
const std::vector<U, Allocator> &t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
typedef typename
|
||||
boost::serialization::use_array_optimization<Archive>::template apply<
|
||||
typename remove_const<U>::type
|
||||
>::type use_optimized;
|
||||
save(ar,t,file_version, use_optimized());
|
||||
}
|
||||
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void load(
|
||||
Archive & ar,
|
||||
std::vector<U, Allocator> &t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
#ifdef BOOST_SERIALIZATION_VECTOR_135_HPP
|
||||
if (ar.get_library_version()==boost::archive::library_version_type(5))
|
||||
{
|
||||
load(ar,t,file_version, boost::is_arithmetic<U>());
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
typedef typename
|
||||
boost::serialization::use_array_optimization<Archive>::template apply<
|
||||
typename remove_const<U>::type
|
||||
>::type use_optimized;
|
||||
load(ar,t,file_version, use_optimized());
|
||||
}
|
||||
|
||||
// split non-intrusive serialization function member into separate
|
||||
// non intrusive save/load member functions
|
||||
template<class Archive, class U, class Allocator>
|
||||
inline void serialize(
|
||||
Archive & ar,
|
||||
std::vector<U, Allocator> & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
boost::serialization::split_free(ar, t, file_version);
|
||||
}
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// vector<bool>
|
||||
template<class Archive, class Allocator>
|
||||
inline void save(
|
||||
Archive & ar,
|
||||
const std::vector<bool, Allocator> &t,
|
||||
const unsigned int /* file_version */
|
||||
){
|
||||
// record number of elements
|
||||
collection_size_type count (t.size());
|
||||
ar << BOOST_SERIALIZATION_NVP(count);
|
||||
std::vector<bool>::const_iterator it = t.begin();
|
||||
while(count-- > 0){
|
||||
bool tb = *it++;
|
||||
ar << boost::serialization::make_nvp("item", tb);
|
||||
}
|
||||
}
|
||||
|
||||
template<class Archive, class Allocator>
|
||||
inline void load(
|
||||
Archive & ar,
|
||||
std::vector<bool, Allocator> &t,
|
||||
const unsigned int /* file_version */
|
||||
){
|
||||
// retrieve number of elements
|
||||
collection_size_type count;
|
||||
ar >> BOOST_SERIALIZATION_NVP(count);
|
||||
t.resize(count);
|
||||
for(collection_size_type i = collection_size_type(0); i < count; ++i){
|
||||
bool b;
|
||||
ar >> boost::serialization::make_nvp("item", b);
|
||||
t[i] = b;
|
||||
}
|
||||
}
|
||||
|
||||
// split non-intrusive serialization function member into separate
|
||||
// non intrusive save/load member functions
|
||||
template<class Archive, class Allocator>
|
||||
inline void serialize(
|
||||
Archive & ar,
|
||||
std::vector<bool, Allocator> & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
boost::serialization::split_free(ar, t, file_version);
|
||||
}
|
||||
|
||||
} // serialization
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/serialization/collection_traits.hpp>
|
||||
|
||||
BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
|
||||
#undef STD
|
||||
|
||||
#endif // BOOST_SERIALIZATION_VECTOR_HPP
|
||||
@@ -0,0 +1,20 @@
|
||||
// (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_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED
|
||||
#define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED
|
||||
|
||||
// should be the last #include
|
||||
#include <boost/type_traits/is_floating_point.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
//* is a type T a floating-point type described in the standard (3.9.1p8)
|
||||
template <class T> struct is_float : public is_floating_point<T> {};
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,12 @@
|
||||
// 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 MPL_LAMBDA_DWA2002122_HPP
|
||||
# define MPL_LAMBDA_DWA2002122_HPP
|
||||
|
||||
// this header should go away soon
|
||||
# include <boost/mpl/aux_/lambda_support.hpp>
|
||||
# define BOOST_PYTHON_MPL_LAMBDA_SUPPORT BOOST_MPL_AUX_LAMBDA_SUPPORT
|
||||
|
||||
#endif // MPL_LAMBDA_DWA2002122_HPP
|
||||
@@ -0,0 +1,26 @@
|
||||
|
||||
#ifndef BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED
|
||||
#define BOOST_MPL_INTEGRAL_C_TAG_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/aux_/adl_barrier.hpp>
|
||||
#include <boost/mpl/aux_/config/static_constant.hpp>
|
||||
|
||||
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
|
||||
struct integral_c_tag { BOOST_STATIC_CONSTANT(int, value = 0); };
|
||||
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
|
||||
BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c_tag)
|
||||
|
||||
#endif // BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED
|
||||
@@ -0,0 +1,124 @@
|
||||
////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright Vicente J. Botet Escriba 2010
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
#ifndef BOOST_MPL_GCD_HPP_INCLUDED
|
||||
#define BOOST_MPL_GCD_HPP_INCLUDED
|
||||
|
||||
#include <boost/mpl/integral_c.hpp>
|
||||
#include <boost/ratio/detail/mpl/abs.hpp>
|
||||
#include <boost/mpl/aux_/largest_int.hpp>
|
||||
#include <boost/mpl/aux_/na_spec.hpp>
|
||||
#include <boost/mpl/aux_/lambda_support.hpp>
|
||||
#include <boost/mpl/aux_/config/integral.hpp>
|
||||
#include <boost/mpl/aux_/config/static_constant.hpp>
|
||||
#include <boost/mpl/aux_/config/dependent_nttp.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
|
||||
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
|
||||
&& !defined(__CUDACC__) \
|
||||
&& ( defined(BOOST_MSVC) \
|
||||
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
|
||||
)
|
||||
|
||||
# define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
|
||||
|
||||
#endif
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template< typename Tag1, typename Tag2 > struct gcd_impl;
|
||||
|
||||
template< typename T > struct gcd_tag
|
||||
{
|
||||
typedef typename T::tag type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename BOOST_MPL_AUX_NA_PARAM(N1)
|
||||
, typename BOOST_MPL_AUX_NA_PARAM(N2)
|
||||
>
|
||||
struct gcd
|
||||
: gcd_impl<
|
||||
typename gcd_tag<N1>::type
|
||||
, typename gcd_tag<N2>::type
|
||||
>::template apply<N1, N2>::type
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, gcd, (N1, N2))
|
||||
};
|
||||
|
||||
BOOST_MPL_AUX_NA_SPEC(2, gcd)
|
||||
|
||||
template<
|
||||
typename T
|
||||
, T n1
|
||||
, T n2
|
||||
>
|
||||
struct gcd_c
|
||||
: gcd<integral_c<T,n1>,integral_c<T,n2> >
|
||||
{
|
||||
};
|
||||
|
||||
namespace aux {
|
||||
|
||||
// Workaround for error: the type of partial specialization template parameter constant "n2"
|
||||
// depends on another template parameter
|
||||
// Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
|
||||
#if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
|
||||
|
||||
template< typename T1, boost::intmax_t n1, bool n1_is_0
|
||||
, typename T2, boost::intmax_t n2, bool n2_is_0 >
|
||||
struct gcd_aux
|
||||
: gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
|
||||
{};
|
||||
|
||||
template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
|
||||
struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
|
||||
{};
|
||||
|
||||
template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
|
||||
struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
|
||||
{};
|
||||
|
||||
#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
|
||||
|
||||
template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
|
||||
struct gcd_aux
|
||||
|
||||
: gcd_aux<T2, n2, n2==0,
|
||||
typename aux::largest_int<T1, T2>::type,
|
||||
//~ T1,
|
||||
(n1 % n2), (n1 % n2)==0>
|
||||
{};
|
||||
|
||||
template <typename T1, T1 n1, typename T2, T2 n2>
|
||||
struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
|
||||
{};
|
||||
|
||||
template <typename T1, T1 n1, typename T2, T2 n2, bool C>
|
||||
struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
|
||||
{};
|
||||
#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
|
||||
}
|
||||
|
||||
template<>
|
||||
struct gcd_impl<integral_c_tag, integral_c_tag>
|
||||
{
|
||||
template< typename N1, typename N2 > struct apply
|
||||
: abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
|
||||
typename N2::value_type, N2::value, N2::value==0 > >
|
||||
{
|
||||
};
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif // BOOST_MPL_GCD_HPP_INCLUDED
|
||||
@@ -0,0 +1,139 @@
|
||||
/*
|
||||
*
|
||||
* 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 match_flags.hpp
|
||||
* VERSION see <boost/version.hpp>
|
||||
* DESCRIPTION: Declares match_flags type.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_REGEX_V4_MATCH_FLAGS
|
||||
#define BOOST_REGEX_V4_MATCH_FLAGS
|
||||
|
||||
#ifdef __cplusplus
|
||||
# include <boost/cstdint.hpp>
|
||||
#endif
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#ifdef __cplusplus
|
||||
namespace boost{
|
||||
namespace regex_constants{
|
||||
#endif
|
||||
|
||||
typedef enum _match_flags
|
||||
{
|
||||
match_default = 0,
|
||||
match_not_bol = 1, /* first is not start of line */
|
||||
match_not_eol = match_not_bol << 1, /* last is not end of line */
|
||||
match_not_bob = match_not_eol << 1, /* first is not start of buffer */
|
||||
match_not_eob = match_not_bob << 1, /* last is not end of buffer */
|
||||
match_not_bow = match_not_eob << 1, /* first is not start of word */
|
||||
match_not_eow = match_not_bow << 1, /* last is not end of word */
|
||||
match_not_dot_newline = match_not_eow << 1, /* \n is not matched by '.' */
|
||||
match_not_dot_null = match_not_dot_newline << 1, /* '\0' is not matched by '.' */
|
||||
match_prev_avail = match_not_dot_null << 1, /* *--first is a valid expression */
|
||||
match_init = match_prev_avail << 1, /* internal use */
|
||||
match_any = match_init << 1, /* don't care what we match */
|
||||
match_not_null = match_any << 1, /* string can't be null */
|
||||
match_continuous = match_not_null << 1, /* each grep match must continue from */
|
||||
/* uninterupted from the previous one */
|
||||
match_partial = match_continuous << 1, /* find partial matches */
|
||||
|
||||
match_stop = match_partial << 1, /* stop after first match (grep) V3 only */
|
||||
match_not_initial_null = match_stop, /* don't match initial null, V4 only */
|
||||
match_all = match_stop << 1, /* must find the whole of input even if match_any is set */
|
||||
match_perl = match_all << 1, /* Use perl matching rules */
|
||||
match_posix = match_perl << 1, /* Use POSIX matching rules */
|
||||
match_nosubs = match_posix << 1, /* don't trap marked subs */
|
||||
match_extra = match_nosubs << 1, /* include full capture information for repeated captures */
|
||||
match_single_line = match_extra << 1, /* treat text as single line and ignor any \n's when matching ^ and $. */
|
||||
match_unused1 = match_single_line << 1, /* unused */
|
||||
match_unused2 = match_unused1 << 1, /* unused */
|
||||
match_unused3 = match_unused2 << 1, /* unused */
|
||||
match_max = match_unused3,
|
||||
|
||||
format_perl = 0, /* perl style replacement */
|
||||
format_default = 0, /* ditto. */
|
||||
format_sed = match_max << 1, /* sed style replacement. */
|
||||
format_all = format_sed << 1, /* enable all extentions to sytax. */
|
||||
format_no_copy = format_all << 1, /* don't copy non-matching segments. */
|
||||
format_first_only = format_no_copy << 1, /* Only replace first occurance. */
|
||||
format_is_if = format_first_only << 1, /* internal use only. */
|
||||
format_literal = format_is_if << 1 /* treat string as a literal */
|
||||
|
||||
} match_flags;
|
||||
|
||||
#if defined(__BORLANDC__) || BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
|
||||
typedef unsigned long match_flag_type;
|
||||
#else
|
||||
typedef match_flags match_flag_type;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
inline match_flags operator&(match_flags m1, match_flags m2)
|
||||
{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
|
||||
inline match_flags operator|(match_flags m1, match_flags m2)
|
||||
{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
|
||||
inline match_flags operator^(match_flags m1, match_flags m2)
|
||||
{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
|
||||
inline match_flags operator~(match_flags m1)
|
||||
{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
|
||||
inline match_flags& operator&=(match_flags& m1, match_flags m2)
|
||||
{ m1 = m1&m2; return m1; }
|
||||
inline match_flags& operator|=(match_flags& m1, match_flags m2)
|
||||
{ m1 = m1|m2; return m1; }
|
||||
inline match_flags& operator^=(match_flags& m1, match_flags m2)
|
||||
{ m1 = m1^m2; return m1; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* namespace regex_constants */
|
||||
/*
|
||||
* import names into boost for backwards compatiblity:
|
||||
*/
|
||||
using regex_constants::match_flag_type;
|
||||
using regex_constants::match_default;
|
||||
using regex_constants::match_not_bol;
|
||||
using regex_constants::match_not_eol;
|
||||
using regex_constants::match_not_bob;
|
||||
using regex_constants::match_not_eob;
|
||||
using regex_constants::match_not_bow;
|
||||
using regex_constants::match_not_eow;
|
||||
using regex_constants::match_not_dot_newline;
|
||||
using regex_constants::match_not_dot_null;
|
||||
using regex_constants::match_prev_avail;
|
||||
/* using regex_constants::match_init; */
|
||||
using regex_constants::match_any;
|
||||
using regex_constants::match_not_null;
|
||||
using regex_constants::match_continuous;
|
||||
using regex_constants::match_partial;
|
||||
/*using regex_constants::match_stop; */
|
||||
using regex_constants::match_all;
|
||||
using regex_constants::match_perl;
|
||||
using regex_constants::match_posix;
|
||||
using regex_constants::match_nosubs;
|
||||
using regex_constants::match_extra;
|
||||
using regex_constants::match_single_line;
|
||||
/*using regex_constants::match_max; */
|
||||
using regex_constants::format_all;
|
||||
using regex_constants::format_sed;
|
||||
using regex_constants::format_perl;
|
||||
using regex_constants::format_default;
|
||||
using regex_constants::format_no_copy;
|
||||
using regex_constants::format_first_only;
|
||||
/*using regex_constants::format_is_if;*/
|
||||
|
||||
} /* namespace boost */
|
||||
#endif /* __cplusplus */
|
||||
#endif /* include guard */
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0)
|
||||
#include <boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp>
|
||||
#endif
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_EXPR_MAKE_ARG(Z, M, DATA) \
|
||||
detail::as_lvalue( \
|
||||
typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_gcc_workaround.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_gcc_workaround.hpp
|
||||
/// Special workaround code to make the make\<\> transform work on certain
|
||||
/// versions of gcc.
|
||||
//
|
||||
// Copyright 2008 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) || \
|
||||
(defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES))
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make_gcc_workaround.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_EXPR_MAKE_ARG
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
// work around GCC bug
|
||||
template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
: transform<make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> >
|
||||
{
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl : transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef proto::expr<Tag, Args, Arity> result_type;
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
result_type operator ()(
|
||||
typename impl::expr_param e
|
||||
, typename impl::state_param s
|
||||
, typename impl::data_param d
|
||||
) const
|
||||
{
|
||||
return proto::expr<Tag, Args, Arity>::make(
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA)
|
||||
);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
: transform<make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> >
|
||||
{
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl : transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef proto::basic_expr<Tag, Args, Arity> result_type;
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
result_type operator ()(
|
||||
typename impl::expr_param e
|
||||
, typename impl::state_param s
|
||||
, typename impl::data_param d
|
||||
) const
|
||||
{
|
||||
return proto::basic_expr<Tag, Args, Arity>::make(
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA)
|
||||
);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,179 @@
|
||||
|
||||
// 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/vector/vector30.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20
|
||||
>
|
||||
struct vector21
|
||||
: v_item<
|
||||
T20
|
||||
, vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >
|
||||
>
|
||||
{
|
||||
typedef vector21 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21
|
||||
>
|
||||
struct vector22
|
||||
: v_item<
|
||||
T21
|
||||
, vector21< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 >
|
||||
>
|
||||
{
|
||||
typedef vector22 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22
|
||||
>
|
||||
struct vector23
|
||||
: v_item<
|
||||
T22
|
||||
, vector22< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 >
|
||||
>
|
||||
{
|
||||
typedef vector23 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23
|
||||
>
|
||||
struct vector24
|
||||
: v_item<
|
||||
T23
|
||||
, vector23< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 >
|
||||
>
|
||||
{
|
||||
typedef vector24 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23, typename T24
|
||||
>
|
||||
struct vector25
|
||||
: v_item<
|
||||
T24
|
||||
, vector24< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 >
|
||||
>
|
||||
{
|
||||
typedef vector25 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23, typename T24
|
||||
, typename T25
|
||||
>
|
||||
struct vector26
|
||||
: v_item<
|
||||
T25
|
||||
, vector25< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 >
|
||||
>
|
||||
{
|
||||
typedef vector26 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23, typename T24
|
||||
, typename T25, typename T26
|
||||
>
|
||||
struct vector27
|
||||
: v_item<
|
||||
T26
|
||||
, vector26< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 >
|
||||
>
|
||||
{
|
||||
typedef vector27 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23, typename T24
|
||||
, typename T25, typename T26, typename T27
|
||||
>
|
||||
struct vector28
|
||||
: v_item<
|
||||
T27
|
||||
, vector27< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 >
|
||||
>
|
||||
{
|
||||
typedef vector28 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23, typename T24
|
||||
, typename T25, typename T26, typename T27, typename T28
|
||||
>
|
||||
struct vector29
|
||||
: v_item<
|
||||
T28
|
||||
, vector28< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 >
|
||||
>
|
||||
{
|
||||
typedef vector29 type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
, typename T20, typename T21, typename T22, typename T23, typename T24
|
||||
, typename T25, typename T26, typename T27, typename T28, typename T29
|
||||
>
|
||||
struct vector30
|
||||
: v_item<
|
||||
T29
|
||||
, vector29< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 >
|
||||
>
|
||||
{
|
||||
typedef vector30 type;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,39 @@
|
||||
# /* **************************************************************************
|
||||
# * *
|
||||
# * (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_REVERSE_HPP
|
||||
# define BOOST_PREPROCESSOR_SEQ_REVERSE_HPP
|
||||
#
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
# include <boost/preprocessor/facilities/empty.hpp>
|
||||
# include <boost/preprocessor/seq/fold_left.hpp>
|
||||
#
|
||||
# /* BOOST_PP_SEQ_REVERSE */
|
||||
#
|
||||
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
|
||||
# define BOOST_PP_SEQ_REVERSE(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)()
|
||||
# else
|
||||
# define BOOST_PP_SEQ_REVERSE(seq) BOOST_PP_SEQ_REVERSE_I(seq)
|
||||
# define BOOST_PP_SEQ_REVERSE_I(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)()
|
||||
# endif
|
||||
#
|
||||
# define BOOST_PP_SEQ_REVERSE_O(s, state, elem) (elem) state
|
||||
#
|
||||
# /* BOOST_PP_SEQ_REVERSE_S */
|
||||
#
|
||||
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
|
||||
# define BOOST_PP_SEQ_REVERSE_S(s, seq) BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)()
|
||||
# else
|
||||
# define BOOST_PP_SEQ_REVERSE_S(s, seq) BOOST_PP_SEQ_REVERSE_S_I(s, seq)
|
||||
# define BOOST_PP_SEQ_REVERSE_S_I(s, seq) BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)()
|
||||
# endif
|
||||
#
|
||||
# endif
|
||||
@@ -0,0 +1,72 @@
|
||||
// This header intentionally has no include guards.
|
||||
//
|
||||
// Copyright (c) 2010 Neil Groves
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
// This code utilises the experience gained during the evolution of
|
||||
// <boost/smart_ptr/operator_bool.hpp>
|
||||
#ifndef BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
|
||||
#define BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/range/config.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
|
||||
template<class DataMemberPtr>
|
||||
class safe_bool
|
||||
{
|
||||
public:
|
||||
typedef safe_bool this_type;
|
||||
|
||||
#if (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570)) || defined(__CINT_)
|
||||
typedef bool unspecified_bool_type;
|
||||
static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
#elif defined(_MANAGED)
|
||||
static void unspecified_bool(this_type***)
|
||||
{
|
||||
}
|
||||
typedef void(*unspecified_bool_type)(this_type***);
|
||||
static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
|
||||
{
|
||||
return x ? unspecified_bool : 0;
|
||||
}
|
||||
#elif \
|
||||
( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
|
||||
( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
|
||||
( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
|
||||
|
||||
typedef bool (this_type::*unspecified_bool_type)() const;
|
||||
|
||||
static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
|
||||
{
|
||||
return x ? &this_type::detail_safe_bool_member_fn : 0;
|
||||
}
|
||||
private:
|
||||
bool detail_safe_bool_member_fn() const { return false; }
|
||||
#else
|
||||
typedef DataMemberPtr unspecified_bool_type;
|
||||
static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr p)
|
||||
{
|
||||
return x ? p : 0;
|
||||
}
|
||||
#endif
|
||||
private:
|
||||
safe_bool();
|
||||
safe_bool(const safe_bool&);
|
||||
void operator=(const safe_bool&);
|
||||
~safe_bool();
|
||||
};
|
||||
|
||||
} // namespace range_detail
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
@@ -0,0 +1,321 @@
|
||||
// Copyright John Maddock 2012.
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_MATH_JACOBI_ELLIPTIC_HPP
|
||||
#define BOOST_MATH_JACOBI_ELLIPTIC_HPP
|
||||
|
||||
#include <boost/math/tools/precision.hpp>
|
||||
#include <boost/math/tools/promotion.hpp>
|
||||
#include <boost/math/policies/error_handling.hpp>
|
||||
#include <boost/math/special_functions/math_fwd.hpp>
|
||||
|
||||
namespace boost{ namespace math{
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <class T, class Policy>
|
||||
T jacobi_recurse(const T& x, const T& k, T anm1, T bnm1, unsigned N, T* pTn, const Policy& pol)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
++N;
|
||||
T Tn;
|
||||
T cn = (anm1 - bnm1) / 2;
|
||||
T an = (anm1 + bnm1) / 2;
|
||||
if(cn < policies::get_epsilon<T, Policy>())
|
||||
{
|
||||
Tn = ldexp(T(1), (int)N) * x * an;
|
||||
}
|
||||
else
|
||||
Tn = jacobi_recurse<T>(x, k, an, sqrt(anm1 * bnm1), N, 0, pol);
|
||||
if(pTn)
|
||||
*pTn = Tn;
|
||||
return (Tn + asin((cn / an) * sin(Tn))) / 2;
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
T jacobi_imp(const T& x, const T& k, T* cn, T* dn, const Policy& pol, const char* function)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
if(k < 0)
|
||||
{
|
||||
*cn = policies::raise_domain_error<T>(function, "Modulus k must be positive but got %1%.", k, pol);
|
||||
*dn = *cn;
|
||||
return *cn;
|
||||
}
|
||||
if(k > 1)
|
||||
{
|
||||
T xp = x * k;
|
||||
T kp = 1 / k;
|
||||
T snp, cnp, dnp;
|
||||
snp = jacobi_imp(xp, kp, &cnp, &dnp, pol, function);
|
||||
*cn = dnp;
|
||||
*dn = cnp;
|
||||
return snp * kp;
|
||||
}
|
||||
//
|
||||
// Special cases first:
|
||||
//
|
||||
if(x == 0)
|
||||
{
|
||||
*cn = *dn = 1;
|
||||
return 0;
|
||||
}
|
||||
if(k == 0)
|
||||
{
|
||||
*cn = cos(x);
|
||||
*dn = 1;
|
||||
return sin(x);
|
||||
}
|
||||
if(k == 1)
|
||||
{
|
||||
*cn = *dn = 1 / cosh(x);
|
||||
return tanh(x);
|
||||
}
|
||||
//
|
||||
// Asymptotic forms from A&S 16.13:
|
||||
//
|
||||
if(k < tools::forth_root_epsilon<T>())
|
||||
{
|
||||
T su = sin(x);
|
||||
T cu = cos(x);
|
||||
T m = k * k;
|
||||
*dn = 1 - m * su * su / 2;
|
||||
*cn = cu + m * (x - su * cu) * su / 4;
|
||||
return su - m * (x - su * cu) * cu / 4;
|
||||
}
|
||||
/* Can't get this to work to adequate precision - disabled for now...
|
||||
//
|
||||
// Asymptotic forms from A&S 16.15:
|
||||
//
|
||||
if(k > 1 - tools::root_epsilon<T>())
|
||||
{
|
||||
T tu = tanh(x);
|
||||
T su = sinh(x);
|
||||
T cu = cosh(x);
|
||||
T sec = 1 / cu;
|
||||
T kp = 1 - k;
|
||||
T m1 = 2 * kp - kp * kp;
|
||||
*dn = sec + m1 * (su * cu + x) * tu * sec / 4;
|
||||
*cn = sec - m1 * (su * cu - x) * tu * sec / 4;
|
||||
T sn = tu;
|
||||
T sn2 = m1 * (x * sec * sec - tu) / 4;
|
||||
T sn3 = (72 * x * cu + 4 * (8 * x * x - 5) * su - 19 * sinh(3 * x) + sinh(5 * x)) * sec * sec * sec * m1 * m1 / 512;
|
||||
return sn + sn2 - sn3;
|
||||
}*/
|
||||
T T1;
|
||||
T kc = 1 - k;
|
||||
T k_prime = k < 0.5 ? T(sqrt(1 - k * k)) : T(sqrt(2 * kc - kc * kc));
|
||||
T T0 = jacobi_recurse(x, k, T(1), k_prime, 0, &T1, pol);
|
||||
*cn = cos(T0);
|
||||
*dn = cos(T0) / cos(T1 - T0);
|
||||
return sin(T0);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T, class U, class V, class Policy>
|
||||
inline typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&)
|
||||
{
|
||||
BOOST_FPU_EXCEPTION_GUARD
|
||||
typedef typename tools::promote_args<T>::type result_type;
|
||||
typedef typename policies::evaluation<result_type, Policy>::type value_type;
|
||||
typedef typename policies::normalise<
|
||||
Policy,
|
||||
policies::promote_float<false>,
|
||||
policies::promote_double<false>,
|
||||
policies::discrete_quantile<>,
|
||||
policies::assert_undefined<> >::type forwarding_policy;
|
||||
|
||||
static const char* function = "boost::math::jacobi_elliptic<%1%>(%1%)";
|
||||
|
||||
value_type sn, cn, dn;
|
||||
sn = detail::jacobi_imp<value_type>(static_cast<value_type>(theta), static_cast<value_type>(k), &cn, &dn, forwarding_policy(), function);
|
||||
if(pcn)
|
||||
*pcn = policies::checked_narrowing_cast<result_type, Policy>(cn, function);
|
||||
if(pdn)
|
||||
*pdn = policies::checked_narrowing_cast<result_type, Policy>(dn, function);
|
||||
return policies::checked_narrowing_cast<result_type, Policy>(sn, function);;
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn)
|
||||
{
|
||||
return jacobi_elliptic(k, theta, pcn, pdn, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class U, class T, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
return jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(0), static_cast<result_type*>(0), pol);
|
||||
}
|
||||
|
||||
template <class U, class T>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta)
|
||||
{
|
||||
return jacobi_sn(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type cn;
|
||||
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, static_cast<result_type*>(0), pol);
|
||||
return cn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta)
|
||||
{
|
||||
return jacobi_cn(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type dn;
|
||||
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(0), &dn, pol);
|
||||
return dn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta)
|
||||
{
|
||||
return jacobi_dn(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type cn, dn;
|
||||
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, &dn, pol);
|
||||
return cn / dn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta)
|
||||
{
|
||||
return jacobi_cd(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type cn, dn;
|
||||
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, &dn, pol);
|
||||
return dn / cn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta)
|
||||
{
|
||||
return jacobi_dc(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
return 1 / jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(0), static_cast<result_type*>(0), pol);
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta)
|
||||
{
|
||||
return jacobi_ns(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type sn, dn;
|
||||
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(0), &dn, pol);
|
||||
return sn / dn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta)
|
||||
{
|
||||
return jacobi_sd(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type sn, dn;
|
||||
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(0), &dn, pol);
|
||||
return dn / sn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta)
|
||||
{
|
||||
return jacobi_ds(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta, const Policy& pol)
|
||||
{
|
||||
return 1 / jacobi_cn(k, theta, pol);
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta)
|
||||
{
|
||||
return jacobi_nc(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta, const Policy& pol)
|
||||
{
|
||||
return 1 / jacobi_dn(k, theta, pol);
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta)
|
||||
{
|
||||
return jacobi_nd(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type sn, cn;
|
||||
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, static_cast<result_type*>(0), pol);
|
||||
return sn / cn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta)
|
||||
{
|
||||
return jacobi_sc(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class T, class U, class Policy>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<T, U>::type result_type;
|
||||
result_type sn, cn;
|
||||
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, static_cast<result_type*>(0), pol);
|
||||
return cn / sn;
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
inline typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta)
|
||||
{
|
||||
return jacobi_cs(k, theta, policies::policy<>());
|
||||
}
|
||||
|
||||
}} // namespaces
|
||||
|
||||
#endif // BOOST_MATH_JACOBI_ELLIPTIC_HPP
|
||||
@@ -0,0 +1,323 @@
|
||||
|
||||
// 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/set.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
|
||||
, typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
|
||||
, typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
|
||||
, typename T12 = na, typename T13 = na, typename T14 = na
|
||||
, typename T15 = na, typename T16 = na, typename T17 = na
|
||||
, typename T18 = na, typename T19 = na
|
||||
>
|
||||
struct set;
|
||||
|
||||
template<
|
||||
|
||||
>
|
||||
struct set<
|
||||
na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set0< >
|
||||
{
|
||||
typedef set0< >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0
|
||||
>
|
||||
struct set<
|
||||
T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set1<T0>
|
||||
{
|
||||
typedef typename set1<T0>::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1
|
||||
>
|
||||
struct set<
|
||||
T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set2< T0,T1 >
|
||||
{
|
||||
typedef typename set2< T0,T1 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set3< T0,T1,T2 >
|
||||
{
|
||||
typedef typename set3< T0,T1,T2 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set4< T0,T1,T2,T3 >
|
||||
{
|
||||
typedef typename set4< T0,T1,T2,T3 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set5< T0,T1,T2,T3,T4 >
|
||||
{
|
||||
typedef typename set5< T0,T1,T2,T3,T4 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set6< T0,T1,T2,T3,T4,T5 >
|
||||
{
|
||||
typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set7< T0,T1,T2,T3,T4,T5,T6 >
|
||||
{
|
||||
typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set8< T0,T1,T2,T3,T4,T5,T6,T7 >
|
||||
{
|
||||
typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
|
||||
{
|
||||
typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
|
||||
{
|
||||
typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
|
||||
, na, na, na
|
||||
>
|
||||
: set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
|
||||
{
|
||||
typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
|
||||
, na, na, na, na
|
||||
>
|
||||
: set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
|
||||
{
|
||||
typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
|
||||
, na, na, na, na
|
||||
>
|
||||
: set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
|
||||
{
|
||||
typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
|
||||
, na, na, na, na
|
||||
>
|
||||
: set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
|
||||
{
|
||||
typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
|
||||
, na, na, na, na
|
||||
>
|
||||
: set15<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
>
|
||||
{
|
||||
typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, na, na, na, na
|
||||
>
|
||||
: set16<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15
|
||||
>
|
||||
{
|
||||
typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16, na, na, na
|
||||
>
|
||||
: set17<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16
|
||||
>
|
||||
{
|
||||
typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16, T17, na, na
|
||||
>
|
||||
: set18<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16, T17
|
||||
>
|
||||
{
|
||||
typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18
|
||||
>
|
||||
struct set<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16, T17, T18, na
|
||||
>
|
||||
: set19<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16, T17, T18
|
||||
>
|
||||
{
|
||||
typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
|
||||
};
|
||||
|
||||
/// primary template (not a specialization!)
|
||||
|
||||
template<
|
||||
typename T0, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5, typename T6, typename T7, typename T8, typename T9
|
||||
, typename T10, typename T11, typename T12, typename T13, typename T14
|
||||
, typename T15, typename T16, typename T17, typename T18, typename T19
|
||||
>
|
||||
struct set
|
||||
: set20<
|
||||
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
|
||||
, T15, T16, T17, T18, T19
|
||||
>
|
||||
{
|
||||
typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
// tuple_comparison.hpp -----------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.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)
|
||||
//
|
||||
// For more information, see http://www.boost.org
|
||||
//
|
||||
// (The idea and first impl. of comparison operators was from Doug Gregor)
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_COMPARISON_HPP
|
||||
#define BOOST_TUPLE_COMPARISON_HPP
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// equality and comparison operators
|
||||
//
|
||||
// == and != compare tuples elementwise
|
||||
// <, >, <= and >= use lexicographical ordering
|
||||
//
|
||||
// Any operator between tuples of different length fails at compile time
|
||||
// No dependencies between operators are assumed
|
||||
// (i.e. !(a<b) does not imply a>=b, a!=b does not imply a==b etc.
|
||||
// so any weirdnesses of elementary operators are respected).
|
||||
//
|
||||
// -------------------------------------------------------------
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
inline bool operator==(const null_type&, const null_type&) { return true; }
|
||||
inline bool operator>=(const null_type&, const null_type&) { return true; }
|
||||
inline bool operator<=(const null_type&, const null_type&) { return true; }
|
||||
inline bool operator!=(const null_type&, const null_type&) { return false; }
|
||||
inline bool operator<(const null_type&, const null_type&) { return false; }
|
||||
inline bool operator>(const null_type&, const null_type&) { return false; }
|
||||
|
||||
|
||||
namespace detail {
|
||||
// comparison operators check statically the length of its operands and
|
||||
// delegate the comparing task to the following functions. Hence
|
||||
// the static check is only made once (should help the compiler).
|
||||
// These functions assume tuples to be of the same length.
|
||||
|
||||
|
||||
template<class T1, class T2>
|
||||
inline bool eq(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() == rhs.get_head() &&
|
||||
eq(lhs.get_tail(), rhs.get_tail());
|
||||
}
|
||||
template<>
|
||||
inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
|
||||
|
||||
template<class T1, class T2>
|
||||
inline bool neq(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() != rhs.get_head() ||
|
||||
neq(lhs.get_tail(), rhs.get_tail());
|
||||
}
|
||||
template<>
|
||||
inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
|
||||
|
||||
template<class T1, class T2>
|
||||
inline bool lt(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() < rhs.get_head() ||
|
||||
( !(rhs.get_head() < lhs.get_head()) &&
|
||||
lt(lhs.get_tail(), rhs.get_tail()));
|
||||
}
|
||||
template<>
|
||||
inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
|
||||
|
||||
template<class T1, class T2>
|
||||
inline bool gt(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() > rhs.get_head() ||
|
||||
( !(rhs.get_head() > lhs.get_head()) &&
|
||||
gt(lhs.get_tail(), rhs.get_tail()));
|
||||
}
|
||||
template<>
|
||||
inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
|
||||
|
||||
template<class T1, class T2>
|
||||
inline bool lte(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() <= rhs.get_head() &&
|
||||
( !(rhs.get_head() <= lhs.get_head()) ||
|
||||
lte(lhs.get_tail(), rhs.get_tail()));
|
||||
}
|
||||
template<>
|
||||
inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
|
||||
|
||||
template<class T1, class T2>
|
||||
inline bool gte(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() >= rhs.get_head() &&
|
||||
( !(rhs.get_head() >= lhs.get_head()) ||
|
||||
gte(lhs.get_tail(), rhs.get_tail()));
|
||||
}
|
||||
template<>
|
||||
inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
|
||||
// equal ----
|
||||
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::eq(lhs, rhs);
|
||||
}
|
||||
|
||||
// not equal -----
|
||||
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::neq(lhs, rhs);
|
||||
}
|
||||
|
||||
// <
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::lt(lhs, rhs);
|
||||
}
|
||||
|
||||
// >
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::gt(lhs, rhs);
|
||||
}
|
||||
|
||||
// <=
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::lte(lhs, rhs);
|
||||
}
|
||||
|
||||
// >=
|
||||
template<class T1, class T2, class S1, class S2>
|
||||
inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
|
||||
{
|
||||
// check that tuple lengths are equal
|
||||
BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
|
||||
|
||||
return detail::gte(lhs, rhs);
|
||||
}
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_TUPLE_COMPARISON_HPP
|
||||
@@ -0,0 +1,138 @@
|
||||
program ldpcsim
|
||||
|
||||
use, intrinsic :: iso_c_binding
|
||||
use hashing
|
||||
use packjt
|
||||
|
||||
character*22 msg,msgsent,msgreceived
|
||||
character*8 arg
|
||||
integer*1, allocatable :: codeword(:), decoded(:), message(:)
|
||||
real*8, allocatable :: rxdata(:), rxavgd(:)
|
||||
real, allocatable :: llr(:)
|
||||
integer ihash
|
||||
integer*1 hardbits(32)
|
||||
|
||||
nargs=iargc()
|
||||
if(nargs.ne.4) then
|
||||
print*,'Usage: ldpcsim niter navg #trials s '
|
||||
print*,'eg: ldpcsim 10 1 1000 0.75'
|
||||
return
|
||||
endif
|
||||
call getarg(1,arg)
|
||||
read(arg,*) max_iterations
|
||||
call getarg(2,arg)
|
||||
read(arg,*) navg
|
||||
call getarg(3,arg)
|
||||
read(arg,*) ntrials
|
||||
call getarg(4,arg)
|
||||
read(arg,*) s
|
||||
|
||||
K=16
|
||||
N=32
|
||||
!rate=real(K)/real(N)
|
||||
! don't count hash bits as data bits
|
||||
rate=4.0/real(N)
|
||||
write(*,*) "rate: ",rate
|
||||
write(*,*) "niter= ",max_iterations,"navg= ",navg," s= ",s
|
||||
|
||||
allocate ( codeword(N), decoded(K), message(K) )
|
||||
allocate ( rxdata(N), rxavgd(N), llr(N) )
|
||||
|
||||
msg="K1JT K9AN"
|
||||
call fmtmsg(msg,iz)
|
||||
call hash(msg,22,ihash)
|
||||
irpt=14
|
||||
ihash=iand(ihash,4095) !12-bit hash
|
||||
ig=16*ihash + irpt !4-bit report
|
||||
write(*,*) irpt,ihash,ig
|
||||
|
||||
do i=1,16
|
||||
message(i)=iand(1,ishft(ig,1-i))
|
||||
enddo
|
||||
write(*,'(16i1)') message
|
||||
call encode_msk40(message,codeword)
|
||||
write(*,'(32i1)') codeword
|
||||
call init_random_seed()
|
||||
|
||||
write(*,*) "Eb/N0 SNR2500 ngood nundetected nbadhash"
|
||||
do idb = 0, 30
|
||||
db=idb/2.0
|
||||
sigma=1/sqrt( 2*rate*(10**(db/10.0)) )
|
||||
ngood=0
|
||||
nue=0
|
||||
nbadhash=0
|
||||
|
||||
itsum=0
|
||||
do itrial=1, ntrials
|
||||
rxavgd=0d0
|
||||
do iav=1,navg
|
||||
call sgran()
|
||||
! Create a realization of a noisy received word
|
||||
do i=1,N
|
||||
rxdata(i) = 2.0*codeword(i)-1.0 + sigma*gran()
|
||||
enddo
|
||||
rxavgd=rxavgd+rxdata
|
||||
enddo
|
||||
rxdata=rxavgd
|
||||
|
||||
! Correct signal normalization is important for this decoder.
|
||||
rxav=sum(rxdata)/N
|
||||
rx2av=sum(rxdata*rxdata)/N
|
||||
rxsig=sqrt(rx2av-rxav*rxav)
|
||||
rxdata=rxdata/rxsig
|
||||
if( s .le. 0 ) then
|
||||
ss=sigma
|
||||
else
|
||||
ss=s
|
||||
endif
|
||||
|
||||
llr=2.0*rxdata/(ss*ss)
|
||||
|
||||
call bpdecode40(llr, max_iterations, decoded, niterations)
|
||||
! If the decoder finds a valid codeword, niterations will be .ge. 0.
|
||||
if( niterations .ge. 0 ) then
|
||||
nueflag=0
|
||||
nhashflag=0
|
||||
imsg=0
|
||||
do i=1,16
|
||||
imsg=ishft(imsg,1)+iand(1,decoded(17-i))
|
||||
enddo
|
||||
nrxrpt=iand(imsg,15)
|
||||
nrxhash=(imsg-nrxrpt)/16
|
||||
if( nrxhash .ne. ihash ) then
|
||||
nbadhash=nbadhash+1
|
||||
nhashflag=1
|
||||
endif
|
||||
|
||||
! Check the message plus hash against what was sent.
|
||||
do i=1,K
|
||||
if( message(i) .ne. decoded(i) ) then
|
||||
nueflag=1
|
||||
endif
|
||||
enddo
|
||||
|
||||
if( nhashflag .eq. 0 .and. nueflag .eq. 0 ) then
|
||||
ngood=ngood+1
|
||||
itsum=itsum+niterations
|
||||
else if( nhashflag .eq. 0 .and. nueflag .eq. 1 ) then
|
||||
nue=nue+1;
|
||||
endif
|
||||
else
|
||||
hardbits=0
|
||||
where(llr .gt. 0) hardbits=1
|
||||
! write(*,'(32i1)') hardbits
|
||||
! write(*,'(32i1)') codeword
|
||||
isum=0
|
||||
do i=1,32
|
||||
if( hardbits(i) .ne. codeword(i) ) isum=isum+1
|
||||
enddo
|
||||
! write(*,*) 'number of errors ',isum
|
||||
endif
|
||||
enddo
|
||||
avits=real(itsum)/real(ngood+0.1)
|
||||
snr2500=db-10.0
|
||||
write(*,"(f4.1,4x,f5.1,1x,i8,1x,i8,1x,i8,1x,f8.2,1x,f8.1)") db,snr2500,ngood,nue,nbadhash,ss,avits
|
||||
|
||||
enddo
|
||||
|
||||
end program ldpcsim
|
||||
@@ -0,0 +1,48 @@
|
||||
// timers.hpp --------------------------------------------------------------//
|
||||
|
||||
// Copyright 2010 Vicente J. Botet Escriba
|
||||
// Copyright 2015 Andrey Semashev
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
|
||||
#ifndef BOOST_DETAIL_WINAPI_TIMERS_HPP
|
||||
#define BOOST_DETAIL_WINAPI_TIMERS_HPP
|
||||
|
||||
#include <boost/detail/winapi/basic_types.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#if !defined( BOOST_USE_WINDOWS_H )
|
||||
extern "C" {
|
||||
BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI
|
||||
QueryPerformanceCounter(::_LARGE_INTEGER* lpPerformanceCount);
|
||||
|
||||
BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI
|
||||
QueryPerformanceFrequency(::_LARGE_INTEGER* lpFrequency);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace winapi {
|
||||
|
||||
BOOST_FORCEINLINE BOOL_ QueryPerformanceCounter(LARGE_INTEGER_* lpPerformanceCount)
|
||||
{
|
||||
return ::QueryPerformanceCounter(reinterpret_cast< ::_LARGE_INTEGER* >(lpPerformanceCount));
|
||||
}
|
||||
|
||||
BOOST_FORCEINLINE BOOL_ QueryPerformanceFrequency(LARGE_INTEGER_* lpFrequency)
|
||||
{
|
||||
return ::QueryPerformanceFrequency(reinterpret_cast< ::_LARGE_INTEGER* >(lpFrequency));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // BOOST_DETAIL_WINAPI_TIMERS_HPP
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
@@ -0,0 +1,139 @@
|
||||
/*==============================================================================
|
||||
Copyright (c) 2001-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_CORE_VALUE_HPP
|
||||
#define BOOST_PHOENIX_CORE_VALUE_HPP
|
||||
|
||||
#include <boost/phoenix/core/limits.hpp>
|
||||
#include <boost/phoenix/core/actor.hpp>
|
||||
#include <boost/phoenix/core/as_actor.hpp>
|
||||
#include <boost/phoenix/core/terminal.hpp>
|
||||
#include <boost/phoenix/core/is_value.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
namespace boost { namespace phoenix
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// values
|
||||
//
|
||||
// function for evaluating values, e.g. val(123)
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace expression
|
||||
{
|
||||
template <typename T>
|
||||
struct value
|
||||
: expression::terminal<T>
|
||||
{
|
||||
typedef
|
||||
typename expression::terminal<T>::type
|
||||
type;
|
||||
/*
|
||||
static const type make(T & t)
|
||||
{
|
||||
typename value<T>::type const e = {{t}};
|
||||
return e;
|
||||
}
|
||||
*/
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline
|
||||
typename expression::value<T>::type const
|
||||
val(T t)
|
||||
{
|
||||
return expression::value<T>::make(t);
|
||||
}
|
||||
|
||||
// Identifies this Expr as a value.
|
||||
// I think this is wrong. It is identifying all actors as values.
|
||||
// Yes, it is giving false positives and needs a rethink.
|
||||
// And this gives no positives.
|
||||
//template <typename T>
|
||||
//struct is_value<expression::value<T> >
|
||||
// : mpl::true_
|
||||
//{};
|
||||
|
||||
// Call out actor for special handling
|
||||
// Is this correct? It applies to any actor.
|
||||
// In which case why is it here?
|
||||
template<typename Expr>
|
||||
struct is_custom_terminal<actor<Expr> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
// Special handling for actor
|
||||
template<typename Expr>
|
||||
struct custom_terminal<actor<Expr> >
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename Actor, typename Context>
|
||||
struct result<This(Actor, Context)>
|
||||
: boost::remove_const<
|
||||
typename boost::remove_reference<
|
||||
typename evaluator::impl<Actor, Context, proto::empty_env>::result_type
|
||||
>::type
|
||||
>
|
||||
{};
|
||||
|
||||
template <typename Context>
|
||||
typename result<custom_terminal(actor<Expr> const &, Context &)>::type
|
||||
operator()(actor<Expr> const & expr, Context & ctx) const
|
||||
{
|
||||
typedef typename result<custom_terminal(actor<Expr> const &, Context &)>::type result_type;
|
||||
result_type r = boost::phoenix::eval(expr, ctx);
|
||||
// std::cout << "Evaluating val() = " << r << std::endl;
|
||||
return r;
|
||||
}
|
||||
};
|
||||
|
||||
namespace meta
|
||||
{
|
||||
template<typename T>
|
||||
struct const_ref
|
||||
: add_reference<typename add_const<T>::type>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct argument_type
|
||||
: mpl::eval_if_c<
|
||||
is_function<typename remove_pointer<T>::type>::value
|
||||
, mpl::identity<T>
|
||||
, const_ref<T>
|
||||
>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct decay
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
template <typename T, int N>
|
||||
struct decay<T[N]> : decay<T const *> {};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct as_actor<T, mpl::false_>
|
||||
{
|
||||
typedef typename expression::value<typename meta::decay<T>::type >::type type;
|
||||
|
||||
static type
|
||||
convert(typename meta::argument_type<typename meta::decay<T>::type>::type t)
|
||||
{
|
||||
return expression::value<typename meta::decay<T>::type >::make(t);
|
||||
}
|
||||
};
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,148 @@
|
||||
// Copyright (C) 2013,2014 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)
|
||||
//
|
||||
// 2013/09 Vicente J. Botet Escriba
|
||||
// Adapt to boost from CCIA C++11 implementation
|
||||
|
||||
#ifndef BOOST_THREAD_EXECUTORS_EXECUTOR_HPP
|
||||
#define BOOST_THREAD_EXECUTORS_EXECUTOR_HPP
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
#include <boost/thread/detail/delete.hpp>
|
||||
#include <boost/thread/detail/move.hpp>
|
||||
#include <boost/thread/executors/work.hpp>
|
||||
|
||||
#include <boost/config/abi_prefix.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace executors
|
||||
{
|
||||
class executor
|
||||
{
|
||||
public:
|
||||
/// type-erasure to store the works to do
|
||||
typedef executors::work work;
|
||||
|
||||
/// executor is not copyable.
|
||||
BOOST_THREAD_NO_COPYABLE(executor)
|
||||
executor() {}
|
||||
|
||||
/**
|
||||
* \par Effects
|
||||
* Destroys the executor.
|
||||
*
|
||||
* \par Synchronization
|
||||
* The completion of all the closures happen before the completion of the executor destructor.
|
||||
*/
|
||||
virtual ~executor() {};
|
||||
|
||||
/**
|
||||
* \par Effects
|
||||
* Close the \c executor for submissions.
|
||||
* The worker threads will work until there is no more closures to run.
|
||||
*/
|
||||
virtual void close() = 0;
|
||||
|
||||
/**
|
||||
* \par Returns
|
||||
* Whether the pool is closed for submissions.
|
||||
*/
|
||||
virtual bool closed() = 0;
|
||||
|
||||
/**
|
||||
* \par Effects
|
||||
* The specified closure will be scheduled for execution at some point in the future.
|
||||
* If invoked closure throws an exception the executor will call std::terminate, as is the case with threads.
|
||||
*
|
||||
* \par Synchronization
|
||||
* Ccompletion of closure on a particular thread happens before destruction of thread's thread local variables.
|
||||
*
|
||||
* \par Throws
|
||||
* \c sync_queue_is_closed if the thread pool is closed.
|
||||
* Whatever exception that can be throw while storing the closure.
|
||||
*/
|
||||
virtual void submit(BOOST_THREAD_RV_REF(work) closure) = 0;
|
||||
// virtual void submit(work& closure) = 0;
|
||||
|
||||
/**
|
||||
* \par Requires
|
||||
* \c Closure is a model of Callable(void()) and a model of CopyConstructible/MoveConstructible.
|
||||
*
|
||||
* \par Effects
|
||||
* The specified closure will be scheduled for execution at some point in the future.
|
||||
* If invoked closure throws an exception the thread pool will call std::terminate, as is the case with threads.
|
||||
*
|
||||
* \par Synchronization
|
||||
* Completion of closure on a particular thread happens before destruction of thread's thread local variables.
|
||||
*
|
||||
* \par Throws
|
||||
* \c sync_queue_is_closed if the thread pool is closed.
|
||||
* Whatever exception that can be throw while storing the closure.
|
||||
*/
|
||||
|
||||
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename Closure>
|
||||
void submit(Closure & closure)
|
||||
{
|
||||
work w ((closure));
|
||||
submit(boost::move(w));
|
||||
}
|
||||
#endif
|
||||
void submit(void (*closure)())
|
||||
{
|
||||
work w ((closure));
|
||||
submit(boost::move(w));
|
||||
}
|
||||
|
||||
template <typename Closure>
|
||||
void submit(BOOST_THREAD_FWD_REF(Closure) closure)
|
||||
{
|
||||
//submit(work(boost::forward<Closure>(closure)));
|
||||
work w((boost::forward<Closure>(closure)));
|
||||
submit(boost::move(w));
|
||||
}
|
||||
|
||||
/**
|
||||
* \par Effects
|
||||
* Try to execute one task.
|
||||
*
|
||||
* \par Returns
|
||||
* Whether a task has been executed.
|
||||
*
|
||||
* \par Throws
|
||||
* Whatever the current task constructor throws or the task() throws.
|
||||
*/
|
||||
virtual bool try_executing_one() = 0;
|
||||
|
||||
/**
|
||||
* \par Requires
|
||||
* This must be called from an scheduled task.
|
||||
*
|
||||
* \par Effects
|
||||
* Reschedule functions until pred()
|
||||
*/
|
||||
template <typename Pred>
|
||||
bool reschedule_until(Pred const& pred)
|
||||
{
|
||||
do {
|
||||
//schedule_one_or_yield();
|
||||
if ( ! try_executing_one())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
} while (! pred());
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
using executors::executor;
|
||||
}
|
||||
|
||||
#include <boost/config/abi_suffix.hpp>
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user