3.0

1 files changed, 765 insertions, 596 deletions

diff --git a/fileHierarchy.h b/fileHierarchy.h
index 755bb97d..0db44c42 100644
--- a/fileHierarchy.h
+++ b/fileHierarchy.h
@@ -4,323 +4,395 @@
 #include "shared/zstring.h"
 #include "shared/systemConstants.h"
 #include <wx/longlong.h>
+#include <map>
 #include <set>
 #include <vector>
 #include "structures.h"
+#include <boost/shared_ptr.hpp>
 
 class DirectoryBuffer;
 
 
 namespace FreeFileSync
 {
-    struct FileDescriptor
-    {
-        FileDescriptor(    const Zstring&     shortNameIn,
-                           const wxLongLong&  lastWriteTimeRawIn,
-                           const wxULongLong& fileSizeIn) :
-                shortName(shortNameIn),
-                lastWriteTimeRaw(lastWriteTimeRawIn),
-                fileSize(fileSizeIn) {}
-
-        //fullname == baseDirectoryPf + parentRelNamePf + shortName
-        Zstring     shortName;
-        wxLongLong  lastWriteTimeRaw; //number of seconds since Jan. 1st 1970 UTC, same semantics like time_t (== signed long)
-        wxULongLong fileSize;
-    };
-
+struct FileDescriptor
+{
+    FileDescriptor(const wxLongLong&  lastWriteTimeRawIn, const wxULongLong& fileSizeIn) :
+        lastWriteTimeRaw(lastWriteTimeRawIn),
+        fileSize(fileSizeIn) {}
+    wxLongLong  lastWriteTimeRaw; //number of seconds since Jan. 1st 1970 UTC, same semantics like time_t (== signed long)
+    wxULongLong fileSize;
+};
 
-    struct DirDescriptor
-    {
-        DirDescriptor(const Zstring& shortNameIn) :
-                shortName(shortNameIn) {}
 
-        //fullname == baseDirectoryPf + parentRelNamePf + shortName
-        Zstring shortName;
-    };
+enum SelectedSide
+{
+    LEFT_SIDE,
+    RIGHT_SIDE
+};
 
 
-    class FileContainer;
-    class FileMapping;
-    class DirMapping;
-    class CompareProcess;
-    class HierarchyObject;
-    class BaseDirMapping;
+class FileContainer;
+class FileMapping;
+class DirMapping;
+class CompareProcess;
+class FileSystemObject;
+class BaseDirMapping;
 //------------------------------------------------------------------
-    /*
-      DirContainer    FileContainer
+/*
+  DirContainer    FileContainer
 
-    ERD:
-    DirContainer 1 -----> 0..n DirContainer
-    DirContainer 1 -----> 0..n FileContainer
-    */
+ERD:
+DirContainer 1 -----> 0..n DirContainer
+DirContainer 1 -----> 0..n FileContainer
+*/
 
 //------------------------------------------------------------------
-    class DirContainer
+class DirContainer
+{
+public:
+    void addSubFile(const Zstring& shortName, const FileDescriptor& fileData);
+    DirContainer& addSubDir(const Zstring& shortName);
+
+    //------------------------------------------------------------------
+    struct CmpFilename
     {
-    public:
-        void addSubFile(const FileDescriptor& fileData, const Zstring& parentRelativeNamePf);
-        DirContainer& addSubDir(const DirDescriptor& dirData, const Zstring& parentRelativeNamePf);
+        bool operator()(const Zstring& a, const Zstring& b) const;
+    };
 
-        //------------------------------------------------------------------
-        template <class T>
-        struct CmpLess : public std::binary_function<T, T, bool>
-        {
-            bool operator()(const T& a, const T& b) const;
-        };
+    typedef std::map<Zstring, DirContainer,  CmpFilename> SubDirList;  //key: shortName
+    typedef std::map<Zstring, FileContainer, CmpFilename> SubFileList; //
+    //------------------------------------------------------------------
 
-        typedef std::set<DirContainer,  CmpLess<DirContainer> >  SubDirList;
-        typedef std::set<FileContainer, CmpLess<FileContainer> > SubFileList;
-        //------------------------------------------------------------------
+    const SubDirList&  getSubDirs() const;
+    const SubFileList& getSubFiles() const;
 
-        const DirDescriptor& getData() const;
-        const Zstring& getParentRelNamePf() const;
+    DirContainer() {} //default constructor use for base directory only!
 
-        const SubDirList& getSubDirs() const;
-        const SubFileList& getSubFiles() const;
+private:
+    SubDirList  subDirs;  //contained directories
+    SubFileList subFiles; //contained files
+};
 
-    private:
-        friend class CompareProcess; //only DirectoryBuffer is allowed to create (Base-)DirContainers
+//------------------------------------------------------------------
+class FileContainer
+{
+public:
+    const FileDescriptor& getData() const;
 
-        DirContainer(const DirDescriptor& dirData, const Zstring& parentRelativeNamePf) :
-                data(dirData),
-                parentRelNamePf(parentRelativeNamePf) {}
+private:
+    friend class DirContainer;
 
-        DirContainer() : data(Zstring()) {} //default constructor used by DirectoryBuffer only!
+    FileContainer(const FileDescriptor& fileData) :
+        data(fileData) {}
 
-        const DirDescriptor data;
-        const Zstring parentRelNamePf; //buffer some redundant data:
+    const FileDescriptor data;
+};
 
-        SubDirList  subDirs;  //contained directories
-        SubFileList subFiles; //contained files
-    };
 
 //------------------------------------------------------------------
-    class FileContainer
-    {
-    public:
-        const FileDescriptor& getData() const;
-        const Zstring& getParentRelNamePf() const;
-
-    private:
-        friend class DirContainer;
-
-        FileContainer(const FileDescriptor& fileData, const Zstring& parentRelativeNamePf) :
-                data(fileData),
-                parentRelNamePf(parentRelativeNamePf) {}
+struct DirInformation
+{
+    //filter settings (used when retrieving directory data)
+    bool filterActive;
+    Zstring includeFilter;
+    Zstring excludeFilter;
+    //hierarchical directory information
+    DirContainer baseDirContainer;
+};
 
-        const FileDescriptor data;
-        const Zstring parentRelNamePf; //buffer some redundant data:
-    };
 
+//save/load full directory information
+const Zstring& getSyncDBFilename(); //get short filename of database file
+void saveToDisk(const BaseDirMapping& baseMapping, SelectedSide side, const Zstring& filename); //throw (FileError) -> return value always bound!
+boost::shared_ptr<const DirInformation> loadFromDisk(const Zstring& filename);                  //throw (FileError)
 
 //------------------------------------------------------------------
-    /*    class hierarchy:
+/*    class hierarchy:
 
-          FileSystemObject  HierarchyObject
-                /|\              /|\
-           ______|______    ______|______
-          |             |  |             |
-    FileMapping      DirMapping    BaseDirMapping
-    */
+      FileSystemObject  HierarchyObject
+            /|\              /|\
+       ______|______    ______|______
+      |             |  |             |
+FileMapping      DirMapping    BaseDirMapping
+*/
 
 //------------------------------------------------------------------
-    enum SelectedSide
+class HierarchyObject
+{
+public:
+    typedef unsigned int ObjectID;
+    FileSystemObject* retrieveById(ObjectID id);             //returns NULL if object is not found; logarithmic complexity
+    const FileSystemObject* retrieveById(ObjectID id) const; //
+
+    DirMapping& addSubDir(bool existsLeft,
+                          const Zstring& dirNameShort,
+                          bool existsRight);
+
+    FileMapping& addSubFile(const FileDescriptor&   left,          //file exists on both sides
+                            const Zstring&          fileNameShort,
+                            CompareFilesResult      defaultCmpResult,
+                            const FileDescriptor&   right);
+    void addSubFile(const FileDescriptor&   left,          //file exists on left side only
+                    const Zstring&          fileNameShort);
+    void addSubFile(const Zstring&          fileNameShort, //file exists on right side only
+                    const FileDescriptor&   right);
+
+    const Zstring& getRelativeNamePf() const; //get name relative to base sync dir with FILE_NAME_SEPARATOR postfix: "blah\"
+    template <SelectedSide side> const Zstring& getBaseDir() const //postfixed!
     {
-        LEFT_SIDE,
-        RIGHT_SIDE
-    };
+        return side == LEFT_SIDE ? baseDirLeft : baseDirRight;
+    }
+
+    typedef std::vector<FileMapping> SubFileMapping;
+    typedef std::vector<DirMapping>  SubDirMapping;
+
+    SubFileMapping subFiles; //contained file maps
+    SubDirMapping  subDirs;  //contained directory maps
+
+protected:
+    //constructor used by DirMapping
+    HierarchyObject(const HierarchyObject& parent, const Zstring& shortName) :
+        relNamePf(parent.getRelativeNamePf() + shortName + globalFunctions::FILE_NAME_SEPARATOR),
+        baseDirLeft(parent.getBaseDir<LEFT_SIDE>()),
+        baseDirRight(parent.getBaseDir<RIGHT_SIDE>()) {}
+
+    //constructor used by BaseDirMapping
+    HierarchyObject(const Zstring& dirPostfixedLeft,
+                    const Zstring& dirPostfixedRight) :
+        baseDirLeft(dirPostfixedLeft),
+        baseDirRight(dirPostfixedRight) {}
+    ~HierarchyObject() {} //don't need polymorphic deletion
+
+    virtual void swap();
+
+private:
+    Zstring relNamePf;
+    Zstring baseDirLeft;  //directory name ending with FILE_NAME_SEPARATOR
+    Zstring baseDirRight; //directory name ending with FILE_NAME_SEPARATOR
+};
 
-    struct RelNamesBuffered
-    {
-        RelNamesBuffered(const Zstring& baseDirPfLIn, //base sync dir postfixed
-                         const Zstring& baseDirPfRIn,
-                         const Zstring& parentRelNamePfIn) : //relative parent name postfixed
-                baseDirPfL(baseDirPfLIn),
-                baseDirPfR(baseDirPfRIn),
-                parentRelNamePf(parentRelNamePfIn) {}
-
-        Zstring baseDirPfL;
-        Zstring baseDirPfR;
-        Zstring parentRelNamePf;
-    };
 
 //------------------------------------------------------------------
-    class FileSystemObject
-    {
-    public:
-        typedef unsigned int ObjectID;
-        template <SelectedSide side>           bool     isEmpty()         const;
-        template <SelectedSide side> const Zstring&     getShortName()    const;
-        template <SelectedSide side> const Zstring      getRelativeName() const; //get name relative to base sync dir without FILE_NAME_SEPARATOR prefix
-        template <SelectedSide side> const Zstring      getParentRelativeName() const; //get name relative to base sync dir without FILE_NAME_SEPARATOR postfix
-        template <SelectedSide side> const Zstring      getFullName()     const; //getFullName() == getBaseDirPf() + getRelativeName()
-        template <SelectedSide side> const Zstring&     getBaseDirPf()    const; //base sync directory postfixed with FILE_NAME_SEPARATOR
-        ObjectID getId() const; //get unique id; ^= logical key
-
-        void swap();
-
-        template <SelectedSide side> void copyTo();          //copy one side to the other (NOT recursive!!!)
-        template <SelectedSide side> void removeObject();    //removes file or directory (recursively!): used by manual deletion
-        bool isEmpty() const; //true, if both sides are empty
-        static void removeEmpty(BaseDirMapping& baseDir);  //remove all invalid entries (where both sides are empty) recursively
-        static void removeEmptyNonRec(HierarchyObject& hierObj); //remove all invalid entries (where both sides are empty) non-recursively
-
-        //sync settings:
-        SyncDirection syncDir;
-        bool selectedForSynchronization;
-
-        virtual CompareFilesResult getCategory() const = 0;
-        virtual const wxString& getConflictDescription() const = 0;
-
-    protected:
-        FileSystemObject(const RelNamesBuffered& relNameBuff) :
-                syncDir(SYNC_DIR_NONE),
-                selectedForSynchronization(true),
-                nameBuffer(relNameBuff),
-                uniqueId(getUniqueId()) {}
-
-        ~FileSystemObject() {} //don't need polymorphic deletion
-
-    private:
-        virtual void swapDescriptors() = 0;
-
-        virtual           bool isEmptyL() const = 0;
-        virtual           bool isEmptyR() const = 0;
-        virtual           void removeObjectL() = 0;
-        virtual           void removeObjectR() = 0;
-        virtual           void copyToL() = 0;
-        virtual           void copyToR() = 0;
-        virtual const Zstring& getShortNameL() const = 0;
-        virtual const Zstring& getShortNameR() const = 0;
-        static ObjectID getUniqueId();
-
-        //buffer some redundant data:
-        RelNamesBuffered nameBuffer; //base sync dirs + relative parent name: this does NOT belong into FileDescriptor/DirDescriptor
-
-        ObjectID uniqueId;
-    };
+struct RelNamesBuffered
+{
+    RelNamesBuffered(const Zstring& baseDirPfLIn, //base sync dir postfixed
+                     const Zstring& baseDirPfRIn,
+                     const Zstring& parentRelNamePfIn) : //relative parent name postfixed
+        baseDirPfL(baseDirPfLIn),
+        baseDirPfR(baseDirPfRIn),
+        parentRelNamePf(parentRelNamePfIn) {}
+
+    Zstring baseDirPfL;
+    Zstring baseDirPfR;
+    Zstring parentRelNamePf;
+};
+
 
 //------------------------------------------------------------------
-    class HierarchyObject
-    {
-    public:
-        FileSystemObject* retrieveById(FileSystemObject::ObjectID id);             //returns NULL if object is not found; logarithmic complexity
-        const FileSystemObject* retrieveById(FileSystemObject::ObjectID id) const; //
-
-        DirMapping& addSubDir(const DirDescriptor&    left,
-                              CompareDirResult        defaultCmpResult,
-                              const DirDescriptor&    right,
-                              const RelNamesBuffered& relNameBuff);
-        FileMapping& addSubFile(const FileDescriptor&   left,
-                                CompareFilesResult      defaultCmpResult,
-                                const FileDescriptor&   right,
-                                const RelNamesBuffered& relNameBuff);
-
-        typedef std::vector<FileMapping> SubFileMapping;
-        typedef std::vector<DirMapping>  SubDirMapping;
-
-        SubFileMapping subFiles; //contained file maps
-        SubDirMapping  subDirs;  //contained directory maps
-
-    protected:
-        HierarchyObject() {}
-        ~HierarchyObject() {} //don't need polymorphic deletion
+class FileSystemObject
+{
+public:
+    const Zstring getParentRelativeName() const; //get name relative to base sync dir without FILE_NAME_SEPARATOR postfix
+    const Zstring getObjRelativeName() const;    //same as getRelativeName() but also returns value if either side is empty
+    const Zstring& getObjShortName() const;       //same as getShortName() but also returns value if either side is empty
+    template <SelectedSide side>           bool     isEmpty()         const;
+    template <SelectedSide side> const Zstring&     getShortName()    const;
+    template <SelectedSide side> const Zstring      getRelativeName() const; //get name relative to base sync dir without FILE_NAME_SEPARATOR prefix
+    template <SelectedSide side> const Zstring      getFullName()     const; //getFullName() == getBaseDirPf() + getRelativeName()
+    template <SelectedSide side> const Zstring&     getBaseDirPf()    const; //base sync directory postfixed with FILE_NAME_SEPARATOR
+
+    HierarchyObject::ObjectID getId() const; //get unique id; ^= logical key
+
+    //comparison result
+    virtual CompareFilesResult getCategory() const = 0;
+    virtual const wxString& getCatConflict() const = 0; //only filled if cmpResult == FILE_CONFLICT
+    //sync operation
+    SyncOperation getSyncOperation() const;
+    const wxString& getSyncOpConflict() const; //only filled if syncDir == SYNC_DIR_INT_CONFLICT
+    SyncOperation testSyncOperation(bool selected, SyncDirection syncDir) const; //get syncOp with provided settings
+
+    //sync settings
+    void setSyncDir(SyncDirection newDir);
+    void setSyncDirConflict(const wxString& description);   //set syncDir = SYNC_DIR_INT_CONFLICT
+
+    bool isActive() const;
+    void setActive(bool active);
+
+    void synchronizeSides();          //copy one side to the other (NOT recursive!!!)
+    template <SelectedSide side> void removeObject();    //removes file or directory (recursively!): used by manual deletion
+    bool isEmpty() const; //true, if both sides are empty
+    static void removeEmpty(BaseDirMapping& baseDir);  //remove all invalid entries (where both sides are empty) recursively
+    static void removeEmptyNonRec(HierarchyObject& hierObj); //remove all invalid entries (where both sides are empty) non-recursively
+
+protected:
+    FileSystemObject(bool existsLeft, bool existsRight, const Zstring& shortName, const HierarchyObject& parent) :
+        selectedForSynchronization(true),
+        syncDir(SYNC_DIR_INT_NONE),
+        nameBuffer(parent.getBaseDir<LEFT_SIDE>(), parent.getBaseDir<RIGHT_SIDE>(), parent.getRelativeNamePf()),
+        existsLeft_(existsLeft),
+        existsRight_(existsRight),
+        shortName_(shortName),
+        uniqueId(getUniqueId()) {}
+
+    ~FileSystemObject() {} //don't need polymorphic deletion
+
+    virtual void swap();
+
+private:
+    virtual           void removeObjectL()  = 0;
+    virtual           void removeObjectR()  = 0;
+    virtual           void copyToL() = 0;
+    virtual           void copyToR() = 0;
+    static HierarchyObject::ObjectID getUniqueId();
+
+    enum SyncDirectionIntern //same as SyncDirection, but one additional conflict type
+    {
+        SYNC_DIR_INT_LEFT  = SYNC_DIR_LEFT,
+        SYNC_DIR_INT_RIGHT = SYNC_DIR_RIGHT,
+        SYNC_DIR_INT_NONE  = SYNC_DIR_NONE,
+        SYNC_DIR_INT_CONFLICT //set if automatic synchronization cannot determine a direction
     };
+    static SyncOperation getSyncOperation(const CompareFilesResult cmpResult,
+                                          const bool selectedForSynchronization,
+                                          const SyncDirectionIntern syncDir); //evaluate comparison result and sync direction
+
+    bool selectedForSynchronization;
+    SyncDirectionIntern syncDir;
+    wxString syncOpConflictDescr; //only filled if syncDir == SYNC_DIR_INT_CONFLICT
+
+
+    //buffer some redundant data:
+    RelNamesBuffered nameBuffer; //base sync dirs + relative parent name: this does NOT belong into FileDescriptor/DirDescriptor
+
+    bool existsLeft_;
+    bool existsRight_;
+    Zstring shortName_;
+    HierarchyObject::ObjectID uniqueId;
+};
 
 //------------------------------------------------------------------
-    class DirMapping : public FileSystemObject, public HierarchyObject
-    {
-    public:
-        static const DirDescriptor& nullData();
-
-        virtual CompareFilesResult getCategory() const;
-        virtual const wxString& getConflictDescription() const;
-
-    private:
-        friend class CompareProcess; //only CompareProcess shall be allowed to change cmpResult
-        friend class HierarchyObject;
-        virtual           void swapDescriptors();
-        virtual           bool isEmptyL() const;
-        virtual           bool isEmptyR() const;
-        virtual           void removeObjectL();
-        virtual           void removeObjectR();
-        virtual           void copyToL();
-        virtual           void copyToR();
-        virtual const Zstring& getShortNameL() const;
-        virtual const Zstring& getShortNameR() const;
-        //------------------------------------------------------------------
-
-        DirMapping(const DirDescriptor& left, CompareDirResult defaultCmpResult, const DirDescriptor& right, const RelNamesBuffered& relNameBuff) :
-                FileSystemObject(relNameBuff),
-                cmpResult(defaultCmpResult),
-                dataLeft(left),
-                dataRight(right) {}
-
-        //categorization
-        CompareDirResult cmpResult;
-
-        DirDescriptor dataLeft;
-        DirDescriptor dataRight;
-    };
+class DirMapping : public FileSystemObject, public HierarchyObject
+{
+public:
+    virtual CompareFilesResult getCategory() const;
+    CompareDirResult getDirCategory() const; //returns actually used subsed of CompareFilesResult
+    virtual const wxString& getCatConflict() const;
+
+private:
+    friend class CompareProcess; //only CompareProcess shall be allowed to change cmpResult
+    friend class HierarchyObject;
+    virtual void swap();
+    virtual void removeObjectL();
+    virtual void removeObjectR();
+    virtual void copyToL();
+    virtual void copyToR();
+    //------------------------------------------------------------------
+
+    DirMapping(bool existsLeft,
+               const Zstring& dirNameShort,
+               bool existsRight,
+               const HierarchyObject& parent) :
+        FileSystemObject(existsLeft, existsRight, dirNameShort, parent),
+        HierarchyObject(parent, dirNameShort),
+        cmpResult(!existsRight ? DIR_LEFT_SIDE_ONLY : existsLeft ? DIR_EQUAL : DIR_RIGHT_SIDE_ONLY) {}
+
+    //categorization
+    CompareDirResult cmpResult;
+};
 
 //------------------------------------------------------------------
-    class FileMapping : public FileSystemObject
-    {
-    public:
-        template <SelectedSide side> const wxLongLong&  getLastWriteTime() const;
-        template <SelectedSide side> const wxULongLong& getFileSize() const;
-
-        static const FileDescriptor& nullData();
-
-        virtual CompareFilesResult getCategory() const;
-        virtual const wxString& getConflictDescription() const;
-
-    private:
-        friend class CompareProcess; //only CompareProcess shall be allowed to change cmpResult
-        friend class HierarchyObject;
-
-        FileMapping(const FileDescriptor& left, CompareFilesResult defaultCmpResult, const FileDescriptor& right, const RelNamesBuffered& relNameBuff) :
-                FileSystemObject(relNameBuff),
-                cmpResult(defaultCmpResult),
-                dataLeft(left),
-                dataRight(right) {}
-
-        virtual           void swapDescriptors();
-        virtual           bool isEmptyL() const;
-        virtual           bool isEmptyR() const;
-        virtual           void removeObjectL();
-        virtual           void removeObjectR();
-        virtual           void copyToL();
-        virtual           void copyToR();
-        virtual const Zstring& getShortNameL() const;
-        virtual const Zstring& getShortNameR() const;
-        //------------------------------------------------------------------
-
-        //categorization
-        CompareFilesResult cmpResult;
-        wxString conflictDescription; //only filled if cmpResult == FILE_CONFLICT
-
-        FileDescriptor dataLeft;
-        FileDescriptor dataRight;
-    };
+class FileMapping : public FileSystemObject
+{
+public:
+    template <SelectedSide side> const wxLongLong&  getLastWriteTime() const;
+    template <SelectedSide side> const wxULongLong& getFileSize() const;
+
+    virtual CompareFilesResult getCategory() const;
+    virtual const wxString& getCatConflict() const;
+
+private:
+    friend class CompareProcess;  //only CompareProcess shall be allowed to change cmpResult
+    friend class HierarchyObject; //construction
+
+    template <CompareFilesResult res>
+    void setCategory();
+    void setCategoryConflict(const wxString& description);
+
+    FileMapping(const FileDescriptor&  left, //file exists on both sides
+                const Zstring&         fileNameShort,
+                CompareFilesResult     defaultCmpResult,
+                const FileDescriptor&  right,
+                const HierarchyObject& parent) :
+        FileSystemObject(true, true, fileNameShort, parent),
+        cmpResult(defaultCmpResult),
+        dataLeft(left),
+        dataRight(right) {}
+    FileMapping(const FileDescriptor&  left, //file exists on left side only
+                const Zstring&         fileNameShort,
+                const HierarchyObject& parent) :
+        FileSystemObject(true, false, fileNameShort, parent),
+        cmpResult(FILE_LEFT_SIDE_ONLY),
+        dataLeft(left),
+        dataRight(0, 0) {}
+    FileMapping(const Zstring&         fileNameShort, //file exists on right side only
+                const FileDescriptor&  right,
+                const HierarchyObject& parent) :
+        FileSystemObject(false, true, fileNameShort, parent),
+        cmpResult(FILE_RIGHT_SIDE_ONLY),
+        dataLeft(0, 0),
+        dataRight(right) {}
+
+    virtual void swap();
+    virtual void removeObjectL();
+    virtual void removeObjectR();
+    virtual void copyToL();
+    virtual void copyToR();
+    //------------------------------------------------------------------
+
+    //categorization
+    CompareFilesResult cmpResult;
+    wxString cmpConflictDescr; //only filled if cmpResult == FILE_CONFLICT
+
+    FileDescriptor dataLeft;
+    FileDescriptor dataRight;
+};
 
 //------------------------------------------------------------------
-    class BaseDirMapping : public HierarchyObject //synchronization base directory
-    {
-    public:
-        BaseDirMapping(const Zstring& dirPostfixedLeft, const Zstring& dirPostfixedRight) :
-                baseDirLeft(dirPostfixedLeft),
-                baseDirRight(dirPostfixedRight) {}
+class BaseDirMapping : public HierarchyObject //synchronization base directory
+{
+public:
+    BaseDirMapping(const Zstring& dirPostfixedLeft,
+                   const Zstring& dirPostfixedRight,
+                   bool filterActive,
+                   const Zstring& includeFilter,
+                   const Zstring& excludeFilter) :
+        HierarchyObject(dirPostfixedLeft, dirPostfixedRight),
+        filter(filterActive, includeFilter, excludeFilter) {}
+
+    struct FilterSettings
+    {
+        FilterSettings(bool active,
+                       const Zstring& include,
+                       const Zstring& exclude) :
+            filterActive(active),
+            includeFilter(include),
+            excludeFilter(exclude) {}
+        bool filterActive;
+        Zstring includeFilter;
+        Zstring excludeFilter;
+    };
 
-        template <SelectedSide side> const Zstring& getBaseDir() const;
+    const FilterSettings& getFilter() const;
+    template <SelectedSide side> Zstring getDBFilename() const;
+    virtual void swap();
 
-    private:
-        Zstring baseDirLeft;  //directory name ending with FILE_NAME_SEPARATOR
-        Zstring baseDirRight; //directory name ending with FILE_NAME_SEPARATOR
-    };
+private:
+    FilterSettings filter;
+};
 
 
-    typedef std::vector<BaseDirMapping> FolderComparison;
+typedef std::vector<BaseDirMapping> FolderComparison;
 
 //------------------------------------------------------------------
 
@@ -343,33 +415,32 @@ namespace FreeFileSync
 
 
 //---------------Inline Implementation---------------------------------------------------
-    inline
-    FileSystemObject* HierarchyObject::retrieveById(FileSystemObject::ObjectID id) //returns NULL if object is not found
-    {
-        //code re-use of const method: see Meyers Effective C++
-        return const_cast<FileSystemObject*>(static_cast<const HierarchyObject&>(*this).retrieveById(id));
-    }
+inline
+FileSystemObject* HierarchyObject::retrieveById(ObjectID id) //returns NULL if object is not found
+{
+    //code re-use of const method: see Meyers Effective C++
+    return const_cast<FileSystemObject*>(static_cast<const HierarchyObject&>(*this).retrieveById(id));
+}
 
 
-    inline
-    FileSystemObject::ObjectID FileSystemObject::getId() const
-    {
-        return uniqueId;
-    }
+inline
+HierarchyObject::ObjectID FileSystemObject::getId() const
+{
+    return uniqueId;
+}
 
 
-    inline
-    FileSystemObject::ObjectID FileSystemObject::getUniqueId()
-    {
-        static unsigned int id = 0;
-        return ++id;
-    }
+inline
+HierarchyObject::ObjectID FileSystemObject::getUniqueId()
+{
+    static unsigned int id = 0;
+    return ++id;
+}
 
 
-    template <class T>
-    inline
-    bool DirContainer::CmpLess<T>::operator()(const T& a, const T& b) const
-    {
+inline
+bool DirContainer::CmpFilename::operator()(const Zstring& a, const Zstring& b) const
+{
 //        //quick check based on string length
 //        const size_t aLength = a.data.shortName.length();
 //        const size_t bLength = b.data.shortName.length();
@@ -377,418 +448,516 @@ namespace FreeFileSync
 //            return aLength < bLength;
 
 #ifdef FFS_WIN //Windows does NOT distinguish between upper/lower-case
-        return a.data.shortName.CmpNoCase(b.data.shortName) < 0;
+    return a.CmpNoCase(b) < 0;
 #elif defined FFS_LINUX //Linux DOES distinguish between upper/lower-case
-        return a.data.shortName.Cmp(b.data.shortName) < 0;
+    return a.Cmp(b) < 0;
 #endif
-    }
+}
 
+inline
+const DirContainer::SubDirList& DirContainer::getSubDirs() const
+{
+    return subDirs;
+}
 
-    inline
-    const DirDescriptor& DirContainer::getData() const
-    {
-        return data;
-    }
 
+inline
+const DirContainer::SubFileList& DirContainer::getSubFiles() const
+{
+    return subFiles;
+}
 
-    inline
-    const Zstring& DirContainer::getParentRelNamePf() const
-    {
-        return parentRelNamePf;
-    }
 
+inline
+const FileDescriptor& FileContainer::getData() const
+{
+    return data;
+}
 
-    inline
-    const DirContainer::SubDirList& DirContainer::getSubDirs() const
-    {
-        return subDirs;
-    }
 
+inline
+DirContainer& DirContainer::addSubDir(const Zstring& shortName)
+{
+    return subDirs.insert(std::make_pair(shortName, DirContainer())).first->second;
+}
 
-    inline
-    const DirContainer::SubFileList& DirContainer::getSubFiles() const
-    {
-        return subFiles;
-    }
 
+inline
+void DirContainer::addSubFile(const Zstring& shortName, const FileDescriptor& fileData)
+{
+    subFiles.insert(std::make_pair(shortName, FileContainer(fileData)));
+}
 
-    inline
-    const FileDescriptor& FileContainer::getData() const
-    {
-        return data;
-    }
 
+inline
+CompareFilesResult FileMapping::getCategory() const
+{
+    return cmpResult;
+}
 
-    inline
-    const Zstring& FileContainer::getParentRelNamePf() const
-    {
-        return parentRelNamePf;
-    }
 
+inline
+const wxString& FileMapping::getCatConflict() const
+{
+    return cmpConflictDescr;
+}
 
-    inline
-    DirContainer& DirContainer::addSubDir(const DirDescriptor& dirData, const Zstring& parentRelativeNamePf)
-    {
-        //const cast: another crime in the name of unproven performance optimization ;) however key part cannot be changed, so this should be safe
-        return const_cast<DirContainer&>(*subDirs.insert(DirContainer(dirData, parentRelativeNamePf)).first);
-    }
 
+inline
+CompareFilesResult DirMapping::getCategory() const
+{
+    return convertToFilesResult(cmpResult);
+}
 
-    inline
-    void DirContainer::addSubFile(const FileDescriptor& fileData, const Zstring& parentRelativeNamePf)
-    {
-        subFiles.insert(FileContainer(fileData, parentRelativeNamePf));
-    }
 
+inline
+CompareDirResult DirMapping::getDirCategory() const
+{
+    return cmpResult;
+}
 
-    inline
-    CompareFilesResult FileMapping::getCategory() const
-    {
-        return cmpResult;
-    }
 
+inline
+const wxString& DirMapping::getCatConflict() const
+{
+    static wxString empty;
+    return empty;
+}
 
-    inline
-    const wxString& FileMapping::getConflictDescription() const
-    {
-        return conflictDescription;
-    }
 
+inline
+void FileSystemObject::setSyncDir(SyncDirection newDir)
+{
+    syncDir = static_cast<SyncDirectionIntern>(newDir); //should be safe by design
+}
 
-    inline
-    CompareFilesResult DirMapping::getCategory() const
-    {
-        return convertToFilesResult(cmpResult);
-    }
 
+inline
+const wxString& FileSystemObject::getSyncOpConflict() const
+{
+    //a sync operation conflict can occur when:
+    //1. category-conflict and syncDir == NONE -> problem finding category
+    //2. syncDir == SYNC_DIR_INT_CONFLICT -> problem finding sync direction
+    return syncDir == SYNC_DIR_INT_CONFLICT ? syncOpConflictDescr : getCatConflict();
+}
 
-    inline
-    const wxString& DirMapping::getConflictDescription() const
-    {
-        static wxString empty;
-        return empty;
-    }
 
+inline
+void FileSystemObject::setSyncDirConflict(const wxString& description) //set syncDir = SYNC_DIR_INT_CONFLICT
+{
+    syncDir = SYNC_DIR_INT_CONFLICT;
+    syncOpConflictDescr = description;
+}
 
-    template <SelectedSide side>
-    inline
-    bool FileSystemObject::isEmpty() const
-    {
-        return side == LEFT_SIDE ? isEmptyL() : isEmptyR();
-    }
 
+inline
+bool FileSystemObject::isActive() const
+{
+    return selectedForSynchronization;
+}
 
-    inline
-    bool FileSystemObject::isEmpty() const
-    {
-        return isEmptyL() && isEmptyR();
-    }
 
+inline
+void FileSystemObject::setActive(bool active)
+{
+    selectedForSynchronization = active;
+}
 
-    template <SelectedSide side>
-    inline
-    const Zstring& FileSystemObject::getShortName() const
-    {
-        return side == LEFT_SIDE ? getShortNameL() : getShortNameR();
-    }
 
+inline
+SyncOperation FileSystemObject::getSyncOperation() const
+{
+    return getSyncOperation(getCategory(), selectedForSynchronization, syncDir);
+}
 
-    template <SelectedSide side>
-    inline
-    const Zstring FileSystemObject::getRelativeName() const
-    {
-        return isEmpty<side>() ? Zstring() : nameBuffer.parentRelNamePf + getShortName<side>();
-    }
 
+inline
+SyncOperation FileSystemObject::testSyncOperation(bool selected, SyncDirection proposedDir) const
+{
+    return getSyncOperation(getCategory(), selected, static_cast<SyncDirectionIntern>(proposedDir)); //should be safe by design
+}
 
-    template <SelectedSide side>
-    inline
-    const Zstring FileSystemObject::getParentRelativeName() const
-    {
-        return nameBuffer.parentRelNamePf.BeforeLast(globalFunctions::FILE_NAME_SEPARATOR);  //returns empty string if char not found
-    }
 
+template <>
+inline
+bool FileSystemObject::isEmpty<LEFT_SIDE>() const
+{
+    return !existsLeft_;
+}
 
-    template <SelectedSide side>
-    inline
-    const Zstring FileSystemObject::getFullName() const
-    {
-        return isEmpty<side>() ? Zstring() : getBaseDirPf<side>() + nameBuffer.parentRelNamePf + getShortName<side>();
-    }
 
+template <>
+inline
+bool FileSystemObject::isEmpty<RIGHT_SIDE>() const
+{
+    return !existsRight_;
+}
 
-    template <SelectedSide side>
-    inline
-    const Zstring& FileSystemObject::getBaseDirPf() const
-    {
-        return side == LEFT_SIDE ? nameBuffer.baseDirPfL : nameBuffer.baseDirPfR;
-    }
 
+inline
+bool FileSystemObject::isEmpty() const
+{
+    return isEmpty<LEFT_SIDE>() && isEmpty<RIGHT_SIDE>();
+}
 
-    template <SelectedSide side>
-    inline
-    void FileSystemObject::removeObject()
-    {
-        if (side == LEFT_SIDE)
-            removeObjectL();
-        else
-            removeObjectR();
-    }
 
+template <SelectedSide side>
+inline
+const Zstring& FileSystemObject::getShortName() const
+{
+    static Zstring null;
+    return isEmpty<side>() ? null : shortName_;
+}
 
-    template <SelectedSide side>
-    inline
-    void FileSystemObject::copyTo()
-    {
-        syncDir   = SYNC_DIR_NONE;
 
-        if (side == LEFT_SIDE)
-            copyToL();
-        else
-            copyToR();
-    }
+template <SelectedSide side>
+inline
+const Zstring FileSystemObject::getRelativeName() const
+{
+    return isEmpty<side>() ? Zstring() : nameBuffer.parentRelNamePf + shortName_;
+}
 
 
-    inline
-    void FileSystemObject::swap()
-    {
-        //swap file descriptors
-        swapDescriptors();
-    }
+inline
+const Zstring FileSystemObject::getObjRelativeName() const
+{
+    return nameBuffer.parentRelNamePf + shortName_;
+}
 
 
-    inline
-    DirMapping& HierarchyObject::addSubDir(const DirDescriptor& left,
-                                           CompareDirResult defaultCmpResult,
-                                           const DirDescriptor& right,
-                                           const RelNamesBuffered& relNameBuff)
-    {
-        subDirs.push_back(DirMapping(left, defaultCmpResult, right, relNameBuff));
-        return subDirs.back();
-    }
+inline
+const Zstring& FileSystemObject::getObjShortName() const
+{
+    return shortName_;
+}
 
 
-    inline
-    FileMapping& HierarchyObject::addSubFile(const FileDescriptor& left,
-            CompareFilesResult defaultCmpResult,
-            const FileDescriptor& right,
-            const RelNamesBuffered& relNameBuff)
-    {
-        subFiles.push_back(FileMapping(left, defaultCmpResult, right, relNameBuff));
-        return subFiles.back();
-    }
+inline
+const Zstring FileSystemObject::getParentRelativeName() const
+{
+    return nameBuffer.parentRelNamePf.BeforeLast(globalFunctions::FILE_NAME_SEPARATOR);  //returns empty string if char not found
+}
 
 
-    inline
-    void DirMapping::swapDescriptors()
-    {
-        //swap compare result
-        switch (cmpResult)
-        {
-        case DIR_LEFT_SIDE_ONLY:
-            cmpResult = DIR_RIGHT_SIDE_ONLY;
-            break;
-        case DIR_RIGHT_SIDE_ONLY:
-            cmpResult = DIR_LEFT_SIDE_ONLY;
-            break;
-        case DIR_EQUAL:
-            break;
-        }
-
-        std::swap(dataLeft, dataRight);
-    }
+template <SelectedSide side>
+inline
+const Zstring FileSystemObject::getFullName() const
+{
+    return isEmpty<side>() ? Zstring() : getBaseDirPf<side>() + nameBuffer.parentRelNamePf + shortName_;
+}
 
 
-    inline
-    const DirDescriptor& DirMapping::nullData()
-    {
-        static DirDescriptor output( static_cast<Zstring>(Zstring()));
-        return output;
-    }
+template <>
+inline
+const Zstring& FileSystemObject::getBaseDirPf<LEFT_SIDE>() const
+{
+    return nameBuffer.baseDirPfL;
+}
 
 
-    inline
-    void DirMapping::removeObjectL()
-    {
-        cmpResult = DIR_RIGHT_SIDE_ONLY;
-        dataLeft = nullData();
-        std::for_each(subFiles.begin(), subFiles.end(), std::mem_fun_ref(&FileSystemObject::removeObject<LEFT_SIDE>));
-        std::for_each(subDirs.begin(),  subDirs.end(),  std::mem_fun_ref(&FileSystemObject::removeObject<LEFT_SIDE>));
-    }
+template <>
+inline
+const Zstring& FileSystemObject::getBaseDirPf<RIGHT_SIDE>() const
+{
+    return nameBuffer.baseDirPfR;
+}
 
 
-    inline
-    void DirMapping::removeObjectR()
-    {
-        cmpResult = DIR_LEFT_SIDE_ONLY;
-        dataRight = nullData();
-        std::for_each(subFiles.begin(), subFiles.end(), std::mem_fun_ref(&FileSystemObject::removeObject<RIGHT_SIDE>));
-        std::for_each(subDirs.begin(),  subDirs.end(),  std::mem_fun_ref(&FileSystemObject::removeObject<RIGHT_SIDE>));
-    }
+template <>
+inline
+void FileSystemObject::removeObject<LEFT_SIDE>()
+{
+    existsLeft_ = false;
+    removeObjectL();
+}
 
 
-    inline
-    void DirMapping::copyToL()
-    {
-        cmpResult = DIR_EQUAL;
-        dataLeft = dataRight;
-    }
+template <>
+inline
+void FileSystemObject::removeObject<RIGHT_SIDE>()
+{
+    existsRight_ = false;
+    removeObjectR();
+}
 
 
-    inline
-    void DirMapping::copyToR()
-    {
-        cmpResult = DIR_EQUAL;
-        dataRight = dataLeft;
-    }
+inline
+void FileSystemObject::synchronizeSides()
+{
+    switch (syncDir)
+    {
+    case SYNC_DIR_INT_LEFT:
+        existsLeft_ = existsRight_;
+        copyToL();
+        break;
+    case SYNC_DIR_INT_RIGHT:
+        existsRight_ = existsLeft_;
+        copyToR();
+        break;
+    case SYNC_DIR_INT_NONE:
+    case SYNC_DIR_INT_CONFLICT:
+        assert(!"if nothing's todo then why arrive here?");
+        break;
+    }
+
+    syncDir = SYNC_DIR_INT_NONE;
+}
 
 
-    inline
-    const Zstring& DirMapping::getShortNameL() const
-    {
-        return dataLeft.shortName;
-    }
+inline
+void FileSystemObject::swap()
+{
+    std::swap(nameBuffer.baseDirPfL, nameBuffer.baseDirPfR);
+    std::swap(existsLeft_, existsRight_);
+}
 
 
-    inline
-    const Zstring& DirMapping::getShortNameR() const
-    {
-        return dataRight.shortName;
-    }
+inline
+void HierarchyObject::swap()
+{
+    std::swap(baseDirLeft, baseDirRight);
 
+    //files
+    std::for_each(subFiles.begin(), subFiles.end(), std::mem_fun_ref(&FileMapping::swap));
+    //directories
+    std::for_each(subDirs.begin(), subDirs.end(), std::mem_fun_ref(&DirMapping::swap));
+}
 
-    inline
-    bool DirMapping::isEmptyL() const
-    {
-        return dataLeft.shortName.empty();
-    }
 
+inline
+const Zstring& HierarchyObject::getRelativeNamePf() const
+{
+    return relNamePf;
+}
 
-    inline
-    bool DirMapping::isEmptyR() const
-    {
-        return dataRight.shortName.empty();
-    }
 
+inline
+DirMapping& HierarchyObject::addSubDir(bool existsLeft,
+                                       const Zstring& dirNameShort,
+                                       bool existsRight)
+{
+    subDirs.push_back(DirMapping(existsLeft, dirNameShort, existsRight, *this));
+    return subDirs.back();
+}
 
-    template <SelectedSide side>
-    inline
-    const Zstring& BaseDirMapping::getBaseDir() const
-    {
-        return side == LEFT_SIDE ? baseDirLeft : baseDirRight;
-    }
 
+inline
+FileMapping& HierarchyObject::addSubFile(const FileDescriptor&   left,          //file exists on both sides
+        const Zstring&          fileNameShort,
+        CompareFilesResult      defaultCmpResult,
+        const FileDescriptor&   right)
+{
+    subFiles.push_back(FileMapping(left, fileNameShort, defaultCmpResult, right, *this));
+    return subFiles.back();
+}
+
+
+inline
+void HierarchyObject::addSubFile(const FileDescriptor&   left,          //file exists on left side only
+                                 const Zstring&          fileNameShort)
+{
+    subFiles.push_back(FileMapping(left, fileNameShort, *this));
+}
+
+
+inline
+void HierarchyObject::addSubFile(const Zstring&          fileNameShort, //file exists on right side only
+                                 const FileDescriptor&   right)
+{
+    subFiles.push_back(FileMapping(fileNameShort, right, *this));
+}
+
+
+inline
+void BaseDirMapping::swap()
+{
+    //call base class versions
+    HierarchyObject::swap();
+}
 
-    inline
-    void FileMapping::swapDescriptors()
-    {
-        //swap compare result
-        switch (cmpResult)
-        {
-        case FILE_LEFT_SIDE_ONLY:
-            cmpResult = FILE_RIGHT_SIDE_ONLY;
-            break;
-        case FILE_RIGHT_SIDE_ONLY:
-            cmpResult = FILE_LEFT_SIDE_ONLY;
-            break;
-        case FILE_LEFT_NEWER:
-            cmpResult = FILE_RIGHT_NEWER;
-            break;
-        case FILE_RIGHT_NEWER:
-            cmpResult = FILE_LEFT_NEWER;
-            break;
-        case FILE_DIFFERENT:
-        case FILE_EQUAL:
-        case FILE_CONFLICT:
-            break;
-        }
-
-        std::swap(dataLeft, dataRight);
-    }
 
+inline
+void DirMapping::swap()
+{
+    //call base class versions
+    HierarchyObject::swap();
+    FileSystemObject::swap();
 
-    inline
-    void FileMapping::removeObjectL()
+    //swap compare result
+    switch (cmpResult)
     {
-        cmpResult = FILE_RIGHT_SIDE_ONLY;
-        dataLeft = nullData();
+    case DIR_LEFT_SIDE_ONLY:
+        cmpResult = DIR_RIGHT_SIDE_ONLY;
+        break;
+    case DIR_RIGHT_SIDE_ONLY:
+        cmpResult = DIR_LEFT_SIDE_ONLY;
+        break;
+    case DIR_EQUAL:
+        break;
     }
+}
+
+
+inline
+void DirMapping::removeObjectL()
+{
+    cmpResult = DIR_RIGHT_SIDE_ONLY;
+    std::for_each(subFiles.begin(), subFiles.end(), std::mem_fun_ref(&FileSystemObject::removeObject<LEFT_SIDE>));
+    std::for_each(subDirs.begin(),  subDirs.end(),  std::mem_fun_ref(&FileSystemObject::removeObject<LEFT_SIDE>));
+}
+
+
+inline
+void DirMapping::removeObjectR()
+{
+    cmpResult = DIR_LEFT_SIDE_ONLY;
+    std::for_each(subFiles.begin(), subFiles.end(), std::mem_fun_ref(&FileSystemObject::removeObject<RIGHT_SIDE>));
+    std::for_each(subDirs.begin(),  subDirs.end(),  std::mem_fun_ref(&FileSystemObject::removeObject<RIGHT_SIDE>));
+}
+
+
+inline
+void DirMapping::copyToL()
+{
+    cmpResult = DIR_EQUAL;
+}
+
+
+inline
+void DirMapping::copyToR()
+{
+    cmpResult = DIR_EQUAL;
+}
+
+
+inline
+const BaseDirMapping::FilterSettings& BaseDirMapping::getFilter() const
+{
+    return filter;
+}
+
+
+template <SelectedSide side>
+inline
+Zstring BaseDirMapping::getDBFilename() const
+{
+    return getBaseDir<side>() + getSyncDBFilename();
+}
 
 
-    inline
-    void FileMapping::removeObjectR()
+inline
+void FileMapping::swap()
+{
+    //call base class version
+    FileSystemObject::swap();
+
+    //swap compare result
+    switch (cmpResult)
     {
+    case FILE_LEFT_SIDE_ONLY:
+        cmpResult = FILE_RIGHT_SIDE_ONLY;
+        break;
+    case FILE_RIGHT_SIDE_ONLY:
         cmpResult = FILE_LEFT_SIDE_ONLY;
-        dataRight = nullData();
-    }
+        break;
+    case FILE_LEFT_NEWER:
+        cmpResult = FILE_RIGHT_NEWER;
+        break;
+    case FILE_RIGHT_NEWER:
+        cmpResult = FILE_LEFT_NEWER;
+        break;
+    case FILE_DIFFERENT:
+    case FILE_EQUAL:
+    case FILE_CONFLICT:
+        break;
+    }
+
+    std::swap(dataLeft, dataRight);
+}
 
 
-    inline
-    void FileMapping::copyToL()
-    {
-        cmpResult = FILE_EQUAL;
-        dataLeft = dataRight;
-    }
+template <CompareFilesResult res>
+inline
+void FileMapping::setCategory()
+{
+    cmpResult = res;
+}
 
+template <>
+inline
+void FileMapping::setCategory<FILE_CONFLICT>(); //if conflict is detected, use setCategoryConflict! => method is not defined!
 
-    inline
-    void FileMapping::copyToR()
-    {
-        cmpResult = FILE_EQUAL;
-        dataRight = dataLeft;
-    }
 
+inline
+void FileMapping::setCategoryConflict(const wxString& description)
+{
+    cmpResult = FILE_CONFLICT;
+    cmpConflictDescr = description;
+}
 
-    inline
-    const FileDescriptor& FileMapping::nullData()
-    {
-        static FileDescriptor output(Zstring(), 0, 0);
-        return output;
-    }
 
+inline
+void FileMapping::removeObjectL()
+{
+    cmpResult = FILE_RIGHT_SIDE_ONLY;
+    dataLeft = FileDescriptor(0, 0);
+}
 
-    inline
-    const Zstring& FileMapping::getShortNameL() const
-    {
-        return dataLeft.shortName;
-    }
 
+inline
+void FileMapping::removeObjectR()
+{
+    cmpResult = FILE_LEFT_SIDE_ONLY;
+    dataRight = FileDescriptor(0, 0);
+}
 
-    inline
-    const Zstring& FileMapping::getShortNameR() const
-    {
-        return dataRight.shortName;
-    }
 
+inline
+void FileMapping::copyToL()
+{
+    cmpResult = FILE_EQUAL;
+    dataLeft = dataRight;
+}
 
-    inline
-    bool FileMapping::isEmptyL() const
-    {
-        return dataLeft.shortName.empty();
-    }
 
+inline
+void FileMapping::copyToR()
+{
+    cmpResult = FILE_EQUAL;
+    dataRight = dataLeft;
+}
 
-    inline
-    bool FileMapping::isEmptyR() const
-    {
-        return dataRight.shortName.empty();
-    }
 
+template <>
+inline
+const wxLongLong& FileMapping::getLastWriteTime<LEFT_SIDE>() const
+{
+    return dataLeft.lastWriteTimeRaw;
+}
 
-    template <SelectedSide side>
-    inline
-    const wxLongLong& FileMapping::getLastWriteTime() const
-    {
-        return side == LEFT_SIDE ? dataLeft.lastWriteTimeRaw : dataRight.lastWriteTimeRaw;
-    }
+
+template <>
+inline
+const wxLongLong& FileMapping::getLastWriteTime<RIGHT_SIDE>() const
+{
+    return dataRight.lastWriteTimeRaw;
+}
 
 
-    template <SelectedSide side>
-    inline
-    const wxULongLong& FileMapping::getFileSize() const
-    {
-        return side == LEFT_SIDE ? dataLeft.fileSize : dataRight.fileSize;
-    }
+template <>
+inline
+const wxULongLong& FileMapping::getFileSize<LEFT_SIDE>() const
+{
+    return dataLeft.fileSize;
+}
+
+
+template <>
+inline
+const wxULongLong& FileMapping::getFileSize<RIGHT_SIDE>() const
+{
+    return dataRight.fileSize;
+}
 }
 
 #endif // FILEHIERARCHY_H_INCLUDED