OSDN Git Service

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