musiccache.h

Go to the documentation of this file.

 
#pragma once
 
#include <retainer.h>
 
struct ThingieCache {
    Retainer<MusicThingie *> item;
    mutable time_t expiration = 0;
    void extend (int seconds = 600) const;
};
 
struct ThingiePoolParameters {
    using size_type = unsigned long;
    time_t initial_duration{ 3600 };           
    time_t reprieve_duration{ 900 };           
    size_type minimum_retained_items{ 4000 };  
    size_type maximum_retained_items{ 4800 };  
    time_t purge_interval{ 307 };              
};
 
class ThingiePool : protected std::unordered_map<std::string, ThingieCache> {
private:
    using map_type = std::unordered_map<std::string, ThingieCache>;
    ThingiePoolParameters settings;
    time_t next_purge{ time (nullptr) + 4000 };
    time_t oldest_entry{ time (nullptr) };
 
    void purge (void);
 
public:
    ThingiePool();
    ThingiePool (const ThingiePoolParameters &params);
    void setParameters (const ThingiePoolParameters &params);
    void add (MusicThingie *thing, bool update = false);
    void add (const SongList &songs);
    void add (const ThingieList &things);
    inline void update (MusicThingie *thing) {
        add (thing, true);
    }
    void update (const SongList &songs);
    void update (const ThingieList &things);
    void erase (MusicThingie *thing);
    MusicThingie *get (const std::string &id);
    ThingieList get (const Filter &filter);
    inline void periodic (void) {
        if (next_purge <= time (nullptr))
            purge();
    }
};
 
class PersistentPool : public ThingiePool {
protected:
    Media::Source * const source{ nullptr }; 
    mutable time_t write_time{ 0 }; 
 
public:
    PersistentPool (Media::Source * const src);
    PersistentPool (Media::Source * const src, const ThingiePoolParameters &params);
 
    inline void markDirty() {
        time_t now = time (nullptr);
        if (write_time == 0) {
            write_time = now + 3600 * 6;
        } else if (write_time > now) {
            write_time -= 5;
        }
    }
    
    inline bool isDirty() const {
        return (write_time != 0);
    }
    
    inline void clearDirty() const {
        write_time = 0;
    }
    
    inline bool writeIsDue () const {
        return (write_time > time (nullptr));
    }
 
    Parsnip::Data persist() const;
    void restore (const Parsnip::Data &data);
    
    virtual MusicThingie *reconstruct (MusicThingie::Type type, const Parsnip::Data &data) = 0;
 
    inline void add (MusicThingie *thing) {
        ThingiePool::add (thing);
        markDirty();
    }
    inline void add (const SongList &songs) {
        ThingiePool::add (songs);
        markDirty();
    }
    inline void add (const ThingieList &things) {
        ThingiePool::add (things);
        markDirty();
    }
};