local_history.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <kicommon.h>
#include <io/kicad/kicad_io_utils.h>
#include <settings/common_settings.h>
 
#include <atomic>
#include <future>
#include <memory>
#include <vector>
#include <set>
#include <map>
#include <functional>
#include <string>
#include <wx/arrstr.h>
#include <wx/datetime.h>
#include <wx/string.h>
#include <wx/window.h>
 
class PROGRESS_REPORTER;
 
enum class SNAPSHOT_COMMIT_RESULT
{
    Error,
    NoChanges,
    Committed
};
 

struct KICOMMON_API HISTORY_FILE_DATA
{
    wxString    relativePath;   
    std::string content;        
    wxString    sourcePath;     
    bool        prettify = false;
    KICAD_FORMAT::FORMAT_MODE formatMode = KICAD_FORMAT::FORMAT_MODE::NORMAL;
};
 
struct KICOMMON_API LOCAL_HISTORY_SNAPSHOT_INFO
{
    wxString      hash;
    wxDateTime    date;
    wxString      summary;
    wxString      message;
    int           filesChanged = 0;
    wxArrayString changedFiles;
};

class KICOMMON_API LOCAL_HISTORY
{
public:
    LOCAL_HISTORY();
    ~LOCAL_HISTORY();

    bool Init( const wxString& aProjectPath );

    bool CommitSnapshot( const std::vector<wxString>& aFiles, const wxString& aTitle );

    bool CommitFullProjectSnapshot( const wxString& aProjectPath, const wxString& aTitle );

    void RegisterSaver(
            const void* aSaverObject,
            const std::function<void( const wxString&, std::vector<HISTORY_FILE_DATA>& )>& aSaver,
            const std::weak_ptr<void>& aLifetime = {} );

    void UnregisterSaver( const void* aSaverObject );

    void ClearAllSavers();

    bool RunRegisteredSaversAndCommit( const wxString& aProjectPath, const wxString& aTitle,
                                       const wxString& aTagFileType = wxEmptyString );

    bool RunRegisteredSaversAsAutosaveFiles( const wxString& aProjectPath );

    std::vector<std::pair<wxString, wxString>> FindStaleAutosaveFiles( const wxString&              aProjectPath,
                                                                       const std::vector<wxString>& aExtensions ) const;

    static std::vector<std::pair<wxString, wxString>>
    CollectAutosaveFilePairs( const wxString& aAutosaveRoot, const wxString& aProjectPath,
                              BACKUP_LOCATION aLocation );

    void RemoveAutosaveFiles( const wxString& aProjectPath ) const;

    void RemoveAutosaveFiles( const wxString& aProjectPath,
                              const std::vector<wxString>& aSourcePaths ) const;

    void NoteFileChange( const wxString& aFile );

    bool CommitPending();

    bool HistoryExists( const wxString& aProjectPath );

    bool TagSave( const wxString& aProjectPath, const wxString& aFileType );

    bool CommitDuplicateOfLastSave( const wxString& aProjectPath, const wxString& aFileType,
                                    const wxString& aMessage );

    bool EnforceSizeLimit( const wxString& aProjectPath, size_t aMaxBytes, PROGRESS_REPORTER* aReporter = nullptr );

    bool HeadNewerThanLastSave( const wxString& aProjectPath );

    wxString GetHeadHash( const wxString& aProjectPath );

    bool RestoreCommit( const wxString& aProjectPath, const wxString& aHash, wxWindow* aParent = nullptr,
                        bool aConfirm = true );

    std::vector<LOCAL_HISTORY_SNAPSHOT_INFO> GetSnapshots( const wxString& aProjectPath );

    bool ExtractAllFilesAtCommit( const wxString& aProjectPath, const wxString& aHash, const wxString& aDestDir,
                                  const std::vector<wxString>& aExtensions = {} );

    wxString TreeFingerprint( const wxString& aProjectPath, const wxString& aHash, const wxString& aExtension );

    void ShowRestoreDialog( const wxString& aProjectPath, wxWindow* aParent );

    void WaitForPendingSave();

    bool IsCompacting() const;

    void EnforceSizeLimitInBackground( const wxString& aProjectPath, size_t aMaxBytes );
 
private:
    std::vector<LOCAL_HISTORY_SNAPSHOT_INFO> LoadSnapshots( const wxString& aProjectPath );

    bool enforceSizeLimit( const wxString& aProjectPath, const wxString& aHistoryPath, size_t aMaxBytes,
                           PROGRESS_REPORTER* aReporter );

    SNAPSHOT_COMMIT_RESULT commitInBackground( const wxString& aProjectPath, const wxString& aTitle,
                                               const std::vector<HISTORY_FILE_DATA>& aFileData,
                                               bool aIsManualSave );

    void scheduleCompaction( const wxString& aProjectPath, size_t aLooseLimit );

    void pruneExpiredSavers();
 
    // A registered saver plus the optional liveness token of the document it serializes.  Tracking
    // is opt-in because a live token at registration is what distinguishes a tracked saver from an
    // untracked one (a default-constructed weak_ptr is indistinguishable from an expired one).
    struct SAVER_ENTRY
    {
        std::function<void( const wxString&, std::vector<HISTORY_FILE_DATA>& )> saver;
        std::weak_ptr<void>                                                     lifetime;
        bool                                                                    tracked = false;
    };
 
    std::set<wxString>                 m_pendingFiles;
    std::map<const void*, SAVER_ENTRY> m_savers;
 
    std::atomic<bool> m_saveInProgress{ false };
    std::future<bool> m_pendingFuture;
 
    std::atomic<bool> m_cancelCompaction{ false };
    std::future<void> m_compactFuture;
};