database_file_source.hpp

Go to the documentation of this file.

#pragma once
 
#include <mbgl/storage/file_source.hpp>
#include <mbgl/storage/offline.hpp>
#include <mbgl/util/expected.hpp>
 
namespace mbgl {
 
class ClientOptions;
class ResourceOptions;
 
// TODO: Split DatabaseFileSource into Ambient cache and Database interfaces.
class DatabaseFileSource : public FileSource {
public:
    explicit DatabaseFileSource(const ResourceOptions& resourceOptions, const ClientOptions& clientOptions);
    ~DatabaseFileSource() override;
 
    std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
    void forward(const Resource&, const Response&, std::function<void()> callback) override;
    bool canRequest(const Resource&) const override;
    void setProperty(const std::string&, const mapbox::base::Value&) override;
    void pause() override;
    void resume() override;
 
    // Methods common to Ambient cache and Offline functionality
 
    virtual void setDatabasePath(const std::string&, std::function<void()> callback);
 
    virtual void resetDatabase(std::function<void(std::exception_ptr)>);
 
    virtual void packDatabase(std::function<void(std::exception_ptr)> callback);
 
    virtual void runPackDatabaseAutomatically(bool);
 
    // Ambient cache
 
    virtual void put(const Resource&, const Response&);
 
    virtual void invalidateAmbientCache(std::function<void(std::exception_ptr)>);
 
    virtual void clearAmbientCache(std::function<void(std::exception_ptr)>);
 
    virtual void setMaximumAmbientCacheSize(uint64_t size, std::function<void(std::exception_ptr)> callback);
 
    // Offline
 
    virtual void listOfflineRegions(std::function<void(expected<OfflineRegions, std::exception_ptr>)>);
 
    virtual void createOfflineRegion(const OfflineRegionDefinition& definition,
                                     const OfflineRegionMetadata& metadata,
                                     std::function<void(expected<OfflineRegion, std::exception_ptr>)>);
    virtual void updateOfflineMetadata(int64_t regionID,
                                       const OfflineRegionMetadata& metadata,
                                       std::function<void(expected<OfflineRegionMetadata, std::exception_ptr>)>);
 
    virtual void setOfflineRegionObserver(const OfflineRegion&, std::unique_ptr<OfflineRegionObserver>);
 
    virtual void setOfflineRegionDownloadState(const OfflineRegion&, OfflineRegionDownloadState);
 
    virtual void getOfflineRegionStatus(const OfflineRegion&,
                                        std::function<void(expected<OfflineRegionStatus, std::exception_ptr>)>) const;
 
    virtual void mergeOfflineRegions(const std::string& sideDatabasePath,
                                     std::function<void(expected<OfflineRegions, std::exception_ptr>)>);
 
    virtual void deleteOfflineRegion(const OfflineRegion&, std::function<void(std::exception_ptr)>);
 
    virtual void invalidateOfflineRegion(const OfflineRegion&, std::function<void(std::exception_ptr)>);
 
    virtual void setOfflineMapboxTileCountLimit(uint64_t) const;
 
    void setResourceOptions(ResourceOptions) override;
    ResourceOptions getResourceOptions() override;
 
    void setClientOptions(ClientOptions) override;
    ClientOptions getClientOptions() override;
 
private:
    class Impl;
    const std::unique_ptr<Impl> impl;
};
 
} // namespace mbgl