cache.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017-2024 Norbert Schlia (nschlia@oblivion-software.de)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * On Debian systems, the complete text of the GNU General Public License
 * Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
 */
 
#ifndef CACHE_H
#define CACHE_H
 
#pragma once
 
#include "buffer.h"
 
#include <map>
#include <memory>
 
#define     DB_BASE_VERSION_MAJOR   1               
#define     DB_BASE_VERSION_MINOR   0               
#define     DB_VERSION_MAJOR        1               
#define     DB_VERSION_MINOR        97              
#define     DB_MIN_VERSION_MAJOR    1               
#define     DB_MIN_VERSION_MINOR    97              
typedef struct sqlite3 sqlite3;                     
typedef struct sqlite3_stmt sqlite3_stmt;           
enum class RESULTCODE
{
    NONE,                                
    FINISHED_INCOMPLETE,                 
    FINISHED_SUCCESS,                    
    FINISHED_ERROR,                      
};
typedef RESULTCODE const *LPCRESULTCODE;            
typedef RESULTCODE *LPRESULTCODE;                   
typedef struct CACHE_INFO
{
    std::string             m_origfile;             
    std::string             m_destfile;             
    std::array<char, 11>    m_desttype;             
    int64_t                 m_audiobitrate;         
    int                     m_audiosamplerate;      
    int64_t                 m_videobitrate;         
    int                     m_videowidth;           
    int                     m_videoheight;          
    bool                    m_deinterlace;          
    int64_t                 m_duration;             
    size_t                  m_predicted_filesize;   
    size_t                  m_encoded_filesize;     
    uint32_t                m_video_frame_count;    
    uint32_t                m_segment_count;        
    RESULTCODE              m_result;               
    bool                    m_error;                
    int                     m_errno;                
    int                     m_averror;              
    time_t                  m_creation_time;        
    time_t                  m_access_time;          
    time_t                  m_file_time;            
    size_t                  m_file_size;            
    unsigned int            m_access_count;         
} CACHE_INFO;
typedef CACHE_INFO const *LPCCACHE_INFO;            
typedef CACHE_INFO *LPCACHE_INFO;                   
class Cache_Entry;
 
class Cache
{
    typedef std::pair<std::string, std::string> cache_key_t;    
    typedef std::map<cache_key_t, Cache_Entry *> cache_t;       
public:
    typedef struct
    {
        const char *    name;                               
        const char *    primary_key;                        
    } TABLE_DEF;
    typedef TABLE_DEF const *LPCTABLE_DEF;                  
    typedef TABLE_DEF *LPTABLE_DEF;                         
    typedef struct
    {
        const char *    name;                               
        const char *    type;                               
    } TABLE_COLUMNS;
    typedef TABLE_COLUMNS const *LPCTABLE_COLUMNS;          
    typedef TABLE_COLUMNS *LPTABLE_COLUMNS;                 
    typedef std::vector<TABLE_COLUMNS> TABLECOLUMNS_VEC;    
    typedef TABLECOLUMNS_VEC const *LPCTABLECOLUMNS_VEC;    
    typedef TABLECOLUMNS_VEC *LPTABLECOLUMNS_VEC;           
    friend class Cache_Entry;
 
    class sqlite_t
    {
    public:
        explicit sqlite_t(const std::string & filename, int flags, const char *zVfs = nullptr);
        virtual ~sqlite_t();
 
        int     ret() const { return m_ret; };
 
#ifdef HAVE_SQLITE_CACHEFLUSH
        bool    flush_index();
#endif // HAVE_SQLITE_CACHEFLUSH
 
        operator sqlite3*() { return m_db_handle; };
 
        const std::string & filename() const { return m_filename; };
 
    protected:
        int                     m_ret;                  
        std::string             m_filename;             
        sqlite3*                m_db_handle;            
    public:
        sqlite3_stmt *          m_select_stmt;          
        sqlite3_stmt *          m_insert_stmt;          
        sqlite3_stmt *          m_delete_stmt;          
    };
 
public:
    explicit Cache();
    virtual ~Cache();
    Cache_Entry *           openio(LPVIRTUALFILE virtualfile);
    bool                    closeio(Cache_Entry **cache_entry, int flags = CACHE_CLOSE_NOOPT);
    bool                    load_index();
    bool                    maintenance(size_t predicted_filesize = 0);
    bool                    clear();
    bool                    prune_expired();
    bool                    prune_cache_size();
    bool                    prune_disk_space(size_t predicted_filesize);
    bool                    remove_cachefile(const std::string & filename, const std::string &fileext);
 
protected:
    bool                    read_info(LPCACHE_INFO cache_info);
    bool                    write_info(LPCCACHE_INFO cache_info);
    bool                    delete_info(const std::string & filename, const std::string & desttype);
    Cache_Entry*            create_entry(LPVIRTUALFILE virtualfile, const std::string & desttype);
    bool                    delete_entry(Cache_Entry **cache_entry, int flags);
    void                    close_index();
    std::string             expanded_sql(sqlite3_stmt *pStmt);
    bool                    prepare_stmts();
    bool                    table_exists(const char *table);
    bool                    column_exists(const char *table, const char *column);
    bool                    check_min_version(int *db_version_major, int *db_version_minor);
    int                     cmp_version(int version_major_l, int version_minor_l, int version_major_r, int version_minor_r);
    bool                    begin_transaction();
    bool                    end_transaction();
    bool                    rollback_transaction();
    bool                    create_table_cache_entry(LPCTABLE_DEF table, const TABLECOLUMNS_VEC & columns);
    /*
     */
    bool                    upgrade_db(int *db_version_major, int *db_version_minor);
 
private:
    static const TABLE_DEF          m_table_cache_entry;    
    static const TABLECOLUMNS_VEC   m_columns_cache_entry;  
    static const TABLE_DEF          m_table_version;        
    static const TABLECOLUMNS_VEC   m_columns_version;      
    std::recursive_mutex            m_mutex;                
    std::unique_ptr<sqlite_t>       m_cacheidx_db;          
    cache_t                         m_cache;                
};
 
#endif