metadb.h

Go to the documentation of this file.

class NOVTABLE metadb_io : public service_base
{
public:
    enum t_load_info_type {
        load_info_default,
        load_info_force,
        load_info_check_if_changed
    };

    enum t_update_info_state {
        update_info_success,
        update_info_aborted,
        update_info_errors,     
    };
    
    enum t_load_info_state {
        load_info_success,
        load_info_aborted,
        load_info_errors,       
    };

    __declspec(deprecated) virtual bool is_busy() = 0;
    __declspec(deprecated) virtual bool is_updating_disabled() = 0;
    __declspec(deprecated) virtual bool is_file_updating_blocked() = 0;
    __declspec(deprecated) virtual void highlight_running_process() = 0;
    __declspec(deprecated) virtual t_load_info_state load_info_multi(metadb_handle_list_cref p_list,t_load_info_type p_type,HWND p_parent_window,bool p_show_errors) = 0;
    __declspec(deprecated) virtual t_update_info_state update_info_multi(metadb_handle_list_cref p_list,const pfc::list_base_const_t<file_info*> & p_new_info,HWND p_parent_window,bool p_show_errors) = 0;
    __declspec(deprecated) virtual t_update_info_state rewrite_info_multi(metadb_handle_list_cref p_list,HWND p_parent_window,bool p_show_errors) = 0;
    __declspec(deprecated) virtual t_update_info_state remove_info_multi(metadb_handle_list_cref p_list,HWND p_parent_window,bool p_show_errors) = 0;

    virtual void hint_multi(metadb_handle_list_cref p_list,const pfc::list_base_const_t<const file_info*> & p_infos,const pfc::list_base_const_t<t_filestats> & p_stats,const bit_array & p_fresh_mask) = 0;

    virtual void hint_multi_async(metadb_handle_list_cref p_list,const pfc::list_base_const_t<const file_info*> & p_infos,const pfc::list_base_const_t<t_filestats> & p_stats,const bit_array & p_fresh_mask) = 0;

    virtual void hint_reader(service_ptr_t<class input_info_reader> p_reader,const char * p_path,abort_callback & p_abort) = 0;

    virtual void path_to_handles_simple(const char * p_path, metadb_handle_list_ref p_out) = 0;

    virtual void dispatch_refresh(metadb_handle_list_cref p_list) = 0;

    void dispatch_refresh(metadb_handle_ptr const & handle) {dispatch_refresh(pfc::list_single_ref_t<metadb_handle_ptr>(handle));}

    void hint_async(metadb_handle_ptr p_item,const file_info & p_info,const t_filestats & p_stats,bool p_fresh);

    __declspec(deprecated) t_load_info_state load_info(metadb_handle_ptr p_item,t_load_info_type p_type,HWND p_parent_window,bool p_show_errors);
    __declspec(deprecated) t_update_info_state update_info(metadb_handle_ptr p_item,file_info & p_info,HWND p_parent_window,bool p_show_errors);
    
    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(metadb_io);
};

class NOVTABLE file_info_filter : public service_base {
public:
    virtual bool apply_filter(metadb_handle_ptr p_location,t_filestats p_stats,file_info & p_info) = 0;
    
    FB2K_MAKE_SERVICE_INTERFACE(file_info_filter,service_base);
};

class NOVTABLE metadb_hint_list : public service_base {
    FB2K_MAKE_SERVICE_INTERFACE(metadb_hint_list,service_base);
public:
    virtual void add_hint(metadb_handle_ptr const & p_location,const file_info & p_info,const t_filestats & p_stats,bool p_freshflag) = 0;
    virtual void add_hint_reader(const char * p_path,service_ptr_t<input_info_reader> const & p_reader,abort_callback & p_abort) = 0;
    virtual void on_done() = 0;
};

class NOVTABLE metadb_hint_list_v2 : public metadb_hint_list {
    FB2K_MAKE_SERVICE_INTERFACE(metadb_hint_list_v2, metadb_hint_list);
public:
    virtual void add_hint_browse(metadb_handle_ptr const & p_location,const file_info & p_info, t_filetimestamp browseTS) = 0;
};

class NOVTABLE metadb_hint_list_v3 : public metadb_hint_list_v2 {
    FB2K_MAKE_SERVICE_INTERFACE(metadb_hint_list_v3, metadb_hint_list_v2);
public:
    virtual void add_hint_v3(metadb_handle_ptr const & p_location, metadb_info_container::ptr info,bool p_freshflag) = 0;
    virtual void add_hint_browse_v3(metadb_handle_ptr const & p_location,metadb_info_container::ptr info) = 0;

    virtual void add_hint_forced(metadb_handle_ptr const & p_location, const file_info & p_info,const t_filestats & p_stats,bool p_freshflag) = 0;
    virtual void add_hint_forced_v3(metadb_handle_ptr const & p_location, metadb_info_container::ptr info,bool p_freshflag) = 0;
    virtual void add_hint_forced_reader(const char * p_path,service_ptr_t<input_info_reader> const & p_reader,abort_callback & p_abort) = 0;
};


class NOVTABLE metadb_io_v2 : public metadb_io {
public:
    enum {
        op_flag_no_errors       = 1 << 0,
        op_flag_background      = 1 << 1,
        op_flag_delay_ui        = 1 << 2,

        op_flag_partial_info_aware = 1 << 3,
    };

    virtual void load_info_async(metadb_handle_list_cref p_list,t_load_info_type p_type,HWND p_parent_window,t_uint32 p_op_flags,completion_notify_ptr p_notify) = 0;
    virtual void update_info_async(metadb_handle_list_cref p_list,service_ptr_t<file_info_filter> p_filter,HWND p_parent_window,t_uint32 p_op_flags,completion_notify_ptr p_notify) = 0;
    virtual void rewrite_info_async(metadb_handle_list_cref p_list,HWND p_parent_window,t_uint32 p_op_flags,completion_notify_ptr p_notify) = 0;
    virtual void remove_info_async(metadb_handle_list_cref p_list,HWND p_parent_window,t_uint32 p_op_flags,completion_notify_ptr p_notify) = 0;

    virtual metadb_hint_list::ptr create_hint_list() = 0;

    void update_info_async_simple(metadb_handle_list_cref p_list,const pfc::list_base_const_t<const file_info*> & p_new_info, HWND p_parent_window,t_uint32 p_op_flags,completion_notify_ptr p_notify);

    FB2K_MAKE_SERVICE_INTERFACE(metadb_io_v2,metadb_io);
};


class NOVTABLE metadb_io_callback_dynamic {
public:
    virtual void on_changed_sorted(metadb_handle_list_cref p_items_sorted, bool p_fromhook) = 0;
};

class NOVTABLE metadb_io_v3 : public metadb_io_v2 {
public:
    virtual void register_callback(metadb_io_callback_dynamic * p_callback) = 0;
    virtual void unregister_callback(metadb_io_callback_dynamic * p_callback) = 0;

    FB2K_MAKE_SERVICE_INTERFACE(metadb_io_v3,metadb_io_v2);
};

class metadb_io_callback_dynamic_impl_base : public metadb_io_callback_dynamic {
public:
    void on_changed_sorted(metadb_handle_list_cref p_items_sorted, bool p_fromhook) {}
    
    metadb_io_callback_dynamic_impl_base() {static_api_ptr_t<metadb_io_v3>()->register_callback(this);}
    ~metadb_io_callback_dynamic_impl_base() {static_api_ptr_t<metadb_io_v3>()->unregister_callback(this);}

    PFC_CLASS_NOT_COPYABLE_EX(metadb_io_callback_dynamic_impl_base)
};
class NOVTABLE metadb_io_callback : public service_base {
public:
    virtual void on_changed_sorted(metadb_handle_list_cref p_items_sorted, bool p_fromhook) = 0;

    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(metadb_io_callback);
};

class NOVTABLE metadb_io_edit_callback : public service_base {
    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(metadb_io_edit_callback)
public:
    typedef const pfc::list_base_const_t<const file_info*> & t_infosref;
    virtual void on_edited(metadb_handle_list_cref items, t_infosref before, t_infosref after) = 0;
};

class NOVTABLE metadb : public service_base
{
protected:  
    virtual void database_lock()=0;
    virtual void database_unlock()=0;
public:
    
    virtual void handle_create(metadb_handle_ptr & p_out,const playable_location & p_location)=0;

    void handle_create_replace_path_canonical(metadb_handle_ptr & p_out,const metadb_handle_ptr & p_source,const char * p_new_path);
    void handle_replace_path_canonical(metadb_handle_ptr & p_out,const char * p_new_path);
    void handle_create_replace_path(metadb_handle_ptr & p_out,const metadb_handle_ptr & p_source,const char * p_new_path);

    static bool g_get_random_handle(metadb_handle_ptr & p_out);

    enum {case_sensitive = true};
    typedef pfc::comparator_strcmp path_comparator;

    inline static int path_compare_ex(const char * p1,t_size len1,const char * p2,t_size len2) {return case_sensitive ? pfc::strcmp_ex(p1,len1,p2,len2) : stricmp_utf8_ex(p1,len1,p2,len2);}
    inline static int path_compare_nc(const char * p1, size_t len1, const char * p2, size_t len2) {return case_sensitive ? pfc::strcmp_nc(p1,len1,p2,len2) : stricmp_utf8_ex(p1,len1,p2,len2);}
    inline static int path_compare(const char * p1,const char * p2) {return case_sensitive ? strcmp(p1,p2) : stricmp_utf8(p1,p2);}
    inline static int path_compare_metadb_handle(const metadb_handle_ptr & p1,const metadb_handle_ptr & p2) {return path_compare(p1->get_path(),p2->get_path());}

    metadb_handle_ptr handle_create(playable_location const & l) {metadb_handle_ptr temp; handle_create(temp, l); return temp;}
    metadb_handle_ptr handle_create(const char * path, uint32_t subsong) {return handle_create(make_playable_location(path, subsong));}

    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(metadb);
};

class titleformat_text_out;
class titleformat_hook_function_params;


class NOVTABLE metadb_display_field_provider : public service_base {
public:
    virtual t_uint32 get_field_count() = 0;
    virtual void get_field_name(t_uint32 index, pfc::string_base & out) = 0;
    virtual bool process_field(t_uint32 index, metadb_handle * handle, titleformat_text_out * out) = 0;

    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(metadb_display_field_provider);
};





class file_info_filter_impl : public file_info_filter {
public:
    file_info_filter_impl(const pfc::list_base_const_t<metadb_handle_ptr> & p_list,const pfc::list_base_const_t<const file_info*> & p_new_info) {
        FB2K_DYNAMIC_ASSERT(p_list.get_count() == p_new_info.get_count());
        pfc::array_t<t_size> order;
        order.set_size(p_list.get_count());
        order_helper::g_fill(order.get_ptr(),order.get_size());
        p_list.sort_get_permutation_t(pfc::compare_t<metadb_handle_ptr,metadb_handle_ptr>,order.get_ptr());
        m_handles.set_count(order.get_size());
        m_infos.set_size(order.get_size());
        for(t_size n = 0; n < order.get_size(); n++) {
            m_handles[n] = p_list[order[n]];
            m_infos[n] = *p_new_info[order[n]];
        }
    }

    bool apply_filter(metadb_handle_ptr p_location,t_filestats p_stats,file_info & p_info) {
        t_size index;
        if (m_handles.bsearch_t(pfc::compare_t<metadb_handle_ptr,metadb_handle_ptr>,p_location,index)) {
            p_info = m_infos[index];
            return true;
        } else {
            return false;
        }
    }
private:
    metadb_handle_list m_handles;
    pfc::array_t<file_info_impl> m_infos;
};


// typedef hasher_md5_result metadb_index_hash;
typedef t_uint64 metadb_index_hash;


class NOVTABLE metadb_index_client : public service_base {
    FB2K_MAKE_SERVICE_INTERFACE(metadb_index_client, service_base)
public:
    virtual metadb_index_hash transform(const file_info & info, const playable_location & location) = 0;

    bool hashHandle(metadb_handle_ptr const & h, metadb_index_hash & out) {
        metadb_info_container::ptr info;
        if (!h->get_info_ref(info)) return false;
        out = transform(info->info(), h->get_location());
        return true;
    }

    static metadb_index_hash from_md5(hasher_md5_result const & in) {return in.xorHalve();}
};

class NOVTABLE metadb_index_manager : public service_base {
    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(metadb_index_manager)
public:
    virtual void add(metadb_index_client::ptr client, const GUID & index_id, t_filetimestamp userDataRetentionPeriod) = 0;
    virtual void remove(const GUID & index_id) = 0;
    virtual void set_user_data(const GUID & index_id, const metadb_index_hash & hash, const void * data, t_size dataSize) = 0;
    virtual void get_user_data(const GUID & index_id, const metadb_index_hash & hash, mem_block_container & out) = 0;


    template<typename t_array> void get_user_data_t(const GUID & index_id, const metadb_index_hash & hash, t_array & out) {
        mem_block_container_ref_impl<t_array> ref(out);
        get_user_data(index_id, hash, ref);
    }

    t_size get_user_data_here(const GUID & index_id, const metadb_index_hash & hash, void * out, t_size outSize) {
        mem_block_container_temp_impl ref(out, outSize);
        get_user_data(index_id, hash, ref);
        return ref.get_size();
    }

    virtual void dispatch_refresh(const GUID & index_id, const pfc::list_base_const_t<metadb_index_hash> & hashes) = 0;
    
    void dispatch_refresh(const GUID & index_id, const metadb_index_hash & hash) {
        pfc::list_single_ref_t<metadb_index_hash> l(hash);
        dispatch_refresh(index_id, l);
    }

    virtual void dispatch_global_refresh() = 0;

    virtual void get_ML_handles(const GUID & index_id, const metadb_index_hash & hash, metadb_handle_list_ref out) = 0;

    virtual void get_all_hashes(const GUID & index_id, pfc::list_base_t<metadb_index_hash> & out) = 0;

    virtual bool have_orphaned_data(const GUID & index_id) = 0;

    virtual void erase_orphaned_data(const GUID & index_id) = 0;

    virtual void save_index_data(const GUID & index_id) = 0;
};