[bfreisen] 72804: [ATL] Add atlpath.h, which provides the CPathT class template and the classes CPath, CPathA and CPathW. CORE-12034
Author: bfreisen Date: Sun Sep 25 19:58:22 2016 New Revision: 72804
URL: http://svn.reactos.org/svn/reactos?rev=72804&view=rev Log: [ATL] Add atlpath.h, which provides the CPathT class template and the classes CPath, CPathA and CPathW. CORE-12034
Added: trunk/reactos/sdk/lib/atl/atlpath.h (with props)
Added: trunk/reactos/sdk/lib/atl/atlpath.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/lib/atl/atlpath.h?rev=7... ============================================================================== --- trunk/reactos/sdk/lib/atl/atlpath.h (added) +++ trunk/reactos/sdk/lib/atl/atlpath.h [iso-8859-1] Sun Sep 25 19:58:22 2016 @@ -0,0 +1,388 @@ +// PROJECT: ReactOS ATL CPathT +// LICENSE: Public Domain +// PURPOSE: Provides compatibility to Microsoft ATL +// PROGRAMMERS: Benedikt Freisen + +#ifndef __ATLPATH_H__ +#define __ATLPATH_H__ + +// WARNING: Untested code + +#pragma once + +#include <atlcore.h> +#include <atlstr.h> +#include <shlwapi.h> + +namespace ATL +{ + +template<typename StringType> +class CPathT +{ + // const + inline BOOL PathFileExistsX(LPCSTR pszPath) { return PathFileExistsA(pszPath); } + inline BOOL PathFileExistsX(LPCWSTR pszPath) { return PathFileExistsW(pszPath); } + inline int PathFindExtensionX(LPCSTR pszPath) { return PathFindExtensionA(pszPath); } + inline int PathFindExtensionX(LPCWSTR pszPath) { return PathFindExtensionW(pszPath); } + inline int PathFindFileNameX(LPCSTR pszPath) { return PathFindFileNameA(pszPath); } + inline int PathFindFileNameX(LPCWSTR pszPath) { return PathFindFileNameW(pszPath); } + inline int PathGetDriveNumberX(LPCSTR pszPath) { return PathGetDriveNumberA(pszPath); } + inline int PathGetDriveNumberX(LPCWSTR pszPath) { return PathGetDriveNumberW(pszPath); } + inline BOOL PathIsDirectoryX(LPCSTR pszPath) { return PathIsDirectoryA(pszPath); } + inline BOOL PathIsDirectoryX(LPCWSTR pszPath) { return PathIsDirectoryW(pszPath); } + inline BOOL PathIsFileSpecX(LPCSTR pszPath) { return PathIsFileSpecA(pszPath); } + inline BOOL PathIsFileSpecX(LPCWSTR pszPath) { return PathIsFileSpecW(pszPath); } + inline BOOL PathIsPrefixX(LPCSTR pszPath, LPCSTR pszPrefix) { return PathIsPrefixA(pszPath, pszPrefix); } + inline BOOL PathIsPrefixX(LPCWSTR pszPath, LPCWSTR pszPrefix) { return PathIsPrefixW(pszPath, pszPrefix); } + inline BOOL PathIsRelativeX(LPCSTR pszPath) { return PathIsRelativeA(pszPath); } + inline BOOL PathIsRelativeX(LPCWSTR pszPath) { return PathIsRelativeW(pszPath); } + inline BOOL PathIsRootX(LPCSTR pszPath) { return PathIsRootA(pszPath); } + inline BOOL PathIsRootX(LPCWSTR pszPath) { return PathIsRootW(pszPath); } + inline BOOL PathIsSameRootX(LPCSTR pszPath, LPCSTR pszOther) { return PathIsSameRootA(pszPath, pszOther); } + inline BOOL PathIsSameRootX(LPCWSTR pszPath, LPCWSTR pszOther) { return PathIsSameRootW(pszPath, pszOther); } + inline BOOL PathIsUNCX(LPCSTR pszPath) { return PathIsUNCA(pszPath); } + inline BOOL PathIsUNCX(LPCWSTR pszPath) { return PathIsUNCW(pszPath); } + inline BOOL PathIsUNCServerX(LPCSTR pszPath) { return PathIsUNCServerA(pszPath); } + inline BOOL PathIsUNCServerX(LPCWSTR pszPath) { return PathIsUNCServerW(pszPath); } + inline BOOL PathIsUNCServerShareX(LPCSTR pszPath) { return PathIsUNCServerShareA(pszPath); } + inline BOOL PathIsUNCServerShareX(LPCWSTR pszPath) { return PathIsUNCServerShareW(pszPath); } + inline BOOL PathMatchSpecX(LPCSTR pszPath, LPCSTR pszSpec) { return PathMatchSpecA(pszPath, pszSpec); } + inline BOOL PathMatchSpecX(LPCWSTR pszPath, LPCWSTR pszSpec) { return PathMatchSpecW(pszPath, pszSpec); } + inline int PathSkipRootX(LPCSTR pszPath) { return PathSkipRootA(pszPath); } + inline int PathSkipRootX(LPCWSTR pszPath) { return PathSkipRootW(pszPath); } + + // non-const + inline void PathAddBackslashX(LPSTR pszPath) { return PathAddBackslashA(pszPath); } + inline void PathAddBackslashX(LPWSTR pszPath) { return PathAddBackslashW(pszPath); } + inline BOOL PathAddExtensionX(LPSTR pszPath, LPCSTR pszExt) { return PathAddExtensionA(pszPath, pszExt); } + inline BOOL PathAddExtensionX(LPWSTR pszPath, LPCWSTR pszExt) { return PathAddExtensionW(pszPath, pszExt); } + inline BOOL PathAppendX(LPSTR pszPath, LPCSTR pszMore) { return PathAppendA(pszPath, pszMore); } + inline BOOL PathAppendX(LPWSTR pszPath, LPCWSTR pszMore) { return PathAppendW(pszPath, pszMore); } + inline void PathBuildRootX(LPSTR pszRoot, int iDrive) { return PathBuildRootA(pszRoot, iDrive); } + inline void PathBuildRootX(LPWSTR pszRoot, int iDrive) { return PathBuildRootW(pszRoot, iDrive); } + inline void PathCanonicalizeX(LPSTR pszDst, LPCSTR pszSrc) { return PathCanonicalizeA(pszDst, pszSrc); } + inline void PathCanonicalizeX(LPWSTR pszDst, LPCWSTR pszSrc) { return PathCanonicalizeW(pszDst, pszSrc); } + inline void PathCombineX(LPSTR pszPathOut, LPCSTR pszPathIn, LPCSTR pszMore) { return PathCombineA(pszPathOut, pszPathIn, pszMore); } + inline void PathCombineX(LPWSTR pszPathOut, LPCWSTR pszPathIn, LPCWSTR pszMore) { return PathCombineW(pszPathOut, pszPathIn, pszMore); } + inline CPathT<StringType> PathCommonPrefixX(LPCSTR pszFile1, LPCSTR pszFile2, LPSTR pszPath) { return PathCommonPrefixA(pszFile1, pszFile2, pszPath); } + inline CPathT<StringType> PathCommonPrefixX(LPCWSTR pszFile1, LPCWSTR pszFile2, LPWSTR pszPath) { return PathCommonPrefixW(pszFile1, pszFile2, pszPath); } + inline BOOL PathCompactPathX(HDC hDC, LPSTR pszPath, UINT dx) { return PathCompactPathA(hDC, pszPath, dx); } + inline BOOL PathCompactPathX(HDC hDC, LPWSTR pszPath, UINT dx) { return PathCompactPathW(hDC, pszPath, dx); } + inline BOOL PathCompactPathExX(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, DWORD dwFlags) { return PathCompactPathExA(pszOut, pszSrc, cchMax, dwFlags); } + inline BOOL PathCompactPathExX(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMax, DWORD dwFlags) { return PathCompactPathExW(pszOut, pszSrc, cchMax, dwFlags); } + inline BOOL PathMakePrettyX(LPSTR pszPath) { return PathMakePrettyA(pszPath); } + inline BOOL PathMakePrettyX(LPWSTR pszPath) { return PathMakePrettyW(pszPath); } + inline void PathQuoteSpacesX(LPSTR pszPath) { return PathQuoteSpacesA(pszPath); } + inline void PathQuoteSpacesX(LPWSTR pszPath) { return PathQuoteSpacesW(pszPath); } + inline BOOL PathRelativePathToX(LPSTR pszPath, LPCSTR pszFrom, DWORD dwAttrFrom, LPCSTR pszTo, DWORD dwAttrTo) { return PathRelativePathToA(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo); } + inline BOOL PathRelativePathToX(LPWSTR pszPath, LPCWSTR pszFrom, DWORD dwAttrFrom, LPCWSTR pszTo, DWORD dwAttrTo) { return PathRelativePathToW(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo); } + inline void PathRemoveArgsX(LPSTR pszPath) { return PathRemoveArgsA(pszPath); } + inline void PathRemoveArgsX(LPWSTR pszPath) { return PathRemoveArgsW(pszPath); } + inline void PathRemoveBackslashX(LPSTR pszPath) { return PathRemoveBackslashA(pszPath); } + inline void PathRemoveBackslashX(LPWSTR pszPath) { return PathRemoveBackslashW(pszPath); } + inline void PathRemoveBlanksX(LPSTR pszPath) { return PathRemoveBlanksA(pszPath); } + inline void PathRemoveBlanksX(LPWSTR pszPath) { return PathRemoveBlanksW(pszPath); } + inline void PathRemoveExtensionX(LPSTR pszPath) { return PathRemoveExtensionA(pszPath); } + inline void PathRemoveExtensionX(LPWSTR pszPath) { return PathRemoveExtensionW(pszPath); } + inline BOOL PathRemoveFileSpecX(LPSTR pszPath) { return PathRemoveFileSpecA(pszPath); } + inline BOOL PathRemoveFileSpecX(LPWSTR pszPath) { return PathRemoveFileSpecW(pszPath); } + inline BOOL PathRenameExtensionX(LPSTR pszPath, LPCSTR pszExt) { return PathRenameExtensionA(pszPath, pszExt); } + inline BOOL PathRenameExtensionX(LPWSTR pszPath, LPCWSTR pszExt) { return PathRenameExtensionW(pszPath, pszExt); } + inline void PathStripPathX(LPSTR pszPath) { return PathStripPathA(pszPath); } + inline void PathStripPathX(LPWSTR pszPath) { return PathStripPathW(pszPath); } + inline BOOL PathStripToRootX(LPSTR pszPath) { return PathStripToRootA(pszPath); } + inline BOOL PathStripToRootX(LPWSTR pszPath) { return PathStripToRootW(pszPath); } + inline void PathUnquoteSpacesX(LPSTR pszPath) { return PathUnquoteSpacesA(pszPath); } + inline void PathUnquoteSpacesX(LPWSTR pszPath) { return PathUnquoteSpacesW(pszPath); } + +public: + typedef typename StringType::PCXSTR PCXSTR; + typedef typename StringType::PXSTR PXSTR; + typedef typename StringType::XCHAR XCHAR; + + StringType m_strPath; + + CPathT(PCXSTR pszPath) + { + m_strPath = StringType(pszPath); + } + + CPathT(const CPathT<StringType>& path) + { + m_strPath = path.m_strPath; + } + + CPathT() throw() + { + // do nothing, m_strPath initializes itself + } + + void AddBackslash() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathAddBackslashX(str); + m_strPath.ReleaseBuffer(); + } + + BOOL AddExtension(PCXSTR pszExtension) + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathAddExtensionX(str, pszExtension); + m_strPath.ReleaseBuffer(); + return result; + } + + BOOL Append(PCXSTR pszMore) + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathAppendX(str, pszMore); + m_strPath.ReleaseBuffer(); + return result; + } + + void BuildRoot(int iDrive) + { + PXSTR str = m_strPath.GetBuffer(4); + PathBuildRootX(str, iDrive); + m_strPath.ReleaseBuffer(); + } + + void Canonicalize() + { + StringType strTemp; + PXSTR str = strTemp.GetBuffer(MAX_PATH); + PathCanonicalizeX(str, m_strPath); + strTemp.ReleaseBuffer(); + m_strPath = strTemp; + } + + void Combine(PCXSTR pszDir, PCXSTR pszFile) + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathCombineX(str, pszDir, pszFile); + m_strPath.ReleaseBuffer(); + } + + CPathT<StringType> CommonPrefix(PCXSTR pszOther) + { + StringType result; + result.SetString(m_strPath, PathCommonPrefixX(m_strPath, pszOther, NULL)); + return result; + } + + BOOL CompactPath(HDC hDC, UINT nWidth) + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathCompactPathX(hDC, str, nWidth); + m_strPath.ReleaseBuffer(); + return result; + } + + BOOL CompactPathEx(UINT nMaxChars, DWORD dwFlags = 0) + { + StringType result; + PXSTR str = result.GetBuffer(nMaxChars); + PathCompactPathExX(str, m_strPath, nMaxChars, dwFlags); + result.ReleaseBuffer(); + return result; + } + + BOOL FileExists() const + { + return PathFileExistsX(m_strPath); + } + + int FindExtension() const + { + return PathFindExtensionX(m_strPath); + } + + int FindFileName() const + { + return PathFindFileNameX(m_strPath); + } + + int GetDriveNumber() const + { + return PathGetDriveNumberX(m_strPath); + } + + StringType GetExtension() const + { + return StringType(PathFindExtensionX(m_strPath)); + } + + BOOL IsDirectory() const + { + return PathIsDirectoryX(m_strPath); + } + + BOOL IsFileSpec() const + { + return PathIsFileSpecX(m_strPath); + } + + BOOL IsPrefix(PCXSTR pszPrefix) const + { + return PathIsPrefixX(m_strPath); + } + + BOOL IsRelative() const + { + return PathIsRelativeX(m_strPath); + } + + BOOL IsRoot() const + { + return PathIsRootX(m_strPath); + } + + BOOL IsSameRoot(PCXSTR pszOther) const + { + return PathIsSameRootX(m_strPath, pszOther); + } + + BOOL IsUNC() const + { + return PathIsUNCX(m_strPath); + } + + BOOL IsUNCServer() const + { + return PathIsUNCServerX(m_strPath); + } + + BOOL IsUNCServerShare() const + { + return PathIsUNCServerShareX(m_strPath); + } + + BOOL MakePretty() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathMakePrettyX(str); + m_strPath.ReleaseBuffer(); + return result; + } + + BOOL MatchSpec(PCXSTR pszSpec) const + { + return PathMatchSpecX(m_strPath, pszSpec); + } + + void QuoteSpaces() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathQuoteSpacesX(str); + m_strPath.ReleaseBuffer(); + } + + BOOL RelativePathTo(PCXSTR pszFrom, DWORD dwAttrFrom, PCXSTR pszTo, DWORD dwAttrTo) + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathRelativePathToX(str, pszFrom, dwAttrFrom, pszTo, dwAttrTo); + m_strPath.ReleaseBuffer(); + return result; + } + + void RemoveArgs() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathRemoveArgsX(str); + m_strPath.ReleaseBuffer(); + } + + void RemoveBackslash() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathRemoveBackslashX(str); + m_strPath.ReleaseBuffer(); + } + + void RemoveBlanks() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathRemoveBlanksX(str); + m_strPath.ReleaseBuffer(); + } + + void RemoveExtension() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathRemoveExtensionX(str); + m_strPath.ReleaseBuffer(); + } + + BOOL RemoveFileSpec() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathRemoveFileSpecX(str); + m_strPath.ReleaseBuffer(); + return result; + } + + BOOL RenameExtension(PCXSTR pszExtension) + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathRenameExtensionX(str, pszExtension); + m_strPath.ReleaseBuffer(); + return result; + } + + int SkipRoot() const + { + return PathSkipRootX(m_strPath); + } + + void StripPath() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathStripPathX(str); + m_strPath.ReleaseBuffer(); + } + + BOOL StripToRoot() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + BOOL result = PathStripToRootX(str); + m_strPath.ReleaseBuffer(); + return result; + } + + void UnquoteSpaces() + { + PXSTR str = m_strPath.GetBuffer(MAX_PATH); + PathUnquoteSpacesX(str); + m_strPath.ReleaseBuffer(); + } + + operator const StringType&() const throw() + { + return m_strPath; + } + + operator PCXSTR() const throw() + { + return m_strPath; + } + + operator StringType&() throw() + { + return m_strPath; + } + + CPathT<StringType>& operator+=(PCXSTR pszMore) + { + m_strPath += pszMore; + } + +}; + +typedef CPathT<CString> CPath; +typedef CPathT<CStringA> CPathA; +typedef CPathT<CStringW> CPathW; + +} // namespace ATL + +#endif
Propchange: trunk/reactos/sdk/lib/atl/atlpath.h ------------------------------------------------------------------------------ svn:eol-style = native
Propchange: trunk/reactos/sdk/lib/atl/atlpath.h ------------------------------------------------------------------------------ svn:mime-type = text/plain
-
bfreisen＠svn.reactos.org