refs #649, added flags amd configuration class for caching strategies of DB data

(use cache? TTL? ...)

src/blackcore/db/databasereaderconfig.cpp

@@ -0,0 +1,129 @@
+/* Copyright (C) 2016
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+#include "blackcore/db/databasereaderconfig.h"
+
+using namespace BlackMisc;
+using namespace BlackMisc::Db;
+using namespace BlackMisc::Network;
+using namespace BlackMisc::PhysicalQuantities;
+
+namespace BlackCore
+{
+    namespace Db
+    {
+        CDatabaseReaderConfig::CDatabaseReaderConfig(CEntityFlags::Entity entities, CDbFlags::DataRetrievalMode retrievalFlags, const CTime &cacheLifetime) :
+            m_entities(entities), m_retrievalFlags(retrievalFlags), m_cacheLifetime(cacheLifetime)
+        {
+            // void
+        }
+
+        QString CDatabaseReaderConfig::convertToQString(bool i18n) const
+        {
+            QString s(CDbFlags::flagToString(this->getRetrievalMode()));
+            s.append(" ");
+            s.append(CEntityFlags::flagToString(this->getEntities()));
+            s.append(" ");
+            s.append(this->m_cacheLifetime.toFormattedQString(i18n));
+            return s;
+        }
+
+        CEntityFlags::Entity CDatabaseReaderConfig::getEntities() const
+        {
+            return static_cast<CEntityFlags::Entity>(this->m_entities);
+        }
+
+        CDbFlags::DataRetrievalMode CDatabaseReaderConfig::getRetrievalMode() const
+        {
+            return static_cast<CDbFlags::DataRetrievalMode>(this->m_retrievalFlags);
+        }
+
+        void CDatabaseReaderConfig::setCacheLifetime(const CTime &time)
+        {
+            this->m_cacheLifetime = time;
+        }
+
+        bool CDatabaseReaderConfig::isValid() const
+        {
+            return this->m_entities != BlackMisc::Network::CEntityFlags::NoEntity;
+        }
+
+        CDatabaseReaderConfigList::CDatabaseReaderConfigList(const CSequence<CDatabaseReaderConfig> &other) :
+            CSequence<CDatabaseReaderConfig>(other)
+        { }
+
+        CDatabaseReaderConfig CDatabaseReaderConfigList::findFirstOrDefaultForEntity(const CEntityFlags::Entity entities) const
+        {
+            const bool single = CEntityFlags::isSingleEntity(entities);
+            const CEntityFlags::EntityFlag testFlag = CEntityFlags::entityToEntityFlag(entities); // cannot cast directly
+            for (const CDatabaseReaderConfig &config : *this)
+            {
+                if (single)
+                {
+                    if (config.getEntities().testFlag(testFlag)) { return config; }
+                }
+                else
+                {
+                    if (config.getEntities() == entities) { return config; }
+                }
+            }
+            return CDatabaseReaderConfig(); // not found
+        }
+
+        void CDatabaseReaderConfigList::setCacheLifetimes(const CTime &time)
+        {
+            for (CDatabaseReaderConfig &config : *this)
+            {
+                config.setCacheLifetime(time);
+            }
+        }
+
+        CDatabaseReaderConfigList CDatabaseReaderConfigList::forMappingTool()
+        {
+            const CTime timeout(5.0, CTimeUnit::min());
+            const CDbFlags::DataRetrievalMode retrievalFlags = CDbFlags::DbCached;
+            CDatabaseReaderConfigList l;
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::AircraftIcaoEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::AirlineIcaoEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::DistributorEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::ModelEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::LiveryEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::CountryEntity, retrievalFlags, timeout));
+            return l;
+        }
+
+        CDatabaseReaderConfigList CDatabaseReaderConfigList::forPilotClient()
+        {
+            const CTime timeout(24.0, CTimeUnit::h());
+            const CDbFlags::DataRetrievalMode retrievalFlags = CDbFlags::SharedCached;
+            CDatabaseReaderConfigList l;
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::AircraftIcaoEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::AirlineIcaoEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::DistributorEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::ModelEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::LiveryEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::CountryEntity, retrievalFlags, timeout));
+            return l;
+        }
+
+        CDatabaseReaderConfigList CDatabaseReaderConfigList::allDirectDbAccess()
+        {
+            const CTime timeout(0.0, CTimeUnit::min());
+            const CDbFlags::DataRetrievalMode retrievalFlags = CDbFlags::DbDirect;
+            CDatabaseReaderConfigList l;
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::AircraftIcaoEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::AirlineIcaoEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::DistributorEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::ModelEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::LiveryEntity, retrievalFlags, timeout));
+            l.push_back(CDatabaseReaderConfig(CEntityFlags::CountryEntity, retrievalFlags, timeout));
+            return l;
+        }
+    } // ns
+} // ns

src/blackcore/db/databasereaderconfig.h

@@ -0,0 +1,111 @@
+/* Copyright (C) 2016
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKCORE_DB_DATABASE_READERCONFIG_H
+#define BLACKCORE_DB_DATABASE_READERCONFIG_H
+
+#include "blackcore/blackcoreexport.h"
+#include "blackmisc/pq/time.h"
+#include "blackmisc/network/entityflags.h"
+#include "blackmisc/network/url.h"
+#include "blackmisc/db/dbflags.h"
+#include "blackmisc/sequence.h"
+#include "blackmisc/valueobject.h"
+
+#include <QDateTime>
+#include <QJsonArray>
+#include <QObject>
+#include <QReadWriteLock>
+#include <QString>
+#include <QTimer>
+#include <QtGlobal>
+
+namespace BlackCore
+{
+    namespace Db
+    {
+        //! Details how to read
+        class BLACKCORE_EXPORT CDatabaseReaderConfig : public BlackMisc::CValueObject<CDatabaseReaderConfig>
+        {
+        public:
+            //! Default constructor.
+            CDatabaseReaderConfig() = default;
+
+            //! Constructor for one or multiple entities
+            CDatabaseReaderConfig(BlackMisc::Network::CEntityFlags::Entity entities,
+                                  BlackMisc::Db::CDbFlags::DataRetrievalMode retrievalFlags,
+                                  const BlackMisc::PhysicalQuantities::CTime &cacheLifetime = BlackMisc::PhysicalQuantities::CTime());
+
+            //! \copydoc BlackMisc::Mixin::String::toQString
+            QString convertToQString(bool i18n = false) const;
+
+            //! Supported entities
+            BlackMisc::Network::CEntityFlags::Entity getEntities() const;
+
+            //! Supported modes
+            BlackMisc::Db::CDbFlags::DataRetrievalMode getRetrievalMode() const;
+
+            //! Timeout
+            void setCacheLifetime(const BlackMisc::PhysicalQuantities::CTime &time);
+
+            //! Fully initialized
+            bool isValid() const;
+
+        private:
+            int m_entities = BlackMisc::Network::CEntityFlags::NoEntity;  //!< BlackMisc::Network::CEntityFlags::Entity
+            int m_retrievalFlags = BlackMisc::Db::CDbFlags::DbDirect;     //!< BlackMisc::Db::CDbFlags::DataRetrievalMode
+            BlackMisc::PhysicalQuantities::CTime m_cacheLifetime;
+
+            BLACK_METACLASS(
+                CDatabaseReaderConfig,
+                BLACK_METAMEMBER(entities),
+                BLACK_METAMEMBER(retrievalFlags),
+                BLACK_METAMEMBER(cacheLifetime));
+        };
+
+        //! Value object encapsulating a list of reader configs.
+        class BLACKCORE_EXPORT CDatabaseReaderConfigList :
+            public BlackMisc::CSequence<CDatabaseReaderConfig>,
+            public BlackMisc::Mixin::MetaType<CDatabaseReaderConfigList>
+        {
+        public:
+            BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CDatabaseReaderConfigList)
+
+            //! Default constructor.
+            CDatabaseReaderConfigList() = default;
+
+            //! Construct from a base class object.
+            CDatabaseReaderConfigList(const CSequence<CDatabaseReaderConfig> &other);
+
+            //! FInd first one matching given
+            CDatabaseReaderConfig findFirstOrDefaultForEntity(const BlackMisc::Network::CEntityFlags::Entity entities) const;
+
+            //! Update lifetimes
+            void setCacheLifetimes(const BlackMisc::PhysicalQuantities::CTime &time);
+
+            //! Init for mapping tool
+            static CDatabaseReaderConfigList forMappingTool();
+
+            //! Init for pilot client
+            static CDatabaseReaderConfigList forPilotClient();
+
+            //! Init all with direct DB access
+            static CDatabaseReaderConfigList allDirectDbAccess();
+        };
+    } // ns
+} // ns
+
+Q_DECLARE_METATYPE(BlackCore::Db::CDatabaseReaderConfig)
+Q_DECLARE_METATYPE(BlackCore::Db::CDatabaseReaderConfigList)
+Q_DECLARE_METATYPE(BlackMisc::CCollection<BlackCore::Db::CDatabaseReaderConfig>)
+Q_DECLARE_METATYPE(BlackMisc::CSequence<BlackCore::Db::CDatabaseReaderConfig>)
+
+#endif // guard

src/blackmisc/db/dbflags.cpp

@@ -0,0 +1,52 @@
+/* Copyright (C) 2015
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+#include "blackmisc/db/dbflags.h"
+#include "blackmisc/verify.h"
+
+#include <QStringList>
+#include <QtGlobal>
+
+namespace BlackMisc
+{
+    namespace Db
+    {
+        QString CDbFlags::flagToString(CDbFlags::DataRetrievalModeFlag flag)
+        {
+            switch (flag)
+            {
+            case Unspecified: return "Unspecified";
+            case DbDirect: return "Direct DB access";
+            case Shared: return "Shared data";
+            case Cached: return "Cached data";
+            default:
+                BLACK_VERIFY_X(false, Q_FUNC_INFO, "wrong flags");
+                return "wrong flags";
+            }
+        }
+
+        QString CDbFlags::flagToString(BlackMisc::Db::CDbFlags::DataRetrievalMode flag)
+        {
+            QStringList list;
+            if (flag.testFlag(Unspecified)) list << "Unspecified";
+            if (flag.testFlag(DbDirect)) list << "Direct DB access";
+            if (flag.testFlag(Shared)) list << "Shared data";
+            if (flag.testFlag(Cached)) list << "Cached data";
+            return list.join(',');
+        }
+
+        void CDbFlags::registerMetadata()
+        {
+            // this is no value class and I register enums here,
+            // that's why I do not use the Mixins
+            qRegisterMetaType<CDbFlags::DataRetrievalModeFlag>();
+            qRegisterMetaType<CDbFlags::DataRetrievalMode>();
+        }
+    } // namespace
+} // namespace

src/blackmisc/db/dbflags.h

@@ -0,0 +1,58 @@
+/* Copyright (C) 2015
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKMISC_DB_DBFLAGS_H
+#define BLACKMISC_DB_DBFLAGS_H
+
+#include "blackmisc/blackmiscexport.h"
+
+#include <QFlags>
+#include <QMetaType>
+#include <QString>
+
+namespace BlackMisc
+{
+    namespace Db
+    {
+        /*!
+         * What and state of reading from web services
+         */
+        class BLACKMISC_EXPORT CDbFlags
+        {
+        public:
+            //! Which data to read, requires corresponding readers
+            enum DataRetrievalModeFlag
+            {
+                Unspecified            = 0,                  //!< Unspecified
+                DbDirect               = 1 << 0,             //!< directly from DB
+                Shared                 = 1 << 1,             //!< shared directory
+                Cached                 = 1 << 2,             //!< from cache
+                DbCached               = DbDirect | Cached,  //!< from DB, but cache when possible
+                SharedCached           = Shared | Cached     //!< from shared files, but cache when possible
+            };
+            Q_DECLARE_FLAGS(DataRetrievalMode, DataRetrievalModeFlag)
+
+            //! Convert to string
+            static QString flagToString(DataRetrievalModeFlag flag);
+
+            //! Convert to string
+            static QString flagToString(BlackMisc::Db::CDbFlags::DataRetrievalMode flag);
+
+            //! Register metadata
+            static void registerMetadata();
+        };
+    } // namespace
+} // namespace
+
+Q_DECLARE_METATYPE(BlackMisc::Db::CDbFlags::DataRetrievalModeFlag)
+Q_DECLARE_METATYPE(BlackMisc::Db::CDbFlags::DataRetrievalMode)
+
+#endif // guard