void JoystickEntityHandler::OnDeletedEntityInternal(const Safir::Dob::EntityProxy &entityProxy)
    {
        Safir::Logging::SendSystemLog(Safir::Logging::Informational,
                                      L"delete Joystick entity: " + entityProxy.GetEntityId().ToString());

        m_engine->DeleteJoystickCB(entityProxy.GetEntityId());
    }
//-------------------------------------------------------
void
PersistenceHandler::Write(const Safir::Dob::EntityProxy& entityProxy, const bool update)
{
    m_debug << "Will try to persist entity " << entityProxy.GetEntityId() << std::endl;

    const char* blob = entityProxy.GetBlob();

    Safir::Dob::Typesystem::BinarySerialization bin =
        std::vector<char>(blob,blob+Safir::Dob::Typesystem::Internal::BlobOperations::GetSize(blob));

    Store(entityProxy.GetEntityId(), entityProxy.GetOwner(), bin, update);
}
    void JoystickEntityHandler::OnNewEntityInternal(const Safir::Dob::EntityProxy &entityProxy)
    {
        Safir::Logging::SendSystemLog(Safir::Logging::Informational,
                                      L"New Joystick entity: " + entityProxy.GetEntityId().ToString());

        const Consoden::TankGame::JoystickPtr joystick_ptr = 
            boost::static_pointer_cast<Consoden::TankGame::Joystick>(entityProxy.GetEntity());

        if (joystick_ptr->GameId() == m_gameId) {
            // Joystick for our game
            m_engine->NewJoystickCB(joystick_ptr->TankId().GetVal(), entityProxy.GetEntityId());
        }
    }
//-------------------------------------------------------
void
PersistenceHandler::OnDeletedEntity(const Safir::Dob::EntityProxy entityProxy,
                                    const bool                    deletedByOwner)
{
    // Remove it from the throttling structure if it happens to be there
    m_toBeWritten.erase(entityProxy.GetEntityId());

    // only remove if removed by owner... Otherwise it is probably because the system shut down or the application died
    if( !deletedByOwner )
    {
        return;
    }

    m_debug << "Removing entity " << entityProxy.GetEntityId() << std::endl;
    Remove(entityProxy);
}
//-------------------------------------------------------
void
PersistenceHandler::HandleEntity(const Safir::Dob::EntityProxy& entityProxy, const bool update)
{
    auto writePeriodIt = m_writePeriod.find(entityProxy.GetTypeId());

    if (writePeriodIt != m_writePeriod.cend())
    {
        // This entity type has a write period limit

        const auto now = boost::chrono::steady_clock::now();

        const auto writePeriod = writePeriodIt->second;

        auto toBeWrittenIt = m_toBeWritten.find(entityProxy.GetEntityId());

        if (toBeWrittenIt == m_toBeWritten.cend())
        {
            // If the entity instance doesn't exist in the map then this instance has never been written.
            // Write it right away!
            Write(entityProxy, update);

            m_toBeWritten[entityProxy.GetEntityId()] = std::make_pair(now + writePeriod,
                                                                      false);  // dirty flag
            m_nextTimeout = now; // Force timeout and a recalculation of nextTimeout
        }
        else if (m_toBeWritten[entityProxy.GetEntityId()].first < now)
        {
            // This instance hasn't been written within its write period
            // Write it right away!
            Write(entityProxy, update);

            toBeWrittenIt->second.first = now + writePeriod; // next timeout
            toBeWrittenIt->second.second = false;            // dirty flag
            m_nextTimeout = now; // Force timeout and a recalculation of nextTimeout
        }
        else
        {
            // Otherwise, mark the entity as dirty and wait until the timer strikes.
            toBeWrittenIt->second.second = true;
        }
    }
    else
    {
        Write(entityProxy, update);
    }
}
//-------------------------------------------------------
void
PersistenceHandler::HandleTimeout()
{
    const auto now = boost::chrono::steady_clock::now();

    // Don't iterate through all unless we are due for a write timeout.
    if (now > m_nextTimeout)
    {
        m_nextTimeout = boost::chrono::steady_clock::time_point::max();

        for (auto entity = m_toBeWritten.begin(); entity != m_toBeWritten.end(); ++entity)
        {
            // Should we write this object?
            if (entity->second.second && entity->second.first < now)
            {
                // The object is dirty and its time to write it
                try
                {
                    const Safir::Dob::EntityProxy entityProxy = m_dobConnection.Read(entity->first);

                    m_debug << "Periodic write time ended for entity " << entityProxy.GetEntityId() << std::endl;

                    Write(entityProxy,true);

                    // Set next write time ...
                    entity->second.first = now + m_writePeriod[entity->first.GetTypeId()];

                    // ...and reset dirty flag
                    entity->second.second = false;
                }
                catch(const Safir::Dob::NotFoundException &)
                {
                    // This could happen if the instance has been deleted but we haven't been told yet
                    // Just fall through and erase it from our internal structure. The delete callback will
                    // take care of this.
                }
            }

            if (entity->second.first < m_nextTimeout)
            {
                m_nextTimeout = entity->second.first;
            }
        }
    }

    m_writeTimer.expires_from_now(boost::chrono::seconds(1));
    m_writeTimer.async_wait([this](const boost::system::error_code& error)
    {
        if (!error)
        {
            HandleTimeout();
        }
    });
}
//-------------------------------------------------------
void OdbcPersistor::Remove(const Safir::Dob::EntityProxy& entityProxy)
{
    Remove(entityProxy.GetEntityId());
}