metadb_handle.h

Go to the documentation of this file.

class titleformat_hook;
class titleformat_text_filter;
class titleformat_object;


class metadb_info_container : public service_base {
    FB2K_MAKE_SERVICE_INTERFACE(metadb_info_container, service_base);
public:
    virtual file_info const & info() = 0;
    virtual t_filestats const & stats() = 0;
    virtual bool isInfoPartial() = 0;
};


class NOVTABLE metadb_handle : public service_base
{
public:
    virtual const playable_location & get_location() const = 0;//never fails, returned pointer valid till the object is released


    virtual bool format_title(titleformat_hook * p_hook,pfc::string_base & p_out,const service_ptr_t<titleformat_object> & p_script,titleformat_text_filter * p_filter) = 0;

    __declspec(deprecated) virtual void metadb_lock() = 0;
    __declspec(deprecated) virtual void metadb_unlock() = 0;
    
    virtual t_filestats get_filestats() const = 0;

    virtual bool is_info_loaded() const = 0;
    virtual bool get_info(file_info & p_info) const = 0;

    __declspec(deprecated) virtual bool get_info_locked(const file_info * & p_info) const = 0;
    
    virtual bool is_info_loaded_async() const = 0;  
    virtual bool get_info_async(file_info & p_info) const = 0;  

    __declspec(deprecated) virtual bool get_info_async_locked(const file_info * & p_info) const = 0;

    virtual void format_title_from_external_info(const file_info & p_info,titleformat_hook * p_hook,pfc::string_base & p_out,const service_ptr_t<titleformat_object> & p_script,titleformat_text_filter * p_filter) = 0;

    __declspec(deprecated) virtual bool format_title_nonlocking(titleformat_hook * p_hook,pfc::string_base & p_out,const service_ptr_t<titleformat_object> & p_script,titleformat_text_filter * p_filter) = 0;
    __declspec(deprecated) virtual void format_title_from_external_info_nonlocking(const file_info & p_info,titleformat_hook * p_hook,pfc::string_base & p_out,const service_ptr_t<titleformat_object> & p_script,titleformat_text_filter * p_filter) = 0;

#if FOOBAR2000_TARGET_VERSION >= 76
    virtual bool get_browse_info(file_info & info, t_filetimestamp & ts) const = 0;

    __declspec(deprecated) virtual bool get_browse_info_locked(const file_info * & p_info, t_filetimestamp & ts) const = 0;
#endif
#if FOOBAR2000_TARGET_VERSION >= 78
    virtual bool get_info_ref(metadb_info_container::ptr & outInfo) const = 0;

    virtual bool get_async_info_ref(metadb_info_container::ptr & outInfo) const = 0;

    virtual void get_browse_info_ref(metadb_info_container::ptr & outInfo, metadb_info_container::ptr & outBrowse) const = 0;

    virtual metadb_info_container::ptr get_info_ref() const = 0; 
    virtual metadb_info_container::ptr get_async_info_ref() const = 0;  

    metadb_info_container::ptr get_full_info_ref( abort_callback & aborter ) const;
#endif

    bool get_browse_info_merged(file_info & infoMerged) const;


    static bool g_should_reload(const t_filestats & p_old_stats,const t_filestats & p_new_stats,bool p_fresh);
    bool should_reload(const t_filestats & p_new_stats,bool p_fresh) const;
    

    bool format_title_legacy(titleformat_hook * p_hook,pfc::string_base & out,const char * p_spec,titleformat_text_filter * p_filter);

    inline const char * get_path() const {return get_location().get_path();}
    inline t_uint32 get_subsong_index() const {return get_location().get_subsong_index();}
    
    double get_length();//helper
    
    t_filetimestamp get_filetimestamp();
    t_filesize get_filesize();

    FB2K_MAKE_SERVICE_INTERFACE(metadb_handle,service_base);
};

typedef service_ptr_t<metadb_handle> metadb_handle_ptr;

typedef pfc::list_base_t<metadb_handle_ptr> & metadb_handle_list_ref;
typedef pfc::list_base_const_t<metadb_handle_ptr> const & metadb_handle_list_cref;

namespace metadb_handle_list_helper {
    void sort_by_format(metadb_handle_list_ref p_list,const char * spec,titleformat_hook * p_hook);
    void sort_by_format_get_order(metadb_handle_list_cref p_list,t_size* order,const char * spec,titleformat_hook * p_hook);
    void sort_by_format(metadb_handle_list_ref p_list,const service_ptr_t<titleformat_object> & p_script,titleformat_hook * p_hook, int direction = 1);
    void sort_by_format_get_order(metadb_handle_list_cref p_list,t_size* order,const service_ptr_t<titleformat_object> & p_script,titleformat_hook * p_hook,int p_direction = 1);

    void sort_by_relative_path(metadb_handle_list_ref p_list);
    void sort_by_relative_path_get_order(metadb_handle_list_cref p_list,t_size* order);
    
    void remove_duplicates(pfc::list_base_t<metadb_handle_ptr> & p_list);
    void sort_by_pointer_remove_duplicates(pfc::list_base_t<metadb_handle_ptr> & p_list);
    void sort_by_path_quick(pfc::list_base_t<metadb_handle_ptr> & p_list);

    void sort_by_pointer(pfc::list_base_t<metadb_handle_ptr> & p_list);
    t_size bsearch_by_pointer(const pfc::list_base_const_t<metadb_handle_ptr> & p_list,const metadb_handle_ptr & val);

    double calc_total_duration(const pfc::list_base_const_t<metadb_handle_ptr> & p_list);

    void sort_by_path(pfc::list_base_t<metadb_handle_ptr> & p_list);

    t_filesize calc_total_size(metadb_handle_list_cref list, bool skipUnknown = false);
    t_filesize calc_total_size_ex(metadb_handle_list_cref list, bool & foundUnknown);

    bool extract_single_path(metadb_handle_list_cref list, const char * &path);
};

template<template<typename> class t_alloc = pfc::alloc_fast >
class metadb_handle_list_t : public service_list_t<metadb_handle,t_alloc> {
private:
    typedef metadb_handle_list_t<t_alloc> t_self;
    typedef list_base_const_t<metadb_handle_ptr> t_interface;
public:
    inline void sort_by_format(const char * spec,titleformat_hook * p_hook) {
        return metadb_handle_list_helper::sort_by_format(*this, spec, p_hook);
    }
    inline void sort_by_format_get_order(t_size* order,const char * spec,titleformat_hook * p_hook) const {
        metadb_handle_list_helper::sort_by_format_get_order(*this, order, spec, p_hook);
    }

    inline void sort_by_format(const service_ptr_t<titleformat_object> & p_script,titleformat_hook * p_hook, int direction = 1) {
        metadb_handle_list_helper::sort_by_format(*this, p_script, p_hook, direction);
    }
    inline void sort_by_format_get_order(t_size* order,const service_ptr_t<titleformat_object> & p_script,titleformat_hook * p_hook) const {
        metadb_handle_list_helper::sort_by_format_get_order(*this, order, p_script, p_hook);
    }
    
    inline void sort_by_relative_path() {
        metadb_handle_list_helper::sort_by_relative_path(*this);
    }
    inline void sort_by_relative_path_get_order(t_size* order) const {
        metadb_handle_list_helper::sort_by_relative_path_get_order(*this,order);
    }
    
    inline void remove_duplicates() {metadb_handle_list_helper::remove_duplicates(*this);}
    inline void sort_by_pointer_remove_duplicates() {metadb_handle_list_helper::sort_by_pointer_remove_duplicates(*this);}
    inline void sort_by_path_quick() {metadb_handle_list_helper::sort_by_path_quick(*this);}

    inline void sort_by_pointer() {metadb_handle_list_helper::sort_by_pointer(*this);}
    inline t_size bsearch_by_pointer(const metadb_handle_ptr & val) const {return metadb_handle_list_helper::bsearch_by_pointer(*this,val);}

    inline double calc_total_duration() const {return metadb_handle_list_helper::calc_total_duration(*this);}

    inline void sort_by_path() {metadb_handle_list_helper::sort_by_path(*this);}

    const t_self & operator=(const t_self & p_source) {remove_all(); add_items(p_source);return *this;}
    const t_self & operator=(const t_interface & p_source) {remove_all(); add_items(p_source);return *this;}
    const t_self & operator=(t_self && p_source) {move_from(p_source); return *this; }
    metadb_handle_list_t(const t_self & p_source) {add_items(p_source);}
    metadb_handle_list_t(const t_interface & p_source) {add_items(p_source);}
    metadb_handle_list_t() {}

    metadb_handle_list_t(t_self && p_source) {move_from(p_source);}

    t_self & operator+=(const t_interface & source) {add_items(source); return *this;}
    t_self & operator+=(const metadb_handle_ptr & source) {add_item(source); return *this;}

    bool extract_single_path(const char * &path) const {return metadb_handle_list_helper::extract_single_path(*this, path);}
};

typedef metadb_handle_list_t<> metadb_handle_list;

namespace metadb_handle_list_helper {
    void sorted_by_pointer_extract_difference(metadb_handle_list const & p_list_1,metadb_handle_list const & p_list_2,metadb_handle_list & p_list_1_specific,metadb_handle_list & p_list_2_specific);
};


inline pfc::string_base & operator<<(pfc::string_base & p_fmt,const metadb_handle_ptr & p_location) {
    if (p_location.is_valid()) 
        return p_fmt << p_location->get_location();
    else
        return p_fmt << "[invalid location]";
}


class string_format_title {
public:
    string_format_title(metadb_handle_ptr p_item,const char * p_script) {
        p_item->format_title_legacy(NULL,m_data,p_script,NULL);
    }
    string_format_title(metadb_handle_ptr p_item,service_ptr_t<class titleformat_object> p_script) {
        p_item->format_title(NULL,m_data,p_script,NULL);
    }

    const char * get_ptr() const {return m_data.get_ptr();}
    operator const char * () const {return m_data.get_ptr();}
private:
    pfc::string8_fastalloc m_data;
};