/www/proggenOrg/dedupe/export/trunk/userinterface/cli/ui.cpp

Go to the documentation of this file.

 #include "ui.h"


Dedupe::CLI::UI::UI( std::ostream &MessageOut )
: Message( MessageOut ), Header( "" )
 {}


bool Dedupe::CLI::UI::WriteDuplicatesToFile( Dedupe::Core::Duplicates Dups,
                                             Dedupe::FilePath PathToFile )
{
  boost::filesystem::ofstream Outputfile;

  Outputfile.open( PathToFile, ofstream::out );
  if( !Outputfile )
  {
    Message << "ERROR: Could not open Outputfile\n" ;
    Outputfile.close();
    return false;
  }

  Outputfile << "# " << Header << std::endl;

  for( auto it = Dups.begin(); it != Dups.end(); ++it )
  {
    Outputfile << "GroupBegin:\n";

    for( auto InIt= it->begin(); InIt != it->end(); ++InIt )
    {
      Outputfile << InIt->GetPath() << std::endl;
    }
    Outputfile <<"GroupEnd\n";
  }

  Outputfile.close();
  return true;
}

Dedupe::Core::FilesToProcess
Dedupe::CLI::UI::ReadDecidedDuplicatesFromFile( Dedupe::FilePath PathToFile )
{
  boost::filesystem::ifstream Inputfile;

  Dedupe::Core::FilesToProcess Dups;

  std::string Line, Decision, LinkPath;

  Inputfile.open( PathToFile, ifstream::in );
  if( !Inputfile )
  {
    Message << "ERROR: Could not open Inputfile\n" ;
    Inputfile.close();
    Dups.clear();
    return Dups;
  }
  while( !Inputfile.eof() )
  {
    std::getline( Inputfile, Line );
    EraseComments( Line );
    EraseWhitespaces( Line );
    if( Line == "" )continue;
    if( !SplitPathFromDecision( Line, Decision, LinkPath ))
    {
      Message << "ERROR: Could not parse current Line: " << Line << std::endl;
    };
    if( Decision == "k" || Decision == "" || Decision == "keep" )
    {
      Dups.push_back( std::make_pair( Line, Dedupe::Core::HandleDuplicates(Dedupe::Core::HandleDuplicates::Keep )));
    }
    else if( Decision == "m" ||  Decision == "mark")
    {
      Dups.push_back( std::make_pair( Line, Dedupe::Core::HandleDuplicates(Dedupe::Core::HandleDuplicates::MarkAsKeep )));
    }
    else if( Decision == "d" || Decision == "delete")
    {
      Dups.push_back( std::make_pair( Line, Dedupe::Core::HandleDuplicates(Dedupe::Core::HandleDuplicates::Delete )));
    }
    else if( Decision == "l" || Decision == "link" )
    {
      Dedupe::Core::HandleDuplicates SpezialHandle( Dedupe::Core::HandleDuplicates::LinkTo );
      SpezialHandle.SetLinkPath( LinkPath );
      Dups.push_back( std::make_pair( Line, SpezialHandle ));
    }
    else
    {
      Dups.push_back( std::make_pair( Line, Dedupe::Core::HandleDuplicates(Dedupe::Core::HandleDuplicates::Error )));
    }
  }

  return Dups;
}

void Dedupe::CLI::UI::SetTitle( std::string Fileheader )
{
  Header = Fileheader;
}

void Dedupe::CLI::UI::EraseComments( std::string &FileLine )
{
  int Commentsign;

  Commentsign = FileLine.find_first_of('#');

  if( Commentsign == -1 ) return;
  else FileLine.erase(Commentsign, FileLine.length());
}

void Dedupe::CLI::UI::EraseWhitespaces( std::string &FileLine )
{
  //Erase only whitespaces after the path in line
  while( FileLine.find(' ',FileLine.find_last_of('"')) != -1u )
  {
    FileLine.erase( FileLine.find( ' ', FileLine.find_last_of('"') ), 1 );
  }
}

//TODO: There must be a much better way to solve the problem in this function. Maybe sub_matches?
bool Dedupe::CLI::UI::SplitPathFromDecision( std::string &LineString, std::string &Decision, std::string &Link )
{
  boost::regex Path, DecisionPattern, PathDecision, PathDecisionPath;
  boost::smatch PathMatch, LinkMatch;

  std::string tmp, tmp1;

  Path = "\"([^\"]*)\"";

  PathDecision = "\"([^\"]*)\"([\\w ]{1,})";

  PathDecisionPath = "\"(.*?)\" [\\w ]*? \".*?\"";

  if( boost::regex_match( LineString, Path ) )
  {
    Decision = "";
    Link = "";

    return true;
  }
  else if( boost::regex_match( LineString, PathDecision ) )
  {
    boost::regex_search(LineString, PathMatch, Path );

    tmp = PathMatch[ 0 ];

    Decision = LineString.substr(tmp.size(), LineString.size());

    LineString = PathMatch[ 0 ];
    Link = "";

    return true;
  }
  else if( boost::regex_match( LineString, PathDecisionPath ) )
  {
    boost::regex_search( LineString, PathMatch, Path, boost::regex_constants::_match_flags::match_any);

    tmp = PathMatch[0];

    boost::regex_search( LineString, LinkMatch, Path, boost::regex_constants::_match_flags::match_all);

    tmp1 = LinkMatch[0];

    LineString = LineString.substr( tmp.size(), LineString.size());
    LineString = LineString.substr( 0, LineString.size() - tmp1.size());

    Decision = LineString;

    for( size_t i = 0 ; i <= Decision.size(); ++i )
    {
      if( Decision[ i ] == ' ' ) Decision.erase( i, 1 );
    }

    LineString = PathMatch[ 0 ];
    Link = LinkMatch [ 0 ];

    return true;
  }

  else
  {
    Message << "ERROR: Could not parse Line: " << LineString << std::endl;
    return false;
  }

  return false;
}