git subrepo pull (merge) ore

subrepo:
  subdir:   "ore"
  merged:   "d129979793"
upstream:
  origin:   "git@gitlab.acadiasoft.net:qs/ore.git"
  branch:   "master"
  commit:   "81f0590c1f"
git-subrepo:
  version:  "0.4.6"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "110b9eb"

Author: jenkins

Docs/UserGuide/userguide.tex

@@ -17,3 +17,4 @@
 5) Run Example
 
    python run.py
+

Examples/Example_8/Readme.txt

@@ -71,7 +71,7 @@ Convention::Convention(const string& id, Type type) : type_(type), id_(id) {}
 
 const boost::shared_ptr<ore::data::Conventions>& InstrumentConventions::conventions(QuantLib::Date d) const {
     QL_REQUIRE(!conventions_.empty(), "InstrumentConventions: No conventions provided.");
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     Date dt = d == Date() ? Settings::instance().evaluationDate() : d;
     auto it = conventions_.lower_bound(dt);
     if(it != conventions_.end() && it->first == dt)
@@ -91,7 +91,7 @@ const boost::shared_ptr<ore::data::Conventions>& InstrumentConventions::conventi
 
 void InstrumentConventions::setConventions(
     const boost::shared_ptr<ore::data::Conventions>& conventions, QuantLib::Date d) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     conventions_[d] = conventions;
 }
 
@@ -2467,7 +2467,7 @@ void Conventions::fromXML(XMLNode* node) {
 }
 
 XMLNode* Conventions::toXML(XMLDocument& doc) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
 
     XMLNode* conventionsNode = doc.allocNode("Conventions");
 
@@ -2480,7 +2480,7 @@ XMLNode* Conventions::toXML(XMLDocument& doc) {
 }
 
 void Conventions::clear() const {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     data_.clear();
 }
 
@@ -2509,7 +2509,7 @@ std::string flip(const std::string& id, const std::string& sep = "-") {
 boost::shared_ptr<Convention> Conventions::get(const string& id) const {
 
     {
-        std::shared_lock<std::shared_mutex> lock(mutex_);
+        boost::shared_lock<boost::shared_mutex> lock(mutex_);
         if (auto it = data_.find(id); it != data_.end()) {
             used_.insert(id);
             return it->second;
@@ -2522,7 +2522,7 @@ boost::shared_ptr<Convention> Conventions::get(const string& id) const {
 
     std::string type, unparsed;
     {
-        std::unique_lock<std::shared_mutex> lock(mutex_);
+        boost::unique_lock<boost::shared_mutex> lock(mutex_);
         if (auto it = unparsed_.find(id); it != unparsed_.end()) {
             std::tie(type, unparsed) = it->second;
             unparsed_.erase(id);
@@ -2597,7 +2597,7 @@ boost::shared_ptr<Convention> Conventions::get(const string& id) const {
 }
 
 boost::shared_ptr<Convention> Conventions::getFxConvention(const string& ccy1, const string& ccy2) const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     for (auto c : data_) {
         auto fxCon = boost::dynamic_pointer_cast<FXConvention>(c.second);
         if (fxCon) {
@@ -2629,7 +2629,7 @@ std::set<boost::shared_ptr<Convention>> Conventions::get(const Convention::Type&
     std::set<std::string> unparsedIds;
     std::string typeStr = ore::data::to_string(type);
     {
-        std::shared_lock<std::shared_mutex> lock(mutex_);
+        boost::shared_lock<boost::shared_mutex> lock(mutex_);
         for (auto const& d : data_) {
             if (d.second->type() == type) {
                 used_.insert(d.first);
@@ -2653,7 +2653,7 @@ bool Conventions::has(const string& id) const {
     } catch (const std::exception& e) {
         return false;
     }
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     return data_.find(id) != data_.end() || unparsed_.find(id) != unparsed_.end() ||
            data_.find(flip(id)) != data_.end() || unparsed_.find(flip(id)) != unparsed_.end();
 }
@@ -2663,7 +2663,7 @@ bool Conventions::has(const std::string& id, const Convention::Type& type) const
 }
 
 void Conventions::add(const boost::shared_ptr<Convention>& convention) const {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     const string& id = convention->id();
     QL_REQUIRE(data_.find(id) == data_.end(), "Convention already exists for id " << id);
     data_[id] = convention;

OREData/ored/configuration/conventions.cpp

@@ -36,8 +36,8 @@
 #include <qle/indexes/bmaindexwrapper.hpp>
 #include <qle/indexes/commodityindex.hpp>
 
-#include <shared_mutex>
-
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/lock_types.hpp>
 
 namespace ore {
 namespace data {
@@ -154,7 +154,7 @@ class Conventions : public XMLSerializable {
     mutable map<string, boost::shared_ptr<Convention>> data_;
     mutable map<string, std::pair<string, string>> unparsed_;
     mutable std::set<string> used_;
-    mutable std::shared_mutex mutex_;
+    mutable boost::shared_mutex mutex_;
 };
 
 //! Singleton to hold conventions
@@ -166,7 +166,7 @@ class InstrumentConventions : public QuantLib::Singleton<InstrumentConventions,
     InstrumentConventions() { conventions_[Date()] = boost::make_shared<ore::data::Conventions>(); }
 
     mutable std::map<QuantLib::Date, boost::shared_ptr<ore::data::Conventions>> conventions_;
-    mutable std::shared_mutex mutex_;
+    mutable boost::shared_mutex mutex_;
     mutable std::size_t numberOfEmittedWarnings_ = 0;
 
 public:

OREData/ored/configuration/conventions.hpp

@@ -48,7 +48,7 @@
 #include <qle/termstructures/creditvolcurve.hpp>
 #include <qle/termstructures/pricetermstructure.hpp>
 
-#include <shared_mutex>
+#include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/locks.hpp>
 
 namespace ore {
@@ -130,16 +130,16 @@ class GlobalPseudoCurrencyMarketParameters
 
 public:
     const PseudoCurrencyMarketParameters& get() const {
-        std::shared_lock<std::shared_mutex> lock(mutex_);
+        boost::shared_lock<boost::shared_mutex> lock(mutex_);
         return params_;
     }
 
     void set(const PseudoCurrencyMarketParameters& params) {
-        std::unique_lock<std::shared_mutex> lock(mutex_);
+        boost::unique_lock<boost::shared_mutex> lock(mutex_);
         params_ = params;
     }
     void set(const std::map<string, string>& pegp) {
-        std::unique_lock<std::shared_mutex> lock(mutex_);
+        boost::unique_lock<boost::shared_mutex> lock(mutex_);
         params_ = buildPseudoCurrencyMarketParameters(pegp);
     }
 
@@ -150,7 +150,7 @@ class GlobalPseudoCurrencyMarketParameters
     };
 
     PseudoCurrencyMarketParameters params_;
-    mutable std::shared_mutex mutex_;
+    mutable boost::shared_mutex mutex_;
 };
 
 //! Market

OREData/ored/marketdata/market.hpp

@@ -25,7 +25,7 @@ namespace ore {
 namespace data {
 
 boost::shared_ptr<CalibrationInstrument> CalibrationInstrumentFactory::build(const string& instrumentType) {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     auto it = map_.find(instrumentType);
     if (it == map_.end())
         return nullptr;
@@ -35,7 +35,7 @@ boost::shared_ptr<CalibrationInstrument> CalibrationInstrumentFactory::build(con
 void CalibrationInstrumentFactory::addBuilder(const string& instrumentType,
                                               function<boost::shared_ptr<CalibrationInstrument>()> builder,
                                               const bool allowOverwrite) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     QL_REQUIRE(map_.insert(std::make_pair(instrumentType, builder)).second,
                "CalibrationInstrumentFactory::addBuilder(" << instrumentType << "): builder for key already exists.");
 }

OREData/ored/model/calibrationinstrumentfactory.cpp

@@ -91,7 +91,7 @@ class CalibrationInstrumentFactory
                     const bool allowOverwrite = false);
 
 private:
-    std::shared_mutex mutex_;
+    boost::shared_mutex mutex_;
     map_type map_;
 };
 

OREData/ored/model/calibrationinstrumentfactory.hpp

@@ -330,7 +330,7 @@ double BondBuilder::Result::inflationFactor() const {
 BondBuilder::Result BondFactory::build(const boost::shared_ptr<EngineFactory>& engineFactory,
                                        const boost::shared_ptr<ReferenceDataManager>& referenceData,
                                        const std::string& securityId) const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     for (auto const& b : builders_) {
         if (referenceData->hasData(b.first, securityId)) {
             auto tmp = b.second->build(engineFactory, referenceData, securityId);
@@ -347,7 +347,7 @@ BondBuilder::Result BondFactory::build(const boost::shared_ptr<EngineFactory>& e
 
 void BondFactory::addBuilder(const std::string& referenceDataType, const boost::shared_ptr<BondBuilder>& builder,
                              const bool allowOverwrite) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     QL_REQUIRE(builders_.insert(std::make_pair(referenceDataType, builder)).second || allowOverwrite,
                "BondFactory::addBuilder(" << referenceDataType << "): builder for key already exists.");
 }

OREData/ored/portfolio/bond.cpp

@@ -203,7 +203,7 @@ struct BondBuilder {
 
 class BondFactory : public QuantLib::Singleton<BondFactory, std::integral_constant<bool, true>> {
     map<std::string, boost::shared_ptr<BondBuilder>> builders_;
-    mutable std::shared_mutex mutex_;
+    mutable boost::shared_mutex mutex_;
 
 public:
     BondBuilder::Result build(const boost::shared_ptr<EngineFactory>& engineFactory,

OREData/ored/portfolio/bond.hpp

@@ -64,7 +64,7 @@ std::string EngineBuilder::modelParameter(const std::string& p, const std::vecto
 
 void EngineBuilderFactory::addEngineBuilder(const std::function<boost::shared_ptr<EngineBuilder>()>& builder,
                                             const bool allowOverwrite) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     auto tmp = builder();
     auto key = make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
     auto it = std::remove_if(engineBuilderBuilders_.begin(), engineBuilderBuilders_.end(),
@@ -84,7 +84,7 @@ void EngineBuilderFactory::addAmcEngineBuilder(
     const std::function<boost::shared_ptr<EngineBuilder>(const boost::shared_ptr<QuantExt::CrossAssetModel>& cam,
                                                          const std::vector<Date>& grid)>& builder,
     const bool allowOverwrite) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     auto tmp = builder(nullptr, {});
     auto key = make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
     auto it = std::remove_if(
@@ -104,7 +104,7 @@ void EngineBuilderFactory::addAmcEngineBuilder(
 
 void EngineBuilderFactory::addLegBuilder(const std::function<boost::shared_ptr<LegBuilder>()>& builder,
                                          const bool allowOverwrite) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
+    boost::unique_lock<boost::shared_mutex> lock(mutex_);
     auto key = builder()->legType();
     auto it =
         std::remove_if(legBuilderBuilders_.begin(), legBuilderBuilders_.end(),
@@ -116,7 +116,7 @@ void EngineBuilderFactory::addLegBuilder(const std::function<boost::shared_ptr<L
 }
 
 std::vector<boost::shared_ptr<EngineBuilder>> EngineBuilderFactory::generateEngineBuilders() const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     std::vector<boost::shared_ptr<EngineBuilder>> result;
     for (auto const& b : engineBuilderBuilders_)
         result.push_back(b());
@@ -126,15 +126,15 @@ std::vector<boost::shared_ptr<EngineBuilder>> EngineBuilderFactory::generateEngi
 std::vector<boost::shared_ptr<EngineBuilder>>
 EngineBuilderFactory::generateAmcEngineBuilders(const boost::shared_ptr<QuantExt::CrossAssetModel>& cam,
                                                 const std::vector<Date>& grid) const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     std::vector<boost::shared_ptr<EngineBuilder>> result;
     for (auto const& b : amcEngineBuilderBuilders_)
         result.push_back(b(cam, grid));
     return result;
 }
 
 std::vector<boost::shared_ptr<LegBuilder>> EngineBuilderFactory::generateLegBuilders() const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
+    boost::shared_lock<boost::shared_mutex> lock(mutex_);
     std::vector<boost::shared_ptr<LegBuilder>> result;
     for (auto const& b : legBuilderBuilders_)
         result.push_back(b());