OSDN Git Service

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