Problem inserting into a std::map with C++

Question

I've got a compiler warning over a map insert, I've used std:map many times before and I must be having a block of some kind because I just can't see whats wrong. I've created the following types in an effort to see where the issue is:

typedef std::string staledatamapkey_t;
typedef staledata_t staledatamapvalue_t;
typedef std::map<staledatamapkey_t, staledatamapvalue_t> staledatamap_t;
typedef std::pair<staledatamapkey_t, staledatamapvalue_t> statedatapair_t;

In a class I define the map as a member:

staledatamap_t m_staledata;

The code to insert into the map:

   for (unsigned i = 0; i < xAllstaledata.size (); ++i)
    {
        staledataXML_t const &xStaledata = xAllstaledata[i];
        staledatamapvalue_t staledata;
        staledatamapkey_t udn;
        statedatapair_t staledatapair;
        udn = staledata.udn = xStaledata.udn();
        staledata.expiry    = xStaledata.expiry();
        staledata.ddo       = xStaledata.ddo();
        staledata.tolerance = xStaledata.tolerance();
        staledata.ip        = xStaledata.ip();
        staledatapair = std::make_pair(udn, staledata);
        m_staledata.insert(staledatapair);
    }

The start of the compiler errors, which is referring to the insert line above:

config.C: In member function ‘void asv::scm::helm::config_t::initialize(const string&)’:
config.C:199:54: error: use of deleted function ‘std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>& std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>::operator=(const std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>&)’
         staledatapair = std::make_pair(udn, staledata);
                                                      ^
In file included from /usr/include/c++/8/bits/stl_algobase.h:64,
                 from /usr/include/c++/8/bits/char_traits.h:39,
                 from /usr/include/c++/8/string:40,
                 from /home/u243348@PORT.L-3Com.com/work-mmcm2/install/include/CCcommon/version.H:19,
                 from config.H:13,
                 from config.C:11:
/usr/include/c++/8/bits/stl_pair.h:208:12: note: ‘std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>& std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>::operator=(const std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>&)’ is implicitly declared as deleted because ‘std::pair<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>’ declares a move constructor or move assignment operator
     struct pair
            ^~~~
config.C:200:41: error: no matching function for call to ‘std::map<std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>::insert(asv::scm::helm::config_t::statedatapair_t&)’
         m_staledata.insert(staledatapair);
                                         ^
In file included from /usr/include/c++/8/map:61,
                 from config.H:15,
                 from config.C:11:

Can anyone see what I don't?

[Edit] Modified typedefs:

    typedef std::string staledatamapkey_t;
    typedef staledata_t staledatamapvalue_t;
    typedef std::map<const staledatamapkey_t, staledatamapvalue_t> staledatamap_t;
    typedef std::pair<const staledatamapkey_t, staledatamapvalue_t> statedatapair_t;

I've also swapped the insert for emplace .

Still getting errors:

config.C:199:42:   required from here
/usr/include/c++/8/ext/new_allocator.h:136:4: error: no matching function for call to ‘std::pair<const std::__cxx11::basic_string<char>, asv::scm::helm::config_t::staledata_t>::pair(std::pair<const std::__cxx11::basic_string<char>, const asv::scm::helm::config_t::staledata_t>&)’
  { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/bits/stl_algobase.h:64,
                 from /usr/include/c++/8/bits/char_traits.h:39,
                 from /usr/include/c++/8/string:40,
                 from /home/u243348@PORT.L-3Com.com/work-mmcm2/install/include/CCcommon/version.H:19,
                 from config.H:13,
                 from config.C:11:
/usr/include/c++/8/bits/stl_pair.h:436:9: note: candidate: ‘template<class ... _Args1, long unsigned int ..._Indexes1, class ... _Args2, long unsigned int ..._Indexes2> std::pair<_T1, _T2>::pair(std::tuple<_Args1 ...>&, std::tuple<_Args2 ...>&, std::_Index_tuple<_Indexes1 ...>, std::_Index_tuple<_Indexes2 ...>)’
         pair(tuple<_Args1...>&, tuple<_Args2...>&,
         ^~~~
/usr/include/c++/8/bits/stl_pair.h:436:9: note:   template argument deduction/substitution failed:
In file included from /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h:33,
                 from /usr/include/c++/8/bits/allocator.h:46,
                 from /usr/include/c++/8/string:41,
                 from /home/u243348@PORT.L-3Com.com/work-mmcm2/install/include/CCcommon/version.H:19,
                 from config.H:13,
                 from config.C:11:
/usr/include/c++/8/ext/new_allocator.h:136:4: note:   ‘std::pair<const std::__cxx11::basic_string<char>, const asv::scm::helm::config_t::staledata_t>’ is not derived from ‘std::tuple<_Tps ...>’

[Edit2] staledata_t:

struct staledata_t
    {
        std::string udn;                    //< Unique Data Number
        std::string expiry;                 //< Watchdog expiry
        std::string ddo;                    //< Different Data Only Flag
        std::string tolerance;              //< Data change tolerance
        std::string ip;                     //< Indicator placement

        QImage img;                         //< Stale image/icon
        QTimer watchdog;                    //< Watchdog timer
        bool stale;                         //< true if data stale else false

        staledata_t()
        {
            QObject::connect(&watchdog, &QTimer::timeout, [this] {
                if ( stale != false ) {
    //Already stale, do nothing
                    return;
                }
                stale = true;
            });
            stale = false;            
        }
        void kickWatchdog()
        {
            const QString timeStr(expiry.data());
            const QTime tm(QTime::fromString(timeStr));
            const int msecs(tm.msec());
            watchdog.start(msecs);
        }
    };

Answer 1

In the end I rewrote, replacing the use of struct with a class and also crossing over to QMap instead of std::map :

    class staledata_t : QObject
    {
        Q_OBJECT

    private:
        QString m_ddo;                    //< Different Data Only Flag
        QString m_expiry;                 //< Watchdog expiry
        QString m_ip;                     //< Indicator placement
        QString m_tolerance;              //< Data change tolerance
        QString m_udn;                    //< Unique Data Number
        QImage m_img;                     //< Stale image/icon
        QTimer m_watchdog;                //< Watchdog timer
        bool m_stale;                     //< true if data stale else false

    public:
        staledata_t() : QObject(nullptr)
        {
            QObject::connect(&m_watchdog, &QTimer::timeout, [this] {
                if ( m_stale != false ) {
    //Already stale, do nothing
                    return;
                }
                m_stale = true;
            });
            m_stale = false;
        }
        void kickWatchdog()
        {
            const QTime tm(QTime::fromString(m_expiry));
            const int msecs(tm.msec());
            m_watchdog.start(msecs);
            m_stale = false;
        }
        const QString& ddo() { return m_ddo; }
        const QString& expiry() { return m_expiry; }
        const QImage& img() { return m_img; }
        const QString& ip() { return m_ip; }
        void setDDO(const QString &ddo) { m_ddo = ddo; }
        void setExpiry(const QString &expiry) { m_expiry = expiry; }
        void setIMG(const QImage& img) { m_img = img; }
        void setIP(const QString& ip) { m_ip = ip; }
        void setStale(bool stale) { m_stale = stale; }
        void setTolerance(const QString& tolerance) { m_tolerance = tolerance; }
        void setUDN(const QString &udn) { m_udn = udn; }
        bool stale() { return m_stale; }
        const QString udn() { return m_udn; }

        Q_PROPERTY(QString ddo READ ddo WRITE setDDO)
        Q_PROPERTY(QString expiry READ expiry WRITE setExpiry)
        Q_PROPERTY(QImage img READ img WRITE setIMG)
        Q_PROPERTY(QString ip READ ip WRITE setIP)
        Q_PROPERTY(bool stale READ stale WRITE setStale)
        Q_PROPERTY(QString tolerance READ tolerance WRITE setTolerance)
        Q_PROPERTY(QString udn READ udn WRITE setUDN)
    };

Types:

    typedef QString staledatamapkey_t;
    typedef staledata_t* staledatamapvalue_t;
    typedef QMap<const staledatamapkey_t, staledatamapvalue_t> staledatamap_t;

Usage:

for (unsigned i = 0; i < xAllstaledata.size (); ++i)
    {
        const staledataXML_t xStaledata = xAllstaledata[i];
        staledatamapvalue_t staledata = new staledata_t;
        staledatamapkey_t udn(xStaledata.udn);
        staledata->setUDN(udn);
        staledata->setExpiry(xStaledata.expiry);
        staledata->setDDO(xStaledata.ddo);
        staledata->setTolerance(xStaledata.tolerance);
        staledata->setIP(xStaledata.ip);
        m_staledata.insert(udn, staledata);
    }