seqIDataMgr.cpp

            if(!(m_bFastSavingMode && itRtc->first == "TTSENSORTEMP"))
                itRtc->second = m_pGetRtcStatus(itRtc->first);
        }
    }

    if(m_pGetTcsPreset && !m_bFastSavingMode)
    {
        m_TcsPreset = m_pGetTcsPreset();
    }

    m_bInstrumentSetupUpdated = true;
    U8_LLOG(__FUNCTION__);
}

float SeqDataMgr::getMeanTemperature()
{
    const std::map<std::string, indi::IElement> & elementsA = sharknirTemperatureDetector.getElements();
    float valueA = 0.f, valueB = 0.f;
    bool bValueA = false, bValueB = false;
    if(elementsA.find("value") != elementsA.end())
    {
        valueA = elementsA.find("value")->second.get<float>();
        bValueA = true;
    }
    const std::map<std::string, indi::IElement> & elementsB = sharknirTemperatureColdFinger.getElements();
    if(elementsB.find("value") != elementsB.end())
    {
        valueB = elementsB.find("value")->second.get<float>();
        bValueB = true;
    }

    float meanTemperature = 0.f;
    if(bValueA)meanTemperature += valueA;
    if(bValueB)meanTemperature += valueB;
    if(bValueA && bValueB)meanTemperature /= 2.f;

    return meanTemperature;
}



int SeqDataMgr::getJsonStatus(std::string & jsonStatus)
{
    int status = EXIT_SUCCESS;
    // GET TEMPERATURE STATUS 
    const std::map<std::string, indi::IElement> & temperatureA_elements = sharknirTemperatureDetector.getElements();
    float valueA = 0.f;
    if(temperatureA_elements.find("value") != temperatureA_elements.end())
    {
        valueA = temperatureA_elements.find("value")->second.get<float>();
    }

    {
        std::stringstream json_alias;
        json_alias << "\"sasha_temp\": { \"name\": \"sasha_temp\", \"value\": \"" << valueA << "\"}";
        jsonStatus += json_alias.str();
        jsonStatus += ", ";
    }
    // GET NUM READS 
    const std::map<std::string, indi::IElement> & nreads_elements = sashaNumReads.getElements();
    int NREADS = 0;
    if(nreads_elements.find("value") != nreads_elements.end())
    {
        NREADS = nreads_elements.find("value")->second.get<int>();
    }

    {
        std::stringstream json_alias;
        json_alias << "\"NREADS\": { \"name\": \"NREADS\", \"value\": \"" << NREADS << "\"}";
        jsonStatus += json_alias.str();
        jsonStatus += ", ";
    }
    // GET NUM COADDS
    const std::map<std::string, indi::IElement> & ncoadds_elements = sashaNumCoadds.getElements();
    int NCOADDS = 0;
    if(ncoadds_elements.find("value") != ncoadds_elements.end())
    {
        NCOADDS = ncoadds_elements.find("value")->second.get<int>();
    }

    {
        std::stringstream json_alias;
        json_alias << "\"NCOADDS\": { \"name\": \"NCOADDS\", \"value\": \"" << NCOADDS << "\"}";
        jsonStatus += json_alias.str();
        jsonStatus += ", ";
    }

    // GET NUM DROPS
    const std::map<std::string, indi::IElement> & ndrops_elements = sashaNumDrops.getElements();
    int NDROPS = 0;
    if(ndrops_elements.find("value") != ndrops_elements.end())
    {
        NDROPS = ndrops_elements.find("value")->second.get<int>();
    }

    {
        std::stringstream json_alias;
        json_alias << "\"NDROPS\": { \"name\": \"NDROPS\", \"value\": \"" << NDROPS << "\"}";
        jsonStatus += json_alias.str();
        jsonStatus += ", ";
    }

    // GET NUM GROUPS
    const std::map<std::string, indi::IElement> & ngroups_elements = sashaNumGroups.getElements();
    int NGROUPS = 0;
    if(ngroups_elements.find("value") != ngroups_elements.end())
    {
        NGROUPS = ngroups_elements.find("value")->second.get<int>();
    }

    {
        std::stringstream json_alias;
        json_alias << "\"NGROUPS\": { \"name\": \"NGROUPS\", \"value\": \"" << NGROUPS << "\"}";
        jsonStatus += json_alias.str();
        jsonStatus += ", ";
    }

    // GET NDIT
    const std::map<std::string, indi::IElement> & ndit_elements = sashaNumSeqs.getElements();
    int NDIT = 0;
    if(ndit_elements.find("value") != ndit_elements.end())
    {
        NDIT = ndit_elements.find("value")->second.get<int>();
    }

    {
        std::stringstream json_alias;
        json_alias << "\"NDIT\": { \"name\": \"NDIT\", \"value\": \"" << NDIT << "\"}";
        jsonStatus += json_alias.str();
        //jsonStatus += ", ";
    }

    
    return status;
}


void SeqDataMgr::setFlags(uint64_t flags, uint64_t more_flags)
{
    if(flags & shins::flags::SAVE_INCOMING_SASHA_FILES)
    {
        m_bSaveIncomingBlob = true;
        U9_LLOG("Save Incoming Sasha files : " << "ON");
    }
    if(flags & shins::flags::SEQDATA_TEST01)
    {
        m_bTest01 = true;
        U9_LLOG("SeqIDataMgr TEST01 : " << "ON");
    }
    if(flags & shins::flags::SAVE_ONLY_EXPOSED_SASHA_FILES)// 2
    {
        if(!m_bSaveOnlyExposedFiles)
        {
            m_bSaveOnlyExposedFiles = true;
            m_bFlagChanged = true;
        }
        U9_LLOG("Save only exposed files : " << "ON");
    }
    if(flags & shins::flags::SEQDATA_FORCE_PROPERTY_SET)
    {
        m_bForcePropertySet = true;
        U9_LLOG("SeqIDataMgr Force Property Set : " << "ON");
    }
    if(flags & shins::flags::FAST_SAVING_MODE)
    {
        updateInstrumentHeader();
        m_bFastSavingMode = true;
        U9_LLOG("SeqIDataMgr Fast Saving Mode Set : ON");
    }
};
void SeqDataMgr::unsetFlags(uint64_t flags, uint64_t more_flags)
{
    if(flags & shins::flags::SAVE_INCOMING_SASHA_FILES)
    {
        m_bSaveIncomingBlob = false;
        U9_LLOG("Save Incoming Sasha files : " << "OFF");
    }
    if(flags & shins::flags::SEQDATA_TEST01)
    {
        m_bTest01 = false;
        U9_LLOG("SeqIDataMgr TEST01 : " << "OFF");
    }
    if(flags & shins::flags::SAVE_ONLY_EXPOSED_SASHA_FILES)// 2
    {
        if(m_bSaveOnlyExposedFiles)
        {
            m_bSaveOnlyExposedFiles = false;
            m_bFlagChanged = true;
        }
        U9_LLOG("Save only exposed files : " << "OFF");
    }
    if(flags & shins::flags::SEQDATA_FORCE_PROPERTY_SET)
    {
        m_bForcePropertySet = false;
        U9_LLOG("SeqIDataMgr Force Property Set : " << "OFF");
    }
    if(flags & shins::flags::FAST_SAVING_MODE)
    {
        m_bFastSavingMode = false;
        U9_LLOG("SeqIDataMgr Fast Saving Mode Set : OFF");
    }
};

void SeqDataMgr::toggleFlags(uint64_t flags, uint64_t more_flags)
{
    if(flags & shins::flags::SAVE_INCOMING_SASHA_FILES)
    {
        m_bSaveIncomingBlob = !m_bSaveIncomingBlob;
        U9_LLOG("Save incoming Sasha files : " << (m_bSaveIncomingBlob ? "ON" : "OFF"));
    }
    if(flags & shins::flags::SEQDATA_TEST01)
    {
        m_bTest01 = !m_bTest01;
        U9_LLOG("SeqIDataMgr TEST01 : " << (m_bTest01 ? "ON" : "OFF"));
    }
    if(flags & shins::flags::SAVE_ONLY_EXPOSED_SASHA_FILES) // 2
    {
        m_bSaveOnlyExposedFiles = !m_bSaveOnlyExposedFiles;
        m_bFlagChanged = true;
        U9_LLOG("Save only exposed files : " << (m_bSaveOnlyExposedFiles ? "ON" : "OFF"));
    }
    if(flags & shins::flags::SEQDATA_FORCE_PROPERTY_SET)
    {
        m_bForcePropertySet = !m_bForcePropertySet;
        U9_LLOG("SeqIDataMgr Force Property Set : " << (m_bForcePropertySet ? "ON" : "OFF"));
    }
    if(flags & shins::flags::FAST_SAVING_MODE)
    {
        if(!m_bFastSavingMode)
        {
            updateInstrumentHeader();
        }
        m_bFastSavingMode = !m_bFastSavingMode;
        U9_LLOG("SeqIDataMgr Fast Saving Mode Set : " << (m_bFastSavingMode ? "ON" : "OFF"));
    }
};


void dummy()
{

}