LCOV - code coverage report
Current view: top level - src/tools/kdb - merge.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 5 48 10.4 %
Date: 2019-09-12 12:28:41 Functions: 3 5 60.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <merge.hpp>
      10             : 
      11             : #include <cmdline.hpp>
      12             : #include <kdb.hpp>
      13             : #include <keysetio.hpp>
      14             : #include <modules.hpp>
      15             : 
      16             : #include <iostream>
      17             : #include <string>
      18             : 
      19             : #include <mergehelper.hpp>
      20             : #include <merging/metamergestrategy.hpp>
      21             : #include <merging/threewaymerge.hpp>
      22             : 
      23             : using namespace kdb;
      24             : using namespace kdb::tools::merging;
      25             : using namespace std;
      26             : 
      27          78 : MergeCommand::MergeCommand ()
      28             : {
      29          78 : }
      30             : 
      31         156 : MergeCommand::~MergeCommand ()
      32             : {
      33          78 : }
      34             : 
      35           0 : int MergeCommand::execute (Cmdline const & cl)
      36             : {
      37             : 
      38           0 :         if (cl.arguments.size () < 4)
      39             :         {
      40           0 :                 throw invalid_argument ("wrong number of arguments, 4 needed");
      41             :         }
      42             : 
      43           0 :         Key oursRoot = cl.createKey (0);
      44           0 :         Key theirsRoot = cl.createKey (1);
      45           0 :         Key baseRoot = cl.createKey (2);
      46           0 :         Key resultRoot = cl.createKey (3);
      47             : 
      48           0 :         KeySet ours;
      49           0 :         KeySet theirs;
      50           0 :         KeySet base;
      51             : 
      52             :         {
      53           0 :                 KDB lkdb;
      54           0 :                 lkdb.get (ours, oursRoot);
      55           0 :                 ours = ours.cut (oursRoot);
      56           0 :                 ours.lookup (oursRoot, KDB_O_POP);
      57           0 :                 if (cl.verbose) std::cout << "we got ours: " << oursRoot << " with keys " << ours << std::endl;
      58             :         }
      59             :         {
      60           0 :                 KDB lkdb;
      61           0 :                 lkdb.get (theirs, theirsRoot);
      62           0 :                 theirs = theirs.cut (theirsRoot);
      63           0 :                 ours.lookup (oursRoot, KDB_O_POP);
      64           0 :                 if (cl.verbose) std::cout << "we got theirs: " << theirsRoot << " with keys " << theirs << std::endl;
      65             :         }
      66             :         {
      67           0 :                 KDB lkdb;
      68           0 :                 lkdb.get (base, baseRoot);
      69           0 :                 base = base.cut (baseRoot);
      70           0 :                 ours.lookup (oursRoot, KDB_O_POP);
      71           0 :                 if (cl.verbose) std::cout << "we got base: " << baseRoot << " with keys " << base << std::endl;
      72             :         }
      73             : 
      74           0 :         KeySet resultKeys;
      75           0 :         kdb.get (resultKeys, resultRoot);
      76             : 
      77           0 :         KeySet discard = resultKeys.cut (resultRoot);
      78           0 :         if (discard.size () != 0)
      79             :         {
      80           0 :                 if (cl.force)
      81             :                 {
      82           0 :                         if (cl.verbose)
      83             :                         {
      84           0 :                                 std::cout << "will remove " << discard.size () << " keys, because -f was given" << std::endl;
      85             :                         }
      86             :                 }
      87             :                 else
      88             :                 {
      89           0 :                         std::cerr << discard.size () << " keys exist in merge resultpath, will quit. Use -f to override the keys there."
      90             :                                   << std::endl;
      91             :                 }
      92             :         }
      93             : 
      94           0 :         MergeHelper helper;
      95           0 :         ThreeWayMerge merger;
      96             : 
      97           0 :         helper.configureMerger (cl, merger);
      98             : 
      99             :         MergeResult result = merger.mergeKeySet (
     100           0 :                 MergeTask (BaseMergeKeys (base, baseRoot), OurMergeKeys (ours, oursRoot), TheirMergeKeys (theirs, theirsRoot), resultRoot));
     101             : 
     102           0 :         helper.reportResult (cl, result, cout, cerr);
     103             : 
     104           0 :         int ret = 0;
     105           0 :         if (!result.hasConflicts ())
     106             :         {
     107           0 :                 resultKeys.append (result.getMergedKeys ());
     108           0 :                 kdb.set (resultKeys, resultRoot);
     109             :         }
     110             :         else
     111             :         {
     112             :                 ret = -1;
     113             :         }
     114             : 
     115           0 :         return ret;
     116        7164 : }

Generated by: LCOV version 1.13