1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
#ifndef FREEFILESYNC_H_INCLUDED
#define FREEFILESYNC_H_INCLUDED
#include <wx/string.h>
#include <set>
#include <vector>
#include "library/zstring.h"
#include <wx/longlong.h>
namespace FreeFileSync
{
enum CompareVariant
{
CMP_BY_CONTENT,
CMP_BY_TIME_SIZE
};
struct SyncConfiguration
{
SyncConfiguration() :
exLeftSideOnly(SYNC_DIR_RIGHT),
exRightSideOnly(SYNC_DIR_RIGHT),
leftNewer(SYNC_DIR_RIGHT),
rightNewer(SYNC_DIR_RIGHT),
different(SYNC_DIR_RIGHT) {}
enum Direction
{
SYNC_DIR_LEFT,
SYNC_DIR_RIGHT,
SYNC_DIR_NONE
};
Direction exLeftSideOnly;
Direction exRightSideOnly;
Direction leftNewer;
Direction rightNewer;
Direction different;
bool operator==(const SyncConfiguration& other) const
{
return exLeftSideOnly == other.exLeftSideOnly &&
exRightSideOnly == other.exRightSideOnly &&
leftNewer == other.leftNewer &&
rightNewer == other.rightNewer &&
different == other.different;
}
};
struct MainConfiguration
{
MainConfiguration();
//Compare setting
CompareVariant compareVar;
//Synchronisation settings
SyncConfiguration syncConfiguration;
//Filter setting
bool filterIsActive;
wxString includeFilter;
wxString excludeFilter;
//misc options
bool useRecycleBin; //use Recycle bin when deleting or overwriting files while synchronizing
bool operator==(const MainConfiguration& other) const
{
return compareVar == other.compareVar &&
syncConfiguration == other.syncConfiguration &&
filterIsActive == other.filterIsActive &&
includeFilter == other.includeFilter &&
excludeFilter == other.excludeFilter;
}
};
struct FolderPair
{
FolderPair() {}
FolderPair(const Zstring& leftDir, const Zstring& rightDir) :
leftDirectory(leftDir),
rightDirectory(rightDir) {}
Zstring leftDirectory;
Zstring rightDirectory;
bool operator==(const FolderPair& other) const
{
return leftDirectory == other.leftDirectory &&
rightDirectory == other.rightDirectory;
}
};
struct FileDescrLine
{
FileDescrLine() : objType(TYPE_NOTHING) {}
enum ObjectType
{
TYPE_NOTHING,
TYPE_DIRECTORY,
TYPE_FILE
};
Zstring fullName; // == directory + relativeName
Zsubstr relativeName; //fullName without directory that is being synchronized
//Note on performance: Keep redundant information "relativeName"!
//Extracting info from "fullName" instead would result in noticeable performance loss, with only limited memory reduction (note ref. counting strings)!
wxLongLong lastWriteTimeRaw; //number of seconds since Jan. 1st 1970 UTC, same semantics like time_t (== signed long)
wxULongLong fileSize;
ObjectType objType; //is it a file or directory or initial?
bool operator < (const FileDescrLine& b) const //used by template class "set"
{
//quick check based on string length: we are not interested in a lexicographical order!
const size_t aLength = relativeName.length();
const size_t bLength = b.relativeName.length();
if (aLength != bLength)
return aLength < bLength;
#ifdef FFS_WIN //Windows does NOT distinguish between upper/lower-case
return FreeFileSync::compareStringsWin32(relativeName.c_str(), b.relativeName.c_str()) < 0; //implementing a (reverse) comparison manually is a lot slower!
#elif defined FFS_LINUX //Linux DOES distinguish between upper/lower-case
return defaultCompare(relativeName.c_str(), b.relativeName.c_str()) < 0;
#endif
}
};
typedef std::vector<FileDescrLine> DirectoryDescrType;
enum CompareFilesResult
{
FILE_LEFT_SIDE_ONLY,
FILE_RIGHT_SIDE_ONLY,
FILE_LEFT_NEWER,
FILE_RIGHT_NEWER,
FILE_DIFFERENT,
FILE_EQUAL,
FILE_UNDEFINED
};
struct FileCompareLine
{
FileCompareLine() : selectedForSynchronization(true) {}
FileDescrLine fileDescrLeft;
FileDescrLine fileDescrRight;
CompareFilesResult cmpResult;
bool selectedForSynchronization;
};
typedef std::vector<FileCompareLine> FileComparison;
struct FolderCompareLine //support for multiple folder pairs
{
FolderPair syncPair; //directories to be synced (ending with separator)
FileComparison fileCmp;
};
typedef std::vector<FolderCompareLine> FolderComparison;
//References to single lines(in FileComparison) inside FolderComparison
typedef std::vector<std::set<int> > FolderCompRef;
class AbortThisProcess //Exception class used to abort the "compare" and "sync" process
{
public:
AbortThisProcess() {}
~AbortThisProcess() {}
};
}
#endif // FREEFILESYNC_H_INCLUDED
|
