filesystem.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <cstdio>
#include <ctime>
 
#include <string>
#include <list>
 
#include "datastore.h"
#include "mediaunit.h"
#include "mediaplayer.h"
#include "audio/audiooutput.h"
#include "fundamentals.h"
#include "musiclibrary.h"
#include "musiclibraryparameters.h"
 
namespace Filesystem {
 
    class Source;
    class Player;
    class Library;
    class Album;
    class Song;
 
    class Artist : public MusicLibrary::Artist {
        friend Album;  // Partial path from library base to artist directory.
        friend Song;
 
    private:
        std::string _path;  
    public:
        using MusicLibrary::Artist::Artist;
        void path (std::string p);
        std::string path() const;
        virtual Parsnip::Data persist() const override;
        virtual void restore (const Parsnip::Data &data) override;
    };
 
    class Album : public MusicLibrary::Album {
        friend Song;
 
    private:
        std::string _path;  
    public:
        using MusicLibrary::Album::Album;
        void path (std::string p);
        std::string path() const;
        virtual void makeCompilation (MusicLibrary::Artist *compilation_artist) override;
        virtual Parsnip::Data persist() const override;
        virtual void restore (const Parsnip::Data &data) override;
    };
 
    class Song : public MusicLibrary::Song {
        friend Source;
        friend Player;
        friend Library;
 
    private:
        std::string _path;     
        bool present = false;  
    public:
        using MusicLibrary::Song::Song;
        void path (std::string p);
        std::string path() const;
        virtual Parsnip::Data persist() const override final;
        virtual void restore (const Parsnip::Data &data) override final;
        virtual PianodConnection &transmitPrivate (PianodConnection &recipient) const override final;
        virtual void serializePrivate (Parsnip::Data &, const User *user) const override final;
    };
 
    struct Parameters : public MusicLibrary::LibraryParameters {
        std::string path;
 
        Parameters (Ownership::Type perm, User *user = nullptr);
        Parameters (const UserData::JSONData &src);
        virtual bool persist (UserData::JSONData &dest) const override final;
        void sanitize (void);
    };
 
    class Library : public MusicLibrary::Library {
        friend Source;
        friend Song;
 
    private:
        using base_library = MusicLibrary::Library;
        using ScanFrequency = MusicLibrary::ScanFrequency;
        std::string _path;
        time_t last_scan = 0;
        bool links_warned = false;
        bool permissions_warned = false;
        time_t next_validity_check = 0;
        bool valid = false;
        ScanFrequency scan_behavior;
 
        enum class ScanItemType { DIRECTORY, FILE };
 
        struct ScanWorkItem {
            ScanItemType type = ScanItemType::FILE;
            std::string path;
            ScanWorkItem (const std::string &newpath) {
                path = newpath;
            }
        };
        typedef std::list<ScanWorkItem> SearchList;
        SearchList searches;
 
    protected:
        void purge();
        virtual void persist (Parsnip::Data &into) const override;
        virtual bool restore (const Parsnip::Data &data) override;
 
    public:
        Library (Media::Source *const owner,
                 const bool persistence,
                 const std::string directory,
                 const MusicLibrary::ScanFrequency behavior);
        inline const std::string &path() {
            return _path;
        };
        float periodic();
        bool checkValidity();
        void startScan();
        void clear();
        bool scanDirectory (const std::string &path);
        void indexFile (const std::string &path);
    };
 
    class Source : public Media::Source {
        friend class Playlist;
 
    private:
        Library library;
        PianodPlaylist *mix_playlist = nullptr;
        PianodPlaylist *everything_playlist = nullptr;
 
    public:
        Source (const Parameters &params);
        ~Source (void);
 
        // Identity
        virtual const char *kind (void) const override;
 
        // Capability check methods
        virtual bool canExpandToAllSongs (void) const override;
 
        // General source stuff
        virtual bool flush (void) override;
        virtual float periodic (void) override;
 
        // Playlist methods
        virtual PlaylistList getPlaylists (const Filter &filter = Filter::All) override;
        virtual MusicThingie *getAnythingById (const Media::SplitId &id) override;
        virtual PianodPlaylist *getMixPlaylist (void) override;
        virtual PianodPlaylist *getEverythingPlaylist (void) override;
 
        // Creating playlists
        virtual PianodPlaylist *createPlaylist (const char *name, MusicThingie::Type type, MusicThingie *from) override;
        virtual PianodPlaylist *createPlaylist (const char *name, const Filter &filter) override;
        virtual PianodPlaylist *getTransientPlaylist (const Filter &criteria) override;
 
        // Miscellaneous
        virtual Media::Player *getPlayer (const AudioSettings &audio, PianodSong *song) override;
        virtual SongList getRandomSongs (PianodPlaylist *playlist,
                                         const UserList &users,
                                         Media::SelectionMethod selectionMethod) override;
        virtual ThingieList getSuggestions (const Filter &filter, SearchRange where) override;
        virtual void playbackProblem (void) override;
 
        // Typecasts
        virtual MusicThingie *getSuggestion (MusicThingie *thing, MusicThingie::Type type, SearchRange where) override;
 
        // Utilities
        void rescan (bool reset);
    };
}  // namespace Filesystem