kicad_merge_engine.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, you may find one here:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */
 
#ifndef KICAD_MERGE_ENGINE_H
#define KICAD_MERGE_ENGINE_H
 
#include <kicommon.h>
 
#include <diff_merge/kicad_diff_types.h>
 
#include <nlohmann/json_fwd.hpp>
 
#include <string>
#include <vector>
 
 
namespace KICAD_DIFF
{

enum class PROP_RES
{
    OURS,
    THEIRS,
    ANCESTOR,
    CUSTOM
};
 

enum class ITEM_RES
{
    TAKE_OURS,
    TAKE_THEIRS,
    TAKE_ANCESTOR,
    MERGE_PROPS,
    DELETE_ITEM,
    KEEP
};
 

KICOMMON_API const char* ItemResToString( ITEM_RES aRes );
KICOMMON_API ITEM_RES    ItemResFromString( const std::string& aStr );
 

KICOMMON_API const char* PropResToString( PROP_RES aRes );
KICOMMON_API PROP_RES    PropResFromString( const std::string& aStr );
 
 
struct KICOMMON_API PROPERTY_RESOLUTION
{
    wxString   name;
    PROP_RES   kind = PROP_RES::OURS;
    DIFF_VALUE customValue;   // populated only when kind == CUSTOM
 
    bool                  operator==( const PROPERTY_RESOLUTION& aOther ) const;
    nlohmann::json        ToJson() const;
    static PROPERTY_RESOLUTION FromJson( const nlohmann::json& aJson );
};
 
 
struct KICOMMON_API ITEM_RESOLUTION
{
    KIID_PATH                          id;
    ITEM_RES                           kind = ITEM_RES::KEEP;
    std::vector<PROPERTY_RESOLUTION>   props;
 
    bool                  operator==( const ITEM_RESOLUTION& aOther ) const;
    nlohmann::json        ToJson() const;
    static ITEM_RESOLUTION FromJson( const nlohmann::json& aJson );
};
 

struct KICOMMON_API MERGE_PLAN
{
    std::vector<ITEM_RESOLUTION>  actions;
    std::vector<KIID_PATH>        unresolved;
    bool                          requiresZoneRefill           = false;
    bool                          requiresConnectivityRebuild  = false;
 
    bool                  Resolved() const { return unresolved.empty(); }
    std::size_t           ConflictCount() const { return unresolved.size(); }
 
    nlohmann::json        ToJson() const;
    static MERGE_PLAN     FromJson( const nlohmann::json& aJson );
};
 

class KICOMMON_API KICAD_MERGE_ENGINE
{
public:
    struct OPTIONS
    {
        bool preferAutoMerge = true;

        bool autoResolveEqualValues = true;
    };
 
    KICAD_MERGE_ENGINE() = default;
    explicit KICAD_MERGE_ENGINE( const OPTIONS& aOptions ) : m_options( aOptions ) {}
 
    const OPTIONS& GetOptions() const { return m_options; }
    void           SetOptions( const OPTIONS& aOptions ) { m_options = aOptions; }

    MERGE_PLAN Plan( const DOCUMENT_DIFF& aAncestorOurs,
                     const DOCUMENT_DIFF& aAncestorTheirs ) const;
 
private:
    OPTIONS m_options;
};
 

struct KICOMMON_API PROPERTY_RESOLUTION_OUTCOME
{
    PROP_RES kind         = PROP_RES::OURS;
    bool     isUnresolved = false;
};
 

KICOMMON_API PROPERTY_RESOLUTION_OUTCOME
ResolvePropertyConflict( const PROPERTY_DELTA* aOurs, const PROPERTY_DELTA* aTheirs,
                         const KICAD_MERGE_ENGINE::OPTIONS& aOptions );
 
} // namespace KICAD_DIFF
 
#endif // KICAD_MERGE_ENGINE_H