OSDN Git Service

TGitPath Add Rename handle
[tortoisegit/TortoiseGitJp.git] / src / Git / TGitPath.h
1 #pragma once\r
2 \r
3 class CTGitPath\r
4 {\r
5 public:\r
6         CTGitPath(void);\r
7         ~CTGitPath(void);\r
8  CTGitPath(const CString& sUnknownPath);\r
9 public:\r
10         enum\r
11         {       \r
12                 LOGACTIONS_ADDED        = 0x00000001,\r
13                 LOGACTIONS_MODIFIED     = 0x00000002,\r
14                 LOGACTIONS_REPLACED     = 0x00000004,\r
15                 LOGACTIONS_DELETED      = 0x00000008,\r
16                 LOGACTIONS_UNVER        = 0x80000000,\r
17                 LOGACTIONS_IGNORE       = 0x40000000,\r
18                 LOGACTIONS_CONFLICT = 0x20000000,\r
19         };\r
20 \r
21         CString m_StatAdd;\r
22         CString m_StatDel;\r
23         int             m_Action;\r
24         bool    m_Checked;\r
25         int     ParserAction(CString action);\r
26         CString GetActionName();\r
27         /**\r
28          * Set the path as an UTF8 string with forward slashes\r
29          */\r
30         void SetFromGit(const char* pPath);\r
31         void SetFromGit(const char* pPath, bool bIsDirectory);\r
32         void SetFromGit(const CString& sPath,CString *OldPath=NULL);\r
33         \r
34         /**\r
35          * Set the path as UNICODE with backslashes\r
36          */\r
37         void SetFromWin(LPCTSTR pPath);\r
38         void SetFromWin(const CString& sPath);\r
39         void SetFromWin(const CString& sPath, bool bIsDirectory);\r
40         /**\r
41          * Set the path from an unknown source.\r
42          */\r
43         void SetFromUnknown(const CString& sPath);\r
44         /**\r
45          * Returns the path in Windows format, i.e. with backslashes\r
46          */\r
47         LPCTSTR GetWinPath() const;\r
48         /**\r
49          * Returns the path in Windows format, i.e. with backslashes\r
50          */\r
51         const CString& GetWinPathString() const;\r
52         /**\r
53          * Returns the path with forward slashes.\r
54          */\r
55         const CString& GetGitPathString() const;\r
56 \r
57         const CString& GetGitOldPathString() const;\r
58         /**\r
59          * Returns the path completely prepared to be fed the the Git APIs\r
60          * It will be in UTF8, with URLs escaped, if necessary\r
61          */\r
62 //      const char* GetGitApiPath(apr_pool_t *pool) const;\r
63         /**\r
64          * Returns the path for showing in an UI.\r
65          *\r
66          * URL's are returned with forward slashes, unescaped if necessary\r
67          * Paths are returned with backward slashes\r
68          */\r
69         const CString& GetUIPathString() const;\r
70         /**\r
71          * Checks if the path is an URL.\r
72          */\r
73         bool IsUrl() const;\r
74         /**\r
75          * Returns true if the path points to a directory\r
76          */\r
77         bool IsDirectory() const;\r
78         /**\r
79          * Returns the directory. If the path points to a directory, then the path\r
80          * is returned unchanged. If the path points to a file, the path to the \r
81          * parent directory is returned.\r
82          */\r
83         CTGitPath GetDirectory() const;\r
84         /**\r
85         * Returns the the directory which contains the item the path refers to.\r
86         * If the path is a directory, then this returns the directory above it.\r
87         * If the path is to a file, then this returns the directory which contains the path\r
88         * parent directory is returned.\r
89         */\r
90         CTGitPath GetContainingDirectory() const;\r
91         /**\r
92          * Get the 'root path' (e.g. "c:\") - Used to pass to GetDriveType \r
93          */\r
94         CString GetRootPathString() const;\r
95         /**\r
96          * Returns the filename part of the full path.\r
97          * \remark don't call this for directories.\r
98          */\r
99         CString GetFilename() const;\r
100         CString GetBaseFilename() const;\r
101         /**\r
102          * Returns the item's name without the full path.\r
103          */\r
104         CString GetFileOrDirectoryName() const;\r
105         /**\r
106          * Returns the item's name without the full path, unescaped if necessary.\r
107          */\r
108         CString GetUIFileOrDirectoryName() const;\r
109         /**\r
110          * Returns the file extension, including the dot.\r
111          * \remark Returns an empty string for directories\r
112          */\r
113         CString GetFileExtension() const;\r
114 \r
115         bool IsEmpty() const;\r
116         void Reset();\r
117         /**\r
118          * Checks if two paths are equal. The slashes are taken care of.\r
119          */\r
120         bool IsEquivalentTo(const CTGitPath& rhs) const;\r
121         bool IsEquivalentToWithoutCase(const CTGitPath& rhs) const;\r
122         bool operator==(const CTGitPath& x) const {return IsEquivalentTo(x);}\r
123         \r
124         /**\r
125          * Checks if \c possibleDescendant is a child of this path.\r
126          */\r
127         bool IsAncestorOf(const CTGitPath& possibleDescendant) const;\r
128         /**\r
129          * Get a string representing the file path, optionally with a base \r
130          * section stripped off the front\r
131          * Returns a string with fwdslash paths \r
132          */\r
133         CString GetDisplayString(const CTGitPath* pOptionalBasePath = NULL) const;\r
134         /**\r
135          * Compares two paths. Slash format is irrelevant.\r
136          */\r
137         static int Compare(const CTGitPath& left, const CTGitPath& right);\r
138 \r
139         /** As PredLeftLessThanRight, but for checking if paths are equivalent \r
140          */\r
141         static bool PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right);\r
142 \r
143         /** Checks if the left path is pointing to the same working copy path as the right.\r
144          * The same wc path means the paths are equivalent once all the admin dir path parts\r
145          * are removed. This is used in the TGitCache crawler to filter out all the 'duplicate'\r
146          * paths to crawl.\r
147          */\r
148         static bool PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right);\r
149         \r
150         static bool CheckChild(const CTGitPath &parent, const CTGitPath& child);\r
151 \r
152         /**\r
153          * appends a string to this path. \r
154          *\remark - missing slashes are not added - this is just a string concatenation, but with\r
155          * preservation of the proper caching behavior.\r
156          * If you want to join a file- or directory-name onto the path, you should use AppendPathString\r
157          */\r
158         void AppendRawString(const CString& sAppend);\r
159 \r
160         /**\r
161         * appends a part of a path to this path. \r
162         *\remark - missing slashes are dealt with properly. Don't use this to append a file extension, for example\r
163         * \r
164         */\r
165         void AppendPathString(const CString& sAppend);\r
166 \r
167         /**\r
168          * Get the file modification time - returns zero for files which don't exist\r
169          * Returns a FILETIME structure cast to an __int64, for easy comparisons\r
170          */\r
171         __int64 GetLastWriteTime() const;\r
172         \r
173         bool IsReadOnly() const;\r
174         \r
175         /**\r
176          * Checks if the path really exists.\r
177          */\r
178         bool Exists() const;\r
179         \r
180         /**\r
181          * Deletes the file/folder\r
182          * \param bTrash if true, uses the Windows trash bin when deleting.\r
183          */\r
184         bool Delete(bool bTrash) const;\r
185 \r
186         /**\r
187          * Checks if a Subversion admin directory is present. For files, the check\r
188          * is done in the same directory. For folders, it checks if the folder itself\r
189          * contains an admin directory.\r
190          */\r
191         bool HasAdminDir() const;\r
192         \r
193         /**\r
194          * Checks if the path point to or below a Subversion admin directory (.Git).\r
195          */\r
196         bool IsAdminDir() const;\r
197 \r
198         void SetCustomData(LPARAM lp) {m_customData = lp;}\r
199         LPARAM GetCustomData() {return m_customData;}\r
200 \r
201         /**\r
202          * Checks if the path or URL is valid on Windows.\r
203          * A path is valid if conforms to the specs in the windows API.\r
204          * An URL is valid if the path checked out from it is valid\r
205          * on windows. That means an URL which is valid according to the WWW specs\r
206          * isn't necessarily valid as a windows path (e.g. http://myserver.com/repos/file:name \r
207          * is a valid URL, but the path is illegal on windows ("file:name" is illegal), so\r
208          * this function would return \c false for that URL).\r
209          */\r
210         bool IsValidOnWindows() const;\r
211 \r
212         /**\r
213          * Checks to see if the path or URL represents one of the special directories\r
214          * (branches, tags, or trunk).\r
215          */\r
216         bool IsSpecialDirectory() const;\r
217 private:\r
218         // All these functions are const, and all the data\r
219         // is mutable, in order that the hidden caching operations\r
220         // can be carried out on a const CTGitPath object, which is what's \r
221         // likely to be passed between functions\r
222         // The public 'SetFromxxx' functions are not const, and so the proper \r
223         // const-correctness semantics are preserved\r
224         void SetFwdslashPath(const CString& sPath) const;\r
225         void SetBackslashPath(const CString& sPath) const;\r
226         void SetUTF8FwdslashPath(const CString& sPath) const;\r
227         void EnsureBackslashPathSet() const;\r
228         void EnsureFwdslashPathSet() const;\r
229         /**\r
230          * Checks if two path strings are equal. No conversion of slashes is done!\r
231          * \remark for slash-independent comparison, use IsEquivalentTo()\r
232          */\r
233         static bool ArePathStringsEqual(const CString& sP1, const CString& sP2);\r
234         static bool ArePathStringsEqualWithCase(const CString& sP1, const CString& sP2);\r
235         \r
236         /**\r
237          * Adds the required trailing slash to local root paths such as 'C:'\r
238          */\r
239         void SanitizeRootPath(CString& sPath, bool bIsForwardPath) const;\r
240 \r
241         void UpdateAttributes() const;\r
242         \r
243 \r
244 \r
245 private:\r
246         mutable CString m_sBackslashPath;\r
247         mutable CString m_sFwdslashPath;\r
248         mutable CString m_sUIPath;\r
249         mutable CStringA m_sUTF8FwdslashPath;\r
250         mutable CStringA m_sUTF8FwdslashPathEscaped;\r
251 \r
252         //used for rename case\r
253         mutable CString m_sOldBackslashPath;\r
254         mutable CString m_sOldFwdslashPath;\r
255         \r
256         // Have we yet determined if this is a directory or not?\r
257         mutable bool m_bDirectoryKnown;\r
258         mutable bool m_bIsDirectory;\r
259         mutable bool m_bLastWriteTimeKnown;\r
260         mutable bool m_bURLKnown;\r
261         mutable bool m_bIsURL;\r
262         mutable __int64 m_lastWriteTime;\r
263         mutable bool m_bIsReadOnly;\r
264         mutable bool m_bHasAdminDirKnown;\r
265         mutable bool m_bHasAdminDir;\r
266         mutable bool m_bIsValidOnWindowsKnown;\r
267         mutable bool m_bIsValidOnWindows;\r
268         mutable bool m_bIsAdminDirKnown;\r
269         mutable bool m_bIsAdminDir;\r
270         mutable bool m_bExists;\r
271         mutable bool m_bExistsKnown;\r
272         mutable LPARAM m_customData;\r
273         mutable bool m_bIsSpecialDirectoryKnown;\r
274         mutable bool m_bIsSpecialDirectory;\r
275 \r
276         friend bool operator<(const CTGitPath& left, const CTGitPath& right);\r
277 };\r
278 /**\r
279  * Compares two paths and return true if left is earlier in sort order than right\r
280  * (Uses CTGitPath::Compare logic, but is suitable for std::sort and similar)\r
281  */\r
282  bool operator<(const CTGitPath& left, const CTGitPath& right);\r
283 \r
284 \r
285 //////////////////////////////////////////////////////////////////////////\r
286 \r
287 /**\r
288  * \ingroup Utils\r
289  * This class represents a list of paths\r
290  */\r
291 class CTGitPathList \r
292 {\r
293 public:\r
294         CTGitPathList();\r
295         // A constructor which allows a path list to be easily built with one initial entry in\r
296         explicit CTGitPathList(const CTGitPath& firstEntry);\r
297         int m_Action;\r
298 public:\r
299         void AddPath(const CTGitPath& newPath);\r
300         bool LoadFromFile(const CTGitPath& filename);\r
301         bool WriteToFile(const CString& sFilename, bool bANSI = false) const;\r
302         CTGitPath * LookForGitPath(CString path);\r
303         int     ParserFromLog(CString &log);\r
304         int FillUnRev(int Action,CTGitPathList *list=NULL);\r
305         int GetAction();\r
306         /**\r
307          * Load from the path argument string, when the 'path' parameter is used\r
308          * This is a list of paths, with '*' between them\r
309          */\r
310         void LoadFromAsteriskSeparatedString(const CString& sPathString);\r
311         CString CreateAsteriskSeparatedString() const;\r
312 \r
313         int GetCount() const;\r
314         void Clear();\r
315         const CTGitPath& operator[](INT_PTR index) const;\r
316         bool AreAllPathsFiles() const;\r
317         bool AreAllPathsFilesInOneDirectory() const;\r
318         CTGitPath GetCommonDirectory() const;\r
319         CTGitPath GetCommonRoot() const;\r
320         void SortByPathname(bool bReverse = false);\r
321         /** \r
322          * Delete all the files in the list, then clear the list.\r
323          * \param bTrash if true, the items are deleted using the Windows trash bin\r
324          */\r
325         void DeleteAllFiles(bool bTrash);\r
326         /** Remove duplicate entries from the list (sorts the list as a side-effect */\r
327         void RemoveDuplicates();\r
328         /** Removes all paths which are on or in a Subversion admin directory */\r
329         void RemoveAdminPaths();\r
330         void RemovePath(const CTGitPath& path);\r
331         void RemoveItem(CTGitPath &path);\r
332         /** \r
333          * Removes all child items and leaves only the top folders. Useful if you\r
334          * create the list to remove them (i.e. if you remove a parent folder, the\r
335          * child files and folders don't have to be deleted anymore)\r
336          */\r
337         void RemoveChildren();\r
338 \r
339         /** Checks if two CTGitPathLists are the same */\r
340         bool IsEqual(const CTGitPathList& list);\r
341 \r
342         /** Convert into the Git API parameter format */\r
343 //      apr_array_header_t * MakePathArray (apr_pool_t *pool) const;\r
344 \r
345 private:\r
346         typedef std::vector<CTGitPath> PathVector;\r
347         PathVector m_paths;\r
348         // If the list contains just files in one directory, then\r
349         // this contains the directory name\r
350         mutable CTGitPath m_commonBaseDirectory;\r
351 };\r