Sqlite3 and LevelDB persistent cache plugins + usage from DataSource

carta/cpp/CartaLib/CartaLib.pro

@@ -47,6 +47,8 @@ SOURCES += \
     Algorithms/LineCombiner.cpp \
     IImageRenderService.cpp \
     IRemoteVGView.cpp \
+    IPCache.cpp \
+    Hooks/GetPersistentCache.cpp \
     Hooks/GetProfileExtractor.cpp \
     Regions/IRegion.cpp \
     InputEvents.cpp \
@@ -55,8 +57,7 @@ SOURCES += \
     Regions/CoordinateSystemFormatter.cpp \
     Regions/Ellipse.cpp \
     Regions/Point.cpp \
-    Regions/Rectangle.cpp \
-    IPCache.cpp
+    Regions/Rectangle.cpp
 
 HEADERS += \
     CartaLib.h\
@@ -108,12 +109,14 @@ HEADERS += \
     IImageRenderService.h \
     Hooks/GetImageRenderService.h \
     IRemoteVGView.h \
+    RegionInfo.h \
     Hooks/GetProfileExtractor.h \
     Regions/IRegion.h \
     InputEvents.h \
     Regions/ICoordSystem.h \
     Hooks/CoordSystemHook.h \
     Regions/CoordinateSystemFormatter.h \
+    Hooks/GetPersistentCache.h \
     Regions/Ellipse.h \
     Regions/Point.h \
     Regions/Rectangle.h \

carta/cpp/CartaLib/Hooks/GetPersistentCache.cpp

@@ -0,0 +1,14 @@
+/**
+ *
+ **/
+
+#include "GetPersistentCache.h"
+
+namespace Carta
+{
+namespace Lib
+{
+namespace Hooks
+{ }
+}
+}

carta/cpp/CartaLib/Hooks/GetPersistentCache.h

@@ -0,0 +1,57 @@
+/**
+ * Defines a hook for obtaining a persistent cache object.
+ *
+ **/
+
+#pragma once
+
+#include "CartaLib/CartaLib.h"
+#include "CartaLib/IPlugin.h"
+#include "CartaLib/IPCache.h"
+
+namespace Carta
+{
+namespace Lib
+{
+namespace Hooks
+{
+/// \brief Hook for loading a plugin of an unknown type
+///
+class GetPersistentCache : public BaseHook
+{
+    CARTA_HOOK_BOILER1( GetPersistentCache );
+
+public:
+
+    /// Result of the hook is an instance of IPCache object.
+    /// This hook should only be ever called once, since the persistent cache
+    /// should be treated as a singleton. The reason I am not implementing this
+    /// as a singleton is because in the future, we may addd a mechanism (see below)
+    /// to be able to create multiple independent caches.
+    typedef IPCache::SharedPtr ResultType;
+
+    /// input parameters are:
+    /// nothing
+    /// All necessary parameters are retrieved from carta.config.
+    ///
+    /// In the future we could make this contain overrides of some sort, in case
+    /// some code would like to create additional independent caches...
+    struct Params {
+        Params( )
+        {
+        }
+    };
+
+    /// standard constructor (could be probably a macro)
+    GetPersistentCache( Params * pptr ) : BaseHook( staticId ), paramsPtr( pptr )
+    {
+        // force instantiation of templates
+        CARTA_ASSERT( is < Me > () );
+    }
+
+    ResultType result;
+    Params * paramsPtr = nullptr;
+};
+}
+}
+}

carta/cpp/CartaLib/Hooks/HookIDs.h

@@ -31,7 +31,7 @@ enum class UniqueHookIDs {
     ProfileHook_ID,
     Fit1DHook_ID,
     ImageStatisticsHook_ID,
-
+    GetPersistentCache_ID,
     GetProfileExtractor_ID,
 
     /// region related stuff, still to be considered experimental

carta/cpp/CartaLib/IPCache.h

@@ -1,9 +1,8 @@
-/**
- *
- **/
+/// IPCache is a set of APIs to access persistent cache.
 
 #pragma once
 
+#include "CartaLib/CartaLib.h"
 #include <QJsonObject>
 #include <QByteArray>
 #include <QString>
@@ -15,6 +14,8 @@ namespace Lib
 {
 class IPCache
 {
+    CLASS_BOILERPLATE( IPCache );
+
 public:
 
     /// return maximum storage in bytes
@@ -34,8 +35,8 @@ class IPCache
     deleteAll() = 0;
 
     /// read a value of an entry
-    /// if entry does not exist, val will be null
-    virtual void
+    /// if entry does not exist, false is returned
+    virtual bool
     readEntry( const QByteArray & key,
                QByteArray & val ) = 0;
 

carta/cpp/CartaLib/IPlugin.h

@@ -104,6 +104,9 @@ class IPlugin
 
     /// called immediately after the plugin was loaded
     /// TODO: should be pure virtual, don't be lazy!
+    ///
+    /// This is different from the Initialize hook, which is delivered after
+    /// all plugins have been loaded and after core is started.
     virtual void
     initialize( const InitInfo & initInfo )
     {

carta/cpp/core/Algorithms/cacheUtils.h

@@ -0,0 +1,119 @@
+/**
+ * Functions for serializing and deserializing keys and values to be used with the disk cache
+ **/
+
+#pragma once
+
+/**
+ * Int --> byte array
+ **/ 
+QByteArray i2qb( const int & d) {
+    QByteArray ba;
+    ba.append( (const char *)( & d), sizeof( int));
+    return ba;
+}
+
+/**
+ * Byte array --> int
+ **/ 
+int qb2i( const QByteArray & ba) {
+    if( ba.size() != sizeof(int)) {
+        throw std::runtime_error("Could not unpack QByteArray into int: size is incorrect.");
+    }
+    return * ((const int *) (ba.constData()));
+}
+
+/**
+ * Double --> byte array
+ **/ 
+QByteArray d2qb( const double & d) {
+    QByteArray ba;
+    ba.append( (const char *)( & d), sizeof( double));
+    return ba;
+}
+
+/**
+ * Byte array --> double
+ **/ 
+double qb2d( const QByteArray & ba) {
+    if( ba.size() != sizeof(double)) {
+        throw std::runtime_error("Could not unpack QByteArray into double: size is incorrect.");
+    }
+    return * ((const double *) (ba.constData()));
+}
+
+/**
+ * Vector of doubles --> byte array
+ **/ 
+QByteArray vd2qb( const std::vector<double> & vd) {
+    QByteArray ba;
+    for( const double & d : vd) {
+        ba.append( (const char *)( & d), sizeof( double));
+    }
+    return ba;
+}
+
+/**
+ * Byte array --> vector of doubles
+ **/ 
+std::vector<double> qb2vd( const QByteArray & ba) {
+    std::vector<double> vd;
+    if( ba.size() % sizeof(double) != 0) {
+        throw std::runtime_error("Could not unpack QByteArray into std::vector<double>: size is incorrect.");
+    }
+    const char * cptr = ba.constData();
+    for( int i = 0 ; i < ba.size() ; i += sizeof(double)) {
+        vd.push_back( * ((const double *) (cptr + i)));
+    }
+    return vd;
+}
+
+/**
+ * Vector of integers --> byte array
+ **/ 
+QByteArray vi2qb( const std::vector<int> & vi) {
+    QByteArray ba;
+    for( const int & i : vi) {
+        ba.append( (const char *)( & i), sizeof( int));
+    }
+    return ba;
+}
+
+/**
+ * Byte array --> vector of integers
+ **/ 
+std::vector<int> qb2vi( const QByteArray & ba) {
+    std::vector<int> vi;
+    if( ba.size() % sizeof(int) != 0) {
+        throw std::runtime_error("Could not unpack QByteArray into std::vector<int>: size is incorrect.");
+    }
+    const char * cptr = ba.constData();
+    for( int i = 0 ; i < ba.size() ; i += sizeof(int)) {
+        vi.push_back( * ((const int *) (cptr + i)));
+    }
+    return vi;
+}
+
+/**
+ * Pair of int, double --> byte array
+ **/ 
+QByteArray id2qb( const std::pair<int, double> & id) {
+    QByteArray ba;
+    ba.append( (const char *)( & id.first), sizeof( int));
+    ba.append( (const char *)( & id.second), sizeof( double));
+    return ba;
+}
+
+
+/**
+ * Byte array --> pair of int, double
+ **/ 
+std::pair<int, double> qb2id( const QByteArray & ba) {
+    if( ba.size() != (sizeof(double) + sizeof(int))) {
+        throw std::runtime_error("Could not unpack QByteArray into std::pair<int, double>: size is incorrect.");
+    }
+    const char * cptr = ba.constData();
+    int int_val( * ((const int *) (cptr)));
+    double double_val( * ((const double *) (cptr + sizeof(int))));
+    return std::make_pair(int_val, double_val);
+}