如何为具有共享指针的结构的多索引制作修饰符以提升记录器后端以重置此后端？

Question

我正在尝试修改结构的多索引，结构有一个共享指针成员，用于提升后端、前端和记录器的记录器共享指针。
根据多索引的性质，在制作迭代器时，每个结构都被认为是常量。
所以当我通过 find 或 equal_range 将迭代器带到某个索引时，这个迭代器是 const .
当我尝试修改结构成员共享指针以重置它时，它给我错误并且无法编译。
这是错误：

cannot convert 'this' pointer from 'const boost::shared_ptr<boost::log::v2s_mt_nt6::sinks::text_file_backend>' to 'boost::shared_ptr<boost::log::v2s_mt_nt6::sinks::text_file_backend> &'

这是修饰符：

if (it_US_MUS_update->BackendSharedPointer.unique() == true)
            {
                assert(US_MUS_index.modify(it_US_MUS_update, change_BSP(it_US_MUS_update->BackendSharedPointer.reset())));
                //assert(it_US_MUS_update->BackendSharedPointer.reset());
            }
            else if (it_US_MUS_update->BackendSharedPointer.unique() != true)
            {
                throw;
            }

这是修饰符 change_BSP 的定义：

struct change_BSP
{
change_BSP(const boost::shared_ptr<sinks::text_file_backend> & new_BSP) :new_BSP_m(new_BSP) {}

void operator()(Log_file_Dur_Sig_F_Map_struct& e)
{
    e.BackendSharedPointer = new_BSP_m;
}

private:
boost::shared_ptr<sinks::text_file_backend> new_BSP_m;
};

我做错了什么？为什么共享指针成员被认为是常量？
"this"指针指向什么???多索引容器或结构或结构成员共享指针或共享指针或修饰符struct change_BSP指向的对象???
如果需要更多代码，我会编辑，但我不想用非必需代码混淆问题？

这些是文件：

//targetver.h //https://mega.nz/#!eDpmDARL!rmuyRtJUO3D6BbiUGUPYS2ZTMcTUxiLuTGcNgihkLOw
//stdafx.cpp
//    https://mega.nz/#!TKgiTaqT!GCEh7seVt41e2GsfNLpzJwA5nRvdilQ0NWgtUenPuSk
//stdafx.h
//    https://mega.nz/#!jTg2TKiQ!fOTHl9VQQuMbjGtfLi1hu4PZFAycimKob21GaE7nc7I




1- https://mega.nz/#!WW4gyCrS!wRE7PV1Qsi5-xza-kQgDaQK80ImgWwi9yDmqiQJQXo0  
2- https://mega.nz/#!eLxCQSbI!BE8bMK6p7NTqK88fqSOWvPJ3WyhKYRP3juNiQNcgwBU  
3- https://mega.nz/#!fSwAyCba!fZHUVNWiuMlonMnvhQTPcSInKoICdBn_7rBw6uX8V9U

文件 1：my_logger_class_single_map_reduced.h

    //#pragma once
#ifndef MY_LOGGER_CLASS_SINGLE_MAP_O_H   // if my_logger.h hasn't been included yet...
#define MY_LOGGER_CLASS_SINGLE_MAP_O_H   //   #define this so the compiler knows it has been included

#include <boost/config.hpp>

#if !defined(NDEBUG)
#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
#endif

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>

using boost::multi_index_container;
using namespace boost::multi_index;


#include <algorithm>
#include <iterator>
#include <string>
#include <iostream>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <vector>

#include <boost/log/core.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/sinks/unlocked_frontend.hpp>
#include <boost/log/sinks/basic_sink_backend.hpp>
#include <boost/log/sinks/frontend_requirements.hpp>
#include <boost/log/sources/severity_channel_logger.hpp>
#include <boost/log/sources/record_ostream.hpp>
#include <boost/log/sinks/sync_frontend.hpp>
#include <boost/log/sinks/text_file_backend.hpp>
//for cout logger
#include <boost/log/sinks/text_ostream_backend.hpp>
#include <boost/core/null_deleter.hpp>

#include <boost/log/attributes.hpp> //for attr:
#include <boost/log/sources/logger.hpp> //for loggers
#include <boost/log/common.hpp> //for macros

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/log/support/date_time.hpp>

#include <boost/bimap.hpp>
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <boost/bimap/multiset_of.hpp>
#include <boost/bimap/vector_of.hpp>
#include <boost/bimap/list_of.hpp>
using namespace boost::bimaps;

#include <boost/ref.hpp>

#include <boost/filesystem.hpp>
using namespace boost::filesystem;

////#include "boost_create_directory_2.h"

#include "boost/date_time/gregorian/gregorian.hpp" //include all types plus i/o
using namespace boost::gregorian;

#include <boost/fusion/adapted/struct.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/phoenix/phoenix.hpp>
using boost::phoenix::arg_names::arg1;

//=============================================================

namespace sinks = boost::log::sinks;
namespace logging = boost::log;
namespace keywords = boost::log::keywords;
namespace expr = boost::log::expressions;
namespace attrs = boost::log::attributes;
namespace src = boost::log::sources;

// Complete sink type
typedef sinks::synchronous_sink< sinks::text_file_backend > file_sink;
//for cout logger
typedef sinks::synchronous_sink< sinks::text_ostream_backend > cout_sink;
//make the RCF ban map using US USvalue and duration
struct RCF_Ban_Map_struct   //
{
    std::string Duration = "";
    std::string UniqueSignal = "";
    std::string UniqueSignalvalue = "";

    RCF_Ban_Map_struct()
    {
    }

    RCF_Ban_Map_struct(const std::string& duration, const std::string& UniqueSignal, std::string const& UniqueSignalvalue) : Duration(duration), UniqueSignal(UniqueSignal), UniqueSignalvalue(UniqueSignalvalue)
    {
    }

    //bool operator<(const Log_file_Dur_Sig_F_Map_struct& e)const { return Duration < e.Duration; }

};

struct change_D_RCF_Ban_Map_struct
{
    change_D_RCF_Ban_Map_struct(const std::string& new_D) :new_D_m(new_D) {}

    void operator()(RCF_Ban_Map_struct& e)
    {
        e.Duration = new_D_m;
    }

private:
    std::string new_D_m;
};
struct change_US_RCF_Ban_Map_struct
{
    change_US_RCF_Ban_Map_struct(const std::string& new_US) :new_US_m(new_US) {}

    void operator()(RCF_Ban_Map_struct& e)
    {
        e.UniqueSignal = new_US_m;
    }

private:
    std::string new_US_m;
};
struct change_USvalue_RCF_Ban_Map_struct
{
    change_USvalue_RCF_Ban_Map_struct(const std::string& new_USvalue) :new_USvalue_m(new_USvalue) {}

    void operator()(RCF_Ban_Map_struct& e)
    {
        e.UniqueSignalvalue = new_USvalue_m;
    }

private:
    std::string new_USvalue_m;
};


// tags for accessing the corresponding indices of  //
struct US_USvalue_D {};
struct D {};
struct US_USvalue {};



/*
*NB: The use of derivation here instead of simple typedef is explained in
* Compiler specifics : type hiding.
*/
////check if we need to define composite_key_compare
struct US_USvalue_D_key :composite_key <
    RCF_Ban_Map_struct,
    BOOST_MULTI_INDEX_MEMBER(RCF_Ban_Map_struct, std::string, UniqueSignal),
    BOOST_MULTI_INDEX_MEMBER(RCF_Ban_Map_struct, std::string, UniqueSignalvalue),
    BOOST_MULTI_INDEX_MEMBER(RCF_Ban_Map_struct, std::string, Duration)

> {};

// reducing symbol names through type hiding
// type hide the index specifier list within employee_set_indices

struct RCF_Ban_Map_struct_set_indices :
    indexed_by <
    ordered_non_unique<
    tag<US_USvalue_D>, US_USvalue_D_key >
    >
{};

typedef multi_index_container<
    RCF_Ban_Map_struct,
    RCF_Ban_Map_struct_set_indices
> RCF_Ban_Map_struct_set;

typedef RCF_Ban_Map_struct_set::index<US_USvalue_D>::type RCF_Ban_Map_struct_set_by_US_USvalue_D;

BOOST_FUSION_ADAPT_STRUCT(RCF_Ban_Map_struct, (std::string, UniqueSignal)(std::string, UniqueSignalvalue) (std::string, Duration));

struct Log_file_Dur_Sig_F_Map_struct   //Duration_Signal_Folder_Map_struct >>>log file destination
{

    int         Id;
    std::string Duration;
    std::string FolderDuration;//??
    std::string FolderDurationSpecefied;
    std::string FolderDurationPathString;//??
    std::string FolderDurationSpecefiedPathString;

    //make fields for UniqueSignal and ModifiedUniqueSignal
    std::string UniqueSignal = "";
    std::string ModifiedUniqueSignal = "";
    std::string ModifiedUniqueSignalCertainUniqueSignal = "";

    std::string FolderDurationSpecefiedUniqueSignal="";
    std::string FolderDurationSpecefiedUniqueSignalPathString = "";
    std::string FolderDurationSpecefiedModifiedUniqueSignalCertainUniqueSignal="";
    std::string FolderDurationSpecefiedModifiedUniqueSignalCertainUniqueSignalPathString = "";

    //5
    //make fields for Backend
    std::string UniqueSignalvalue = "";
    std::string BackendName{ "" };
    std::string BackendFileName{ "" };
    std::string BackendFileNamePathString{ "" };
    std::string BackendFileNamePathString_parent{ "" };
    boost::shared_ptr<sinks::text_file_backend> BackendSharedPointer{ nullptr };//12-23-2019 study shared pointer //default constructed empty

    //make fields for logger
    std::string loggerChannelName{""};
    boost::shared_ptr<src::channel_logger_mt<>> loggerChannelSharedPointer{ nullptr };//default constructed empty

    //make fields for FrontendName
    std::string FrontendName { "" };    
    boost::shared_ptr<file_sink> FrontendSharedPointer{ nullptr };//default constructed empty

    Log_file_Dur_Sig_F_Map_struct(const std::string& duration, const std::string& folderdurationspecefied, std::string const& folderdurationspecefiedpathstring, const path folderdurationspecefiedpath) : Duration(duration), FolderDurationSpecefied(folderdurationspecefied), FolderDurationSpecefiedPathString(folderdurationspecefiedpathstring)
    {
        if (duration == "AllTime")
        {
            Id = 0;
        }
        else if (duration == "Yearly")
        {
            Id = 1;
        }
        else if (duration == "Monthly")
        {
            Id = 2;
        }
        else if (duration == "Daily")
        {
            Id = 3;
        }

        FolderDuration = folderdurationspecefiedpath.parent_path().filename().generic_string();//why i get Duration in arguments???>>>>>>>>>>>>>>>>>>>>x1>>because duration means the time duration and FolderDuration means the folder built for time duration which include certain time like 2019 or 00 month...
        FolderDurationPathString = folderdurationspecefiedpath.parent_path().generic_string() ;
    }
    bool operator<(const Log_file_Dur_Sig_F_Map_struct& e)const { return Id<e.Id; }
};

BOOST_FUSION_ADAPT_STRUCT(Log_file_Dur_Sig_F_Map_struct, (int, Id)(std::string, Duration)(std::string, FolderDuration)(std::string, FolderDurationSpecefied)(std::string, FolderDurationPathString)(std::string, FolderDurationSpecefiedPathString)(std::string, UniqueSignal)(std::string, ModifiedUniqueSignal)(std::string, ModifiedUniqueSignalCertainUniqueSignal)(std::string, FolderDurationSpecefiedUniqueSignal)(std::string, FolderDurationSpecefiedUniqueSignalPathString)(std::string, FolderDurationSpecefiedModifiedUniqueSignalCertainUniqueSignal) (std::string, FolderDurationSpecefiedModifiedUniqueSignalCertainUniqueSignalPathString) (std::string ,UniqueSignalvalue) (std::string, BackendName)(std::string, BackendFileName)(std::string, BackendFileNamePathString)  (std::string, BackendFileNamePathString_parent) (std::string ,loggerChannelName)(std::string ,FrontendName)(boost::shared_ptr<sinks::text_file_backend>, BackendSharedPointer));//12-23-2019 study shared pointer (boost::shared_ptr<sinks::text_file_backend>, BackendSharedPointer)(boost::shared_ptr<file_sink> ,FrontendSharedPointer)(boost::shared_ptr<src::channel_logger_mt<>> ,loggerChannelSharedPointer)

struct change_BName
{
    change_BName(const std::string& new_BName) :new_BName_m(new_BName) {}

    void operator()(Log_file_Dur_Sig_F_Map_struct& e)
    {
        e.BackendName = new_BName_m;
    }

private:
    std::string new_BName_m;
};

struct change_BSP
{
    change_BSP(const boost::shared_ptr<sinks::text_file_backend> & new_BSP) :new_BSP_m(new_BSP) {}

    void operator()(Log_file_Dur_Sig_F_Map_struct& e)
    {
        e.BackendSharedPointer = new_BSP_m;
    }

private:
    boost::shared_ptr<sinks::text_file_backend> new_BSP_m;
};

struct change_LCSP
{
    change_LCSP(const boost::shared_ptr<src::channel_logger_mt<>> &new_LCSP) :new_LCSP_m(new_LCSP) {}

    void operator()(Log_file_Dur_Sig_F_Map_struct& e)
    {
        e.loggerChannelSharedPointer = new_LCSP_m;
    }

private:
    boost::shared_ptr<src::channel_logger_mt<>> new_LCSP_m;
};

struct change_FSP
{
    change_FSP(const boost::shared_ptr<file_sink> &new_FSP) :new_FSP_m(new_FSP) {}

    void operator()(Log_file_Dur_Sig_F_Map_struct& e)
    {
        e.FrontendSharedPointer = new_FSP_m;
    }

private:
    boost::shared_ptr<file_sink>    new_FSP_m;
};
struct US_MUS {};

/*
*NB: The use of derivation here instead of simple typedef is explained in
* Compiler specifics : type hiding.
*/
////check if we need to define composite_key_compare
struct US_MUS_key :composite_key <
    Log_file_Dur_Sig_F_Map_struct,
    BOOST_MULTI_INDEX_MEMBER(Log_file_Dur_Sig_F_Map_struct, std::string, UniqueSignal), 
    BOOST_MULTI_INDEX_MEMBER(Log_file_Dur_Sig_F_Map_struct, std::string, ModifiedUniqueSignal)
> {};

// reducing symbol names through type hiding
// type hide the index specifier list within employee_set_indices

struct Log_file_Dur_Sig_F_Map_struct_set_indices :
    indexed_by <    
    ordered_non_unique<
    tag<US_MUS>, US_MUS_key >
    >
{};

typedef multi_index_container<
    Log_file_Dur_Sig_F_Map_struct,
    Log_file_Dur_Sig_F_Map_struct_set_indices
> Log_file_Dur_Sig_F_Map_struct_set;

typedef Log_file_Dur_Sig_F_Map_struct_set::index<US_MUS>::type Log_file_Dur_Sig_F_Map_struct_set_by_US_MUS;

class LoggingClass_2
{
private:
    RCF_Ban_Map_struct_set RCF_Ban_Map;

    Log_file_Dur_Sig_F_Map_struct_set Log_file_Dur_Sig_F_Map;
    static boost::bimap<set_of<std::string>, set_of<std::string>> mMUS_Map; 
    std::vector<const Log_file_Dur_Sig_F_Map_struct *> vector_new_structs;

    //make UniqueSignal vector
    static std::vector<std::string>  UniqueSignalVector;
    //make UniqueSignal map
    static std::map<std::string,unsigned int>  mlogUS_SizeMap;

    // create a cout backend
    boost::shared_ptr< sinks::text_ostream_backend > backendCout = boost::make_shared< sinks::text_ostream_backend >();

    // create a cout frontend   
    boost::shared_ptr< cout_sink > sink_cout = boost::make_shared<cout_sink>(backendCout);  

public:
    LoggingClass_2();//it automatically defines where log files are stored
    LoggingClass_2(std::string, std::string);

    void CreateUpdateLoggingStructure(std::string, std::string);
    void CreateUpdate_RCF_Ban_Map(std::string, std::string);

    void RotateLogFile(boost::shared_ptr< file_sink >);
    void init_file_collecting_path(boost::shared_ptr< file_sink >, std::string);
    src::channel_logger_mt<> mloggerCoutLog{ keywords::channel = "m_cout_log" };

    //getting the instance of core singleton class
    boost::shared_ptr< logging::core > core = logging::core::get();

    // Setup the common formatter for all sinks
    logging::formatter fmt;
};
#endif//MY_LOGGER_CLASS_SINGLE_MAP_O_H

文件 2：my_logger_class_single_map_reduced.cpp

//#include "../../stdafx.h"
#include "stdafx.h"
//#include "../../stdafx.h"
#include "my_logger_class_single_map_reduced.h"
//allUniqueSignalResponsesOfSameValue 00 00 00 Or 01 01 01 or 200 200 200 Or 404 404 404
std::string allUniqueSignalResponsesOfSameValue{ "ARS_" };// AllRespSame_ = ARS_

//allUniqueSignalResponses 00 01 02 01 19 or 200 200 200 400 404 404 >>>>>>>>>>>>>single file
std::string allUniqueSignalResponsesTogether{ "AR_" };//AllResp_ = AR_

//allUniqueSignalResponsesForFirstTime  00 01 02 04 22 or 200 300 500 400 404 >>>>>>>>>>>>>>>>>>>>single file
std::string allUniqueSignalResponsesForFirstTimeTogether{ "ARF_" };// AllRespFirst_ = ARF_

//UniqueSignalResponseOfCertainValueForFirstTime  00 Or 01 or 300 Or 200 Or 404
std::string UniqueSignalResponseOfCertainValueForFirstTime{ "RCF_" };// RespCertainFirst_= RCF_

boost::bimap<set_of<std::string>, set_of<std::string>> LoggingClass_2::mMUS_Map;


std::vector<std::string>  LoggingClass_2::UniqueSignalVector;
std::map<std::string, unsigned int>  LoggingClass_2::mlogUS_SizeMap;

//==========================================================================
LoggingClass_2::LoggingClass_2()
{
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("allUniqueSignalResponsesOfSameValue", allUniqueSignalResponsesOfSameValue));
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("allUniqueSignalResponsesTogether", allUniqueSignalResponsesTogether));
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("allUniqueSignalResponsesForFirstTimeTogether", allUniqueSignalResponsesForFirstTimeTogether));
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("UniqueSignalResponseOfCertainValueForFirstTime", UniqueSignalResponseOfCertainValueForFirstTime));

    backendCout->add_stream(boost::shared_ptr< std::ostream >(&std::cout, boost::null_deleter()));
    sink_cout->set_filter(expr::attr<std::string>("Channel") == "m_cout_log");//==
    sink_cout->set_formatter(fmt);
    core->add_sink(sink_cout);

    // And also add some logging core attributes
    core->add_global_attribute("TimeStamp", attrs::local_clock());
    core->add_global_attribute("RecordID", attrs::counter< unsigned int >());

    // Setup the common formatter for all sinks
    fmt = expr::format("[%1%] [%2%]  [%5%]")//[%3%] [%4%]
        % expr::format_date_time< boost::posix_time::ptime >("TimeStamp", "%Y-%m-%d %H:%M:%S.%f")
        % expr::attr<unsigned int>("ThreadID")
        //% expr::attr<string>("Scope")
        //% trivial::severity       
        % expr::smessage;


}

LoggingClass_2::LoggingClass_2(std::string pathFolder, std::string folderBehaviour)
{
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("allUniqueSignalResponsesOfSameValue", allUniqueSignalResponsesOfSameValue));
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("allUniqueSignalResponsesTogether", allUniqueSignalResponsesTogether));
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("allUniqueSignalResponsesForFirstTimeTogether", allUniqueSignalResponsesForFirstTimeTogether));
    LoggingClass_2::mMUS_Map.left.insert(boost::bimap<set_of<std::string>, set_of<std::string>>::left_value_type("UniqueSignalResponseOfCertainValueForFirstTime", UniqueSignalResponseOfCertainValueForFirstTime));

    backendCout->add_stream(boost::shared_ptr< std::ostream >(&std::cout, boost::null_deleter()));
    sink_cout->set_filter(expr::attr<std::string>("Channel") == "m_cout_log");
    sink_cout->set_formatter(fmt);

    // And also add some logging core attributes
    core->add_global_attribute("TimeStamp", attrs::local_clock());
    core->add_global_attribute("RecordID", attrs::counter< unsigned int >());


    //========================================================================
    // Setup the common formatter for all sinks
    fmt = expr::format("[%1%] [%2%]  [%5%]")//[%3%] [%4%]
        % expr::format_date_time< boost::posix_time::ptime >("TimeStamp", "%Y-%m-%d %H:%M:%S.%f")
        % expr::attr<unsigned int>("ThreadID")
        //% expr::attr<string>("Scope")
        //% trivial::severity       
        % expr::smessage;


}


void LoggingClass_2::CreateUpdate_RCF_Ban_Map(std::string UniqueSignal, std::string UniqueSignalValue)
{
    //1
    RCF_Ban_Map_struct_set_by_US_USvalue_D & US_USvalue_D_index = RCF_Ban_Map.get<US_USvalue_D>();
    //2-2
    RCF_Ban_Map_struct_set_by_US_USvalue_D::iterator it_US_USvalue_D_0, it_US_USvalue_D_1;
    boost::tie(it_US_USvalue_D_0, it_US_USvalue_D_1) = US_USvalue_D_index.equal_range(boost::make_tuple(UniqueSignal, UniqueSignalValue));
    auto it_US_USvalue_D_update = it_US_USvalue_D_0;
    if (it_US_USvalue_D_0 == it_US_USvalue_D_1)
    {
        //boost::fusion::for_each(*it_US_USvalue_D_update, std::cout << arg1 << "\n");

        //RCF_Ban_Map_struct new_struct{ *it_US_USvalue_D_update };
        RCF_Ban_Map_struct new_struct{  };

        change_US_RCF_Ban_Map_struct(UniqueSignal).operator()(new_struct);
        change_USvalue_RCF_Ban_Map_struct(UniqueSignalValue).operator()(new_struct);
        //change_D(Duration).operator()(new_struct);

        bool successful_insert = false;
        RCF_Ban_Map_struct_set_by_US_USvalue_D::iterator it_US_USvalue_D_new;
        boost::tie(it_US_USvalue_D_new, successful_insert) = US_USvalue_D_index.insert(new_struct);////,FolderDuration,FolderDurationSpecefied));
                                                                                                                //here i should put code to catch error regarding insert>>>>>>>>>>>>>>>>>>>>x2>>
        assert(successful_insert);
        boost::fusion::for_each(*it_US_USvalue_D_new, std::cout << arg1 << "\n");

    }
    else if (it_US_USvalue_D_0 != it_US_USvalue_D_1)
    {
        //do nothing because value is already registered for this UniqueSignal
    }
}

//mLogModifiedUniqueSignalUpdateBackendsParametersMap???????????????????????????//

void LoggingClass_2::CreateUpdateLoggingStructure(std::string UniqueSignal, std::string UniqueSignalValue)
{
    //make RCF_ items clear
    //make index and get range having RCF_
    //using iterator clear RCF_ items to ""
    Log_file_Dur_Sig_F_Map_struct_set_by_US_MUS & US_MUS_index = Log_file_Dur_Sig_F_Map.get<US_MUS>();

    Log_file_Dur_Sig_F_Map_struct_set_by_US_MUS::iterator it_US_MUS_0, it_US_MUS_1;//, it_US_D_FD_FDS_MUS_update_original;
    boost::tie(it_US_MUS_0, it_US_MUS_1) = US_MUS_index.equal_range(boost::make_tuple(UniqueSignal, UniqueSignalResponseOfCertainValueForFirstTime));
    if (it_US_MUS_0 == it_US_MUS_1)
    {
        //error happens because there is no such US in the folder system so look at Modify_Unique_Signal
        throw;
    }
    else if (it_US_MUS_0 != it_US_MUS_1)
    {
        auto itx = it_US_MUS_1;
        std::advance(itx, -1);

        //3
        for (auto it_US_MUS_update = it_US_MUS_0; it_US_MUS_update != it_US_MUS_1;)
        {
            //std::cout << "3[2J3[1;1H"   << std::endl;
            std::cout << "\n" << std::endl;
            boost::fusion::for_each(*it_US_MUS_update, std::cout << arg1 << "\n");
            std::cout << US_MUS_index.count(boost::make_tuple(UniqueSignal,UniqueSignalResponseOfCertainValueForFirstTime)) << std::endl;
            boost::fusion::for_each(*itx, std::cout << arg1 << "\n");

            if (it_US_MUS_update->BackendName != "")
            {
                assert(US_MUS_index.modify(it_US_MUS_update, change_BName("")));
                //assert(US_MUS_index.modify(it_US_MUS_update, change_BSP(boost::make_shared< sinks::text_file_backend >(keywords::file_name = BackendFileName))));
                if (it_US_MUS_update->BackendSharedPointer.unique() == true)
                {
                    assert(US_MUS_index.modify(it_US_MUS_update, change_BSP(it_US_MUS_update->BackendSharedPointer.reset())));
                    //assert(it_US_MUS_update->BackendSharedPointer.reset());
                    ////assert(dynamic_pointer_cast<Log_file_Dur_Sig_F_Map_struct::BackendSharedPointer>(it_US_MUS_update->BackendSharedPointer).reset());
                    //const_cast<const foo*>(this)->bar();
                }
                else if (it_US_MUS_update->BackendSharedPointer.unique() != true)
                {
                    throw;
                }


                // Break the feeding loop
                ////it_US_MUS_update->FrontendSharedPointer->stop();

                // Flush all log records that may have left buffered
                it_US_MUS_update->FrontendSharedPointer->flush();

                if (it_US_MUS_update->ModifiedUniqueSignal == "AR_" || it_US_MUS_update->ModifiedUniqueSignal == "ARF_")
                {
                    //it_US_MUS_update->FrontendSharedPointer->reset_filter();//????????????ARS_
                    throw;
                }
                //else if (ModifiedUniqueSignal == "ARS_" || ModifiedUniqueSignal == "RCF_")
                else if (it_US_MUS_update->ModifiedUniqueSignal == "RCF_")
                {
                    it_US_MUS_update->FrontendSharedPointer->reset_filter();
                    it_US_MUS_update->FrontendSharedPointer->reset_formatter();
                    it_US_MUS_update->FrontendSharedPointer->locked_backend()->rotate_file();//???????
                    it_US_MUS_update->FrontendSharedPointer->locked_backend()->set_file_collector(sinks::file::make_collector(
                        keywords::target = ""));//< the target directory >

                }

                //??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
                if (it_US_MUS_update->FrontendSharedPointer.unique() == true)
                {
                    assert(US_MUS_index.modify(it_US_MUS_update, change_FSP(it_US_MUS_update->FrontendSharedPointer.reset())));
                }
                else if (it_US_MUS_update->FrontendSharedPointer.unique() != true)
                {
                    throw;
                }   

                // Remove the sink from the core, so that no records are passed to it
                core->remove_sink(it_US_MUS_update->FrontendSharedPointer);




                //the next line might be changed so that channel=ModifiedUniqueSignalCertainUniqueSignal with AR_,ARF_,RCF_ and channel=ModifiedUniqueSignalCertainUniqueSignalCertainValue with ARS_
                if (it_US_MUS_update->ModifiedUniqueSignal == "AR_" || it_US_MUS_update->ModifiedUniqueSignal == "ARF_")
                {
                    ////assert(US_MUS_index.modify(it_US_MUS_update, change_LCSP(boost::make_shared<src::channel_logger_mt<>>(keywords::channel = ModifiedUniqueSignalCertainUniqueSignal))));
                    throw;
                }
                ////else if (ModifiedUniqueSignal == "ARS_" || ModifiedUniqueSignal == "RCF_")
                else if (it_US_MUS_update->ModifiedUniqueSignal == "RCF_")
                {
                    ////assert(US_MUS_index.modify(it_US_MUS_update, change_LCSP(boost::make_shared<src::channel_logger_mt<>>(keywords::channel = ModifiedUniqueSignalCertainUniqueSignalCertainValue))));
                    if (it_US_MUS_update->loggerChannelSharedPointer.unique() == true)
                    {
                        assert(US_MUS_index.modify(it_US_MUS_update, change_LCSP(it_US_MUS_update->loggerChannelSharedPointer.reset())));
                    }
                    else if (it_US_MUS_update->loggerChannelSharedPointer.unique() != true)
                    {
                        throw;
                    }
                }

                boost::fusion::for_each(*it_US_MUS_update, std::cout << arg1 << "\n");
                //it_US_MUS_update_original = it_US_MUS_update;
                ++it_US_MUS_update;//5
                std::cout << "\n ++it_US_MUS_update " << std::endl;

                if (it_US_MUS_update != it_US_MUS_1)
                {
                    boost::fusion::for_each(*it_US_MUS_update, std::cout << arg1 << "\n");
                }

            }

        }

    }
}

文件 3：logging_trial_ars_single_map_reduced.cpp

// logger_class_trial_2.cpp : Defines the entry point for the console application.
//
// logger_trial.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "my_logger_class_single_map_reduced.h"
//#include "boost_create_directory_2.h"


int main()
{
  //make LoggingClass_2 instance
    LoggingClass_2 mLoggingInstance;
    BOOST_LOG(mLoggingInstance.mloggerCoutLog) << "starting program";


        std::string UniqueSignal{ "u_h" };

        for (int hour = 0; hour < 2; hour++)
        {
            std::stringstream ss_hour;
            ss_hour << std::setw(2) << std::setfill('0') << hour;
            std::string url_hour{ ss_hour.str() };
            std::stringstream().swap(ss_hour); // swap m with a default constructed stringstream

            mLoggingInstance.CreateUpdate_RCF_Ban_Map(UniqueSignal, url_hour);
            mLoggingInstance.CreateUpdateLoggingStructure(UniqueSignal, url_hour);
        }


    return 0;
}

Answer 1

问题出在表达式 it_US_MUS_update->BackendSharedPointer.reset() 中：

assert(US_MUS_index.modify(
    it_US_MUS_update,
    change_BSP(it_US_MUS_update->BackendSharedPointer.reset())));

因为 it_US_MUS_update 是常量迭代器，所以 it_US_MUS_update->BackendSharedPointer 也被视为常量，不能被 reset() 编辑。如果你所追求的只是重置东西，你不需要通过 change_BSP 进行扭曲；相反，请执行以下操作：

US_MUS_index.modify(
    it_US_MUS_update,
    [](Log_file_Dur_Sig_F_Map_struct& e){ e.BackendSharedPointer.reset(); });

Answer 2

what am I doing wrong? why the shared pointer member is considered const?? what does "this" pointer point to???the multi index container or struct or struct member shared pointer or object pointed to by shared pointer or the modifier struct change_BSP???

编译错误指的是这段代码：

it_US_MUS_update->BackendSharedPointer.reset()

迭代器 it_US_MUS_update 是一个 const 迭代器，这意味着它的 operator-> returns 是对 Log_file_Dur_Sig_F_Map_struct 的 const 引用，因此被引用的 BackendSharedPointer 成员是const 限定的。 reset() 成员函数需要在非 const boost::shared_ptr 上调用，这就是编译器告诉您的内容 — this（指向 boost::shared_ptr 的指针）是reset().

需要一个 const 指针和一个非常量指针

change_BSP 构造也不正确还有一个原因。该函数对象将由 multi_index_container 索引的 modify() 成员调用，并将接收对该函数应该修改的容器元素的引用。根据您的 change_BSP 定义，它应该将 BackendSharedPointer 成员设置为 change_BSP 构造函数中接收到的值。但是您试图将 BackendSharedPointer 成员值传递给 change_BSP 构造函数，这是没有意义的。您可能尝试做的是将要设置的 new 值传递给 change_BSP 构造函数。如果您只是想重置指针，请传递默认构造的 shared_ptr.

US_MUS_index.modify(it_US_MUS_update,
    change_BSP(boost::shared_ptr<sinks::text_file_backend>()));

请注意，您还可以修改标记为 mutable 或直接使用 const_cast 的 multi_index_container 元素的成员，而无需调用 modify()。请记住，修改后的成员不得参与用于查找和排序的索引键。

如何为具有共享指针的结构的多索引制作修饰符以提升记录器后端以重置此后端？

how to make modifier for a multiindex of struct having shared pointer to boost logger backend to reset this back end?

c++

struct

boost

boost-multi-index

boost-log