/www/proggenOrg/dedupe/export/trunk/kernel/kernel.h

#ifndef ORG_PROGGEN_DEDUPE_KERNELINTERFACE
#define ORG_PROGGEN_DEDUPE_KERNELINTERFACE

#include <fileinfo.h>
#include <hash.h>
#include <dataholding.h>
#include <boost/function.hpp>
#include <boost/bind.hpp>


namespace Dedupe
{
  namespace Core
  {

    class HandleDuplicates
    {
      protected:
      int value;
      Dedupe::FilePath LinkToFile;

      public:

      HandleDuplicates( const int Handle ): value ( Handle ) {}

      const int operator()(void ) const {return value;}

      inline HandleDuplicates operator= ( const int given )
      {
        value = given;
        return *this;
      }

      inline bool operator==( const int rhs )
      {
        return (this->value == rhs);
      }

      inline bool SetLinkPath( Dedupe::FilePath Path )
      {
        if( value != 4 ) return false;

        LinkToFile = Path;
        return true;
      }

      inline Dedupe::FilePath GetLinkPath()
      {
        return LinkToFile;
      }

      static int const Empty = 0; 
      static int const Keep = 1;  
      static int const MarkAsKeep = 2; 
      static int const Delete = 3; 
      static int const LinkTo = 4; 
      static int const Error = 5; 
    };

    typedef std::vector<Dedupe::FileInfo> DuplicateGroup;

    typedef std::vector<DuplicateGroup> Duplicates;

    typedef std::pair<Dedupe::FilePath, HandleDuplicates> DuplicateHandle;

    typedef std::vector<DuplicateHandle> FilesToProcess;

    class Kernel
    {
      public:

      Kernel( Dedupe::FilePath DatabaseLocation, size_t Threads, std::ostream &Messages );

      void TrackFiles( Dedupe::FilePaths const &Paths , bool recursiv  );

      void ListDatabase();

      Dedupe::FileStream GetDatabase();

      void UntrackFiles( Dedupe::FilePaths const &Paths, bool recursiv );

      Duplicates FindHashDuplicates();

      Duplicates FindHashDuplicatesExtern( Dedupe::FilePaths,
                                           bool recursiv );

      Duplicates FindFilenameDuplicates();

      Duplicates FindFilenameDuplicatesExtern( Dedupe::FilePaths,
                                               bool recursiv );
      Duplicates FindFilesizeDuplicates();

      Duplicates FindFilesizeDuplicatesExtern( Dedupe::FilePaths,
                                               bool recursiv );

      Duplicates FindFiledateDuplicates();

      Duplicates FindFiledateDuplicatesExtern( Dedupe::FilePaths,
                                               bool recursiv );

      void ProcessDuplicates( FilesToProcess Dups );

      void AutoUpdateDatabase();

      void QuitKernel( bool &AmIDead );

      private:

      void AddFile( Dedupe::FileInfo &Info );

      void FileAndDirectoryHandlerToFunction( Dedupe::FilePaths const &Paths,
                      bool recursiv,
                      boost::function<void ( Dedupe::FileInfo& )>Function );

      Dedupe::FileStream FileAndDirectoryHandler( Dedupe::FilePaths const &Paths,
                                                  bool recursiv);

      void Threadcontroller( std::function<void(Dedupe::FileInfo&)> Func, Dedupe::FileStream &stream );

      Duplicates FindDuplicates( Dedupe::FileStream Files,
                                 std::function<bool(Dedupe::FileInfo, Dedupe::FileInfo)>SortFunc,
                                 std::function<bool(Dedupe::FileInfo, Dedupe::FileInfo)> EqualFunc);

      Duplicates FindExternDuplicates( Dedupe::FilePaths Paths,
                                       bool recursiv,
                                       std::function<bool(Dedupe::FileInfo, Dedupe::FileInfo)>SortFunc,
                                       std::function<bool(Dedupe::FileInfo, Dedupe::FileInfo)> EqualFunc);

      Dedupe::Dataholding::Dataholding Database;
      size_t Threadcount;
      Dedupe::FileSearch::SearchFiles Searcher;
      Dedupe::Hash::Hash64 Hasher;

      std::ostream &MessageOut;

    };

  }
}

#endif