diff options
Diffstat (limited to 'shared')
72 files changed, 23185 insertions, 640 deletions
diff --git a/shared/appMain.cpp b/shared/appMain.cpp new file mode 100644 index 00000000..fe6d3af5 --- /dev/null +++ b/shared/appMain.cpp @@ -0,0 +1,24 @@ +#include "appMain.h" +#include <wx/window.h> +#include <wx/app.h> + +using namespace FreeFileSync; + + +bool AppMainWindow::mainWndAct = false; + + +void FreeFileSync::AppMainWindow::setMainWindow(wxWindow* window) +{ + wxTheApp->SetTopWindow(window); + wxTheApp->SetExitOnFrameDelete(true); + + assert (!mainWndAct); + mainWndAct = true; +} + + +bool AppMainWindow::mainWindowWasSet() +{ + return mainWndAct; +} diff --git a/shared/appMain.h b/shared/appMain.h new file mode 100644 index 00000000..130a6e2a --- /dev/null +++ b/shared/appMain.h @@ -0,0 +1,21 @@ +#ifndef APPMAIN_H_INCLUDED +#define APPMAIN_H_INCLUDED + +class wxWindow; + +namespace FreeFileSync +{ +//just some wrapper around a global variable representing the (logical) main application window +class AppMainWindow +{ +public: + static void setMainWindow(wxWindow* window); //set main window and enable "exit on frame delete" + static bool mainWindowWasSet(); + +private: + static bool mainWndAct; +}; +} + + +#endif // APPMAIN_H_INCLUDED diff --git a/shared/customButton.cpp b/shared/customButton.cpp index 4027d3ef..40c0397f 100644 --- a/shared/customButton.cpp +++ b/shared/customButton.cpp @@ -10,9 +10,9 @@ wxButtonWithImage::wxButtonWithImage(wxWindow *parent, long style, const wxValidator& validator, const wxString& name) : - wxBitmapButton(parent, id, wxNullBitmap, pos, size, style | wxBU_AUTODRAW, validator, name), - m_spaceAfter(0), - m_spaceBefore(0) + wxBitmapButton(parent, id, wxNullBitmap, pos, size, style | wxBU_AUTODRAW, validator, name), + m_spaceAfter(0), + m_spaceBefore(0) { setTextLabel(label); } diff --git a/shared/dragAndDrop.cpp b/shared/dragAndDrop.cpp index 9261d604..89f4da4d 100644 --- a/shared/dragAndDrop.cpp +++ b/shared/dragAndDrop.cpp @@ -19,9 +19,9 @@ class FFSFileDropEvent : public wxCommandEvent { public: FFSFileDropEvent(const wxString& nameDropped, const wxWindow* dropWindow) : - wxCommandEvent(FFS_DROP_FILE_EVENT), - nameDropped_(nameDropped), - dropWindow_(dropWindow) {} + wxCommandEvent(FFS_DROP_FILE_EVENT), + nameDropped_(nameDropped), + dropWindow_(dropWindow) {} virtual wxEvent* Clone() const { @@ -39,7 +39,7 @@ class WindowDropTarget : public wxFileDropTarget { public: WindowDropTarget(wxWindow* dropWindow) : - dropWindow_(dropWindow) {} + dropWindow_(dropWindow) {} virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) { @@ -68,10 +68,10 @@ DragDropOnMainDlg::DragDropOnMainDlg(wxWindow* dropWindow1, wxWindow* dropWindow2, wxDirPickerCtrl* dirPicker, wxComboBox* dirName) : - dropWindow1_(dropWindow1), - dropWindow2_(dropWindow2), - dirPicker_(dirPicker), - dirName_(dirName) + dropWindow1_(dropWindow1), + dropWindow2_(dropWindow2), + dirPicker_(dirPicker), + dirName_(dirName) { //prepare drag & drop dropWindow1->SetDropTarget(new WindowDropTarget(dropWindow1)); //takes ownership @@ -155,9 +155,9 @@ using FreeFileSync::DragDropOnDlg; DragDropOnDlg::DragDropOnDlg(wxWindow* dropWindow, wxDirPickerCtrl* dirPicker, wxTextCtrl* dirName) : - dropWindow_(dropWindow), - dirPicker_(dirPicker), - dirName_(dirName) + dropWindow_(dropWindow), + dirPicker_(dirPicker), + dirName_(dirName) { //prepare drag & drop dropWindow->SetDropTarget(new WindowDropTarget(dropWindow)); //takes ownership diff --git a/shared/dragAndDrop.h b/shared/dragAndDrop.h index a8c7561a..4e6bbd31 100644 --- a/shared/dragAndDrop.h +++ b/shared/dragAndDrop.h @@ -15,48 +15,48 @@ class wxFileDirPickerEvent; namespace FreeFileSync { - //add drag and drop functionality, coordinating a wxWindow, wxDirPickerCtrl, and wxComboBox/wxTextCtrl +//add drag and drop functionality, coordinating a wxWindow, wxDirPickerCtrl, and wxComboBox/wxTextCtrl - class DragDropOnMainDlg : private wxEvtHandler - { - public: - DragDropOnMainDlg(wxWindow* dropWindow1, - wxWindow* dropWindow2, - wxDirPickerCtrl* dirPicker, - wxComboBox* dirName); - - virtual ~DragDropOnMainDlg() {} - - virtual bool AcceptDrop(const wxString& dropName) = 0; //return true if drop should be processed +class DragDropOnMainDlg : private wxEvtHandler +{ +public: + DragDropOnMainDlg(wxWindow* dropWindow1, + wxWindow* dropWindow2, + wxDirPickerCtrl* dirPicker, + wxComboBox* dirName); - private: - void OnFilesDropped(FFSFileDropEvent& event); - void OnWriteDirManually(wxCommandEvent& event); - void OnDirSelected(wxFileDirPickerEvent& event); + virtual ~DragDropOnMainDlg() {} - const wxWindow* dropWindow1_; - const wxWindow* dropWindow2_; - wxDirPickerCtrl* dirPicker_; - wxComboBox* dirName_; - }; + virtual bool AcceptDrop(const wxString& dropName) = 0; //return true if drop should be processed +private: + void OnFilesDropped(FFSFileDropEvent& event); + void OnWriteDirManually(wxCommandEvent& event); + void OnDirSelected(wxFileDirPickerEvent& event); - class DragDropOnDlg: private wxEvtHandler - { - public: - DragDropOnDlg(wxWindow* dropWindow, - wxDirPickerCtrl* dirPicker, - wxTextCtrl* dirName); + const wxWindow* dropWindow1_; + const wxWindow* dropWindow2_; + wxDirPickerCtrl* dirPicker_; + wxComboBox* dirName_; +}; - private: - void OnFilesDropped(FFSFileDropEvent& event); - void OnWriteDirManually(wxCommandEvent& event); - void OnDirSelected(wxFileDirPickerEvent& event); - const wxWindow* dropWindow_; - wxDirPickerCtrl* dirPicker_; - wxTextCtrl* dirName_; - }; +class DragDropOnDlg: private wxEvtHandler +{ +public: + DragDropOnDlg(wxWindow* dropWindow, + wxDirPickerCtrl* dirPicker, + wxTextCtrl* dirName); + +private: + void OnFilesDropped(FFSFileDropEvent& event); + void OnWriteDirManually(wxCommandEvent& event); + void OnDirSelected(wxFileDirPickerEvent& event); + + const wxWindow* dropWindow_; + wxDirPickerCtrl* dirPicker_; + wxTextCtrl* dirName_; +}; } diff --git a/shared/fileError.h b/shared/fileError.h index f5c6bdbd..daf97910 100644 --- a/shared/fileError.h +++ b/shared/fileError.h @@ -6,20 +6,20 @@ namespace FreeFileSync { - class FileError //Exception class used to notify file/directory copy/delete errors - { - public: - FileError(const wxString& message) : - errorMessage(message) {} +class FileError //Exception class used to notify file/directory copy/delete errors +{ +public: + FileError(const wxString& message) : + errorMessage(message) {} - const wxString& show() const - { - return errorMessage; - } + const wxString& show() const + { + return errorMessage; + } - private: - wxString errorMessage; - }; +private: + wxString errorMessage; +}; } #endif // FILEERROR_H_INCLUDED diff --git a/shared/fileHandling.cpp b/shared/fileHandling.cpp index 55fd7ff5..cea701cc 100644 --- a/shared/fileHandling.cpp +++ b/shared/fileHandling.cpp @@ -1,6 +1,7 @@ #include "fileHandling.h" #include <wx/intl.h> #include "systemFunctions.h" +#include "globalFunctions.h" #include "systemConstants.h" #include "fileTraverser.h" #include <wx/file.h> @@ -8,6 +9,8 @@ #include <boost/bind.hpp> #include <algorithm> #include <wx/log.h> +#include <wx/datetime.h> +#include "stringConv.h" #ifdef FFS_WIN #include <wx/msw/wrapwin.h> //includes "windows.h" @@ -28,21 +31,30 @@ using FreeFileSync::FileError; Zstring FreeFileSync::getFormattedDirectoryName(const Zstring& dirname) -{ //Formatting is needed since functions expect the directory to end with '\' to be able to split the relative names. +{ + //Formatting is needed since functions expect the directory to end with '\' to be able to split the relative names. //Also improves usability. - Zstring dirnameTmp = dirname; + wxString dirnameTmp = zToWx(dirname); dirnameTmp.Trim(true); //remove whitespace characters from right dirnameTmp.Trim(false); //remove whitespace characters from left if (dirnameTmp.empty()) //an empty string is interpreted as "\"; this is not desired return Zstring(); - if (!dirnameTmp.EndsWith(globalFunctions::FILE_NAME_SEPARATOR)) - dirnameTmp += globalFunctions::FILE_NAME_SEPARATOR; + if (!dirnameTmp.EndsWith(zToWx(globalFunctions::FILE_NAME_SEPARATOR))) + dirnameTmp += zToWx(globalFunctions::FILE_NAME_SEPARATOR); + + //replace macros + wxString timeNow = wxDateTime::Now().FormatISOTime(); + timeNow.Replace(wxT(":"), wxT("-")); + dirnameTmp.Replace(wxT("%time%"), timeNow.c_str()); + + const wxString dateToday = wxDateTime::Now().FormatISODate(); + dirnameTmp.Replace(wxT("%date%"), dateToday.c_str()); //don't do directory formatting with wxFileName, as it doesn't respect //?/ - prefix - return dirnameTmp; + return wxToZ(dirnameTmp); } @@ -64,7 +76,7 @@ public: private: RecycleBin() : - recycleBinAvailable(false) + recycleBinAvailable(false) { #ifdef FFS_WIN recycleBinAvailable = true; @@ -117,7 +129,8 @@ bool moveToRecycleBin(const Zstring& filename) //throw (std::logic_error) bool FreeFileSync::fileExists(const DefaultChar* filename) -{ //symbolic links (broken or not) are also treated as existing files! +{ + //symbolic links (broken or not) are also treated as existing files! #ifdef FFS_WIN // we must use GetFileAttributes() instead of the ANSI C functions because // it can cope with network (UNC) paths unlike them @@ -134,7 +147,8 @@ bool FreeFileSync::fileExists(const DefaultChar* filename) bool FreeFileSync::dirExists(const DefaultChar* dirname) -{ //symbolic links (broken or not) are also treated as existing directories! +{ + //symbolic links (broken or not) are also treated as existing directories! #ifdef FFS_WIN // we must use GetFileAttributes() instead of the ANSI C functions because // it can cope with network (UNC) paths unlike them @@ -166,15 +180,15 @@ bool FreeFileSync::symlinkExists(const DefaultChar* objname) bool FreeFileSync::isMovable(const Zstring& pathFrom, const Zstring& pathTo) { - wxLogNull noWxLogs; //prevent wxWidgets logging if dummy file creation failed + wxLogNull noWxLogs; //prevent wxWidgets logging if dummy file creation failed const Zstring dummyFileSource = pathFrom.EndsWith(globalFunctions::FILE_NAME_SEPARATOR) ? - pathFrom + wxT("DeleteMe.tmp") : - pathFrom + globalFunctions::FILE_NAME_SEPARATOR + wxT("DeleteMe.tmp"); + pathFrom + DefaultStr("DeleteMe.tmp") : + pathFrom + globalFunctions::FILE_NAME_SEPARATOR + DefaultStr("DeleteMe.tmp"); const Zstring dummyFileTarget = pathTo.EndsWith(globalFunctions::FILE_NAME_SEPARATOR) ? - pathTo + wxT("DeleteMe.tmp") : - pathTo + globalFunctions::FILE_NAME_SEPARATOR + wxT("DeleteMe.tmp"); + pathTo + DefaultStr("DeleteMe.tmp") : + pathTo + globalFunctions::FILE_NAME_SEPARATOR + DefaultStr("DeleteMe.tmp"); try { removeFile(dummyFileSource, false); @@ -184,7 +198,7 @@ bool FreeFileSync::isMovable(const Zstring& pathFrom, const Zstring& pathTo) //create dummy file { - wxFile dummy(dummyFileSource.c_str(), wxFile::write); + wxFile dummy(zToWx(dummyFileSource), wxFile::write); if (!dummy.IsOpened()) return false; //if there's no write access, files can't be moved neither dummy.Write(wxT("FreeFileSync dummy file. May be deleted safely.\n")); @@ -195,7 +209,7 @@ bool FreeFileSync::isMovable(const Zstring& pathFrom, const Zstring& pathTo) #ifdef FFS_WIN ::MoveFileEx(dummyFileSource.c_str(), //__in LPCTSTR lpExistingFileName, dummyFileTarget.c_str(), //__in_opt LPCTSTR lpNewFileName, - 0) != 0; //__in DWORD dwFlags + 0) != 0; //__in DWORD dwFlags #elif defined FFS_LINUX ::rename(dummyFileSource.c_str(), dummyFileTarget.c_str()) == 0; #endif @@ -227,7 +241,7 @@ void FreeFileSync::removeFile(const Zstring& filename, const bool useRecycleBin) if (useRecycleBin) { if (!moveToRecycleBin(filename)) - throw FileError(wxString(_("Error moving to Recycle Bin:")) + wxT("\n\"") + filename.c_str() + wxT("\"")); + throw FileError(wxString(_("Error moving to Recycle Bin:")) + wxT("\n\"") + zToWx(filename) + wxT("\"")); return; } @@ -237,20 +251,20 @@ void FreeFileSync::removeFile(const Zstring& filename, const bool useRecycleBin) filename.c_str(), //address of filename FILE_ATTRIBUTE_NORMAL)) //attributes to set { - wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + filename.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + zToWx(filename) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } //remove file, support for \\?\-prefix if (!::DeleteFile(filename.c_str())) { - wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + filename.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + zToWx(filename) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } #elif defined FFS_LINUX if (::unlink(filename.c_str()) != 0) { - wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + filename.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + zToWx(filename) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } #endif @@ -286,7 +300,8 @@ void FreeFileSync::moveFile(const Zstring& sourceFile, const Zstring& targetFile { if (fileExists(targetFile.c_str())) //test file existence: e.g. Linux might silently overwrite existing symlinks { - const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + sourceFile + wxT("\" ->\n\"") + targetFile + wxT("\""); + const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\" ->\n\"") + + zToWx(targetFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + _("Target file already existing!")); } @@ -303,7 +318,8 @@ void FreeFileSync::moveFile(const Zstring& sourceFile, const Zstring& targetFile const DWORD lastError = ::GetLastError(); if (lastError != ERROR_NOT_SAME_DEVICE) { - const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\" ->\n\"") + targetFile.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\" ->\n\"") + + zToWx(targetFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError)); } @@ -318,14 +334,15 @@ void FreeFileSync::moveFile(const Zstring& sourceFile, const Zstring& targetFile #elif defined FFS_LINUX //first try to move the file directly without copying - if (rename(sourceFile.c_str(), targetFile.c_str()) == 0) + if (::rename(sourceFile.c_str(), targetFile.c_str()) == 0) return; //if moving failed treat as error (except when it tried to move to a different volume: in this case we will copy the file) if (errno != EXDEV) { - const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\" ->\n\"") + targetFile.c_str() + wxT("\""); - throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(errno)); + const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\" ->\n\"") + + zToWx(targetFile) + wxT("\""); + throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } //file is on a different volume: let's copy it @@ -349,8 +366,8 @@ public: typedef std::vector<std::pair<Zstring, Zstring> > NamePair; TraverseOneLevel(NamePair& filesShort, NamePair& dirsShort) : - m_files(filesShort), - m_dirs(dirsShort) {} + m_files(filesShort), + m_dirs(dirsShort) {} virtual ReturnValue onFile(const DefaultChar* shortName, const Zstring& fullName, const FileInfo& details) { @@ -375,19 +392,22 @@ private: void moveDirectoryImpl(const Zstring& sourceDir, const Zstring& targetDir, bool ignoreExistingDirs, MoveFileCallback* callback) //throw (FileError); { + using namespace FreeFileSync; + //handle symbolic links - if (FreeFileSync::symlinkExists(sourceDir)) + if (symlinkExists(sourceDir)) { - FreeFileSync::createDirectory(targetDir, sourceDir, true); //copy symbolic link - FreeFileSync::removeDirectory(sourceDir, false); //if target is already another symlink or directory, sourceDir-symlink is silently deleted + createDirectory(targetDir, sourceDir, true); //copy symbolic link + removeDirectory(sourceDir, false); //if target is already another symlink or directory, sourceDir-symlink is silently deleted return; } - if (FreeFileSync::dirExists(targetDir)) + if (dirExists(targetDir)) { if (!ignoreExistingDirs) //directory or symlink exists { - const wxString errorMessage = wxString(_("Error moving directory:")) + wxT("\n\"") + sourceDir + wxT("\" ->\n\"") + targetDir + wxT("\""); + const wxString errorMessage = wxString(_("Error moving directory:")) + wxT("\n\"") + + zToWx(sourceDir) + wxT("\" ->\n\"") + zToWx(targetDir) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + _("Target directory already existing!")); } } @@ -404,7 +424,8 @@ void moveDirectoryImpl(const Zstring& sourceDir, const Zstring& targetDir, bool const DWORD lastError = ::GetLastError(); if (lastError != ERROR_NOT_SAME_DEVICE) { - const wxString errorMessage = wxString(_("Error moving directory:")) + wxT("\n\"") + sourceDir.c_str() + wxT("\" ->\n\"") + targetDir.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error moving directory:")) + wxT("\n\"") + zToWx(sourceDir) + wxT("\" ->\n\"") + + zToWx(targetDir) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError)); } #elif defined FFS_LINUX @@ -414,13 +435,14 @@ void moveDirectoryImpl(const Zstring& sourceDir, const Zstring& targetDir, bool //if moving failed treat as error (except when it tried to move to a different volume: in this case we will copy the directory) if (errno != EXDEV) { - const wxString errorMessage = wxString(_("Error moving directory:")) + wxT("\n\"") + sourceDir.c_str() + wxT("\" ->\n\"") + targetDir.c_str() + wxT("\""); - throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(errno)); + const wxString errorMessage = wxString(_("Error moving directory:")) + wxT("\n\"") + + zToWx(sourceDir) + wxT("\" ->\n\"") + zToWx(targetDir) + wxT("\""); + throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } #endif //create target - FreeFileSync::createDirectory(targetDir, sourceDir, false); //throw (FileError); + createDirectory(targetDir, sourceDir, false); //throw (FileError); } //call back once per folder @@ -431,8 +453,8 @@ void moveDirectoryImpl(const Zstring& sourceDir, const Zstring& targetDir, bool break; case MoveFileCallback::CANCEL: //an user aborted operation IS an error condition! - throw FileError(wxString(_("Error moving directory:")) + wxT("\n\"") + sourceDir.c_str() + wxT("\" ->\n\"") + - targetDir.c_str() + wxT("\"") + wxT("\n\n") + _("Operation aborted!")); + throw FileError(wxString(_("Error moving directory:")) + wxT("\n\"") + zToWx(sourceDir) + wxT("\" ->\n\"") + + zToWx(targetDir) + wxT("\"") + wxT("\n\n") + _("Operation aborted!")); } //move files/folders recursively @@ -441,7 +463,7 @@ void moveDirectoryImpl(const Zstring& sourceDir, const Zstring& targetDir, bool //traverse source directory one level TraverseOneLevel traverseCallback(fileList, dirList); - FreeFileSync::traverseFolder(sourceDir, false, &traverseCallback); //traverse one level + traverseFolder(sourceDir, false, &traverseCallback); //traverse one level const Zstring targetDirFormatted = targetDir.EndsWith(globalFunctions::FILE_NAME_SEPARATOR) ? //ends with path separator targetDir : @@ -458,9 +480,7 @@ void moveDirectoryImpl(const Zstring& sourceDir, const Zstring& targetDir, bool //attention: if move-operation was cancelled an exception is thrown => sourceDir is not deleted, as we wish! //delete source - FreeFileSync::removeDirectory(sourceDir, false); //throw (FileError); - - return; + removeDirectory(sourceDir, false); //throw (FileError); } @@ -488,8 +508,8 @@ class FilesDirsOnlyTraverser : public FreeFileSync::TraverseCallback { public: FilesDirsOnlyTraverser(std::vector<Zstring>& files, std::vector<Zstring>& dirs) : - m_files(files), - m_dirs(dirs) {} + m_files(files), + m_dirs(dirs) {} virtual ReturnValue onFile(const DefaultChar* shortName, const Zstring& fullName, const FileInfo& details) { @@ -529,7 +549,7 @@ void FreeFileSync::removeDirectory(const Zstring& directory, const bool useRecyc if (useRecycleBin) { if (!moveToRecycleBin(directory)) - throw FileError(wxString(_("Error moving to Recycle Bin:")) + wxT("\n\"") + directory.c_str() + wxT("\"")); + throw FileError(wxString(_("Error moving to Recycle Bin:")) + wxT("\n\"") + zToWx(directory) + wxT("\"")); return; } @@ -561,7 +581,7 @@ void FreeFileSync::removeDirectory(const Zstring& directory, const bool useRecyc { if (::unlink(directory.c_str()) != 0) { - wxString errorMessage = wxString(_("Error deleting directory:")) + wxT("\n\"") + directory.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error deleting directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } return; @@ -585,17 +605,13 @@ void FreeFileSync::removeDirectory(const Zstring& directory, const bool useRecyc #ifdef FFS_WIN //remove directory, support for \\?\-prefix if (!::RemoveDirectory(directory.c_str())) - { - wxString errorMessage = wxString(_("Error deleting directory:")) + wxT("\n\"") + directory.c_str() + wxT("\""); - throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); - } #else if (::rmdir(directory.c_str()) != 0) +#endif { - wxString errorMessage = wxString(_("Error deleting directory:")) + wxT("\n\"") + directory.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error deleting directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } -#endif } @@ -697,8 +713,8 @@ public: private: KernelDllHandler() : - getFinalPathNameByHandle(NULL), - hKernel(NULL) + getFinalPathNameByHandle(NULL), + hKernel(NULL) { //get a handle to the DLL module containing required functionality hKernel = ::LoadLibrary(wxT("kernel32.dll")); @@ -748,50 +764,49 @@ Zstring resolveDirectorySymlink(const Zstring& dirLinkName) //get full target pa return targetPath; } - +//#warning teste //#include <aclapi.h> -//optionally: copy additional metadata, DO NOTHING if something fails +////optionally: copy additional metadata, DO NOTHING if something fails //void copyAdditionalMetadata(const Zstring& sourceDir, const Zstring& targetDir) //{ +// //copy NTFS permissions +// // PSECURITY_DESCRIPTOR pSD; // -// PSID pSidOwner; -// PSID pSidGroup; // PACL pDacl; -// PACL pSacl; // if (::GetNamedSecurityInfo( // const_cast<DefaultChar*>(sourceDir.c_str()), // SE_FILE_OBJECT, //file or directory -// OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION, -// &pSidOwner, -// &pSidGroup, +// DACL_SECURITY_INFORMATION, +// NULL, +// NULL, // &pDacl, -// &pSacl, +// NULL, // &pSD // ) == ERROR_SUCCESS) // { // //(try to) set new security information // if (::SetNamedSecurityInfo( -// const_cast<DefaultChar*>(targetDir.c_str()), -// SE_FILE_OBJECT, //file or directory -// OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION, -// pSidOwner, -// pSidGroup, -// pDacl, -// pSacl) != ERROR_SUCCESS) //return value not evalutated! -// { +// const_cast<DefaultChar*>(targetDir.c_str()), +// SE_FILE_OBJECT, //file or directory +// DACL_SECURITY_INFORMATION, +// NULL, +// NULL, +// pDacl, +// NULL) != ERROR_SUCCESS) //return value not evalutated! +// { // const wxString errorMessage = wxString(wxT("Error 2:")) + wxT("\n\"") + targetDir.c_str() + wxT("\""); // throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); // } -//warning BUG! // -// LocalFree(pSD); //pSidOwner, pSidGroup, pDacl, pSacl must not be freed! +//#warning BUG! +// LocalFree(pSD); // } // else -// { -// const wxString errorMessage = wxString(wxT("Error 1:")) + wxT("\n\"") + sourceDir.c_str() + wxT("\""); -// throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); -// } +// { +// const wxString errorMessage = wxString(wxT("Error 1:")) + wxT("\n\"") + sourceDir.c_str() + wxT("\""); +// throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); +// } // //} #endif @@ -799,6 +814,8 @@ Zstring resolveDirectorySymlink(const Zstring& dirLinkName) //get full target pa void createDirectoryRecursively(const Zstring& directory, const Zstring& templateDir, const bool copyDirectorySymLinks, const int level) { + using namespace FreeFileSync; + if (FreeFileSync::dirExists(directory)) return; @@ -882,7 +899,7 @@ void createDirectoryRecursively(const Zstring& directory, const Zstring& templat const int bytesWritten = readlink(templateDir.c_str(), buffer, BUFFER_SIZE); if (bytesWritten < 0 || bytesWritten == BUFFER_SIZE) { - wxString errorMessage = wxString(_("Error resolving symbolic link:")) + wxT("\n\"") + templateDir.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error resolving symbolic link:")) + wxT("\n\"") + zToWx(templateDir) + wxT("\""); if (bytesWritten < 0) errorMessage += wxString(wxT("\n\n")) + FreeFileSync::getLastErrorFormatted(); throw FileError(errorMessage); } @@ -891,7 +908,7 @@ void createDirectoryRecursively(const Zstring& directory, const Zstring& templat if (symlink(buffer, directory.c_str()) != 0) { - wxString errorMessage = wxString(_("Error creating directory:")) + wxT("\n\"") + directory.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error creating directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } return; //symlink created successfully @@ -899,9 +916,9 @@ void createDirectoryRecursively(const Zstring& directory, const Zstring& templat } //default directory creation - if (mkdir(directory.c_str(), 0755) != 0 && level == 0) + if (::mkdir(directory.c_str(), 0755) != 0 && level == 0) { - wxString errorMessage = wxString(_("Error creating directory:")) + wxT("\n\"") + directory.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error creating directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } @@ -944,6 +961,24 @@ void FreeFileSync::createDirectory(const Zstring& directory, const Zstring& temp } +Zstring createTempName(const Zstring& filename) +{ + Zstring output = filename + DefaultStr(".tmp"); + + //ensure uniqueness + if (FreeFileSync::fileExists(output)) + { + //if it's not unique, add a postfix number + int postfix = 1; + while (FreeFileSync::fileExists(output + DefaultChar('_') + numberToZstring(postfix))) + ++postfix; + + output += DefaultChar('_') + numberToZstring(postfix); + } + return output; +} + + #ifdef FFS_WIN #ifndef COPY_FILE_COPY_SYMLINK @@ -1011,8 +1046,8 @@ bool supportForSymbolicLinks() void FreeFileSync::copyFile(const Zstring& sourceFile, const Zstring& targetFile, const bool copyFileSymLinks, - ShadowCopy* shadowCopyHandler, - CopyFileCallback* callback) + FreeFileSync::ShadowCopy* shadowCopyHandler, + FreeFileSync::CopyFileCallback* callback) { DWORD copyFlags = COPY_FILE_FAIL_IF_EXISTS; @@ -1021,9 +1056,10 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, if (copyFileSymLinks && symlinksSupported) copyFlags |= COPY_FILE_COPY_SYMLINK; + const Zstring temporary = createTempName(targetFile); //use temporary file until a correct date has been set if (!::CopyFileEx( //same performance as CopyFile() sourceFile.c_str(), - targetFile.c_str(), + temporary.c_str(), copyCallbackInternal, callback, NULL, @@ -1039,17 +1075,26 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, lastError == ERROR_LOCK_VIOLATION)) { const Zstring shadowFilename(shadowCopyHandler->makeShadowCopy(sourceFile)); - FreeFileSync::copyFile(shadowFilename, //transferred bytes is automatically reset when new file is copied - targetFile, - copyFileSymLinks, - NULL, - callback); + copyFile(shadowFilename, //transferred bytes is automatically reset when new file is copied + targetFile, + copyFileSymLinks, + NULL, + callback); return; } const wxString errorMessage = wxString(_("Error copying file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\" ->\n\"") + targetFile.c_str() + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError)); } + + //rename temporary file + if (!::MoveFileEx(temporary.c_str(), //__in LPCTSTR lpExistingFileName, + targetFile.c_str(), //__in_opt LPCTSTR lpNewFileName, + 0)) //__in DWORD dwFlags + { + const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + temporary + wxT("\" ->\n\"") + targetFile + wxT("\""); + throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); + } } @@ -1079,7 +1124,7 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, using FreeFileSync::CopyFileCallback; if (FreeFileSync::fileExists(targetFile.c_str())) - throw FileError(wxString(_("Error copying file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\" ->\n\"") + targetFile.c_str() + wxT("\"\n\n") + throw FileError(wxString(_("Error copying file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\" ->\n\"") + zToWx(targetFile) + wxT("\"\n\n") + _("Target file already existing!")); //symbolic link handling @@ -1089,7 +1134,7 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, struct stat linkInfo; if (lstat(sourceFile.c_str(), &linkInfo) != 0) { - const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } @@ -1101,7 +1146,7 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, const int bytesWritten = readlink(sourceFile.c_str(), buffer, BUFFER_SIZE); if (bytesWritten < 0 || bytesWritten == BUFFER_SIZE) { - wxString errorMessage = wxString(_("Error resolving symbolic link:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error resolving symbolic link:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\""); if (bytesWritten < 0) errorMessage += wxString(wxT("\n\n")) + FreeFileSync::getLastErrorFormatted(); throw FileError(errorMessage); } @@ -1110,7 +1155,7 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, if (symlink(buffer, targetFile.c_str()) != 0) { - const wxString errorMessage = wxString(_("Error writing file:")) + wxT("\n\"") + targetFile.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error writing file:")) + wxT("\n\"") + zToWx(targetFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } @@ -1122,19 +1167,21 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, struct stat fileInfo; if (stat(sourceFile.c_str(), &fileInfo) != 0) //read file attributes from source file (resolving symlinks; but cannot be one in this context) { - const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } //open sourceFile for reading std::ifstream fileIn(sourceFile.c_str(), std::ios_base::binary); if (fileIn.fail()) - throw FileError(wxString(_("Error opening file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\"")); + throw FileError(wxString(_("Error opening file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\"")); //create targetFile and open it for writing - std::ofstream fileOut(targetFile.c_str(), std::ios_base::binary); + const Zstring temporary = createTempName(targetFile); //use temporary file until a correct date has been set + + std::ofstream fileOut(temporary.c_str(), std::ios_base::binary); if (fileOut.fail()) - throw FileError(wxString(_("Error opening file:")) + wxT("\n\"") + targetFile.c_str() + wxT("\"")); + throw FileError(wxString(_("Error opening file:")) + wxT("\n\"") + zToWx(targetFile) + wxT("\"")); try { @@ -1148,16 +1195,16 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, { fileOut.write(memory.buffer, fileIn.gcount()); if (fileOut.bad()) - throw FileError(wxString(_("Error writing file:")) + wxT("\n\"") + targetFile.c_str() + wxT("\"")); + throw FileError(wxString(_("Error writing file:")) + wxT("\n\"") + zToWx(targetFile) + wxT("\"")); break; } else if (fileIn.fail()) - throw FileError(wxString(_("Error reading file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\"")); + throw FileError(wxString(_("Error reading file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\"")); fileOut.write(memory.buffer, memory.bufferSize); if (fileOut.bad()) - throw FileError(wxString(_("Error writing file:")) + wxT("\n\"") + targetFile.c_str() + wxT("\"")); + throw FileError(wxString(_("Error writing file:")) + wxT("\n\"") + zToWx(targetFile) + wxT("\"")); totalBytesTransferred += memory.bufferSize; @@ -1171,8 +1218,8 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, case CopyFileCallback::CANCEL: //an user aborted operation IS an error condition! - throw FileError(wxString(_("Error copying file:")) + wxT("\n\"") + sourceFile.c_str() + wxT("\" ->\n\"") + - targetFile.c_str() + wxT("\"\n\n") + _("Operation aborted!")); + throw FileError(wxString(_("Error copying file:")) + wxT("\n\"") + zToWx(sourceFile) + wxT("\" ->\n\"") + + zToWx(targetFile) + wxT("\"\n\n") + _("Operation aborted!")); } } } @@ -1183,25 +1230,35 @@ void FreeFileSync::copyFile(const Zstring& sourceFile, //adapt file modification time: struct utimbuf newTimes; - time(&newTimes.actime); //set file access time to current time + ::time(&newTimes.actime); //set file access time to current time newTimes.modtime = fileInfo.st_mtime; - if (utime(targetFile.c_str(), &newTimes) != 0) + if (utime(temporary.c_str(), &newTimes) != 0) { - wxString errorMessage = wxString(_("Error changing modification time:")) + wxT("\n\"") + targetFile.c_str() + wxT("\""); + wxString errorMessage = wxString(_("Error changing modification time:")) + wxT("\n\"") + zToWx(targetFile) + wxT("\""); + throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); + } + + //rename temporary file + if (::rename(temporary.c_str(), targetFile.c_str()) != 0) + { + const wxString errorMessage = wxString(_("Error moving file:")) + wxT("\n\"") + zToWx(temporary) + wxT("\" ->\n\"") + zToWx(targetFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } //set file access rights - if (chmod(targetFile.c_str(), fileInfo.st_mode) != 0) + if (::chmod(targetFile.c_str(), fileInfo.st_mode) != 0) { - wxString errorMessage = wxString(_("Error writing file attributes:")) + wxT("\n\"") + targetFile.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error writing file attributes:")) + wxT("\n\"") + zToWx(targetFile) + wxT("\""); throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()); } } catch (...) - { //try to delete target file if error occured, or exception was thrown in callback function + { + //try to delete target file if error occured, or exception was thrown in callback function if (FreeFileSync::fileExists(targetFile)) ::unlink(targetFile); //don't handle error situations! + if (FreeFileSync::fileExists(temporary)) + ::unlink(temporary); //don't handle error situations! throw; } diff --git a/shared/fileHandling.h b/shared/fileHandling.h index 5ccd595f..d856603f 100644 --- a/shared/fileHandling.h +++ b/shared/fileHandling.h @@ -8,76 +8,74 @@ namespace FreeFileSync { - Zstring getFormattedDirectoryName(const Zstring& dirname); +Zstring getFormattedDirectoryName(const Zstring& dirname); - bool fileExists(const DefaultChar* filename); //throw() replaces wxFileExists()! - bool dirExists(const DefaultChar* dirname); //throw() replaces wxDirExists(): optional 'cause wxDirExists treats symlinks correctly - bool symlinkExists(const DefaultChar* objname); //throw() check if a symbolic link exists +bool fileExists(const DefaultChar* filename); //throw() replaces wxFileExists()! +bool dirExists(const DefaultChar* dirname); //throw() replaces wxDirExists(): optional 'cause wxDirExists treats symlinks correctly +bool symlinkExists(const DefaultChar* objname); //throw() check if a symbolic link exists - //check if files can be moved between two EXISTING paths (without copying) - bool isMovable(const Zstring& pathFrom, const Zstring& pathTo); //throw() +//check if files can be moved between two EXISTING paths (without copying) +bool isMovable(const Zstring& pathFrom, const Zstring& pathTo); //throw() - //optionally: copy directory last change date, DOES NOTHING if something fails - void copyDirLastChangeDate(const Zstring& sourceDir, const Zstring& targetDir); +//optionally: copy directory last change date, DOES NOTHING if something fails +void copyDirLastChangeDate(const Zstring& sourceDir, const Zstring& targetDir); - //recycler - bool recycleBinExists(); //test existence of Recycle Bin API on current system +//recycler +bool recycleBinExists(); //test existence of Recycle Bin API on current system - //file handling - void removeFile(const Zstring& filename, const bool useRecycleBin); //throw (FileError, std::logic_error) - void removeDirectory(const Zstring& directory, const bool useRecycleBin); //throw (FileError) +//file handling +void removeFile(const Zstring& filename, const bool useRecycleBin); //throw (FileError, std::logic_error) +void removeDirectory(const Zstring& directory, const bool useRecycleBin); //throw (FileError) - class MoveFileCallback //callback functionality +struct MoveFileCallback //callback functionality +{ + virtual ~MoveFileCallback() {} + + enum Response { - public: - virtual ~MoveFileCallback() {} - - enum Response - { - CONTINUE, - CANCEL - }; - virtual Response requestUiRefresh() = 0; //DON'T throw exceptions here, at least in Windows build! + CONTINUE, + CANCEL }; + virtual Response requestUiRefresh() = 0; //DON'T throw exceptions here, at least in Windows build! +}; - //move source to target; expectations: target not existing, all super-directories of target exist - void moveFile(const Zstring& sourceFile, const Zstring& targetFile, MoveFileCallback* callback = NULL); //throw (FileError); +//move source to target; expectations: target not existing, all super-directories of target exist +void moveFile(const Zstring& sourceFile, const Zstring& targetFile, MoveFileCallback* callback = NULL); //throw (FileError); - //move source to target including subdirectories - //"ignoreExistingDirs": existing directories will be enhanced as long as this is possible without overwriting files - void moveDirectory(const Zstring& sourceDir, const Zstring& targetDir, bool ignoreExistingDirs, MoveFileCallback* callback = NULL); //throw (FileError); +//move source to target including subdirectories +//"ignoreExistingDirs": existing directories will be enhanced as long as this is possible without overwriting files +void moveDirectory(const Zstring& sourceDir, const Zstring& targetDir, bool ignoreExistingDirs, MoveFileCallback* callback = NULL); //throw (FileError); - //creates superdirectories automatically: - void createDirectory(const Zstring& directory, const Zstring& templateDir = Zstring(), const bool copyDirectorySymLinks = false); //throw (FileError); +//creates superdirectories automatically: +void createDirectory(const Zstring& directory, const Zstring& templateDir = Zstring(), const bool copyDirectorySymLinks = false); //throw (FileError); + +struct CopyFileCallback //callback functionality +{ + virtual ~CopyFileCallback() {} - class CopyFileCallback //callback functionality + enum Response { - public: - virtual ~CopyFileCallback() {} - - enum Response - { - CONTINUE, - CANCEL - }; - virtual Response updateCopyStatus(const wxULongLong& totalBytesTransferred) = 0; //DON'T throw exceptions here, at least in Windows build! + CONTINUE, + CANCEL }; + virtual Response updateCopyStatus(const wxULongLong& totalBytesTransferred) = 0; //DON'T throw exceptions here, at least in Windows build! +}; #ifdef FFS_WIN - class ShadowCopy; +class ShadowCopy; - void copyFile(const Zstring& sourceFile, - const Zstring& targetFile, - const bool copyFileSymLinks, - ShadowCopy* shadowCopyHandler = NULL, //supply handler for making shadow copies - CopyFileCallback* callback = NULL); //throw (FileError); +void copyFile(const Zstring& sourceFile, + const Zstring& targetFile, + const bool copyFileSymLinks, + ShadowCopy* shadowCopyHandler = NULL, //supply handler for making shadow copies + CopyFileCallback* callback = NULL); //throw (FileError); #elif defined FFS_LINUX - void copyFile(const Zstring& sourceFile, - const Zstring& targetFile, - const bool copyFileSymLinks, - CopyFileCallback* callback = NULL); //throw (FileError); +void copyFile(const Zstring& sourceFile, + const Zstring& targetFile, + const bool copyFileSymLinks, + CopyFileCallback* callback = NULL); //throw (FileError); #endif } diff --git a/shared/fileTraverser.cpp b/shared/fileTraverser.cpp index ab223791..c323f1a3 100644 --- a/shared/fileTraverser.cpp +++ b/shared/fileTraverser.cpp @@ -2,6 +2,7 @@ #include "systemConstants.h" #include "systemFunctions.h" #include <wx/intl.h> +#include "stringConv.h" #ifdef FFS_WIN #include <wx/msw/wrapwin.h> //includes "windows.h" @@ -108,11 +109,11 @@ private: template <bool traverseDirectorySymlinks> bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* sink, const int level) { - using FreeFileSync::TraverseCallback; + using namespace FreeFileSync; if (level == 100) //catch endless recursion { - switch (sink->onError(wxString(_("Endless loop when traversing directory:")) + wxT("\n\"") + directory + wxT("\""))) + switch (sink->onError(wxString(_("Endless loop when traversing directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\""))) { case TraverseCallback::TRAVERSING_STOP: return false; @@ -139,7 +140,7 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* return true; //else: we have a problem... report it: - const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + directory.c_str() + wxT("\"") ; + const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\"") ; switch (sink->onError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError))) { case TraverseCallback::TRAVERSING_STOP: @@ -151,7 +152,8 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* CloseFindHandleOnExit dummy(searchHandle); do - { //don't return "." and ".." + { + //don't return "." and ".." const wxChar* const shortName = fileMetaData.cFileName; if ( shortName[0] == wxChar('.') && ((shortName[1] == wxChar('.') && shortName[2] == wxChar('\0')) || @@ -211,7 +213,7 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* return true; //everything okay //else: we have a problem... report it: - const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + directory.c_str() + wxT("\"") ; + const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\"") ; switch (sink->onError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError))) { case TraverseCallback::TRAVERSING_STOP: @@ -224,7 +226,7 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* DIR* dirObj = ::opendir(directory.c_str()); //directory must NOT end with path separator, except "/" if (dirObj == NULL) { - const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + directory.c_str() + wxT("\"") ; + const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\"") ; switch (sink->onError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted())) { case TraverseCallback::TRAVERSING_STOP: @@ -245,7 +247,7 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* return true; //everything okay //else: we have a problem... report it: - const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + directory.c_str() + wxT("\"") ; + const wxString errorMessage = wxString(_("Error traversing directory:")) + wxT("\n\"") + zToWx(directory) + wxT("\"") ; switch (sink->onError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted())) { case TraverseCallback::TRAVERSING_STOP: @@ -256,7 +258,7 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* } //don't return "." and ".." - const wxChar* const shortName = dirEntry->d_name; + const DefaultChar* const shortName = dirEntry->d_name; if ( shortName[0] == wxChar('.') && ((shortName[1] == wxChar('.') && shortName[2] == wxChar('\0')) || shortName[1] == wxChar('\0'))) @@ -269,7 +271,7 @@ bool traverseDirectory(const Zstring& directory, FreeFileSync::TraverseCallback* struct stat fileInfo; if (lstat(fullName.c_str(), &fileInfo) != 0) //lstat() does not resolve symlinks { - const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + fullName.c_str() + wxT("\""); + const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + zToWx(fullName) + wxT("\""); switch (sink->onError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted())) { case TraverseCallback::TRAVERSING_STOP: diff --git a/shared/fileTraverser.h b/shared/fileTraverser.h index d2aa7f3e..c1277d87 100644 --- a/shared/fileTraverser.h +++ b/shared/fileTraverser.h @@ -10,55 +10,55 @@ namespace FreeFileSync { - class TraverseCallback - { - public: - virtual ~TraverseCallback() {} - - enum ReturnValue - { - TRAVERSING_STOP, - TRAVERSING_CONTINUE - }; +class TraverseCallback +{ +public: + virtual ~TraverseCallback() {} - struct FileInfo - { - wxULongLong fileSize; //unit: bytes! - wxLongLong lastWriteTimeRaw; //number of seconds since Jan. 1st 1970 UTC - }; + enum ReturnValue + { + TRAVERSING_STOP, + TRAVERSING_CONTINUE + }; - class ReturnValDir - { - public: - //some proxy classes - class Stop {}; - class Ignore {}; - class Continue {}; + struct FileInfo + { + wxULongLong fileSize; //unit: bytes! + wxLongLong lastWriteTimeRaw; //number of seconds since Jan. 1st 1970 UTC + }; - ReturnValDir(const Stop&) : returnCode(TRAVERSING_STOP), subDirCb(NULL) {} - ReturnValDir(const Ignore&) : returnCode(TRAVERSING_IGNORE_DIR), subDirCb(NULL) {} - ReturnValDir(const Continue&, TraverseCallback* subDirCallback) : returnCode(TRAVERSING_CONTINUE), subDirCb(subDirCallback) {} + class ReturnValDir + { + public: + //some proxy classes + class Stop {}; + class Ignore {}; + class Continue {}; + ReturnValDir(const Stop&) : returnCode(TRAVERSING_STOP), subDirCb(NULL) {} + ReturnValDir(const Ignore&) : returnCode(TRAVERSING_IGNORE_DIR), subDirCb(NULL) {} + ReturnValDir(const Continue&, TraverseCallback* subDirCallback) : returnCode(TRAVERSING_CONTINUE), subDirCb(subDirCallback) {} - enum ReturnValueEnh - { - TRAVERSING_STOP, - TRAVERSING_IGNORE_DIR, - TRAVERSING_CONTINUE - }; - const ReturnValueEnh returnCode; - TraverseCallback* const subDirCb; + enum ReturnValueEnh + { + TRAVERSING_STOP, + TRAVERSING_IGNORE_DIR, + TRAVERSING_CONTINUE }; - //overwrite these virtual methods - virtual ReturnValue onError(const wxString& errorText) = 0; - virtual ReturnValue onFile(const DefaultChar* shortName, const Zstring& fullName, const FileInfo& details) = 0; - virtual ReturnValDir onDir(const DefaultChar* shortName, const Zstring& fullName) = 0; + const ReturnValueEnh returnCode; + TraverseCallback* const subDirCb; }; - //custom traverser with detail information about files - void traverseFolder(const Zstring& directory, const bool traverseDirectorySymlinks, TraverseCallback* sink); //throw() + //overwrite these virtual methods + virtual ReturnValue onError(const wxString& errorText) = 0; + virtual ReturnValue onFile(const DefaultChar* shortName, const Zstring& fullName, const FileInfo& details) = 0; + virtual ReturnValDir onDir(const DefaultChar* shortName, const Zstring& fullName) = 0; +}; + +//custom traverser with detail information about files +void traverseFolder(const Zstring& directory, const bool traverseDirectorySymlinks, TraverseCallback* sink); //throw() } #endif // FILETRAVERSER_H_INCLUDED diff --git a/shared/globalFunctions.cpp b/shared/globalFunctions.cpp index f50a3097..a5ebba68 100644 --- a/shared/globalFunctions.cpp +++ b/shared/globalFunctions.cpp @@ -1,49 +1,11 @@ #include "globalFunctions.h" #include <wx/msgdlg.h> #include <wx/file.h> -#include <fstream> -#include <wx/stream.h> #include <wx/stopwatch.h> #include <cmath> #include "systemConstants.h" -wxString globalFunctions::numberToWxString(const unsigned int number) -{ - return wxString::Format(wxT("%u"), number); -} - - -wxString globalFunctions::numberToWxString(const int number) -{ - return wxString::Format(wxT("%i"), number); -} - - -wxString globalFunctions::numberToWxString(const float number) -{ - return wxString::Format(wxT("%f"), number); -} - - -int globalFunctions::stringToInt(const std::string& number) -{ - return atoi(number.c_str()); -} - - -long globalFunctions::stringToLong(const std::string& number) -{ - return atol(number.c_str()); -} - - -double globalFunctions::stringToDouble(const std::string& number) -{ - return atof(number.c_str()); -} - - int globalFunctions::wxStringToInt(const wxString& number) { long result = 0; @@ -70,42 +32,10 @@ unsigned int globalFunctions::getDigitCount(const unsigned int number) //count n } -int globalFunctions::readInt(std::ifstream& stream) -{ - int result = 0; - char* buffer = reinterpret_cast<char*>(&result); - stream.read(buffer, sizeof(int)); - return result; -} - - -void globalFunctions::writeInt(std::ofstream& stream, const int number) -{ - const char* buffer = reinterpret_cast<const char*>(&number); - stream.write(buffer, sizeof(int)); -} - - -int globalFunctions::readInt(wxInputStream& stream) -{ - int result = 0; - char* buffer = reinterpret_cast<char*>(&result); - stream.Read(buffer, sizeof(int)); - return result; -} - - -void globalFunctions::writeInt(wxOutputStream& stream, const int number) -{ - const char* buffer = reinterpret_cast<const char*>(&number); - stream.Write(buffer, sizeof(int)); -} - - //############################################################################ Performance::Performance() : - resultWasShown(false), - timer(new wxStopWatch) + resultWasShown(false), + timer(new wxStopWatch) { timer->Start(); } @@ -128,8 +58,8 @@ void Performance::showResult() //############################################################################ DebugLog::DebugLog() : - lineCount(0), - logFile(NULL) + lineCount(0), + logFile(NULL) { logFile = new wxFile; logfileName = assembleFileName(); diff --git a/shared/globalFunctions.h b/shared/globalFunctions.h index b53ba596..74387959 100644 --- a/shared/globalFunctions.h +++ b/shared/globalFunctions.h @@ -9,6 +9,8 @@ #include <wx/longlong.h> #include <memory> #include <sstream> +#include <fstream> +#include <wx/stream.h> class wxInputStream; class wxOutputStream; @@ -20,129 +22,131 @@ namespace globalFunctions //------------------------------------------------ // FUNCTIONS //------------------------------------------------ - inline - int round(double d) //little rounding function - { - return static_cast<int>(d < 0 ? d - .5 : d + .5); - } +inline +int round(double d) //little rounding function +{ + return static_cast<int>(d < 0 ? d - .5 : d + .5); +} - template <class T> - inline - T abs(const T& d) //absolute value - { - return(d < 0 ? -d : d); - } +template <class T> +inline +T abs(const T& d) //absolute value +{ + return(d < 0 ? -d : d); +} - template <class T> - inline std::string numberToString(const T& number) //convert number to string the C++ way - { - std::stringstream ss; - ss << number; - return ss.str(); - } +template <class T> +inline +std::string numberToString(const T& number) //convert number to string the C++ way +{ + std::stringstream ss; + ss << number; + return ss.str(); +} - wxString numberToWxString(const unsigned int number); //convert number to wxString - wxString numberToWxString(const int number); //convert number to wxString - wxString numberToWxString(const float number); //convert number to wxString +wxString numberToWxString(const unsigned int number); //convert number to wxString +wxString numberToWxString(const int number); //convert number to wxString +wxString numberToWxString(const float number); //convert number to wxString - int stringToInt( const std::string& number); //convert String to number - long stringToLong( const std::string& number); //convert String to number - double stringToDouble(const std::string& number); //convert String to number +int stringToInt( const std::string& number); //convert String to number +long stringToLong( const std::string& number); //convert String to number +double stringToDouble(const std::string& number); //convert String to number - int wxStringToInt( const wxString& number); //convert wxString to number - double wxStringToDouble(const wxString& number); //convert wxString to number +int wxStringToInt( const wxString& number); //convert wxString to number +double wxStringToDouble(const wxString& number); //convert wxString to number - unsigned int getDigitCount(const unsigned int number); //count number of digits +unsigned int getDigitCount(const unsigned int number); //count number of digits - int readInt(std::ifstream& stream); //read int from file stream - void writeInt(std::ofstream& stream, const int number); //write int to filestream +//read/write numbers: int, long, unsigned int ... ect +template <class T> T readNumber(std::ifstream& stream); +template <class T> void writeNumber(std::ofstream& stream, T number); - int readInt(wxInputStream& stream); //read int from file stream - void writeInt(wxOutputStream& stream, const int number); //write int to filestream +template <class T> T readNumber(wxInputStream& stream); +template <class T> void writeNumber(wxOutputStream& stream, T number); - inline - wxLongLong convertToSigned(const wxULongLong number) - { - return wxLongLong(number.GetHi(), number.GetLo()); - } +inline +wxLongLong convertToSigned(const wxULongLong number) +{ + return wxLongLong(number.GetHi(), number.GetLo()); +} //Note: the following lines are a performance optimization for deleting elements from a vector: linear runtime at most! - template <class T> - void removeRowsFromVector(const std::set<unsigned int>& rowsToRemove, std::vector<T>& grid) - { - if (rowsToRemove.empty()) - return; +template <class T> +void removeRowsFromVector(const std::set<unsigned int>& rowsToRemove, std::vector<T>& grid) +{ + if (rowsToRemove.empty()) + return; - std::set<unsigned int>::const_iterator rowToSkipIndex = rowsToRemove.begin(); - unsigned int rowToSkip = *rowToSkipIndex; + std::set<unsigned int>::const_iterator rowToSkipIndex = rowsToRemove.begin(); + unsigned int rowToSkip = *rowToSkipIndex; - if (rowToSkip >= grid.size()) - return; + if (rowToSkip >= grid.size()) + return; - typename std::vector<T>::iterator insertPos = grid.begin() + rowToSkip; + typename std::vector<T>::iterator insertPos = grid.begin() + rowToSkip; - for (unsigned int i = rowToSkip; i < grid.size(); ++i) + for (unsigned int i = rowToSkip; i < grid.size(); ++i) + { + if (i != rowToSkip) { - if (i != rowToSkip) - { - *insertPos = grid[i]; - ++insertPos; - } - else - { - ++rowToSkipIndex; - if (rowToSkipIndex != rowsToRemove.end()) - rowToSkip = *rowToSkipIndex; - } + *insertPos = grid[i]; + ++insertPos; } - grid.erase(insertPos, grid.end()); - } - - //bubble sort using swap() instead of assignment: useful if assignment is very expensive - template <class VectorData, typename CompareFct> - void bubbleSwapSort(VectorData& folderCmp, CompareFct compare) - { - for (int i = folderCmp.size() - 2; i >= 0; --i) + else { - bool swapped = false; - for (int j = 0; j <= i; ++j) - if (compare(folderCmp[j + 1], folderCmp[j])) - { - folderCmp[j + 1].swap(folderCmp[j]); - swapped = true; - } - - if (!swapped) - return; + ++rowToSkipIndex; + if (rowToSkipIndex != rowsToRemove.end()) + rowToSkip = *rowToSkipIndex; } } + grid.erase(insertPos, grid.end()); +} - //enhanced binary search template: returns an iterator - template <class ForwardIterator, class T> - inline - ForwardIterator custom_binary_search(ForwardIterator first, ForwardIterator last, const T& value) +//bubble sort using swap() instead of assignment: useful if assignment is very expensive +template <class VectorData, typename CompareFct> +void bubbleSwapSort(VectorData& folderCmp, CompareFct compare) +{ + for (int i = folderCmp.size() - 2; i >= 0; --i) { - first = lower_bound(first, last, value); - if (first != last && !(value < *first)) - return first; - else - return last; - } + bool swapped = false; + for (int j = 0; j <= i; ++j) + if (compare(folderCmp[j + 1], folderCmp[j])) + { + folderCmp[j + 1].swap(folderCmp[j]); + swapped = true; + } - //enhanced binary search template: returns an iterator - template <class ForwardIterator, class T, typename Compare> - inline - ForwardIterator custom_binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp) - { - first = lower_bound(first, last, value, comp); - if (first != last && !comp(value, *first)) - return first; - else - return last; + if (!swapped) + return; } } +//enhanced binary search template: returns an iterator +template <class ForwardIterator, class T> +inline +ForwardIterator custom_binary_search(ForwardIterator first, ForwardIterator last, const T& value) +{ + first = lower_bound(first, last, value); + if (first != last && !(value < *first)) + return first; + else + return last; +} + +//enhanced binary search template: returns an iterator +template <class ForwardIterator, class T, typename Compare> +inline +ForwardIterator custom_binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp) +{ + first = lower_bound(first, last, value, comp); + if (first != last && !comp(value, *first)) + return first; + else + return last; +} +} + //############################################################################ class Performance @@ -185,4 +189,96 @@ wxString getCodeLocation(const wxString file, const int line); //speed alternative: wxLogDebug(wxT("text")) + DebugView + + + + + + + + + + + + + +//---------------Inline Implementation--------------------------------------------------- +template <class T> +inline +T globalFunctions::readNumber(std::ifstream& stream) +{ + T result = 0; + stream.read(reinterpret_cast<char*>(&result), sizeof(T)); + return result; +} + + +template <class T> +inline +void globalFunctions::writeNumber(std::ofstream& stream, T number) +{ + stream.write(reinterpret_cast<const char*>(&number), sizeof(T)); +} + + +template <class T> +inline +T globalFunctions::readNumber(wxInputStream& stream) +{ + T result = 0; + stream.Read(&result, sizeof(T)); + return result; +} + + +template <class T> +inline +void globalFunctions::writeNumber(wxOutputStream& stream, T number) +{ + stream.Write(&number, sizeof(T)); +} + + +inline +wxString globalFunctions::numberToWxString(const unsigned int number) +{ + return wxString::Format(wxT("%u"), number); +} + + +inline +wxString globalFunctions::numberToWxString(const int number) +{ + return wxString::Format(wxT("%i"), number); +} + + +inline +wxString globalFunctions::numberToWxString(const float number) +{ + return wxString::Format(wxT("%f"), number); +} + + +inline +int globalFunctions::stringToInt(const std::string& number) +{ + return atoi(number.c_str()); +} + + +inline +long globalFunctions::stringToLong(const std::string& number) +{ + return atol(number.c_str()); +} + + +inline +double globalFunctions::stringToDouble(const std::string& number) +{ + return atof(number.c_str()); +} + + #endif // GLOBALFUNCTIONS_H_INCLUDED diff --git a/shared/localization.cpp b/shared/localization.cpp index 20bf6d2e..ff14c980 100644 --- a/shared/localization.cpp +++ b/shared/localization.cpp @@ -1,6 +1,7 @@ #include "localization.h" #include <wx/msgdlg.h> #include "../shared/standardPaths.h" +#include "../shared/stringConv.h" #include "systemConstants.h" #include <fstream> #include <map> @@ -112,6 +113,13 @@ LocalizationInfo::LocalizationInfo() newEntry.languageFlag = wxT("brazil.png"); locMapping.push_back(newEntry); + newEntry.languageID = wxLANGUAGE_ROMANIAN; + newEntry.languageName = wxT("Română"); + newEntry.languageFile = wxT("romanian.lng"); + newEntry.translatorName = wxT("Alexandru Bogdan Munteanu"); + newEntry.languageFlag = wxT("romania.png"); + locMapping.push_back(newEntry); + newEntry.languageID = wxLANGUAGE_SLOVENIAN; newEntry.languageName = wxT("SlovenÅ¡Äina"); newEntry.languageFile = wxT("slovenian.lng"); @@ -119,6 +127,13 @@ LocalizationInfo::LocalizationInfo() newEntry.languageFlag = wxT("slovakia.png"); locMapping.push_back(newEntry); + newEntry.languageID = wxLANGUAGE_TURKISH; + newEntry.languageName = wxT("Türkçe"); + newEntry.languageFile = wxT("turkish.lng"); + newEntry.translatorName = wxT("H.Barbaros BIÇAKCI"); + newEntry.languageFlag = wxT("turkey.png"); + locMapping.push_back(newEntry); + newEntry.languageID = wxLANGUAGE_JAPANESE; newEntry.languageName = wxT("日本語"); newEntry.languageFile = wxT("japanese.lng"); @@ -236,9 +251,9 @@ CustomLocale& CustomLocale::getInstance() CustomLocale::CustomLocale() : - wxLocale(wxLANGUAGE_DEFAULT), //setting a different language needn't be supported on all systems! - translationDB(new Translation), - currentLanguage(wxLANGUAGE_ENGLISH) {} + wxLocale(wxLANGUAGE_DEFAULT), //setting a different language needn't be supported on all systems! + translationDB(new Translation), + currentLanguage(wxLANGUAGE_ENGLISH) {} inline @@ -290,7 +305,7 @@ class UnicodeFileReader { public: UnicodeFileReader(const wxString& filename) : - inputFile(NULL) + inputFile(NULL) { //workaround to get a FILE* from a unicode filename wxFFile dummyFile(filename, wxT("rb")); @@ -363,8 +378,8 @@ void CustomLocale::setLanguage(const int language) translationDB->clear(); if (!languageFile.empty()) { - UnicodeFileReader langFile(FreeFileSync::getInstallationDir() + globalFunctions::FILE_NAME_SEPARATOR + - wxT("Languages") + globalFunctions::FILE_NAME_SEPARATOR + languageFile); + UnicodeFileReader langFile(FreeFileSync::getInstallationDir() + zToWx(globalFunctions::FILE_NAME_SEPARATOR) + + wxT("Languages") + zToWx(globalFunctions::FILE_NAME_SEPARATOR) + languageFile); if (langFile.isOkay()) { int rowNumber = 0; diff --git a/shared/localization.h b/shared/localization.h index 2a5ee80d..0a5ca4fb 100644 --- a/shared/localization.h +++ b/shared/localization.h @@ -10,53 +10,55 @@ class Translation; namespace FreeFileSync { - //language dependent global variables: need to be initialized by CustomLocale on program startup and language switch +//language dependent global variables: need to be initialized by CustomLocale on program startup and language switch - extern const wxChar* THOUSANDS_SEPARATOR; - extern const wxChar* DECIMAL_POINT; +extern const wxChar* THOUSANDS_SEPARATOR; +extern const wxChar* DECIMAL_POINT; - struct LocInfoLine - { - int languageID; - wxString languageName; - wxString languageFile; - wxString translatorName; - wxString languageFlag; - }; - - class LocalizationInfo - { - public: - static const std::vector<LocInfoLine>& getMapping(); +struct LocInfoLine +{ + int languageID; + wxString languageName; + wxString languageFile; + wxString translatorName; + wxString languageFlag; +}; + +class LocalizationInfo +{ +public: + static const std::vector<LocInfoLine>& getMapping(); - private: - LocalizationInfo(); +private: + LocalizationInfo(); + LocalizationInfo(const LocalizationInfo&); + LocalizationInfo& operator=(const LocalizationInfo&); - std::vector<LocInfoLine> locMapping; - }; + std::vector<LocInfoLine> locMapping; +}; - class CustomLocale : public wxLocale - { - public: - static CustomLocale& getInstance(); +class CustomLocale : public wxLocale +{ +public: + static CustomLocale& getInstance(); - void setLanguage(const int language); + void setLanguage(const int language); - int getLanguage() const - { - return currentLanguage; - } + int getLanguage() const + { + return currentLanguage; + } - virtual const wxChar* GetString(const wxChar* szOrigString, const wxChar* szDomain = NULL) const; + virtual const wxChar* GetString(const wxChar* szOrigString, const wxChar* szDomain = NULL) const; - private: - CustomLocale(); +private: + CustomLocale(); - std::auto_ptr<Translation> translationDB; - int currentLanguage; - }; + std::auto_ptr<Translation> translationDB; + int currentLanguage; +}; } #endif // MISC_H_INCLUDED diff --git a/shared/loki/AbstractFactory.h b/shared/loki/AbstractFactory.h new file mode 100644 index 00000000..8ff518dc --- /dev/null +++ b/shared/loki/AbstractFactory.h @@ -0,0 +1,185 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_ABSTRACTFACTORY_INC_ +#define LOKI_ABSTRACTFACTORY_INC_ + +// $Id: AbstractFactory.h 771 2006-10-27 18:05:03Z clitte_bbt $ + + +#include "Typelist.h" +#include "Sequence.h" +#include "TypeManip.h" +#include "HierarchyGenerators.h" + +#include <cassert> + +/** + * \defgroup FactoriesGroup Factories + * \defgroup AbstractFactoryGroup Abstract Factory + * \ingroup FactoriesGroup + * \brief Implements an abstract object factory. + */ + +/** + * \class AbstractFactory + * \ingroup AbstractFactoryGroup + * \brief Implements an abstract object factory. + */ + +namespace Loki +{ + +//////////////////////////////////////////////////////////////////////////////// +// class template AbstractFactoryUnit +// The building block of an Abstract Factory +//////////////////////////////////////////////////////////////////////////////// + + template <class T> + class AbstractFactoryUnit + { + public: + virtual T* DoCreate(Type2Type<T>) = 0; + virtual ~AbstractFactoryUnit() {} + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template AbstractFactory +// Defines an Abstract Factory interface starting from a typelist +//////////////////////////////////////////////////////////////////////////////// + + template + < + class TList, + template <class> class Unit = AbstractFactoryUnit + > + class AbstractFactory : public GenScatterHierarchy<TList, Unit> + { + public: + typedef TList ProductList; + + template <class T> T* Create() + { + Unit<T>& unit = *this; + return unit.DoCreate(Type2Type<T>()); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template OpNewFactoryUnit +// Creates an object by invoking the new operator +//////////////////////////////////////////////////////////////////////////////// + + template <class ConcreteProduct, class Base> + class OpNewFactoryUnit : public Base + { + typedef typename Base::ProductList BaseProductList; + + protected: + typedef typename BaseProductList::Tail ProductList; + + public: + typedef typename BaseProductList::Head AbstractProduct; + ConcreteProduct* DoCreate(Type2Type<AbstractProduct>) + { + return new ConcreteProduct; + } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template PrototypeFactoryUnit +// Creates an object by cloning a prototype +// There is a difference between the implementation herein and the one described +// in the book: GetPrototype and SetPrototype use the helper friend +// functions DoGetPrototype and DoSetPrototype. The friend functions avoid +// name hiding issues. Plus, GetPrototype takes a reference to pointer +// instead of returning the pointer by value. +//////////////////////////////////////////////////////////////////////////////// + + template <class ConcreteProduct, class Base> + class PrototypeFactoryUnit : public Base + { + typedef typename Base::ProductList BaseProductList; + + protected: + typedef typename BaseProductList::Tail ProductList; + + public: + typedef typename BaseProductList::Head AbstractProduct; + + PrototypeFactoryUnit(AbstractProduct* p = 0) + : pPrototype_(p) + {} + + template <class CP, class Base1> + friend void DoGetPrototype(const PrototypeFactoryUnit<CP, Base1>& me, + typename Base1::ProductList::Head*& pPrototype); + + template <class CP, class Base1> + friend void DoSetPrototype(PrototypeFactoryUnit<CP, Base1>& me, + typename Base1::ProductList::Head* pObj); + + template <class U> + void GetPrototype(U*& p) + { return DoGetPrototype(*this, p); } + + template <class U> + void SetPrototype(U* pObj) + { DoSetPrototype(*this, pObj); } + + AbstractProduct* DoCreate(Type2Type<AbstractProduct>) + { + assert(pPrototype_); + return pPrototype_->Clone(); + } + + private: + AbstractProduct* pPrototype_; + }; + + template <class CP, class Base> + inline void DoGetPrototype(const PrototypeFactoryUnit<CP, Base>& me, + typename Base::ProductList::Head*& pPrototype) + { pPrototype = me.pPrototype_; } + + template <class CP, class Base> + inline void DoSetPrototype(PrototypeFactoryUnit<CP, Base>& me, + typename Base::ProductList::Head* pObj) + { me.pPrototype_ = pObj; } + +//////////////////////////////////////////////////////////////////////////////// +// class template ConcreteFactory +// Implements an AbstractFactory interface +//////////////////////////////////////////////////////////////////////////////// + + template + < + class AbstractFact, + template <class, class> class Creator = OpNewFactoryUnit, + class TList = typename AbstractFact::ProductList + > + class ConcreteFactory + : public GenLinearHierarchy< + typename TL::Reverse<TList>::Result, Creator, AbstractFact> + { + public: + typedef typename AbstractFact::ProductList ProductList; + typedef TList ConcreteProductList; + }; + +} // namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/Allocator.h b/shared/loki/Allocator.h new file mode 100644 index 00000000..a79ee061 --- /dev/null +++ b/shared/loki/Allocator.h @@ -0,0 +1,153 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2008 by Rich Sposato +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// + +#ifndef LOKI_ALLOCATOR_HPP_INCLUDED +#define LOKI_ALLOCATOR_HPP_INCLUDED + +// $Id: Allocator.h 896 2008-08-08 22:20:05Z syntheticpp $ + +// Requires project to be compiled with loki/src/SmallObj.cpp and loki/src/Singleton.cpp + +#include <loki/SmallObj.h> + + +namespace Loki +{ + + +//----------------------------------------------------------------------------- + +/** @class LokiAllocator + Adapts Loki's Small-Object Allocator for STL container classes. + This class provides all the functionality required for STL allocators, but + uses Loki's Small-Object Allocator to perform actual memory operations. + Implementation comes from a post in Loki forums (by Rasmus Ekman?). + */ +template +< + typename Type, + typename AllocT = Loki::AllocatorSingleton<> +> +class LokiAllocator +{ +public: + + typedef ::std::size_t size_type; + typedef ::std::ptrdiff_t difference_type; + typedef Type * pointer; + typedef const Type * const_pointer; + typedef Type & reference; + typedef const Type & const_reference; + typedef Type value_type; + + /// Default constructor does nothing. + inline LokiAllocator( void ) throw() { } + + /// Copy constructor does nothing. + inline LokiAllocator( const LokiAllocator & ) throw() { } + + /// Type converting allocator constructor does nothing. + template < typename Type1 > + inline LokiAllocator( const LokiAllocator< Type1 > & ) throw() { } + + /// Destructor does nothing. + inline ~LokiAllocator() throw() { } + + /// Convert an allocator<Type> to an allocator <Type1>. + template < typename Type1 > + struct rebind + { + typedef LokiAllocator< Type1 > other; + }; + + /// Return address of reference to mutable element. + pointer address( reference elem ) const { return &elem; } + + /// Return address of reference to const element. + const_pointer address( const_reference elem ) const { return &elem; } + + /** Allocate an array of count elements. Warning! The true parameter in + the call to Allocate means this function can throw exceptions. This is + better than not throwing, and returning a null pointer in case the caller + assumes the return value is not null. + @param count # of elements in array. + @param hint Place where caller thinks allocation should occur. + @return Pointer to block of memory. + */ + pointer allocate( size_type count, const void * hint = 0 ) + { + (void)hint; // Ignore the hint. + void * p = AllocT::Instance().Allocate( count * sizeof( Type ), true ); + return reinterpret_cast< pointer >( p ); + } + + /// Ask allocator to release memory at pointer with size bytes. + void deallocate( pointer p, size_type size ) + { + AllocT::Instance().Deallocate( p, size * sizeof( Type ) ); + } + + /// Calculate max # of elements allocator can handle. + size_type max_size( void ) const throw() + { + // A good optimizer will see these calculations always produce the same + // value and optimize this function away completely. + const size_type max_bytes = size_type( -1 ); + const size_type bytes = max_bytes / sizeof( Type ); + return bytes; + } + + /// Construct an element at the pointer. + void construct( pointer p, const Type & value ) + { + // A call to global placement new forces a call to copy constructor. + ::new( p ) Type( value ); + } + + /// Destruct the object at pointer. + void destroy( pointer p ) + { + // If the Type has no destructor, then some compilers complain about + // an unreferenced parameter, so use the void cast trick to prevent + // spurious warnings. + (void)p; + p->~Type(); + } + +}; + +//----------------------------------------------------------------------------- + +/** All equality operators return true since LokiAllocator is basically a + monostate design pattern, so all instances of it are identical. + */ +template < typename Type > +inline bool operator == ( const LokiAllocator< Type > &, const LokiAllocator< Type > & ) +{ + return true; +} + +/** All inequality operators return false since LokiAllocator is basically a + monostate design pattern, so all instances of it are identical. + */ +template < typename Type > +inline bool operator != ( const LokiAllocator< Type > & , const LokiAllocator< Type > & ) +{ + return false; +} + +//----------------------------------------------------------------------------- + +} // namespace Loki + +#endif // LOKI_ALLOCATOR_INCLUDED diff --git a/shared/loki/AssocVector.h b/shared/loki/AssocVector.h new file mode 100644 index 00000000..905e0963 --- /dev/null +++ b/shared/loki/AssocVector.h @@ -0,0 +1,358 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_ASSOCVECTOR_INC_ +#define LOKI_ASSOCVECTOR_INC_ + +// $Id: AssocVector.h 765 2006-10-18 13:55:32Z syntheticpp $ + + +#include <algorithm> +#include <functional> +#include <vector> +#include <utility> + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class template AssocVectorCompare +// Used by AssocVector +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class Value, class C> + class AssocVectorCompare : public C + { + typedef std::pair<typename C::first_argument_type, Value> + Data; + typedef typename C::first_argument_type first_argument_type; + + public: + AssocVectorCompare() + {} + + AssocVectorCompare(const C& src) : C(src) + {} + + bool operator()(const first_argument_type& lhs, + const first_argument_type& rhs) const + { return C::operator()(lhs, rhs); } + + bool operator()(const Data& lhs, const Data& rhs) const + { return operator()(lhs.first, rhs.first); } + + bool operator()(const Data& lhs, + const first_argument_type& rhs) const + { return operator()(lhs.first, rhs); } + + bool operator()(const first_argument_type& lhs, + const Data& rhs) const + { return operator()(lhs, rhs.first); } + }; + } + +//////////////////////////////////////////////////////////////////////////////// +// class template AssocVector +// An associative vector built as a syntactic drop-in replacement for std::map +// BEWARE: AssocVector doesn't respect all map's guarantees, the most important +// being: +// * iterators are invalidated by insert and erase operations +// * the complexity of insert/erase is O(N) not O(log N) +// * value_type is std::pair<K, V> not std::pair<const K, V> +// * iterators are random +//////////////////////////////////////////////////////////////////////////////// + + + template + < + class K, + class V, + class C = std::less<K>, + class A = std::allocator< std::pair<K, V> > + > + class AssocVector + : private std::vector< std::pair<K, V>, A > + , private Private::AssocVectorCompare<V, C> + { + typedef std::vector<std::pair<K, V>, A> Base; + typedef Private::AssocVectorCompare<V, C> MyCompare; + + public: + typedef K key_type; + typedef V mapped_type; + typedef typename Base::value_type value_type; + + typedef C key_compare; + typedef A allocator_type; + typedef typename A::reference reference; + typedef typename A::const_reference const_reference; + typedef typename Base::iterator iterator; + typedef typename Base::const_iterator const_iterator; + typedef typename Base::size_type size_type; + typedef typename Base::difference_type difference_type; + typedef typename A::pointer pointer; + typedef typename A::const_pointer const_pointer; + typedef typename Base::reverse_iterator reverse_iterator; + typedef typename Base::const_reverse_iterator const_reverse_iterator; + + class value_compare + : public std::binary_function<value_type, value_type, bool> + , private key_compare + { + friend class AssocVector; + + protected: + value_compare(key_compare pred) : key_compare(pred) + {} + + public: + bool operator()(const value_type& lhs, const value_type& rhs) const + { return key_compare::operator()(lhs.first, rhs.first); } + }; + + // 23.3.1.1 construct/copy/destroy + + explicit AssocVector(const key_compare& comp = key_compare(), + const A& alloc = A()) + : Base(alloc), MyCompare(comp) + {} + + template <class InputIterator> + AssocVector(InputIterator first, InputIterator last, + const key_compare& comp = key_compare(), + const A& alloc = A()) + : Base(first, last, alloc), MyCompare(comp) + { + MyCompare& me = *this; + std::sort(begin(), end(), me); + } + + AssocVector& operator=(const AssocVector& rhs) + { + AssocVector(rhs).swap(*this); + return *this; + } + + // iterators: + // The following are here because MWCW gets 'using' wrong + iterator begin() { return Base::begin(); } + const_iterator begin() const { return Base::begin(); } + iterator end() { return Base::end(); } + const_iterator end() const { return Base::end(); } + reverse_iterator rbegin() { return Base::rbegin(); } + const_reverse_iterator rbegin() const { return Base::rbegin(); } + reverse_iterator rend() { return Base::rend(); } + const_reverse_iterator rend() const { return Base::rend(); } + + // capacity: + bool empty() const { return Base::empty(); } + size_type size() const { return Base::size(); } + size_type max_size() { return Base::max_size(); } + + // 23.3.1.2 element access: + mapped_type& operator[](const key_type& key) + { return insert(value_type(key, mapped_type())).first->second; } + + // modifiers: + std::pair<iterator, bool> insert(const value_type& val) + { + bool found(true); + iterator i(lower_bound(val.first)); + + if (i == end() || this->operator()(val.first, i->first)) + { + i = Base::insert(i, val); + found = false; + } + return std::make_pair(i, !found); + } + //Section [23.1.2], Table 69 + //http://developer.apple.com/documentation/DeveloperTools/gcc-3.3/libstdc++/23_containers/howto.html#4 + iterator insert(iterator pos, const value_type& val) + { + if( (pos == begin() || this->operator()(*(pos-1),val)) && + (pos == end() || this->operator()(val, *pos)) ) + { + return Base::insert(pos, val); + } + return insert(val).first; + } + + template <class InputIterator> + void insert(InputIterator first, InputIterator last) + { for (; first != last; ++first) insert(*first); } + + void erase(iterator pos) + { Base::erase(pos); } + + size_type erase(const key_type& k) + { + iterator i(find(k)); + if (i == end()) return 0; + erase(i); + return 1; + } + + void erase(iterator first, iterator last) + { Base::erase(first, last); } + + void swap(AssocVector& other) + { + Base::swap(other); + MyCompare& me = *this; + MyCompare& rhs = other; + std::swap(me, rhs); + } + + void clear() + { Base::clear(); } + + // observers: + key_compare key_comp() const + { return *this; } + + value_compare value_comp() const + { + const key_compare& comp = *this; + return value_compare(comp); + } + + // 23.3.1.3 map operations: + iterator find(const key_type& k) + { + iterator i(lower_bound(k)); + if (i != end() && this->operator()(k, i->first)) + { + i = end(); + } + return i; + } + + const_iterator find(const key_type& k) const + { + const_iterator i(lower_bound(k)); + if (i != end() && this->operator()(k, i->first)) + { + i = end(); + } + return i; + } + + size_type count(const key_type& k) const + { return find(k) != end(); } + + iterator lower_bound(const key_type& k) + { + MyCompare& me = *this; + return std::lower_bound(begin(), end(), k, me); + } + + const_iterator lower_bound(const key_type& k) const + { + const MyCompare& me = *this; + return std::lower_bound(begin(), end(), k, me); + } + + iterator upper_bound(const key_type& k) + { + MyCompare& me = *this; + return std::upper_bound(begin(), end(), k, me); + } + + const_iterator upper_bound(const key_type& k) const + { + const MyCompare& me = *this; + return std::upper_bound(begin(), end(), k, me); + } + + std::pair<iterator, iterator> equal_range(const key_type& k) + { + MyCompare& me = *this; + return std::equal_range(begin(), end(), k, me); + } + + std::pair<const_iterator, const_iterator> equal_range( + const key_type& k) const + { + const MyCompare& me = *this; + return std::equal_range(begin(), end(), k, me); + } + + template <class K1, class V1, class C1, class A1> + friend bool operator==(const AssocVector<K1, V1, C1, A1>& lhs, + const AssocVector<K1, V1, C1, A1>& rhs); + + bool operator<(const AssocVector& rhs) const + { + const Base& me = *this; + const Base& yo = rhs; + return me < yo; + } + + template <class K1, class V1, class C1, class A1> + friend bool operator!=(const AssocVector<K1, V1, C1, A1>& lhs, + const AssocVector<K1, V1, C1, A1>& rhs); + + template <class K1, class V1, class C1, class A1> + friend bool operator>(const AssocVector<K1, V1, C1, A1>& lhs, + const AssocVector<K1, V1, C1, A1>& rhs); + + template <class K1, class V1, class C1, class A1> + friend bool operator>=(const AssocVector<K1, V1, C1, A1>& lhs, + const AssocVector<K1, V1, C1, A1>& rhs); + + template <class K1, class V1, class C1, class A1> + friend bool operator<=(const AssocVector<K1, V1, C1, A1>& lhs, + const AssocVector<K1, V1, C1, A1>& rhs); + }; + + template <class K, class V, class C, class A> + inline bool operator==(const AssocVector<K, V, C, A>& lhs, + const AssocVector<K, V, C, A>& rhs) + { + const std::vector<std::pair<K, V>, A>& me = lhs; + return me == rhs; + } + + template <class K, class V, class C, class A> + inline bool operator!=(const AssocVector<K, V, C, A>& lhs, + const AssocVector<K, V, C, A>& rhs) + { return !(lhs == rhs); } + + template <class K, class V, class C, class A> + inline bool operator>(const AssocVector<K, V, C, A>& lhs, + const AssocVector<K, V, C, A>& rhs) + { return rhs < lhs; } + + template <class K, class V, class C, class A> + inline bool operator>=(const AssocVector<K, V, C, A>& lhs, + const AssocVector<K, V, C, A>& rhs) + { return !(lhs < rhs); } + + template <class K, class V, class C, class A> + inline bool operator<=(const AssocVector<K, V, C, A>& lhs, + const AssocVector<K, V, C, A>& rhs) + { return !(rhs < lhs); } + + + // specialized algorithms: + template <class K, class V, class C, class A> + void swap(AssocVector<K, V, C, A>& lhs, AssocVector<K, V, C, A>& rhs) + { lhs.swap(rhs); } + +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/CachedFactory.h b/shared/loki/CachedFactory.h new file mode 100644 index 00000000..15c9a801 --- /dev/null +++ b/shared/loki/CachedFactory.h @@ -0,0 +1,1167 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 by Guillaume Chatelet +// +// Code covered by the MIT License +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// +// The authors make no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +// +// This code DOES NOT accompany the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_CACHEDFACTORY_INC_ +#define LOKI_CACHEDFACTORY_INC_ + +// $Id: CachedFactory.h 950 2009-01-26 19:45:54Z syntheticpp $ + +#include <functional> +#include <algorithm> +#include <iostream> +#include <vector> +#include <iterator> +#include <map> +#include <cassert> +#include <loki/Key.h> + +#ifdef DO_EXTRA_LOKI_TESTS + #define D( x ) x +#else + #define D( x ) ; +#endif + +#if defined(_MSC_VER) || defined(__CYGWIN__) +#include <time.h> +#endif + +/** + * \defgroup FactoriesGroup Factories + * \defgroup CachedFactoryGroup Cached Factory + * \ingroup FactoriesGroup + * \brief CachedFactory provides an extension of a Factory with caching + * support. + * + * Once used objects are returned to the CachedFactory that manages its + * destruction. + * If your code uses lots of "long to construct/destruct objects" using the + * CachedFactory will surely speedup the execution. + */ +namespace Loki +{ +/** + * \defgroup EncapsulationPolicyCachedFactoryGroup Encapsulation policies + * \ingroup CachedFactoryGroup + * \brief Defines how the object is returned to the client + */ + /** + * \class SimplePointer + * \ingroup EncapsulationPolicyCachedFactoryGroup + * \brief No encaspulation : returns the pointer + * + * This implementation does not make any encapsulation. + * It simply returns the object's pointer. + */ + template<class AbstractProduct> + class SimplePointer + { + protected: + typedef AbstractProduct* ProductReturn; + ProductReturn encapsulate(AbstractProduct* pProduct) + { + return pProduct; + } + + AbstractProduct* release(ProductReturn &pProduct) + { + AbstractProduct* pPointer(pProduct); + pProduct=NULL; + return pPointer; + } + const char* name(){return "pointer";} + }; + +/** + * \defgroup CreationPolicyCachedFactoryGroup Creation policies + * \ingroup CachedFactoryGroup + * \brief Defines a way to limit the creation operation. + * + * For instance one may want to be alerted (Exception) when + * - Cache has created a more than X object within the last x seconds + * - Cache creation rate has increased dramatically + * . + * which may result from bad caching strategy, or critical overload + */ + /** + * \class NeverCreate + * \ingroup CreationPolicyCachedFactoryGroup + * \brief Never allows creation. Testing purposes only. + * + * Using this policy will throw an exception. + */ + class NeverCreate + { + protected: + struct Exception : public std::exception + { + const char* what() const throw() { return "NeverFetch Policy : No Fetching allowed"; } + }; + + bool canCreate() + { + throw Exception(); + } + + void onCreate(){} + void onDestroy(){} + const char* name(){return "never";} + }; + + /** + * \class AlwaysCreate + * \ingroup CreationPolicyCachedFactoryGroup + * \brief Always allows creation. + * + * Doesn't limit the creation in any way + */ + class AlwaysCreate + { + protected: + bool canCreate() + { + return true; + } + + void onCreate(){} + void onDestroy(){} + const char* name(){return "always";} + }; + + + /** + * \class RateLimitedCreation + * \ingroup CreationPolicyCachedFactoryGroup + * \brief Limit in rate. + * + * This implementation will prevent from Creating more than maxCreation objects + * within byTime ms by throwing an exception. + * Could be usefull to detect prevent loads (http connection for instance). + * Use the setRate method to set the rate parameters. + * default is 10 objects in a second. + */ + // !! CAUTION !! + // The std::clock() function is not quite precise + // under linux this policy might not work. + // TODO : get a better implementation (platform dependant) + class RateLimitedCreation + { + private: + typedef std::vector< clock_t > Vector; + Vector m_vTimes; + unsigned maxCreation; + clock_t timeValidity; + clock_t lastUpdate; + + void cleanVector() + { + using namespace std; + clock_t currentTime = clock(); + D( cout << "currentTime = " << currentTime<< endl; ) + D( cout << "currentTime - lastUpdate = " << currentTime - lastUpdate<< endl; ) + if(currentTime - lastUpdate > timeValidity) + { + m_vTimes.clear(); + D( cout << " is less than time validity " << timeValidity; ) + D( cout << " so clearing vector" << endl; ) + } + else + { + D( cout << "Cleaning time less than " << currentTime - timeValidity << endl; ) + D( displayVector(); ) + Vector::iterator newEnd = remove_if(m_vTimes.begin(), m_vTimes.end(), bind2nd(less<clock_t>(), currentTime - timeValidity)); + // this rearrangement might be costly, consider optimization + // by calling cleanVector in less used onCreate function + // ... although it may not be correct + m_vTimes.erase(newEnd, m_vTimes.end()); + D( displayVector(); ) + } + lastUpdate = currentTime; + } +#ifdef DO_EXTRA_LOKI_TESTS + void displayVector() + { + std::cout << "Vector : "; + copy(m_vTimes.begin(), m_vTimes.end(), std::ostream_iterator<clock_t>(std::cout, " ")); + std::cout << std::endl; + } +#endif + protected: + RateLimitedCreation() : maxCreation(10), timeValidity(CLOCKS_PER_SEC), lastUpdate(clock()) + {} + + struct Exception : public std::exception + { + const char* what() const throw() { return "RateLimitedCreation Policy : Exceeded the authorized creation rate"; } + }; + + bool canCreate() + { + cleanVector(); + if(m_vTimes.size()>maxCreation) + throw Exception(); + else + return true; + } + + void onCreate() + { + m_vTimes.push_back(clock()); + } + + void onDestroy() + { + } + const char* name(){return "rate limited";} + public: + // set the creation rate + // No more than maxCreation within byTime milliseconds + void setRate(unsigned maxCreation, unsigned byTime) + { + assert(byTime>0); + this->maxCreation = maxCreation; + this->timeValidity = static_cast<clock_t>(byTime * CLOCKS_PER_SEC / 1000); + D( std::cout << "Setting no more than "<< maxCreation <<" creation within " << this->timeValidity <<" ms"<< std::endl; ) + } + }; + + /** + * \class AmountLimitedCreation + * \ingroup CreationPolicyCachedFactoryGroup + * \brief Limit by number of objects + * + * This implementation will prevent from Creating more than maxCreation objects + * within byTime ms by calling eviction policy. + * Use the setRate method to set the rate parameters. + * default is 10 objects. + */ + class AmountLimitedCreation + { + private: + unsigned maxCreation; + unsigned created; + + protected: + AmountLimitedCreation() : maxCreation(10), created(0) + {} + + bool canCreate() + { + return !(created>=maxCreation); + } + + void onCreate() + { + ++created; + } + + void onDestroy() + { + --created; + } + const char* name(){return "amount limited";} + public: + // set the creation max amount + void setMaxCreation(unsigned maxCreation) + { + assert(maxCreation>0); + this->maxCreation = maxCreation; + D( std::cout << "Setting no more than " << maxCreation <<" creation" << std::endl; ) + } + }; + +/** + * \defgroup EvictionPolicyCachedFactoryGroup Eviction policies + * \ingroup CachedFactoryGroup + * \brief Gathers informations about the stored objects and choose a + * candidate for eviction. + */ + + class EvictionException : public std::exception + { + public: + const char* what() const throw() { return "Eviction Policy : trying to make room but no objects are available"; } + }; + + // The following class is intented to provide helpers to sort + // the container that will hold an eviction score + template + < + typename ST, // Score type + typename DT // Data type + > + class EvictionHelper + { + protected: + typedef typename std::map< DT, ST > HitMap; + typedef typename HitMap::iterator HitMapItr; + private: + typedef std::pair< ST, DT > SwappedPair; + typedef std::multimap< ST, DT > SwappedHitMap; + typedef typename SwappedHitMap::iterator SwappedHitMapItr; + protected: + HitMap m_mHitCount; + + // This function sorts the map according to the score + // and returns the lower bound of the sorted container + DT& getLowerBound(){ + assert(!m_mHitCount.empty()); + // inserting the swapped pair into a multimap + SwappedHitMap copyMap; + for(HitMapItr itr = m_mHitCount.begin(); itr != m_mHitCount.end(); ++itr) + copyMap.insert(SwappedPair((*itr).second, (*itr).first)); + if((*copyMap.rbegin()).first == 0) // the higher score is 0 ... + throw EvictionException(); // there is no key evict + return (*copyMap.begin()).second; + } + }; + + /** + * \class EvictLRU + * \ingroup EvictionPolicyCachedFactoryGroup + * \brief Evicts least accessed objects first. + * + * Implementation of the Least recent used algorithm as + * described in http://en.wikipedia.org/wiki/Page_replacement_algorithms . + * + * WARNING : If an object is heavily fetched + * (more than ULONG_MAX = UINT_MAX = 4294967295U) + * it could unfortunately be removed from the cache. + */ + template + < + typename DT, // Data Type (AbstractProduct*) + typename ST = unsigned // default data type to use as Score Type + > + class EvictLRU : public EvictionHelper< ST , DT > + { + private: + typedef EvictionHelper< ST , DT > EH; + protected: + + virtual ~EvictLRU(){} + + // OnStore initialize the counter for the new key + // If the key already exists, the counter is reseted + void onCreate(const DT& key) + { + EH::m_mHitCount[key] = 0; + } + + void onFetch(const DT&) + { + } + + // onRelease increments the hit counter associated with the object + void onRelease(const DT& key) + { + ++(EH::m_mHitCount[key]); + } + + void onDestroy(const DT& key) + { + EH::m_mHitCount.erase(key); + } + + // this function is implemented in Cache and redirected + // to the Storage Policy + virtual void remove(DT const key)=0; + + // LRU Eviction policy + void evict() + { + remove(EH::getLowerBound()); + } + const char* name(){return "LRU";} + }; + + /** + * \class EvictAging + * \ingroup EvictionPolicyCachedFactoryGroup + * \brief LRU aware of the time span of use + * + * Implementation of the Aging algorithm as + * described in http://en.wikipedia.org/wiki/Page_replacement_algorithms . + * + * This method is much more costly than evict LRU so + * if you need extreme performance consider switching to EvictLRU + */ + template + < + typename DT, // Data Type (AbstractProduct*) + typename ST = unsigned // default data type to use as Score Type + > + class EvictAging : public EvictionHelper< ST, DT > + { + private: + EvictAging(const EvictAging&); + EvictAging& operator=(const EvictAging&); + typedef EvictionHelper< ST, DT > EH; + typedef typename EH::HitMap HitMap; + typedef typename EH::HitMapItr HitMapItr; + + // update the counter + template<class T> struct updateCounter : public std::unary_function<T, void> + { + updateCounter(const DT& key): key_(key){} + void operator()(T x) + { + x.second = (x.first == key_ ? (x.second >> 1) | ( 1 << ((sizeof(ST)-1)*8) ) : x.second >> 1); + D( std::cout << x.second << std::endl; ) + } + const DT &key_; + updateCounter(const updateCounter& rhs) : key_(rhs.key_){} + private: + updateCounter& operator=(const updateCounter& rhs); + }; + protected: + EvictAging(){} + virtual ~EvictAging(){} + + // OnStore initialize the counter for the new key + // If the key already exists, the counter is reseted + void onCreate(const DT& key){ + EH::m_mHitCount[key] = 0; + } + + void onFetch(const DT&){} + + // onRelease increments the hit counter associated with the object + // Updating every counters by iterating over the map + // If the key is the key of the fetched object : + // the counter is shifted to the right and it's MSB is set to 1 + // else + // the counter is shifted to the left + void onRelease(const DT& key) + { + std::for_each(EH::m_mHitCount.begin(), EH::m_mHitCount.end(), updateCounter< typename HitMap::value_type >(key)); + } + + void onDestroy(const DT& key) + { + EH::m_mHitCount.erase(key); + } + + // this function is implemented in Cache and redirected + // to the Storage Policy + virtual void remove(DT const key)=0; + + // LRU with Aging Eviction policy + void evict() + { + remove(EH::getLowerBound()); + } + const char* name(){return "LRU with aging";} + }; + + /** + * \class EvictRandom + * \ingroup EvictionPolicyCachedFactoryGroup + * \brief Evicts a random object + * + * Implementation of the Random algorithm as + * described in http://en.wikipedia.org/wiki/Page_replacement_algorithms . + */ + template + < + typename DT, // Data Type (AbstractProduct*) + typename ST = void // Score Type not used by this policy + > + class EvictRandom + { + private: + std::vector< DT > m_vKeys; + typedef typename std::vector< DT >::size_type size_type; + typedef typename std::vector< DT >::iterator iterator; + + protected: + + virtual ~EvictRandom(){} + + void onCreate(const DT&){ + } + + void onFetch(const DT& ){ + } + + void onRelease(const DT& key){ + m_vKeys.push_back(key); + } + + void onDestroy(const DT& key){ + using namespace std; + m_vKeys.erase(remove_if(m_vKeys.begin(), m_vKeys.end(), bind2nd(equal_to< DT >(), key)), m_vKeys.end()); + } + + // Implemented in Cache and redirected to the Storage Policy + virtual void remove(DT const key)=0; + + // Random Eviction policy + void evict() + { + if(m_vKeys.empty()) + throw EvictionException(); + size_type random = static_cast<size_type>((m_vKeys.size()*rand())/(static_cast<size_type>(RAND_MAX) + 1)); + remove(*(m_vKeys.begin()+random)); + } + const char* name(){return "random";} + }; + +/** + * \defgroup StatisticPolicyCachedFactoryGroup Statistic policies + * \ingroup CachedFactoryGroup + * \brief Gathers information about the cache. + * + * For debugging purpose this policy proposes to gather informations + * about the cache. This could be useful to determine whether the cache is + * mandatory or if the policies are well suited to the application. + */ + /** + * \class NoStatisticPolicy + * \ingroup StatisticPolicyCachedFactoryGroup + * \brief Do nothing + * + * Should be used in release code for better performances + */ + class NoStatisticPolicy + { + protected: + void onDebug(){} + void onFetch(){} + void onRelease(){} + void onCreate(){} + void onDestroy(){} + const char* name(){return "no";} + }; + + /** + * \class SimpleStatisticPolicy + * \ingroup StatisticPolicyCachedFactoryGroup + * \brief Simple statistics + * + * Provides the following informations about the cache : + * - Created objects + * - Fetched objects + * - Destroyed objects + * - Cache hit + * - Cache miss + * - Currently allocated + * - Currently out + * - Cache overall efficiency + */ + class SimpleStatisticPolicy + { + private: + unsigned allocated, created, hit, out, fetched; + protected: + SimpleStatisticPolicy() : allocated(0), created(0), hit(0), out(0), fetched(0) + { + } + + void onDebug() + { + using namespace std; + cout << "############################" << endl; + cout << "## About this cache " << this << endl; + cout << "## + Created objects : " << created << endl; + cout << "## + Fetched objects : " << fetched << endl; + cout << "## + Destroyed objects : " << created - allocated << endl; + cout << "## + Cache hit : " << hit << endl; + cout << "## + Cache miss : " << fetched - hit << endl; + cout << "## + Currently allocated : " << allocated << endl; + cout << "## + Currently out : " << out << endl; + cout << "############################" << endl; + if(fetched!=0){ + cout << "## Overall efficiency " << 100*double(hit)/fetched <<"%"<< endl; + cout << "############################" << endl; + } + cout << endl; + } + + void onFetch() + { + ++fetched; + ++out; + ++hit; + } + void onRelease() + { + --out; + } + void onCreate() + { + ++created; + ++allocated; + --hit; + } + void onDestroy() + { + --allocated; + } + + const char* name(){return "simple";} + public: + unsigned getCreated(){return created;} + unsigned getFetched(){return fetched;} + unsigned getHit(){return hit;} + unsigned getMissed(){return fetched - hit;} + unsigned getAllocated(){return allocated;} + unsigned getOut(){return out;} + unsigned getDestroyed(){return created-allocated;} + }; + + /////////////////////////////////////////////////////////////////////////// + // Cache Factory definition + /////////////////////////////////////////////////////////////////////////// + class CacheException : public std::exception + { + public: + const char* what() const throw() { return "Internal Cache Error"; } + }; + + /** + * \class CachedFactory + * \ingroup CachedFactoryGroup + * \brief Factory with caching support + * + * This class acts as a Factory (it creates objects) + * but also keeps the already created objects to prevent + * long constructions time. + * + * Note this implementation do not retain ownership. + */ + template + < + class AbstractProduct, + typename IdentifierType, + typename CreatorParmTList = NullType, + template<class> class EncapsulationPolicy = SimplePointer, + class CreationPolicy = AlwaysCreate, + template <typename , typename> class EvictionPolicy = EvictRandom, + class StatisticPolicy = NoStatisticPolicy, + template<typename, class> class FactoryErrorPolicy = DefaultFactoryError, + class ObjVector = std::vector<AbstractProduct*> + > + class CachedFactory : + protected EncapsulationPolicy<AbstractProduct>, + public CreationPolicy, public StatisticPolicy, EvictionPolicy< AbstractProduct * , unsigned > + { + private: + typedef Factory< AbstractProduct, IdentifierType, CreatorParmTList, FactoryErrorPolicy> MyFactory; + typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl; + typedef Functor< AbstractProduct* , CreatorParmTList > ProductCreator; + typedef EncapsulationPolicy<AbstractProduct> NP; + typedef CreationPolicy CP; + typedef StatisticPolicy SP; + typedef EvictionPolicy< AbstractProduct* , unsigned > EP; + + typedef typename Impl::Parm1 Parm1; + typedef typename Impl::Parm2 Parm2; + typedef typename Impl::Parm3 Parm3; + typedef typename Impl::Parm4 Parm4; + typedef typename Impl::Parm5 Parm5; + typedef typename Impl::Parm6 Parm6; + typedef typename Impl::Parm7 Parm7; + typedef typename Impl::Parm8 Parm8; + typedef typename Impl::Parm9 Parm9; + typedef typename Impl::Parm10 Parm10; + typedef typename Impl::Parm11 Parm11; + typedef typename Impl::Parm12 Parm12; + typedef typename Impl::Parm13 Parm13; + typedef typename Impl::Parm14 Parm14; + typedef typename Impl::Parm15 Parm15; + + public: + typedef typename NP::ProductReturn ProductReturn; + private: + typedef Key< Impl, IdentifierType > MyKey; + typedef std::map< MyKey, ObjVector > KeyToObjVectorMap; + typedef std::map< AbstractProduct*, MyKey > FetchedObjToKeyMap; + + MyFactory factory; + KeyToObjVectorMap fromKeyToObjVector; + FetchedObjToKeyMap providedObjects; + unsigned outObjects; + + ObjVector& getContainerFromKey(MyKey key){ + return fromKeyToObjVector[key]; + } + + AbstractProduct* const getPointerToObjectInContainer(ObjVector &entry) + { + if(entry.empty()) // No object available + { // the object will be created in the calling function. + // It has to be created in the calling function because of + // the variable number of parameters for CreateObject(...) method + return NULL; + } + else + { // returning the found object + AbstractProduct* pObject(entry.back()); + assert(pObject!=NULL); + entry.pop_back(); + return pObject; + } + } + + bool shouldCreateObject(AbstractProduct * const pProduct){ + if(pProduct!=NULL) // object already exists + return false; + if(CP::canCreate()==false) // Are we allowed to Create ? + EP::evict(); // calling Eviction Policy to clean up + return true; + } + + void ReleaseObjectFromContainer(ObjVector &entry, AbstractProduct * const object) + { + entry.push_back(object); + } + + void onFetch(AbstractProduct * const pProduct) + { + SP::onFetch(); + EP::onFetch(pProduct); + ++outObjects; + } + + void onRelease(AbstractProduct * const pProduct) + { + SP::onRelease(); + EP::onRelease(pProduct); + --outObjects; + } + + void onCreate(AbstractProduct * const pProduct) + { + CP::onCreate(); + SP::onCreate(); + EP::onCreate(pProduct); + } + + void onDestroy(AbstractProduct * const pProduct) + { + CP::onDestroy(); + SP::onDestroy(); + EP::onDestroy(pProduct); + } + + // delete the object + template<class T> struct deleteObject : public std::unary_function<T, void> + { + void operator()(T x){ delete x; } + }; + + // delete the objects in the vector + template<class T> struct deleteVectorObjects : public std::unary_function<T, void> + { + void operator()(T x){ + ObjVector &vec(x.second); + std::for_each(vec.begin(), vec.end(), deleteObject< typename ObjVector::value_type>()); + } + }; + + // delete the keys of the map + template<class T> struct deleteMapKeys : public std::unary_function<T, void> + { + void operator()(T x){ delete x.first; } + }; + + protected: + virtual void remove(AbstractProduct * const pProduct) + { + typename FetchedObjToKeyMap::iterator fetchedItr = providedObjects.find(pProduct); + if(fetchedItr!=providedObjects.end()) // object is unreleased. + throw CacheException(); + bool productRemoved = false; + typename KeyToObjVectorMap::iterator objVectorItr; + typename ObjVector::iterator objItr; + for(objVectorItr=fromKeyToObjVector.begin();objVectorItr!=fromKeyToObjVector.end();++objVectorItr) + { + ObjVector &v((*objVectorItr).second); + objItr = remove_if(v.begin(), v.end(), std::bind2nd(std::equal_to<AbstractProduct*>(), pProduct)); + if(objItr != v.end()) // we found the vector containing pProduct and removed it + { + onDestroy(pProduct); // warning policies we are about to destroy an object + v.erase(objItr, v.end()); // real removing + productRemoved = true; + break; + } + } + if(productRemoved==false) + throw CacheException(); // the product is not in the cache ?! + delete pProduct; // deleting it + } + + public: + CachedFactory() : factory(), fromKeyToObjVector(), providedObjects(), outObjects(0) + { + } + + ~CachedFactory() + { + using namespace std; + // debug information + SP::onDebug(); + // cleaning the Cache + for_each(fromKeyToObjVector.begin(), fromKeyToObjVector.end(), + deleteVectorObjects< typename KeyToObjVectorMap::value_type >() + ); + if(!providedObjects.empty()) + { + // The factory is responsible for the creation and destruction of objects. + // If objects are out during the destruction of the Factory : deleting anyway. + // This might not be a good idea. But throwing an exception in a destructor is + // considered as a bad pratice and asserting might be too much. + // What to do ? Leaking memory or corrupting in use pointers ? hmm... + D( cout << "====>> Cache destructor : deleting "<< providedObjects.size()<<" in use objects <<====" << endl << endl; ) + for_each(providedObjects.begin(), providedObjects.end(), + deleteMapKeys< typename FetchedObjToKeyMap::value_type >() + ); + } + } + + /////////////////////////////////// + // Acts as the proxy pattern and // + // forwards factory methods // + /////////////////////////////////// + + bool Register(const IdentifierType& id, ProductCreator creator) + { + return factory.Register(id, creator); + } + + template <class PtrObj, typename CreaFn> + bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn) + { + return factory.Register(id, p, fn); + } + + bool Unregister(const IdentifierType& id) + { + return factory.Unregister(id); + } + + /// Return the registered ID in this Factory + std::vector<IdentifierType>& RegisteredIds() + { + return factory.RegisteredIds(); + } + + ProductReturn CreateObject(const IdentifierType& id) + { + MyKey key(id); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1) + { + MyKey key(id,p1); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2) + { + MyKey key(id,p1,p2); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3) + { + MyKey key(id,p1,p2,p3); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) + { + MyKey key(id,p1,p2,p3,p4); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) + { + MyKey key(id,p1,p2,p3,p4,p5); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) + { + MyKey key(id,p1,p2,p3,p4,p5,p6); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7 ) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9,Parm10 p10) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12, Parm13 p13) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12 + ,key.p13); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12 + ,key.p13,key.p14); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + ProductReturn CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) + { + MyKey key(id,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15); + AbstractProduct *pProduct(getPointerToObjectInContainer(getContainerFromKey(key))); + if(shouldCreateObject(pProduct)) + { + pProduct = factory.CreateObject(key.id,key.p1,key.p2,key.p3 + ,key.p4,key.p5,key.p6,key.p7,key.p8,key.p9,key.p10,key.p11,key.p12 + ,key.p13,key.p14,key.p15); + onCreate(pProduct); + } + onFetch(pProduct); + providedObjects[pProduct] = key; + return NP::encapsulate(pProduct); + } + + /// Use this function to release the object + /** + * if execution brakes in this function then you tried + * to release an object that wasn't provided by this Cache + * ... which is bad :-) + */ + void ReleaseObject(ProductReturn &object) + { + AbstractProduct* pProduct(NP::release(object)); + typename FetchedObjToKeyMap::iterator itr = providedObjects.find(pProduct); + if(itr == providedObjects.end()) + throw CacheException(); + onRelease(pProduct); + ReleaseObjectFromContainer(getContainerFromKey((*itr).second), pProduct); + providedObjects.erase(itr); + } + + /// display the cache configuration + void displayCacheType() + { + using namespace std; + cout << "############################" << endl; + cout << "## Cache configuration" << endl; + cout << "## + Encapsulation " << NP::name() << endl; + cout << "## + Creating " << CP::name() << endl; + cout << "## + Eviction " << EP::name() << endl; + cout << "## + Statistics " << SP::name() << endl; + cout << "############################" << endl; + } + }; +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/CheckReturn.h b/shared/loki/CheckReturn.h new file mode 100644 index 00000000..fbe63ed0 --- /dev/null +++ b/shared/loki/CheckReturn.h @@ -0,0 +1,165 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2007 by Rich Sposato +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// + +#ifndef LOKI_CHECK_RETURN_INC_ +#define LOKI_CHECK_RETURN_INC_ + +// $Id$ + + +#include <assert.h> +#include <stdio.h> +#include <stdexcept> + + +namespace Loki +{ + +// ---------------------------------------------------------------------------- + +//////////////////////////////////////////////////////////////////////////////// +/// \class CheckReturn +/// +/// \par Purpose +/// C++ provides no mechanism within the language itself to force code to +/// check the return value from a function call. This simple class provides +/// a mechanism by which programmers can force calling functions to check the +/// return value. Or at least make them consciously choose to disregard the +/// return value. If the calling function fails to use or store the return +/// value, the destructor calls the OnError policy. +/// +/// \par Template Parameters +/// CheckReturn has two template parameters, Value and OnError. +/// - Value is the return type from the function. CheckReturn stores a copy of +/// it rather than a reference or pointer since return value could be local to +/// a function. CheckReturn works best when the return type is a built-in +/// primitive (bool, int, etc...) a pointer, or an enum (such as an error +/// condition enum). It can work with other types that have cheap copy +/// operations. +/// - OnError is a policy class indicating how to handle the situation when a +/// caller does not check or copy the returned value. Loki provides some +/// policy classs and you may also write your own. For example, you can write +/// a policy to create a message box when the function ignores the return value. +/// That would quickly tell you places where code ignores the function call. +/// If your write your own, you only need a templated class or struct with a +/// public function named "run" that accepts a reference to a const value. +/// +/// @par Provided Policy Classes +/// - IgnoreReturnValue Deliberately ignores when the caller ignores the return value. +/// - TriggerAssert Asserts in debug builds if the caller ignores the return value. +/// - FprintfStderr Prints out an error message if the caller ignores the return value. +/// - ThrowTheValue Throws the ignored value as an exception. +/// - ThrowLogicError Throws a logic_error exception to indicate a programming error. +//////////////////////////////////////////////////////////////////////////////// + + +template<class T> +struct IgnoreReturnValue +{ + static void run(const T&) + { + /// Do nothing at all. + } +}; + +template<class T> +struct ThrowTheValue +{ + static void run(const T & value ) + { + throw value; + } +}; + +template<class T> +struct ThrowLogicError +{ + static void run( const T & ) + { + throw ::std::logic_error( "CheckReturn: return value was not checked.\n" ); + } +}; + +template<class T> +struct TriggerAssert +{ + static void run(const T&) + { + assert( 0 ); + } +}; + +template<class T> +struct FprintfStderr +{ + static void run(const T&) + { + fprintf(stderr, "CheckReturn: return value was not checked.\n"); + } +}; + + + +template < class Value , template<class> class OnError = TriggerAssert > +class CheckReturn +{ +public: + + /// Conversion constructor changes Value type to CheckReturn type. + inline CheckReturn( const Value & value ) : + m_value( value ), m_checked( false ) {} + + /// Copy-constructor allows functions to call another function within the + /// return statement. The other CheckReturn's m_checked flag is set since + /// its duty has been passed to the m_checked flag in this one. + inline CheckReturn( const CheckReturn & that ) : + m_value( that.m_value ), m_checked( false ) + { that.m_checked = true; } + + /// Destructor checks if return value was used. + inline ~CheckReturn( void ) + { + // If m_checked is false, then a function failed to check the + // return value from a function call. + if (!m_checked) + OnError<Value>::run(m_value); + } + + /// Conversion operator changes CheckReturn back to Value type. + inline operator Value ( void ) + { + m_checked = true; + return m_value; + } + +private: + /// Default constructor not implemented. + CheckReturn( void ); + + /// Copy-assignment operator not implemented. + CheckReturn & operator = ( const CheckReturn & that ); + + /// Copy of returned value. + Value m_value; + + /// Flag for whether calling function checked return value yet. + mutable bool m_checked; +}; + +// ---------------------------------------------------------------------------- + +} // namespace Loki + +#endif // end file guardian + +// $Log$ + diff --git a/shared/loki/Checker.h b/shared/loki/Checker.h new file mode 100644 index 00000000..19350679 --- /dev/null +++ b/shared/loki/Checker.h @@ -0,0 +1,516 @@ +//////////////////////////////////////////////////////////////////////////////// +// +// The Loki Library +// Copyright (c) 2008 Rich Sposato +// The copyright on this file is protected under the terms of the MIT license. +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// +// The author makes no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +// +//////////////////////////////////////////////////////////////////////////////// + +// $Id$ + +/// @file Checker.h This file provides Loki's Checker facility. + + +// ---------------------------------------------------------------------------- + +#ifndef LOKI_CHECKER_H_INCLUDED +#define LOKI_CHECKER_H_INCLUDED + +#include <exception> // needed for calls to uncaught_exception. +#include <assert.h> + + +namespace Loki +{ + +/** @par ContractChecker and StaticChecker Overview + The ContractChecker and StaticChecker classes have two purposes: + - provide a mechanism by which programmers can determine which functions + violate class/data invariants, + - and determine which exception safety a function provides. + + @par Class & Data Invariants + The ContractChecker and StaticChecker define invariants as "expressions that + are true for particular data". They uses a function which returns true if all + data are valid, and returns false if any datum is invalid. This is called the + validator function, and the host class or function provides a pointer to it. + The validator could also assert for any invariant which fails rather than + return false. If the validator is a static member function, you can use it + with checkers in any function, but especially standalone functions and class + static functions. If the validator is a non-static member function, you can + use it only within non-static member functions. + + @par Exception Safety Levels + Years ago, David Abrahams formalized a framework for assessing the exception + safety level a function provides. His framework describes three levels of + guarantees. Any function which does not provide any of these levels is + considered unsafe. ContractChecker and StaticChecker determine a function's + safety level through the use of policy classes. Checker's policy classes can + show if a function provides any of these three guarantees. Since there is no + universal way to detect leaks, this facility provides no mechanism for finding + leaks, but users may create their own validators which do. StaticChecker's + policy classes only provide direct checking for the no-throw and invariant + guarantees. With some finesse, a programmer can write a validator for + StaticChecker that checks for the Strong guarantee. + + - No-throw guarantee: A function will not throw any exceptions. + - Strong guarantee: A function will not change data if an exception occurs. + (Which I call the no-change guarantee.) + - Basic guarantee: A function will not leak resources and data will remain + in a valid state if an exception occurs. (Which I call either the no-leak + or no-break guarantee depending on context.) + */ + +// ---------------------------------------------------------------------------- + +/** @class CheckForNoThrow + + @par Exception Safety Level: + This exception-checking policy class for ContractChecker asserts if an + exception exists. Host classes can use this to show that a member function + provides the no-throw exception safety guarantees. + + @par Requirements For Host Class: + This policy imposes no requirements on a host class. + */ +template < class Host > +class CheckForNoThrow +{ +public: + + inline explicit CheckForNoThrow( const Host * ) {} + + inline bool Check( const Host * ) const + { + const bool okay = ( !::std::uncaught_exception() ); + assert( okay ); + return okay; + } +}; + +// ---------------------------------------------------------------------------- + +/** @class CheckForNoChange + + @par Exception Safety Level: + This exception-checking policy class for ContractChecker asserts only if a + copy of the host differs from the host object when an exception occurs. Host + classes can use this policy to show which member functions provide the strong + exception guarantee. + + @par Requirements: + This policy requires hosts to provide both the copy-constructor and the + equality operator, and is intended for classes with value semantics. + equality operator. + */ + +template < class Host > +class CheckForNoChange +{ +public: + + inline explicit CheckForNoChange( const Host * host ) : + m_compare( *host ) {} + + inline bool Check( const Host * host ) const + { + const bool okay = ( !::std::uncaught_exception() ) + || ( m_compare == *host ); + assert( okay ); + return okay; + } + +private: + Host m_compare; +}; + +// ---------------------------------------------------------------------------- + +/** @class CheckForNoChangeOrThrow + + @par Exception Safety Level: + This exception-checking policy class for ContractChecker asserts either if a + copy of the host differs from the original host object, or if an exception + occurs. Host classes can use this policy to show which member functions provide + the no-throw exception guarantee, and would never change data anyway. + + @par Requirements For Host Class: + This policy requires hosts to provide both the copy-constructor and the + equality operator, and is intended for classes with value semantics. + */ + +template < class Host > +class CheckForNoChangeOrThrow +{ +public: + + inline explicit CheckForNoChangeOrThrow( const Host * host ) : + m_compare( *host ) {} + + inline bool Check( const Host * host ) const + { + bool okay = ( !::std::uncaught_exception() ); + assert( okay ); + okay = ( m_compare == *host ); + assert( okay ); + return okay; + } + +private: + Host m_compare; +}; + +// ---------------------------------------------------------------------------- + +/** @class CheckForEquality + + @par Exception Safety Level: + This exception-checking policy class for ContractChecker asserts if a copy of the host differs from the host object regardless of whether an exception occurs. + Host classes can use this policy to show which member functions never change + data members, and thereby provide the strong exception safety level by default. + + @par Requirements For Host Class: + This policy requires hosts to provide both the copy-constructor and the + equality operator, and is intended for classes with value semantics. + */ + +template < class Host > +class CheckForEquality +{ +public: + + inline explicit CheckForEquality( const Host * host ) : + m_compare( *host ) {} + + inline bool Check( const Host * host ) const + { + const bool okay = ( m_compare == *host ); + assert( okay ); + return okay; + } + +private: + Host m_compare; +}; + +// ---------------------------------------------------------------------------- + +/** @class CheckForNothing + + @par Exception Safety Level: + This exception-checking policy class for ContractChecker does nothing when + called. Host classes can use this to show which member functions provide + neither the strong nor no-throw exception guarantees. The best guarantee such + functions can provide is that nothing gets leaked. + + @par Requirements For Host Class: + This policy imposes no requirements on a host class. + */ + +template < class Host > +class CheckForNothing +{ +public: + inline explicit CheckForNothing( const Host * ) {} + inline bool Check( const Host * ) const { return true; } +}; + +// ---------------------------------------------------------------------------- + +/** @class ContractChecker + This class determines if a function violated any class invariant, but it also + determines if a function fulfills its contract with client code. In the + "Design by Contract" paradigm, each function has certain pre-conditions and + post-conditions which may differ from the class invariants. This asserts if a + check for an invariant fails as well as if any pre- or post-condition fails. + It also demonstrate which exception safety level a function provides. + + @par Usage + -# Implement a function that checks each class invariant. The function must + have the signature similar to the Validator type. Something like: + "bool Host::IsValid( void ) const;" + - The function should return true if everything is okay, but false if + something is wrong. + - Or it could assert if anything is wrong. + - Ideally, it should be private. + -# Implement similar functions to check for pre-conditions and post-conditions. + Functions which verify pre-conditions and post-conditions do not need to + check all class invariants, just conditions specific to certain public + functions in the host class. + -# Declare some typedef's inside the class declaration like these. Make one + typedef for each exception policy you use. I typedef'ed the CheckForNothing + policy as CheckInvariants because even if a function can't provide either the + no-throw nor the no-change policies, it should still make sure the object + remains in a valid state. + - typedef ::Loki::ContractChecker< Host, ::Loki::CheckForNoThrow > CheckForNoThrow; + - typedef ::Loki::ContractChecker< Host, ::Loki::CheckForNoChange > CheckForNoChange; + - typedef ::Loki::ContractChecker< Host, ::Loki::CheckForEquality > CheckForEquality; + - typedef ::Loki::ContractChecker< Host, ::Loki::CheckForNothing > CheckInvariants; + -# Construct a checker near the top of each member function - except in the + validator member function. Pass the this pointer and the address of your + validator function into the checker's constructor. You may also pass in pointers + to function which check pre- and post-conditions. + - If the function never throws, then use the CheckForNoThrow policy. + - If the function never changes any data members, then use CheckForEquality + policy. + - If the function's normal execution flow changes data, but must make sure + data remains unchanged when any exceptions occur, then use the + CheckForNoChange policy. + - Otherwise use the CheckInvariants policy. + -# Recompile a debug version of your program, run the program and all the unit + tests, and look for which assertions failed. + */ + +template +< + class Host, + template < class > class ExceptionPolicy +> +class ContractChecker : public ExceptionPolicy< Host > +{ + /// Shorthand for the ExceptionPolicy class. + typedef ExceptionPolicy< Host > Ep; + +public: + + /// Signature for the validation function. + typedef bool ( Host:: * Validator )( void ) const; + + /** The constructor makes sure the host is valid at the time the checker + was created, thus insuring the host object was not corrupt from the start. + @par host Pointer to host object. + @par validator Pointer to function that checks class invariants. + @par pre Optional pointer to function that checks pre-conditions. + @par post Optional pointer to function that checks post-conditions. + */ + inline ContractChecker( const Host * host, Validator validator, + Validator pre = 0, Validator post = 0 ) : + Ep( host ), + m_host( host ), + m_validator( validator ), + m_pre( pre ), + m_post( post ) + { + assert( Check() ); + if ( 0 != m_pre ) + assert( ( m_host->*( m_pre ) )() ); + } + + /** The destructor checks if any Host invariants failed, and then calls the + ExceptionPolicy's Check function to determine what to do in case of an + exception. + */ + inline ~ContractChecker( void ) + { + assert( Check() ); + if ( 0 != m_post ) + assert( ( m_host->*( m_post ) )() ); + assert( Ep::Check( m_host ) ); + } + + /** This first checks the invariants for ContractChecker, and then calls the + validator function for the host to make sure no class invariants were + broken by the host within the Host's member function body. The host + member function can call Check directly to verify the object remains valid + at any time. This does not care if the pre- and post-condition validator + pointers are null since a host class may pass in NULL pointers for either + to indicate the pre-conditions or post-conditions are the same as the + overall class invariants. + */ + inline bool Check( void ) const + { + assert( 0 != this ); + assert( 0 != m_host ); + assert( 0 != m_validator ); + // Now that this confirms the pointers to the host and validation + // functions are not null, go ahead and validate the host object. + const bool okay = ( m_host->*( m_validator ) )(); + assert( okay ); + return okay; + } + +private: + + /// Default constructor is not implemented. + ContractChecker( void ); + /// Copy constructor is not implemented. + ContractChecker( const ContractChecker & ); + /// Copy-assignment operator is not implemented. + ContractChecker & operator = ( const ContractChecker & ); + + /// Pointer to the host object. + const Host * m_host; + + /// Pointer to member function that checks Host object's invariants. + Validator m_validator; + + /// Pointer to member function that checks Host object's pre-conditions. + Validator m_pre; + + /// Pointer to member function that checks Host object's post-conditions. + Validator m_post; + +}; + +// ---------------------------------------------------------------------------- + +/** @class CheckStaticForNoThrow + + @par Exception Safety Level: + This exception-checking policy class for StaticChecker asserts if an exception + exists. Functions can use this to show they provide the no-throw exception + safety guarantee. + */ +class CheckStaticForNoThrow +{ +public: + inline bool Check( void ) + { + const bool okay = !::std::uncaught_exception(); + assert( okay ); + return okay; + } +}; + +// ---------------------------------------------------------------------------- + +/** @class CheckStaticForNothing + + @par Exception Safety Level: + This exception-checking policy class for StaticChecker does nothing when called. + Functions can use this to show they might provide the weak exception guarantee. + The best guarantee such functions can provide is that nothing gets leaked. + */ +class CheckStaticForNothing +{ +public: + inline bool Check( void ) { return true; } +}; + +// ---------------------------------------------------------------------------- + +/** @class StaticChecker + This class checks if a function provides the no-throw exception safety level + and if the function violated any invariants. Invariants for stand-alone and + static functions act as pre-conditions and post-conditions. + + @par Usage + -# Implement a function that checks the invariants associated with a function, + or with the static data for a class. The function must + have the signature similar to the Validator type. Something like: + "static bool Host::StaticIsValid( void );" or "bool IsOkay( void );" + - The function should return true if everything is okay, but false if + something is wrong. + - Or it could assert if anything is wrong. + -# If the checker is for static functions within a class, declare typedef's + inside the class declaration like these. Make one typedef for each policy + you use. I typedef'ed the CheckForNothing policy as CheckInvariants because + even if a function can't provide the no-throw guarantee, it should still + make sure that static data remains in a valid state. + - typedef ::Loki::StaticChecker< ::Loki::CheckForNoThrow > CheckStaticForNoThrow; + - typedef ::Loki::StaticChecker< ::Loki::CheckForNothing > CheckStaticInvariants; + -# Construct a checker near the top of each member function - except in the + validator member function. Pass the address of your validator function into + the checker's constructor. + - If the function never throws, then use the CheckForNoThrow policy. + - Otherwise use the CheckInvariants policy. + -# Recompile a debug version of your program, run it, and see if an assertion + fails. + */ + +template +< + class ExceptionPolicy +> +class StaticChecker : public ExceptionPolicy +{ + /// Shorthand for the ExceptionPolicy class. + typedef ExceptionPolicy Ep; + +public: + + /// Signature for the validation function. + typedef bool ( * Validator )( void ); + + /** The constructor makes sure the host is valid at the time the checker + was created, thus insuring the host object was not corrupt from the start. + @par validator Pointer to function that checks class invariants. + @par pre Optional pointer to function that checks pre-conditions. + @par post Optional pointer to function that checks post-conditions. + */ + inline explicit StaticChecker( Validator validator, + Validator pre = 0, Validator post = 0 ) : + Ep(), + m_validator( validator ), + m_pre( pre ), + m_post( post ) + { + assert( Check() ); + if ( 0 != m_pre ) + assert( m_pre() ); + } + + /** The destructor checks if any Host invariants failed, and then calls the + ExceptionPolicy's Check function to determine what to do in case of an + exception. + */ + inline ~StaticChecker( void ) + { + assert( Check() ); + if ( 0 != m_post ) + assert( m_post() ); + assert( Ep::Check() ); + } + + /** This first checks its own invariants, and then calls the validator + function to make sure no invariants were broken by the function which + created this checker. That function can call Check directly to verify the + data remains valid at any time. This does not care if the pre- and post- + condition validator pointers are null since a host class may pass in NULL + pointers for either to indicate the pre-conditions or post-conditions are + the same as the overall class invariants. + */ + inline bool Check( void ) const + { + assert( 0 != this ); + assert( 0 != m_validator ); + // Now that this confirms the pointers to the host and validation + // functions are not null, go ahead and validate the host object. + const bool okay = m_validator(); + assert( okay ); + return okay; + } + +private: + + /// Default constructor is not implemented. + StaticChecker( void ); + /// Copy constructor is not implemented. + StaticChecker( const StaticChecker & ); + /// Copy-assignment operator is not implemented. + StaticChecker & operator = ( const StaticChecker & ); + + /// Pointer to member function that checks Host object's invariants. + Validator m_validator; + + /// Pointer to member function that checks Host object's pre-conditions. + Validator m_pre; + + /// Pointer to member function that checks Host object's post-conditions. + Validator m_post; + +}; + +// ---------------------------------------------------------------------------- + +}; // end namespace Loki + +#endif diff --git a/shared/loki/ConstPolicy.h b/shared/loki/ConstPolicy.h new file mode 100644 index 00000000..74c9e5aa --- /dev/null +++ b/shared/loki/ConstPolicy.h @@ -0,0 +1,61 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 Richard Sposato +// Copyright (c) 2006 Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The authors make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_CONST_POLICY_INC_ +#define LOKI_CONST_POLICY_INC_ + +// $Id: ConstPolicy.h 769 2006-10-26 10:58:19Z syntheticpp $ + + +namespace Loki +{ + +//////////////////////////////////////////////////////////////////////////////// +/// @note These policy classes are used in LockingPtr and SmartPtr to define +/// how const is propagated from the pointee. +//////////////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////////////// +/// \class DontPropagateConst +/// +/// \ingroup ConstGroup +/// Don't propagate constness of pointed or referred object. +//////////////////////////////////////////////////////////////////////////////// + + template< class T > + struct DontPropagateConst + { + typedef T Type; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class PropagateConst +/// +/// \ingroup ConstGroup +/// Propagate constness of pointed or referred object. +//////////////////////////////////////////////////////////////////////////////// + + template< class T > + struct PropagateConst + { + typedef const T Type; + }; + +// default will not break existing code +#ifndef LOKI_DEFAULT_CONSTNESS +#define LOKI_DEFAULT_CONSTNESS ::Loki::DontPropagateConst +#endif + +} // end namespace Loki + +#endif // end file guardian diff --git a/shared/loki/DataGenerators.h b/shared/loki/DataGenerators.h new file mode 100644 index 00000000..1c8e2df0 --- /dev/null +++ b/shared/loki/DataGenerators.h @@ -0,0 +1,113 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Data Generator by Shannon Barber +// This code DOES NOT accompany the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// +// Code covered by the MIT License +// The author makes no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_DATAGENERATORS_INC_ +#define LOKI_DATAGENERATORS_INC_ + +// $Id: DataGenerators.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +#include "Typelist.h" + +//Reference version + +/************************************************************************************ +// class template GenData +// Iteratates a Typelist, and invokes the functor GenFunc<T> +// for each type in the list, passing a functor along the way. +// The functor is designed to be an insertion iterator which GenFunc<T> +// can use to output information about the types in the list. +// + +Example Use + +template<typename T> +struct ExtractDataType + { + some_type operator()() + { + return create_value_from_type<T>; + } + }; + +Loki::IterateTypes<parameter_tl, ExtractDataType> gendata; +std::vector<some_type> stuff; +gendata(std::back_inserter(stuff)); +*******************************************************************************/ +namespace Loki +{ + namespace TL + { + template<typename T> + struct nameof_type + { + const char* operator()() + { + return typeid(T).name(); + } + }; + template<typename T> + struct sizeof_type + { + size_t operator()() + { + return sizeof(T); + } + }; + template <class TList, template <class> class GenFunc> + struct IterateTypes; + + template <class T1, class T2, template <class> class GenFunc> + struct IterateTypes<Typelist<T1, T2>, GenFunc> + { + typedef IterateTypes<T1, GenFunc> head_t; + head_t head; + typedef IterateTypes<T2, GenFunc> tail_t; + tail_t tail; + template<class II> + void operator()(II ii) + { + head.operator()(ii); + tail.operator()(ii); + } + }; + + template <class AtomicType, template <class> class GenFunc> + struct IterateTypes + { + template<class II> + void operator()(II ii) + { + GenFunc<AtomicType> genfunc; + *ii = genfunc(); + ++ii; //Is this even needed? + } + }; + + template <template <class> class GenFunc> + struct IterateTypes<NullType, GenFunc> + { + template<class II> + void operator()(II ii) + {} + }; + + template<typename Types, template <class> class UnitFunc, typename II> + void iterate_types(II ii) + { + Loki::TL::IterateTypes<Types, UnitFunc> it; + it(ii); + } + }//ns TL +}//ns Loki + +#endif // end file guardian + diff --git a/shared/loki/EmptyType.h b/shared/loki/EmptyType.h new file mode 100644 index 00000000..b228e2e8 --- /dev/null +++ b/shared/loki/EmptyType.h @@ -0,0 +1,49 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_EMPTYTYPE_INC_ +#define LOKI_EMPTYTYPE_INC_ + +// $Id: EmptyType.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class EmptyType +// Used as a class type that doesn't hold anything +// Useful as a strawman class +//////////////////////////////////////////////////////////////////////////////// + + class EmptyType {}; + + + inline bool operator==(const EmptyType&, const EmptyType&) + { + return true; + } + + inline bool operator<(const EmptyType&, const EmptyType&) + { + return false; + } + + inline bool operator>(const EmptyType&, const EmptyType&) + { + return false; + } +} + +#endif // end file guardian + diff --git a/shared/loki/Factory.h b/shared/loki/Factory.h new file mode 100644 index 00000000..c4c3b22a --- /dev/null +++ b/shared/loki/Factory.h @@ -0,0 +1,1084 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// Copyright (c) 2005 by Peter Kuemmel +// This code DOES NOT accompany the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// +// Code covered by the MIT License +// The authors make no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_FACTORYPARM_INC_ +#define LOKI_FACTORYPARM_INC_ + +// $Id: Factory.h 788 2006-11-24 22:30:54Z clitte_bbt $ + + +#include "LokiTypeInfo.h" +#include "Functor.h" +#include "AssocVector.h" +#include "SmallObj.h" +#include "Sequence.h" + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable: 4702) +//unreachable code if OnUnknownType throws an exception +#endif + +/** + * \defgroup FactoriesGroup Factories + * \defgroup FactoryGroup Factory + * \ingroup FactoriesGroup + * \brief Implements a generic object factory. + * + * <i>The Factory Method pattern is an object-oriented design pattern. + * Like other creational patterns, it deals with the problem of creating objects + * (products) without specifying the exact class of object that will be created. + * Factory Method, one of the patterns from the Design Patterns book, handles + * this problem by defining a separate method for creating the objects, which + * subclasses can then override to specify the derived type of product that will + * be created. + * <br> + * More generally, the term Factory Method is often used to refer to any method + * whose main purpose is creation of objects.</i> + * <div ALIGN="RIGHT"><a href="http://en.wikipedia.org/wiki/Factory_method_pattern"> + * Wikipedia</a></div> + * + * Loki proposes a generic version of the Factory. Here is a typical use.<br> + * <code><br> + * 1. Factory< AbstractProduct, int > aFactory;<br> + * 2. aFactory.Register( 1, createProductNull );<br> + * 3. aFactory.CreateObject( 1 ); <br> + * </code><br> + * <br> + * - 1. The declaration<br> + * You want a Factory that produces AbstractProduct.<br> + * The client will refer to a creation method through an int.<br> + * - 2.The registration<br> + * The code that will contribute to the Factory will now need to declare its + * ProductCreator by registering them into the Factory.<br> + * A ProductCreator is a just a function that will return the right object. ie <br> + * <code> + * Product* createProductNull()<br> + * {<br> + * return new Product<br> + * }<br> + * </code><br> + * - 3. The use<br> + * Now the client can create object by calling the Factory's CreateObject method + * with the right identifier. If the ProductCreator were to have arguments + * (<i>ie :Product* createProductParm( int a, int b )</i>) + */ + +namespace Loki +{ + +/** + * \defgroup FactoryErrorPoliciesGroup Factory Error Policies + * \ingroup FactoryGroup + * \brief Manages the "Unknown Type" error in an object factory + * + * \class DefaultFactoryError + * \ingroup FactoryErrorPoliciesGroup + * \brief Default policy that throws an exception + * + */ + + template <typename IdentifierType, class AbstractProduct> + struct DefaultFactoryError + { + struct Exception : public std::exception + { + const char* what() const throw() { return "Unknown Type"; } + }; + + static AbstractProduct* OnUnknownType(IdentifierType) + { + throw Exception(); + } + }; + + +#define LOKI_ENABLE_NEW_FACTORY_CODE +#ifdef LOKI_ENABLE_NEW_FACTORY_CODE + + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +//////////////////////////////////////////////////////////////////////////////// + + struct FactoryImplBase + { + typedef EmptyType Parm1; + typedef EmptyType Parm2; + typedef EmptyType Parm3; + typedef EmptyType Parm4; + typedef EmptyType Parm5; + typedef EmptyType Parm6; + typedef EmptyType Parm7; + typedef EmptyType Parm8; + typedef EmptyType Parm9; + typedef EmptyType Parm10; + typedef EmptyType Parm11; + typedef EmptyType Parm12; + typedef EmptyType Parm13; + typedef EmptyType Parm14; + typedef EmptyType Parm15; + }; + + template <typename AP, typename Id, typename TList > + struct FactoryImpl; + + template<typename AP, typename Id> + struct FactoryImpl<AP, Id, NullType> + : public FactoryImplBase + { + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id & id ) = 0; + }; +template <typename AP, typename Id, typename P1 > + struct FactoryImpl<AP,Id, Seq<P1> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1 ) = 0; + }; + + template<typename AP, typename Id, typename P1,typename P2 > + struct FactoryImpl<AP, Id, Seq<P1, P2> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2 ) = 0; + }; + + template<typename AP, typename Id, typename P1,typename P2,typename P3 > + struct FactoryImpl<AP, Id, Seq<P1, P2, P3> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3 ) = 0; + }; + + template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 > + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4 ) = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5 > + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6 ) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7 ) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11,Parm12) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12,typename P13> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11,Parm12,Parm13) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12,typename P13,typename P14> + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm8,Parm10, + Parm11,Parm12,Parm13,Parm14) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12,typename P13,typename P14,typename P15 > + struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> > + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + typedef typename TypeTraits<P15>::ParameterType Parm15; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11,Parm12,Parm13,Parm14,Parm15 ) + = 0; + }; + +#ifndef LOKI_DISABLE_TYPELIST_MACROS + + template <typename AP, typename Id, typename P1 > + struct FactoryImpl<AP,Id, LOKI_TYPELIST_1( P1 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1 ) = 0; + }; + + template<typename AP, typename Id, typename P1,typename P2 > + struct FactoryImpl<AP, Id, LOKI_TYPELIST_2( P1, P2 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2 ) = 0; + }; + + template<typename AP, typename Id, typename P1,typename P2,typename P3 > + struct FactoryImpl<AP, Id, LOKI_TYPELIST_3( P1, P2, P3 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3 ) = 0; + }; + + template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 > + struct FactoryImpl<AP, Id, LOKI_TYPELIST_4( P1, P2, P3, P4 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4 ) = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5 > + struct FactoryImpl<AP, Id, LOKI_TYPELIST_5( P1, P2, P3, P4, P5 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_6( P1, P2, P3, P4, P5, P6 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6 ) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_7( P1, P2, P3, P4, P5, P6, P7 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7 ) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_8( P1, P2, P3, P4, P5, P6, P7, P8 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_9( P1, P2, P3, P4, P5, P6, P7, P8, P9 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_10( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_11( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_12( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11,Parm12) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12,typename P13> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_13( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11,Parm12,Parm13) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12,typename P13,typename P14> + struct FactoryImpl<AP, Id, LOKI_TYPELIST_14( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm8,Parm10, + Parm11,Parm12,Parm13,Parm14) + = 0; + }; + + template<typename AP, typename Id, + typename P1,typename P2,typename P3,typename P4,typename P5, + typename P6,typename P7,typename P8,typename P9,typename P10, + typename P11,typename P12,typename P13,typename P14,typename P15 > + struct FactoryImpl<AP, Id, LOKI_TYPELIST_15( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 )> + : public FactoryImplBase + { + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + typedef typename TypeTraits<P15>::ParameterType Parm15; + virtual ~FactoryImpl() {} + virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5, + Parm6, Parm7, Parm8, Parm9,Parm10, + Parm11,Parm12,Parm13,Parm14,Parm15 ) + = 0; + }; + +#endif //LOKI_DISABLE_TYPELIST_MACROS + + +//////////////////////////////////////////////////////////////////////////////// +/// \class Factory +/// +/// \ingroup FactoryGroup +/// Implements a generic object factory. +/// +/// Create functions can have up to 15 parameters. +/// +/// \par Singleton lifetime when used with Loki::SingletonHolder +/// Because Factory uses internally Functors which inherits from +/// SmallObject you must use the singleton lifetime +/// \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode +/// Alternatively you could suppress for Functor the inheritance +/// from SmallObject by defining the macro: +/// \code LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT \endcode +//////////////////////////////////////////////////////////////////////////////// + template + < + class AbstractProduct, + typename IdentifierType, + typename CreatorParmTList = NullType, + template<typename, class> class FactoryErrorPolicy = DefaultFactoryError + > + class Factory : public FactoryErrorPolicy<IdentifierType, AbstractProduct> + { + typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl; + + typedef typename Impl::Parm1 Parm1; + typedef typename Impl::Parm2 Parm2; + typedef typename Impl::Parm3 Parm3; + typedef typename Impl::Parm4 Parm4; + typedef typename Impl::Parm5 Parm5; + typedef typename Impl::Parm6 Parm6; + typedef typename Impl::Parm7 Parm7; + typedef typename Impl::Parm8 Parm8; + typedef typename Impl::Parm9 Parm9; + typedef typename Impl::Parm10 Parm10; + typedef typename Impl::Parm11 Parm11; + typedef typename Impl::Parm12 Parm12; + typedef typename Impl::Parm13 Parm13; + typedef typename Impl::Parm14 Parm14; + typedef typename Impl::Parm15 Parm15; + + typedef Functor<AbstractProduct*, CreatorParmTList> ProductCreator; + + typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap; + + IdToProductMap associations_; + + public: + + Factory() + : associations_() + { + } + + ~Factory() + { + associations_.erase(associations_.begin(), associations_.end()); + } + + bool Register(const IdentifierType& id, ProductCreator creator) + { + return associations_.insert( + typename IdToProductMap::value_type(id, creator)).second != 0; + } + + template <class PtrObj, typename CreaFn> + bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn) + { + ProductCreator creator( p, fn ); + return associations_.insert( + typename IdToProductMap::value_type(id, creator)).second != 0; + } + + bool Unregister(const IdentifierType& id) + { + return associations_.erase(id) != 0; + } + + std::vector<IdentifierType> RegisteredIds() + { + std::vector<IdentifierType> ids; + for(typename IdToProductMap::iterator it = associations_.begin(); + it != associations_.end(); ++it) + { + ids.push_back(it->first); + } + return ids; + } + + AbstractProduct* CreateObject(const IdentifierType& id) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7 ) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9 ); + return this->OnUnknownType(id); + } + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9,Parm10 p10) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12, Parm13 p13) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14 ); + return this->OnUnknownType(id); + } + + AbstractProduct* CreateObject(const IdentifierType& id, + Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, + Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15 ); + return this->OnUnknownType(id); + } + + }; + +#else + + template + < + class AbstractProduct, + typename IdentifierType, + typename ProductCreator = AbstractProduct* (*)(), + template<typename, class> + class FactoryErrorPolicy = DefaultFactoryError + > + class Factory + : public FactoryErrorPolicy<IdentifierType, AbstractProduct> + { + public: + bool Register(const IdentifierType& id, ProductCreator creator) + { + return associations_.insert( + typename IdToProductMap::value_type(id, creator)).second != 0; + } + + bool Unregister(const IdentifierType& id) + { + return associations_.erase(id) != 0; + } + + AbstractProduct* CreateObject(const IdentifierType& id) + { + typename IdToProductMap::iterator i = associations_.find(id); + if (i != associations_.end()) + { + return (i->second)(); + } + return this->OnUnknownType(id); + } + + private: + typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap; + IdToProductMap associations_; + }; + +#endif //#define ENABLE_NEW_FACTORY_CODE + +/** + * \defgroup CloneFactoryGroup Clone Factory + * \ingroup FactoriesGroup + * \brief Creates a copy from a polymorphic object. + * + * \class CloneFactory + * \ingroup CloneFactoryGroup + * \brief Creates a copy from a polymorphic object. + */ + + template + < + class AbstractProduct, + class ProductCreator = + AbstractProduct* (*)(const AbstractProduct*), + template<typename, class> + class FactoryErrorPolicy = DefaultFactoryError + > + class CloneFactory + : public FactoryErrorPolicy<TypeInfo, AbstractProduct> + { + public: + bool Register(const TypeInfo& ti, ProductCreator creator) + { + return associations_.insert( + typename IdToProductMap::value_type(ti, creator)).second != 0; + } + + bool Unregister(const TypeInfo& id) + { + return associations_.erase(id) != 0; + } + + AbstractProduct* CreateObject(const AbstractProduct* model) + { + if (model == NULL) + { + return NULL; + } + + typename IdToProductMap::iterator i = + associations_.find(typeid(*model)); + + if (i != associations_.end()) + { + return (i->second)(model); + } + return this->OnUnknownType(typeid(*model)); + } + + private: + typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap; + IdToProductMap associations_; + }; + +} // namespace Loki + + +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + +#endif // end file guardian + diff --git a/shared/loki/Function.h b/shared/loki/Function.h new file mode 100644 index 00000000..2d0ad4bb --- /dev/null +++ b/shared/loki/Function.h @@ -0,0 +1,373 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2005 Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_FUNCTION_INC_ +#define LOKI_FUNCTION_INC_ + +// $Id: Function.h 841 2008-03-24 23:58:28Z rich_sposato $ + + +#define LOKI_ENABLE_FUNCTION + +#include <stdexcept> + +#include <loki/Functor.h> +#include <loki/Sequence.h> + +namespace Loki +{ + + //////////////////////////////////////////////////////////////////////////////// + /// \struct Function + /// + /// \ingroup FunctorGroup + /// Allows a boost/TR1 like usage of Functor. + /// + /// \par Usage + /// + /// - free functions: e.g. \code Function<int(int,int)> f(&freeFunction); + /// \endcode + /// - member functions: e.g \code Function<int()> f(&object,&ObjectType::memberFunction); + /// \endcode + /// + /// see also test/Function/FunctionTest.cpp (the modified test program from boost) + //////////////////////////////////////////////////////////////////////////////// + + template<class R = void()> + struct Function; + + + template<class R> + struct Function<R()> : public Functor<R> + { + typedef Functor<R> FBase; + + Function() : FBase() {} + + Function(const Function& func) : FBase() + { + if( !func.empty()) + FBase::operator=(func); + } + + // test on emptiness + template<class R2> + Function(Function<R2()> func) : FBase() + { + if(!func.empty()) + FBase::operator=(func); + } + + // clear by '= 0' + Function(const int i) : FBase() + { + if(i==0) + FBase::clear(); + else + throw std::runtime_error("Loki::Function(const int i): i!=0"); + } + + template<class Func> + Function(Func func) : FBase(func) {} + + template<class Host, class Func> + Function(const Host& host, const Func& func) : FBase(host,func) {} + + }; + + +//////////////////////////////////////////////////////////////////////////////// +// macros for the repetitions +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_FUNCTION_BODY \ + \ + Function() : FBase() {} \ + \ + Function(const Function& func) : FBase() \ + { \ + if( !func.empty()) \ + FBase::operator=(func); \ + } \ + \ + Function(const int i) : FBase() \ + { \ + if(i==0) \ + FBase::clear(); \ + else \ + throw std::runtime_error( \ + "Loki::Function(const int i): i!=0"); \ + } \ + \ + template<class Func> \ + Function(Func func) : FBase(func) {} \ + \ + template<class Host, class Func> \ + Function(const Host& host, const Func& func): FBase(host,func) {} + + +#define LOKI_FUNCTION_R2_CTOR_BODY \ + \ + : FBase() \ + { \ + if(!func.empty()) \ + FBase::operator=(func); \ + } + + +//////////////////////////////////////////////////////////////////////////////// +// repetitions +//////////////////////////////////////////////////////////////////////////////// + + template<> + struct Function<> + : public Loki::Functor<> + { + typedef Functor<> FBase; + + template<class R2> + Function(Function<R2()> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY // if compilation breaks here then + // Function.h was not included before + // Functor.h, check your include order + // or define LOKI_ENABLE_FUNCTION + }; + + template<class R,class P01> + struct Function<R(P01)> + : public Loki::Functor<R, Seq<P01> > + { + typedef Functor<R, Seq<P01> > FBase; + + template<class R2,class Q01> + Function(Function<R2(Q01)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R,class P01,class P02> + struct Function<R(P01,P02)> + : public Functor<R, Seq<P01,P02> > + { + typedef Functor<R, Seq<P01,P02> > FBase; + + template<class R2,class Q01, class Q02> + Function(Function<R2(Q01,Q02)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R,class P01,class P02, class P03> + struct Function<R(P01,P02,P03)> + : public Functor<R, Seq<P01,P02,P03> > + { + typedef Functor<R, Seq<P01,P02,P03> > FBase; + + template<class R2,class Q01, class Q02,class Q03> + Function(Function<R2(Q01,Q02,Q03)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R,class P01,class P02, class P03,class P04> + struct Function<R(P01,P02,P03,P04)> + : public Functor<R, Seq<P01,P02,P03,P04> > + { + typedef Functor<R, Seq<P01,P02,P03,P04> > FBase; + + template<class R2,class Q01,class Q02, class Q03,class Q04> + Function(Function<R2(Q01,Q02,Q03,Q04)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R,class P01,class P02, class P03,class P04,class P05> + struct Function<R(P01,P02,P03,P04,P05)> + : public Functor<R, Seq<P01,P02,P03,P04,P05> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05> > FBase; + + template<class R2,class Q01,class Q02, class Q03,class Q04,class Q05> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06> + struct Function<R(P01,P02,P03,P04,P05,P06)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07> + struct Function<R(P01,P02,P03,P04,P05,P06,P07)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09 > > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09,class P10> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09,class Q10> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09,class P10, + class P11> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11> >FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09,class Q10, + class Q11> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09,class P10, + class P11,class P12> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09,class Q10, + class Q11,class Q12> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09,class P10, + class P11,class P12, class P13> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09,class Q10, + class Q11,class Q12, class Q13> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09,class P10, + class P11,class P12, class P13,class P14> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14> > FBase; + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09,class Q10, + class Q11,class Q12, class Q13,class Q14> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13,Q14)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + + template<class R, class P01,class P02, class P03,class P04,class P05, + class P06,class P07, class P08,class P09,class P10, + class P11,class P12, class P13,class P14,class P15> + struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15)> + : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15> > + { + typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15> > FBase; + + template<class R2, class Q01,class Q02, class Q03,class Q04,class Q05, + class Q06,class Q07, class Q08,class Q09,class Q10, + class Q11,class Q12, class Q13,class Q14,class Q15> + Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13,Q14,Q15)> func) + LOKI_FUNCTION_R2_CTOR_BODY + + LOKI_FUNCTION_BODY + }; + +}// namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/Functor.h b/shared/loki/Functor.h new file mode 100644 index 00000000..bcba855d --- /dev/null +++ b/shared/loki/Functor.h @@ -0,0 +1,1789 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_FUNCTOR_INC_ +#define LOKI_FUNCTOR_INC_ + +// $Id: Functor.h 750 2006-10-17 19:50:02Z syntheticpp $ + + +#include "Typelist.h" +#include "Sequence.h" +#include "EmptyType.h" +#include "SmallObj.h" +#include "TypeTraits.h" +#include <typeinfo> +#include <memory> + +/// \defgroup FunctorGroup Function objects + +#ifndef LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT +//#define LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT +#endif + +#ifndef LOKI_FUNCTORS_ARE_COMPARABLE +//#define LOKI_FUNCTORS_ARE_COMPARABLE +#endif + + +/// \namespace Loki +/// All classes of Loki are in the Loki namespace +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl (internal) +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <typename R, template <class, class> class ThreadingModel> + struct FunctorImplBase +#ifdef LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT + { +#else + : public SmallValueObject<ThreadingModel> + { + inline FunctorImplBase() : + SmallValueObject<ThreadingModel>() {} + inline FunctorImplBase(const FunctorImplBase&) : + SmallValueObject<ThreadingModel>() {} +#endif + + typedef R ResultType; + typedef FunctorImplBase<R, ThreadingModel> FunctorImplBaseType; + + typedef EmptyType Parm1; + typedef EmptyType Parm2; + typedef EmptyType Parm3; + typedef EmptyType Parm4; + typedef EmptyType Parm5; + typedef EmptyType Parm6; + typedef EmptyType Parm7; + typedef EmptyType Parm8; + typedef EmptyType Parm9; + typedef EmptyType Parm10; + typedef EmptyType Parm11; + typedef EmptyType Parm12; + typedef EmptyType Parm13; + typedef EmptyType Parm14; + typedef EmptyType Parm15; + + + virtual ~FunctorImplBase() + {} + + virtual FunctorImplBase* DoClone() const = 0; + + template <class U> + static U* Clone(U* pObj) + { + if (!pObj) return 0; + U* pClone = static_cast<U*>(pObj->DoClone()); + assert(typeid(*pClone) == typeid(*pObj)); + return pClone; + } + + +#ifdef LOKI_FUNCTORS_ARE_COMPARABLE + + virtual bool operator==(const FunctorImplBase&) const = 0; + +#endif + + }; + } + +//////////////////////////////////////////////////////////////////////////////// +// macro LOKI_DEFINE_CLONE_FUNCTORIMPL +// Implements the DoClone function for a functor implementation +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_DEFINE_CLONE_FUNCTORIMPL(Cls) \ + virtual Cls* DoClone() const { return new Cls(*this); } + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// The base class for a hierarchy of functors. The FunctorImpl class is not used +// directly; rather, the Functor class manages and forwards to a pointer to +// FunctorImpl +// You may want to derive your own functors from FunctorImpl. +// Specializations of FunctorImpl for up to 15 parameters follow +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, class TList, + template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL> + class FunctorImpl; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 0 (zero) parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, template <class, class> class ThreadingModel> + class FunctorImpl<R, NullType, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + virtual R operator()() = 0; + }; + + //////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 1 parameter +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + virtual R operator()(Parm1) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 2 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + virtual R operator()(Parm1, Parm2) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 3 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + virtual R operator()(Parm1, Parm2, Parm3) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 4 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 5 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4, P5>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 6 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 7 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7>, ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 8 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7, P8>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 9 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 10 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, + template <class, class> class ThreadingModel> + class FunctorImpl<R, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 11 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 12 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 13 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, typename P13, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 14 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, typename P13, typename P14, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, + P14>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 15 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, typename P13, typename P14, + typename P15, template <class, class> class ThreadingModel> + class FunctorImpl<R, + Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, + P14, P15>, + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + typedef typename TypeTraits<P15>::ParameterType Parm15; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14, + Parm15) = 0; + }; + +#ifndef LOKI_DISABLE_TYPELIST_MACROS + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 1 parameter +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_1(P1), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + virtual R operator()(Parm1) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 2 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_2(P1, P2), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + virtual R operator()(Parm1, Parm2) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 3 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_3(P1, P2, P3), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + virtual R operator()(Parm1, Parm2, Parm3) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 4 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_4(P1, P2, P3, P4), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + virtual R operator()(Parm1, Parm2, Parm3, Parm4) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 5 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_5(P1, P2, P3, P4, P5), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 6 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_6(P1, P2, P3, P4, P5, P6), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 7 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_7(P1, P2, P3, P4, P5, P6, P7), ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 8 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_8(P1, P2, P3, P4, P5, P6, P7, P8), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 9 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_9(P1, P2, P3, P4, P5, P6, P7, P8, P9), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 10 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, + template <class, class> class ThreadingModel> + class FunctorImpl<R, LOKI_TYPELIST_10(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 11 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + LOKI_TYPELIST_11(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 12 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + LOKI_TYPELIST_12(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 13 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, typename P13, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + LOKI_TYPELIST_13(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 14 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, typename P13, typename P14, + template <class, class> class ThreadingModel> + class FunctorImpl<R, + LOKI_TYPELIST_14(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, + P14), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorImpl +// Specialization for 15 parameters +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, typename P1, typename P2, typename P3, typename P4, + typename P5, typename P6, typename P7, typename P8, typename P9, + typename P10, typename P11, typename P12, typename P13, typename P14, + typename P15, template <class, class> class ThreadingModel> + class FunctorImpl<R, + LOKI_TYPELIST_15(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, + P14, P15), + ThreadingModel> + : public Private::FunctorImplBase<R, ThreadingModel> + { + public: + typedef R ResultType; + typedef typename TypeTraits<P1>::ParameterType Parm1; + typedef typename TypeTraits<P2>::ParameterType Parm2; + typedef typename TypeTraits<P3>::ParameterType Parm3; + typedef typename TypeTraits<P4>::ParameterType Parm4; + typedef typename TypeTraits<P5>::ParameterType Parm5; + typedef typename TypeTraits<P6>::ParameterType Parm6; + typedef typename TypeTraits<P7>::ParameterType Parm7; + typedef typename TypeTraits<P8>::ParameterType Parm8; + typedef typename TypeTraits<P9>::ParameterType Parm9; + typedef typename TypeTraits<P10>::ParameterType Parm10; + typedef typename TypeTraits<P11>::ParameterType Parm11; + typedef typename TypeTraits<P12>::ParameterType Parm12; + typedef typename TypeTraits<P13>::ParameterType Parm13; + typedef typename TypeTraits<P14>::ParameterType Parm14; + typedef typename TypeTraits<P15>::ParameterType Parm15; + virtual R operator()(Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, + Parm7, Parm8, Parm9, Parm10, Parm11, Parm12, Parm13, Parm14, + Parm15) = 0; + }; + +#endif //LOKI_DISABLE_TYPELIST_MACROS + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorHandler +// Wraps functors and pointers to functions +//////////////////////////////////////////////////////////////////////////////// + + template <class ParentFunctor, typename Fun> + class FunctorHandler + : public ParentFunctor::Impl + { + typedef typename ParentFunctor::Impl Base; + + public: + typedef typename Base::ResultType ResultType; + typedef typename Base::Parm1 Parm1; + typedef typename Base::Parm2 Parm2; + typedef typename Base::Parm3 Parm3; + typedef typename Base::Parm4 Parm4; + typedef typename Base::Parm5 Parm5; + typedef typename Base::Parm6 Parm6; + typedef typename Base::Parm7 Parm7; + typedef typename Base::Parm8 Parm8; + typedef typename Base::Parm9 Parm9; + typedef typename Base::Parm10 Parm10; + typedef typename Base::Parm11 Parm11; + typedef typename Base::Parm12 Parm12; + typedef typename Base::Parm13 Parm13; + typedef typename Base::Parm14 Parm14; + typedef typename Base::Parm15 Parm15; + + FunctorHandler(const Fun& fun) : f_(fun) {} + + LOKI_DEFINE_CLONE_FUNCTORIMPL(FunctorHandler) + + +#ifdef LOKI_FUNCTORS_ARE_COMPARABLE + + + bool operator==(const typename Base::FunctorImplBaseType& rhs) const + { + // there is no static information if Functor holds a member function + // or a free function; this is the main difference to tr1::function + if(typeid(*this) != typeid(rhs)) + return false; // cannot be equal + + const FunctorHandler& fh = static_cast<const FunctorHandler&>(rhs); + // if this line gives a compiler error, you are using a function object. + // you need to implement bool MyFnObj::operator == (const MyFnObj&) const; + return f_==fh.f_; + } +#endif + // operator() implementations for up to 15 arguments + + ResultType operator()() + { return f_(); } + + ResultType operator()(Parm1 p1) + { return f_(p1); } + + ResultType operator()(Parm1 p1, Parm2 p2) + { return f_(p1, p2); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) + { return f_(p1, p2, p3); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) + { return f_(p1, p2, p3, p4); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) + { return f_(p1, p2, p3, p4, p5); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) + { return f_(p1, p2, p3, p4, p5, p6); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7) + { return f_(p1, p2, p3, p4, p5, p6, p7); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) + { return f_(p1, p2, p3, p4, p5, p6, p7, p8); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) + { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) + { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) + { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12) + { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13) + { return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14) + { + return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) + { + return f_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14, p15); + } + + private: + Fun f_; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorHandler +// Wraps pointers to member functions +//////////////////////////////////////////////////////////////////////////////// + + template <class ParentFunctor, typename PointerToObj, + typename PointerToMemFn> + class MemFunHandler : public ParentFunctor::Impl + { + typedef typename ParentFunctor::Impl Base; + + public: + typedef typename Base::ResultType ResultType; + typedef typename Base::Parm1 Parm1; + typedef typename Base::Parm2 Parm2; + typedef typename Base::Parm3 Parm3; + typedef typename Base::Parm4 Parm4; + typedef typename Base::Parm5 Parm5; + typedef typename Base::Parm6 Parm6; + typedef typename Base::Parm7 Parm7; + typedef typename Base::Parm8 Parm8; + typedef typename Base::Parm9 Parm9; + typedef typename Base::Parm10 Parm10; + typedef typename Base::Parm11 Parm11; + typedef typename Base::Parm12 Parm12; + typedef typename Base::Parm13 Parm13; + typedef typename Base::Parm14 Parm14; + typedef typename Base::Parm15 Parm15; + + MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn) + : pObj_(pObj), pMemFn_(pMemFn) + {} + + LOKI_DEFINE_CLONE_FUNCTORIMPL(MemFunHandler) + + +#ifdef LOKI_FUNCTORS_ARE_COMPARABLE + + bool operator==(const typename Base::FunctorImplBaseType& rhs) const + { + if(typeid(*this) != typeid(rhs)) + return false; // cannot be equal + + const MemFunHandler& mfh = static_cast<const MemFunHandler&>(rhs); + // if this line gives a compiler error, you are using a function object. + // you need to implement bool MyFnObj::operator == (const MyFnObj&) const; + return pObj_==mfh.pObj_ && pMemFn_==mfh.pMemFn_; + } +#endif + + ResultType operator()() + { return ((*pObj_).*pMemFn_)(); } + + ResultType operator()(Parm1 p1) + { return ((*pObj_).*pMemFn_)(p1); } + + ResultType operator()(Parm1 p1, Parm2 p2) + { return ((*pObj_).*pMemFn_)(p1, p2); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) + { return ((*pObj_).*pMemFn_)(p1, p2, p3); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) + { return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) + { + return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + p11); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12) + { + return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + p11, p12); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13) + { + return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + p11, p12, p13); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14) + { + return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + p11, p12, p13, p14); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) + { + return ((*pObj_).*pMemFn_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + p11, p12, p13, p14, p15); + } + + private: + PointerToObj pObj_; + PointerToMemFn pMemFn_; + }; + +//////////////////////////////////////////////////////////////////////////////// +// TR1 exception +////////////////////////////////////////////////////////////////////////////////// + +#ifdef LOKI_ENABLE_FUNCTION + + class bad_function_call : public std::runtime_error + { + public: + bad_function_call() : std::runtime_error("bad_function_call in Loki::Functor") + {} + }; + +#define LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL if(empty()) throw bad_function_call(); + +#else + +#define LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + +#endif + +//////////////////////////////////////////////////////////////////////////////// +/// \class Functor +/// +/// \ingroup FunctorGroup +/// A generalized functor implementation with value semantics +/// +/// \par Macro: LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT +/// Define +/// \code LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT \endcode +/// to avoid static instantiation/delete +/// order problems. +/// It often helps against crashes when using static Functors and multi threading. +/// Defining also removes problems when unloading Dlls which hosts +/// static Functor objects. +/// +/// \par Macro: LOKI_FUNCTORS_ARE_COMPARABLE +/// To enable the operator== define the macro +/// \code LOKI_FUNCTORS_ARE_COMPARABLE \endcode +/// The macro is disabled by default, because it breaks compiling functor +/// objects which have no operator== implemented, keep in mind when you enable +/// operator==. +//////////////////////////////////////////////////////////////////////////////// + template <typename R = void, class TList = NullType, + template<class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL> + class Functor + { + public: + // Handy type definitions for the body type + typedef FunctorImpl<R, TList, ThreadingModel> Impl; + typedef R ResultType; + typedef TList ParmList; + typedef typename Impl::Parm1 Parm1; + typedef typename Impl::Parm2 Parm2; + typedef typename Impl::Parm3 Parm3; + typedef typename Impl::Parm4 Parm4; + typedef typename Impl::Parm5 Parm5; + typedef typename Impl::Parm6 Parm6; + typedef typename Impl::Parm7 Parm7; + typedef typename Impl::Parm8 Parm8; + typedef typename Impl::Parm9 Parm9; + typedef typename Impl::Parm10 Parm10; + typedef typename Impl::Parm11 Parm11; + typedef typename Impl::Parm12 Parm12; + typedef typename Impl::Parm13 Parm13; + typedef typename Impl::Parm14 Parm14; + typedef typename Impl::Parm15 Parm15; + + // Member functions + + Functor() : spImpl_(0) + {} + + Functor(const Functor& rhs) : spImpl_(Impl::Clone(rhs.spImpl_.get())) + {} + + Functor(std::auto_ptr<Impl> spImpl) : spImpl_(spImpl) + {} + + template <typename Fun> + Functor(Fun fun) + : spImpl_(new FunctorHandler<Functor, Fun>(fun)) + {} + + template <class PtrObj, typename MemFn> + Functor(const PtrObj& p, MemFn memFn) + : spImpl_(new MemFunHandler<Functor, PtrObj, MemFn>(p, memFn)) + {} + + typedef Impl * (std::auto_ptr<Impl>::*unspecified_bool_type)() const; + + operator unspecified_bool_type() const + { + return spImpl_.get() ? &std::auto_ptr<Impl>::get : 0; + } + + Functor& operator=(const Functor& rhs) + { + Functor copy(rhs); + // swap auto_ptrs by hand + Impl* p = spImpl_.release(); + spImpl_.reset(copy.spImpl_.release()); + copy.spImpl_.reset(p); + return *this; + } + +#ifdef LOKI_ENABLE_FUNCTION + + bool empty() const + { + return spImpl_.get() == 0; + } + + void clear() + { + spImpl_.reset(0); + } +#endif + +#ifdef LOKI_FUNCTORS_ARE_COMPARABLE + + bool operator==(const Functor& rhs) const + { + if(spImpl_.get()==0 && rhs.spImpl_.get()==0) + return true; + if(spImpl_.get()!=0 && rhs.spImpl_.get()!=0) + return *spImpl_.get() == *rhs.spImpl_.get(); + else + return false; + } + + bool operator!=(const Functor& rhs) const + { + return !(*this==rhs); + } +#endif + + // operator() implementations for up to 15 arguments + + ResultType operator()() const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(); + } + + ResultType operator()(Parm1 p1) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1); + } + + ResultType operator()(Parm1 p1, Parm2 p2) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + p12); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + p12, p13); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + p12, p13, p14); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) const + { + LOKI_FUNCTION_THROW_BAD_FUNCTION_CALL + return (*spImpl_)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + p12, p13, p14, p15); + } + + private: + std::auto_ptr<Impl> spImpl_; + }; + + +//////////////////////////////////////////////////////////////////////////////// +// +// BindersFirst and Chainer +// +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class Fctor> struct BinderFirstTraits; + + template <typename R, class TList, template <class, class> class ThreadingModel> + struct BinderFirstTraits< Functor<R, TList, ThreadingModel> > + { + typedef Functor<R, TList, ThreadingModel> OriginalFunctor; + + typedef typename TL::Erase<TList,typename TL::TypeAt<TList, 0>::Result> + ::Result + ParmList; + + typedef typename TL::TypeAt<TList, 0>::Result OriginalParm1; + + typedef Functor<R, ParmList, ThreadingModel> BoundFunctorType; + + typedef typename BoundFunctorType::Impl Impl; + + }; + + + template<class T> + struct BinderFirstBoundTypeStorage; + + template<class T> + struct BinderFirstBoundTypeStorage + { + typedef typename TypeTraits<T>::ParameterType RefOrValue; + }; + + template <typename R, class TList, template <class, class> class ThreadingModel> + struct BinderFirstBoundTypeStorage< Functor<R, TList, ThreadingModel> > + { + typedef Functor<R, TList, ThreadingModel> OriginalFunctor; + typedef const typename TypeTraits<OriginalFunctor>::ReferredType RefOrValue; + }; + + + } // namespace Private + +//////////////////////////////////////////////////////////////////////////////// +/// \class BinderFirst +/// +/// \ingroup FunctorGroup +/// Binds the first parameter of a Functor object to a specific value +//////////////////////////////////////////////////////////////////////////////// + + template <class OriginalFunctor> + class BinderFirst + : public Private::BinderFirstTraits<OriginalFunctor>::Impl + { + typedef typename Private::BinderFirstTraits<OriginalFunctor>::Impl Base; + typedef typename OriginalFunctor::ResultType ResultType; + + typedef typename OriginalFunctor::Parm1 BoundType; + + typedef typename Private::BinderFirstBoundTypeStorage< + typename Private::BinderFirstTraits<OriginalFunctor> + ::OriginalParm1> + ::RefOrValue + BoundTypeStorage; + + typedef typename OriginalFunctor::Parm2 Parm1; + typedef typename OriginalFunctor::Parm3 Parm2; + typedef typename OriginalFunctor::Parm4 Parm3; + typedef typename OriginalFunctor::Parm5 Parm4; + typedef typename OriginalFunctor::Parm6 Parm5; + typedef typename OriginalFunctor::Parm7 Parm6; + typedef typename OriginalFunctor::Parm8 Parm7; + typedef typename OriginalFunctor::Parm9 Parm8; + typedef typename OriginalFunctor::Parm10 Parm9; + typedef typename OriginalFunctor::Parm11 Parm10; + typedef typename OriginalFunctor::Parm12 Parm11; + typedef typename OriginalFunctor::Parm13 Parm12; + typedef typename OriginalFunctor::Parm14 Parm13; + typedef typename OriginalFunctor::Parm15 Parm14; + typedef EmptyType Parm15; + + public: + + BinderFirst(const OriginalFunctor& fun, BoundType bound) + : f_(fun), b_(bound) + {} + + LOKI_DEFINE_CLONE_FUNCTORIMPL(BinderFirst) + +#ifdef LOKI_FUNCTORS_ARE_COMPARABLE + + bool operator==(const typename Base::FunctorImplBaseType& rhs) const + { + if(typeid(*this) != typeid(rhs)) + return false; // cannot be equal + // if this line gives a compiler error, you are using a function object. + // you need to implement bool MyFnObj::operator == (const MyFnObj&) const; + return f_ == ((static_cast<const BinderFirst&> (rhs)).f_) && + b_ == ((static_cast<const BinderFirst&> (rhs)).b_); + } +#endif + + // operator() implementations for up to 15 arguments + + ResultType operator()() + { return f_(b_); } + + ResultType operator()(Parm1 p1) + { return f_(b_, p1); } + + ResultType operator()(Parm1 p1, Parm2 p2) + { return f_(b_, p1, p2); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) + { return f_(b_, p1, p2, p3); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) + { return f_(b_, p1, p2, p3, p4); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) + { return f_(b_, p1, p2, p3, p4, p5); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) + { return f_(b_, p1, p2, p3, p4, p5, p6); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13) + { return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14) + { + return f_(b_, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14); + } + + private: + OriginalFunctor f_; + BoundTypeStorage b_; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// Binds the first parameter of a Functor object to a specific value +/// \ingroup FunctorGroup +//////////////////////////////////////////////////////////////////////////////// + + template <class Fctor> + typename Private::BinderFirstTraits<Fctor>::BoundFunctorType + BindFirst( + const Fctor& fun, + typename Fctor::Parm1 bound) + { + typedef typename Private::BinderFirstTraits<Fctor>::BoundFunctorType + Outgoing; + + return Outgoing(std::auto_ptr<typename Outgoing::Impl>( + new BinderFirst<Fctor>(fun, bound))); + } + +//////////////////////////////////////////////////////////////////////////////// +/// \class Chainer +/// +/// \ingroup FunctorGroup +/// Chains two functor calls one after another +//////////////////////////////////////////////////////////////////////////////// + + template <typename Fun1, typename Fun2> + class Chainer : public Fun2::Impl + { + typedef Fun2 Base; + + public: + typedef typename Base::ResultType ResultType; + typedef typename Base::Parm1 Parm1; + typedef typename Base::Parm2 Parm2; + typedef typename Base::Parm3 Parm3; + typedef typename Base::Parm4 Parm4; + typedef typename Base::Parm5 Parm5; + typedef typename Base::Parm6 Parm6; + typedef typename Base::Parm7 Parm7; + typedef typename Base::Parm8 Parm8; + typedef typename Base::Parm9 Parm9; + typedef typename Base::Parm10 Parm10; + typedef typename Base::Parm11 Parm11; + typedef typename Base::Parm12 Parm12; + typedef typename Base::Parm13 Parm13; + typedef typename Base::Parm14 Parm14; + typedef typename Base::Parm15 Parm15; + + Chainer(const Fun1& fun1, const Fun2& fun2) : f1_(fun1), f2_(fun2) {} + + LOKI_DEFINE_CLONE_FUNCTORIMPL(Chainer) + +#ifdef LOKI_FUNCTORS_ARE_COMPARABLE + + bool operator==(const typename Base::Impl::FunctorImplBaseType& rhs) const + { + if(typeid(*this) != typeid(rhs)) + return false; // cannot be equal + // if this line gives a compiler error, you are using a function object. + // you need to implement bool MyFnObj::operator == (const MyFnObj&) const; + return f1_ == ((static_cast<const Chainer&> (rhs)).f2_) && + f2_ == ((static_cast<const Chainer&> (rhs)).f1_); + } +#endif + + // operator() implementations for up to 15 arguments + + ResultType operator()() + { return f1_(), f2_(); } + + ResultType operator()(Parm1 p1) + { return f1_(p1), f2_(p1); } + + ResultType operator()(Parm1 p1, Parm2 p2) + { return f1_(p1, p2), f2_(p1, p2); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3) + { return f1_(p1, p2, p3), f2_(p1, p2, p3); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4) + { return f1_(p1, p2, p3, p4), f2_(p1, p2, p3, p4); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5) + { return f1_(p1, p2, p3, p4, p5), f2_(p1, p2, p3, p4, p5); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6) + { return f1_(p1, p2, p3, p4, p5, p6), f2_(p1, p2, p3, p4, p5, p6); } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7) + { + return f1_(p1, p2, p3, p4, p5, p6, p7), + f2_(p1, p2, p3, p4, p5, p6, p7); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8), + f2_(p1, p2, p3, p4, p5, p6, p7, p8); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14); + } + + ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5, + Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11, + Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15) + { + return f1_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14, p15), + f2_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, + p14, p15); + } + + private: + Fun1 f1_; + Fun2 f2_; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// Chains two functor calls one after another +/// \ingroup FunctorGroup +//////////////////////////////////////////////////////////////////////////////// + + + template <class Fun1, class Fun2> + Fun2 Chain( + const Fun1& fun1, + const Fun2& fun2) + { + return Fun2(std::auto_ptr<typename Fun2::Impl>( + new Chainer<Fun1, Fun2>(fun1, fun2))); + } + +} // namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/HierarchyGenerators.h b/shared/loki/HierarchyGenerators.h new file mode 100644 index 00000000..3fa11ffc --- /dev/null +++ b/shared/loki/HierarchyGenerators.h @@ -0,0 +1,291 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_HIERARCHYGENERATORS_INC_ +#define LOKI_HIERARCHYGENERATORS_INC_ + +// $Id: HierarchyGenerators.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +#include "Typelist.h" +#include "TypeTraits.h" +#include "EmptyType.h" + +namespace Loki +{ +#if defined(_MSC_VER) && _MSC_VER >= 1300 +#pragma warning( push ) + // 'class1' : base-class 'class2' is already a base-class of 'class3' +#pragma warning( disable : 4584 ) +#endif // _MSC_VER + +//////////////////////////////////////////////////////////////////////////////// +// class template GenScatterHierarchy +// Generates a scattered hierarchy starting from a typelist and a template +// Invocation (TList is a typelist, Unit is a template of one arg): +// GenScatterHierarchy<TList, Unit> +// The generated class inherits all classes generated by instantiating the +// template 'Unit' with the types contained in TList +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + // The following type helps to overcome subtle flaw in the original + // implementation of GenScatterHierarchy. + // The flaw is revealed when the input type list of GenScatterHierarchy + // contains more then one element of the same type (e.g. LOKI_TYPELIST_2(int, int)). + // In this case GenScatterHierarchy will contain multiple bases of the same + // type and some of them will not be reachable (per 10.3). + // For example before the fix the first element of Tuple<LOKI_TYPELIST_2(int, int)> + // is not reachable in any way! + template<class, class> + struct ScatterHierarchyTag; + } + + template <class TList, template <class> class Unit> + class GenScatterHierarchy; + + template <class T1, class T2, template <class> class Unit> + class GenScatterHierarchy<Typelist<T1, T2>, Unit> + : public GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit> + , public GenScatterHierarchy<T2, Unit> + { + public: + typedef Typelist<T1, T2> TList; + // Insure that LeftBase is unique and therefore reachable + typedef GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit> LeftBase; + typedef GenScatterHierarchy<T2, Unit> RightBase; + template <typename T> struct Rebind + { + typedef Unit<T> Result; + }; + }; + + // In the middle *unique* class that resolve possible ambiguity + template <class T1, class T2, template <class> class Unit> + class GenScatterHierarchy<Private::ScatterHierarchyTag<T1, T2>, Unit> + : public GenScatterHierarchy<T1, Unit> + { + }; + + template <class AtomicType, template <class> class Unit> + class GenScatterHierarchy : public Unit<AtomicType> + { + typedef Unit<AtomicType> LeftBase; + template <typename T> struct Rebind + { + typedef Unit<T> Result; + }; + }; + + template <template <class> class Unit> + class GenScatterHierarchy<NullType, Unit> + { + template <typename T> struct Rebind + { + typedef Unit<T> Result; + }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// function template Field +// Accesses a field in an object of a type generated with GenScatterHierarchy +// Invocation (obj is an object of a type H generated with GenScatterHierarchy, +// T is a type in the typelist used to generate H): +// Field<T>(obj) +// returns a reference to Unit<T>, where Unit is the template used to generate H +//////////////////////////////////////////////////////////////////////////////// + + template <class T, class H> + typename H::template Rebind<T>::Result& Field(H& obj) + { + return obj; + } + + template <class T, class H> + const typename H::template Rebind<T>::Result& Field(const H& obj) + { + return obj; + } + +//////////////////////////////////////////////////////////////////////////////// +// function template TupleUnit +// The building block of tuples +//////////////////////////////////////////////////////////////////////////////// + + template <class T> + struct TupleUnit + { + T value_; + operator T&() { return value_; } + operator const T&() const { return value_; } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Tuple +// Implements a tuple class that holds a number of values and provides field +// access to them via the Field function (below) +//////////////////////////////////////////////////////////////////////////////// + + template <class TList> + struct Tuple : public GenScatterHierarchy<TList, TupleUnit> + { + }; + +//////////////////////////////////////////////////////////////////////////////// +// helper class template FieldHelper +// See Field below +//////////////////////////////////////////////////////////////////////////////// + + template <class H, unsigned int i> struct FieldHelper; + + template <class H> + struct FieldHelper<H, 0> + { + typedef typename H::TList::Head ElementType; + typedef typename H::template Rebind<ElementType>::Result UnitType; + + enum + { + isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType, + isConst = TypeTraits<H>::isConst + }; + + typedef const typename H::LeftBase ConstLeftBase; + + typedef typename Select<isConst, ConstLeftBase, + typename H::LeftBase>::Result LeftBase; + + typedef typename Select<isTuple, ElementType, + UnitType>::Result UnqualifiedResultType; + + typedef typename Select<isConst, const UnqualifiedResultType, + UnqualifiedResultType>::Result ResultType; + + static ResultType& Do(H& obj) + { + LeftBase& leftBase = obj; + return leftBase; + } + }; + + template <class H, unsigned int i> + struct FieldHelper + { + typedef typename TL::TypeAt<typename H::TList, i>::Result ElementType; + typedef typename H::template Rebind<ElementType>::Result UnitType; + + enum + { + isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType, + isConst = TypeTraits<H>::isConst + }; + + typedef const typename H::RightBase ConstRightBase; + + typedef typename Select<isConst, ConstRightBase, + typename H::RightBase>::Result RightBase; + + typedef typename Select<isTuple, ElementType, + UnitType>::Result UnqualifiedResultType; + + typedef typename Select<isConst, const UnqualifiedResultType, + UnqualifiedResultType>::Result ResultType; + + static ResultType& Do(H& obj) + { + RightBase& rightBase = obj; + return FieldHelper<RightBase, i - 1>::Do(rightBase); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +// function template Field +// Accesses a field in an object of a type generated with GenScatterHierarchy +// Invocation (obj is an object of a type H generated with GenScatterHierarchy, +// i is the index of a type in the typelist used to generate H): +// Field<i>(obj) +// returns a reference to Unit<T>, where Unit is the template used to generate H +// and T is the i-th type in the typelist +//////////////////////////////////////////////////////////////////////////////// + + template <int i, class H> + typename FieldHelper<H, i>::ResultType& + Field(H& obj) + { + return FieldHelper<H, i>::Do(obj); + } + +// template <int i, class H> +// const typename FieldHelper<H, i>::ResultType& +// Field(const H& obj) +// { +// return FieldHelper<H, i>::Do(obj); +// } + +//////////////////////////////////////////////////////////////////////////////// +// class template GenLinearHierarchy +// Generates a linear hierarchy starting from a typelist and a template +// Invocation (TList is a typelist, Unit is a template of two args): +// GenScatterHierarchy<TList, Unit> +//////////////////////////////////////////////////////////////////////////////// + + template + < + class TList, + template <class AtomicType, class Base> class Unit, + class Root = EmptyType + > + class GenLinearHierarchy; + + template + < + class T1, + class T2, + template <class, class> class Unit, + class Root + > + class GenLinearHierarchy<Typelist<T1, T2>, Unit, Root> + : public Unit< T1, GenLinearHierarchy<T2, Unit, Root> > + { + }; + + template + < + class T, + template <class, class> class Unit, + class Root + > + class GenLinearHierarchy<Typelist<T, NullType>, Unit, Root> + : public Unit<T, Root> + { + }; + + template + < + template <class, class> class Unit, + class Root + > + class GenLinearHierarchy<NullType , Unit, Root> + : public Root // is this better: Unit<NullType, Root> ? + { + }; + +#if defined(_MSC_VER) && _MSC_VER >= 1300 +#pragma warning( pop ) +#endif +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/Key.h b/shared/loki/Key.h new file mode 100644 index 00000000..4daaa603 --- /dev/null +++ b/shared/loki/Key.h @@ -0,0 +1,764 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 by Guillaume Chatelet +// +// Code covered by the MIT License +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// +// The authors make no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +// +// This code DOES NOT accompany the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_KEY_INC_ +#define LOKI_KEY_INC_ + +// $Id: Key.h 771 2006-10-27 18:05:03Z clitte_bbt $ + + +#include <loki/Factory.h> + +namespace Loki +{ + + template< + class Factory, + typename IdentifierType + > + class Key; + + template<class F, typename I> + bool operator==(const Key<F, I> &k1, const Key<F, I> &k2); + + template<class F, typename I> + bool operator<(const Key<F, I> &k1, const Key<F, I> &k2); + + + /** + * A Key class + */ + template< + class Factory, + typename IdentifierType + > + class Key + { + typedef typename Factory::Parm1 Parm1; + typedef typename Factory::Parm2 Parm2; + typedef typename Factory::Parm3 Parm3; + typedef typename Factory::Parm4 Parm4; + typedef typename Factory::Parm5 Parm5; + typedef typename Factory::Parm6 Parm6; + typedef typename Factory::Parm7 Parm7; + typedef typename Factory::Parm8 Parm8; + typedef typename Factory::Parm9 Parm9; + typedef typename Factory::Parm10 Parm10; + typedef typename Factory::Parm11 Parm11; + typedef typename Factory::Parm12 Parm12; + typedef typename Factory::Parm13 Parm13; + typedef typename Factory::Parm14 Parm14; + typedef typename Factory::Parm15 Parm15; + public: + // member variables + int count; // should be const, but constness prevent default copy ctor + IdentifierType id; + Parm1 p1; + Parm2 p2; + Parm3 p3; + Parm4 p4; + Parm5 p5; + Parm6 p6; + Parm7 p7; + Parm8 p8; + Parm9 p9; + Parm10 p10; + Parm11 p11; + Parm12 p12; + Parm13 p13; + Parm14 p14; + Parm15 p15; + + // member functions + Key() : count(-1) + { + } + + Key(const IdentifierType& id) : count(0) + { + this->id = id; + } + + Key(const IdentifierType& id, + Parm1 &p1) : count(1) + { + this->id = id; + this->p1 = p1; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2) : count(2) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3) : count(3) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4) : count(4) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5) : count(5) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6) : count(6) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7 ) : count(7) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8) : count(8) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9) : count(9) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9,Parm10 &p10) : count(10) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + this->p10 = p10; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, + Parm11 &p11) : count(11) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + this->p10 = p10; + this->p11 = p11; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, + Parm11 &p11, Parm12 &p12) : count(12) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + this->p10 = p10; + this->p11 = p11; + this->p12 = p12; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, + Parm11 &p11, Parm12 &p12, Parm13 &p13) : count(13) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + this->p10 = p10; + this->p11 = p11; + this->p12 = p12; + this->p13 = p13; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, + Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14) : count(14) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + this->p10 = p10; + this->p11 = p11; + this->p12 = p12; + this->p13 = p13; + this->p14 = p14; + } + + Key(const IdentifierType& id, + Parm1 &p1, Parm2 &p2, Parm3 &p3, Parm4 &p4, Parm5 &p5, + Parm6 &p6, Parm7 &p7, Parm8 &p8, Parm9 &p9, Parm10 &p10, + Parm11 &p11, Parm12 &p12, Parm13 &p13, Parm14 &p14, Parm15 &p15) : count(15) + { + this->id = id; + this->p1 = p1; + this->p2 = p2; + this->p3 = p3; + this->p4 = p4; + this->p5 = p5; + this->p6 = p6; + this->p7 = p7; + this->p8 = p8; + this->p9 = p9; + this->p10 = p10; + this->p11 = p11; + this->p12 = p12; + this->p13 = p13; + this->p14 = p14; + this->p15 = p15; + } + + template<class F, typename I> + friend bool operator==(const Key<F, I> &k1, const Key<F, I> &k2); + + template<class F, typename I> + friend bool operator<(const Key<F, I> &k1, const Key<F, I> &k2); + }; + + + template<class F, typename I> + bool operator==(const Key<F, I> &k1, const Key<F, I> &k2) + { + if( k1.count != k2.count ) + return false; + switch(k1.count){ + case -1: + return true; + case 0: + if( k1.id == k2.id ) + return true; + else + return false; + case 1: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) ) + return true; + else + return false; + case 2: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) ) + return true; + else + return false; + case 3: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) ) + return true; + else + return false; + case 4: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) ) + return true; + else + return false; + case 5: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) ) + return true; + else + return false; + case 6: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) ) + return true; + else + return false; + case 7: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) ) + return true; + else + return false; + case 8: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) ) + return true; + else + return false; + case 9: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) ) + return true; + else + return false; + case 10: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) && + (k1.p10 == k2.p10) ) + return true; + else + return false; + case 11: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) && + (k1.p10 == k2.p10) && + (k1.p11 == k2.p11) ) + return true; + else + return false; + case 12: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) && + (k1.p10 == k2.p10) && + (k1.p11 == k2.p11) && + (k1.p12 == k2.p12) ) + return true; + else + return false; + case 13: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) && + (k1.p10 == k2.p10) && + (k1.p11 == k2.p11) && + (k1.p12 == k2.p12) && + (k1.p13 == k2.p13) ) + return true; + else + return false; + case 14: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) && + (k1.p10 == k2.p10) && + (k1.p11 == k2.p11) && + (k1.p12 == k2.p12) && + (k1.p13 == k2.p13) && + (k1.p14 == k2.p14) ) + return true; + else + return false; + case 15: + if( (k1.id == k2.id) && + (k1.p1 == k2.p1) && + (k1.p2 == k2.p2) && + (k1.p3 == k2.p3) && + (k1.p4 == k2.p4) && + (k1.p5 == k2.p5) && + (k1.p6 == k2.p6) && + (k1.p7 == k2.p7) && + (k1.p8 == k2.p8) && + (k1.p9 == k2.p9) && + (k1.p10 == k2.p10) && + (k1.p11 == k2.p11) && + (k1.p12 == k2.p12) && + (k1.p13 == k2.p13) && + (k1.p14 == k2.p14) && + (k1.p15 == k2.p15) ) + return true; + else + return false; + default: + return false; + } + } + + + + template<class F, typename I> + bool operator<(const Key<F, I> &k1, const Key<F, I> &k2) + { + if( k1.count < k2.count ) + return true; + switch(k1.count){ + case -1: + return false; + case 0: + if( k1.id < k2.id ) + return true; + else + return false; + case 1: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) ) + return true; + else + return false; + case 2: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) ) + return true; + else + return false; + case 3: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) ) + return true; + else + return false; + case 4: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) ) + return true; + else + return false; + case 5: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) ) + return true; + else + return false; + case 6: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) ) + return true; + else + return false; + case 7: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) ) + return true; + else + return false; + case 8: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) ) + return true; + else + return false; + case 9: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) ) + return true; + else + return false; + case 10: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) || + (k1.p10 < k2.p10) ) + return true; + else + return false; + case 11: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) || + (k1.p10 < k2.p10) || + (k1.p11 < k2.p11) ) + return true; + else + return false; + case 12: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) || + (k1.p10 < k2.p10) || + (k1.p11 < k2.p11) || + (k1.p12 < k2.p12) ) + return true; + else + return false; + case 13: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) || + (k1.p10 < k2.p10) || + (k1.p11 < k2.p11) || + (k1.p12 < k2.p12) || + (k1.p13 < k2.p13) ) + return true; + else + return false; + case 14: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) || + (k1.p10 < k2.p10) || + (k1.p11 < k2.p11) || + (k1.p12 < k2.p12) || + (k1.p13 < k2.p13) || + (k1.p14 < k2.p14) ) + return true; + else + return false; + case 15: + if( (k1.id < k2.id) || + (k1.p1 < k2.p1) || + (k1.p2 < k2.p2) || + (k1.p3 < k2.p3) || + (k1.p4 < k2.p4) || + (k1.p5 < k2.p5) || + (k1.p6 < k2.p6) || + (k1.p7 < k2.p7) || + (k1.p8 < k2.p8) || + (k1.p9 < k2.p9) || + (k1.p10 < k2.p10) || + (k1.p11 < k2.p11) || + (k1.p12 < k2.p12) || + (k1.p13 < k2.p13) || + (k1.p14 < k2.p14) || + (k1.p15 < k2.p15) ) + return true; + else + return false; + default: + return false; + } + } + + + +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/LevelMutex.h b/shared/loki/LevelMutex.h new file mode 100644 index 00000000..c048000f --- /dev/null +++ b/shared/loki/LevelMutex.h @@ -0,0 +1,1211 @@ +//////////////////////////////////////////////////////////////////////////////// +// +// LevelMutex facility for the Loki Library +// Copyright (c) 2008 Richard Sposato +// The copyright on this file is protected under the terms of the MIT license. +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// +// The author makes no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +// +//////////////////////////////////////////////////////////////////////////////// + +// $Id$ + +/// @file LevelMutex.h Defines classes and functions for LevelMutex facility. + +#ifndef LOKI_LEVEL_MUTEX_H_INCLUDED +#define LOKI_LEVEL_MUTEX_H_INCLUDED + + +// ---------------------------------------------------------------------------- + +#include <vector> +#include <assert.h> +#include <time.h> + +#if defined( _MSC_VER ) + #include <Windows.h> +#else + #include <pthread.h> +#endif + +#if !defined(_WIN32) && !defined(_WIN64) + #include <unistd.h> // declares sleep under Linux +#endif + +/** @par thread_local Keyword + The mutexes require compilers to provide thread local storage - meaning each + thread gets its own copy of the data. The next version of C++ will have a + new keyword, thread_local for that purpose. Some existing compilers already + provide thread local storage using different syntax, so these lines use + thread_local to mimic that syntax. If your compiler provides thread local + storage but using different syntax besides "thread_local", you may want to + modify these lines. If your compiler does not support thread local storage, + you can't use LevelMutex. + */ +#ifndef LOKI_THREAD_LOCAL + #if defined( _MSC_VER ) + #if ( _MSC_VER >= 1300 ) + #define LOKI_THREAD_LOCAL __declspec( thread ) + #else + #error "Only Visual Studio versions 7.0 and after supported." + #endif + + #elif ( __GNUC__ ) + #define LOKI_THREAD_LOCAL __thread + + #else + #warning "Check if your compiler provides thread local storage." + #define LOKI_THREAD_LOCAL thread_local + #endif +#endif + +#if defined( DEBUG ) || defined( _DEBUG ) + #define LOKI_MUTEX_DEBUG_CODE( x ) x +#else + #define LOKI_MUTEX_DEBUG_CODE( x ) +#endif + + +namespace Loki +{ + + +// ---------------------------------------------------------------------------- + +class MutexErrors +{ +public: + + /// @enum Type Possible error conditions detected by LevelMutex functions. + enum Type + { + Success = 0, ///< Operation occurred correctly. + NoProblem, ///< Pre-lock and pre-unlock checks passed. + WrongLevel, ///< All mutexes in container must have same level. + LevelTooLow, ///< Trying to unlock a mutex lower than current level. + LevelTooHigh, ///< Trying to lock a mutex higher than current level. + TryFailed, ///< TryLock call failed to lock mutex. + NullMutexPointer, ///< Container has a NULL pointer in it. + DuplicateMutex, ///< Container must have unique pointers - no duplicates. + EmptyContainer, ///< Container must have at least 1 pointer in it. + AlreadyLocked, ///< TryLock call failed because mutex already locked. + WasntLocked, ///< Unlock failed because mutex was not even locked. + NotRecentLock, ///< Mutex in container was not recently locked by this thread. + NotLockedByThread, ///< Can't unlock a mutex not locked by this thread. + MultiUnlockFailed, ///< MultiUnlock can't unlock at least 1 mutex in container. + TimedOut, ///< Wait time elapsed without locking mutex. + TooMuchRecursion, ///< Tried to relock a PThread mutex which is not re-entrant. + NotInitialized, ///< Tried to lock a PThread mutex which did not get setup. + AlreadyInitialized, ///< PThread mutex initialized before ctor called. + InvalidAttribute, ///< PThread mutex improperly initialized. + InvalidAddress, ///< Bad pointer used to initialize a PThread mutex. + ExceptionThrown, ///< Exception caught in mutex operation. + MayDeadlock, ///< Locking this mutex may cause a deadlock. + OtherError ///< Unknown error occurred. + }; +}; + +// ---------------------------------------------------------------------------- + +/** @class LevelMutexInfo + This monolithic base class stores common info for a template class used to + control mutexes. The template class, LevelMutex, is policy-based class. + + @par Implementation + Each thread has a list of mutexes it locked. When a mutex first gets locked, it + gets added to the head of the list. If locked again, LevelMutex merely increments + a count. When unlocked, the count gets decremented until it reaches zero, and + then it gets removed from the list. Each mutex has a pointer to the mutex most + recently locked by the current thread. The current level of a thread is always + the level of the most recently locked mutex, or UnlockedLevel if the thread does + not have any mutexes locked now. A mutex is considered "recently" locked if it is at + the head of the list, or the same level as the current mutex and also locked by the + current thread. + + @par Class Invariants + This class maintains invariants for each LevelMutexInfo so that no function + calls corrupt a mutex. Each function makes a call to IsValid at the start so + that LevelMutex knows it acts on valid internal data. Many functions call + IsValid again when they return to insure the function did not leave any data in + an invalid state. The exit call to IsValid occurs through a tiny helper class + called Checker to insure all data remain valid even when exceptions occur. + Another helper class, MutexUndoer, unlocks mutexes in a container if an + exception occurs during calls to MultiLock. + + @par Error Results + Many functions return an enum value to indicate an error status. Many enum values + indicate errors detected within LevelMutex, but some indicate errors found in policy + classes, SpinLevelMutex and SleepLevelMutex. + */ + +class LevelMutexInfo +{ +public: + + /** Level for thread that has not locked any mutex. Maximum possible level + for a mutex is UnlockedLevel-1; No mutex may have a level of UnlockedLevel. + */ + static const unsigned int UnlockedLevel = 0xFFFFFFFF; + + /// Container for locking multiple mutexes at once. + typedef ::std::vector< volatile LevelMutexInfo * > MutexContainer; + typedef MutexContainer::iterator LevelMutexContainerIter; + typedef MutexContainer::const_iterator LevelMutexContainerCIter; + typedef MutexContainer::reverse_iterator LevelMutexContainerRIter; + typedef MutexContainer::const_reverse_iterator LevelMutexContainerCRIter; + + /** Locks several mutexes at once. Requires O(m + n*n) actions where m is the + number of mutexes currently locked by the thread and n is the number of mutexes + in the container. This provides strong exception safety. If an exception occurs, + any mutexes that were locked during this call will get unlocked. + @param mutexes Container of pointers to mutexes. Container must have at + least 1 mutex, all mutexes must have the same level, no NULL pointers, and all + mutexes must not exceed the thread's current level. This sorts the container + by address order. + @return Enum value indicating success or error. + */ + static MutexErrors::Type MultiLock( MutexContainer & mutexes ); + + /** Locks several mutexes at once. Requires O(m + n*n + n*t) actions where m is + the number of mutexes currently locked by the thread, n is the number of mutexes + in the container, and t is the wait time for each mutex. This provides strong + exception safety. If an exception occurs, any mutexes that were locked during + this call will ge unlocked. + @param mutexes Container of pointers to mutexes. Container must have at + least 1 mutex, all mutexes must have the same level, no NULL pointers, and all + mutexes must not exceed the thread's current level. This sorts the container + by address order. + @param milliSeconds Amount of time to wait for each mutex. + @return Enum value indicating success or error. + */ + static MutexErrors::Type MultiLock( MutexContainer & mutexes, + unsigned int milliSeconds ); + + /** Unlocks several mutexes at once. Requires O(m) actions where m is the number of + mutexes in the container. This provides strong exception safety. If an exception + occurs when unlocking one mutex, other mutexes in the container get unlocked anyway. + @param mutexes Container of pointers to mutexes. Container must have at least 1 + mutex, all mutexes must have the same level, no NULL pointers, and all mutexes must + be locked by the current thread. This sorts the container dby address order. + @return Enum value indicating success or error. + */ + static MutexErrors::Type MultiUnlock( MutexContainer & mutexes ); + + /** Gives pointer to most recently locked mutex, or NULL if nothing locked. + The pointer is for a const mutex so the mutex can't be modified inappropriately. + The pointer is for a volatile mutex so callers can call volatile member + functions to get info about the mutex. + */ + static const volatile LevelMutexInfo * GetCurrentMutex( void ); + + /// Returns the level of this mutex. + inline unsigned int GetLevel( void ) const volatile { return m_level; } + + /// Returns true if this mutex was locked at least once. + inline bool IsLocked( void ) const volatile { return ( 0 < m_count ); } + + /// Returns count of how many times this mutex got locked. + inline unsigned int GetLockCount( void ) const volatile { return m_count; } + + /// Returns pointer to mutex previously locked by the thread which locked this. + inline const volatile LevelMutexInfo * GetPrevious( void ) const volatile + { + return m_previous; + } + + /** Tries to lock mutex, and returns immediately if mutex already locked by + another thread. It will return immediately with a value of AlreadyLocked + if the mutex was locked by a different thread. It may throw an exception + or assert when errors occur if the ErrorPolicy class implements that behavior. + @return An error condition if any occurred, else Success. + */ + virtual MutexErrors::Type TryLock( void ) volatile = 0; + + /** Blocking call will attempt to lock mutex and wait until it can lock. + This may throw an exception if the lock failed or an error occurred - if + that is what the error policy specifies. + @return An error condition if any occurred, else Success. + */ + virtual MutexErrors::Type Lock( void ) volatile = 0; + + /** Attempts to lock mutex, but only waits for a limited amount of time + before it gives up. Will return quickly if an error occurs before any + attempt to lock. This may throw an exception if the lock failed or an + error occurred - if that is what the error policy specifies. + @param milliSeconds How long to wait. + @return An error condition if any occurred, else Success. + */ + virtual MutexErrors::Type Lock( unsigned int milliSeconds ) volatile = 0; + + /** Unlocks the mutex, or returns an error condition. This may throw an + exception if the lock failed or an error occurred - if that is what the + error policy specifies. + @return An error condition if any occurred, else Success. + */ + virtual MutexErrors::Type Unlock( void ) volatile = 0; + + /** Returns true if this mutex was locked by current thread, and level is the same + as the current thread's level. Which means this was the most recently locked + mutex, or it was locked along with several others of the same level recently. + */ + bool IsRecentLock( void ) const volatile; + + /** Returns true if this mutex was locked within the last count mutexes. + @param count How many recent mutexes to look through to find this mutex. + */ + bool IsRecentLock( unsigned int count ) const volatile; + + /// Returns true if this was locked by current thread. + bool IsLockedByCurrentThread( void ) const volatile; + + /// Returns true if this was locked by another thread. + bool IsLockedByAnotherThread( void ) const volatile; + +protected: + + /** @class Checker Performs validity check on mutex to insure no class invariants + were violated inside any member function. This class only gets used in debug + builds, and any instance of it gets optimized away in release builds. A checker + is created inside many of member functions so that it's destructor gets called + when the function exits. It determines if any class invariants were violated + during the function call. + */ + class Checker + { + public: + inline explicit Checker( const volatile LevelMutexInfo * mutex ) : + m_mutex( mutex ) {} + inline ~Checker( void ) { m_mutex->IsValid(); } + private: + Checker( void ); + Checker( const Checker & ); + Checker & operator = ( const Checker & ); + const volatile LevelMutexInfo * m_mutex; + }; + + /** @class MutexUndoer + Undoes actions by MultiLock if an exception occurs. It keeps track of + which mutexes in a container got locked, and if an exception occurs, then + the destructor unlocks them. If MultiLock succeeds, then it cancels the + undoer so nothing gets unlocked inadvertently. + */ + class MutexUndoer + { + public: + + explicit MutexUndoer( MutexContainer & mutexes ); + ~MutexUndoer( void ); + void SetPlace( LevelMutexContainerIter & here ); + void Cancel( void ); + + private: + + MutexUndoer( void ); + MutexUndoer( const MutexUndoer & ); + MutexUndoer & operator = ( const MutexUndoer & ); + + MutexContainer & m_mutexes; + LevelMutexContainerIter m_here; + }; + + /** Returns true if linked-list of locked mutexes in this thread is valid. + Which means the list has no loops, and each previous mutex on the list has a + higher or same level as the current mutex. Called by IsValid. + */ + static bool IsValidList( void ); + + /** This is the only available constructor, and it forces any derived class to set + a level for each mutex. + */ + explicit LevelMutexInfo( unsigned int level ); + + /// The destructor only gets called by the derived class. + virtual ~LevelMutexInfo( void ); + + MutexErrors::Type PreLockCheck( bool forTryLock ) volatile; + + MutexErrors::Type PreUnlockCheck( void ) volatile; + + /** This gets called after each call to DoLock and DoTryLock to make sure the data + members in this object get set correctly. + */ + void PostLock( void ) volatile; + + /// Gets called just before an attempt to unlock a mutex. + void PreUnlock( void ) volatile; + + /// Called to relock a mutex already locked by the current thread. + void IncrementCount( void ) volatile; + + /// Called to unlock a mutex locked multiple times by the current thread. + void DecrementCount( void ) volatile; + + /** Returns true if no class invariant broken, otherwise asserts. This function + only gets called in debug builds. + */ + bool IsValid( void ) const volatile; + +private: + + /// Copy constructor is not implemented. + LevelMutexInfo( const LevelMutexInfo & ); + /// Copy-assignment operator is not implemented. + LevelMutexInfo & operator = ( const LevelMutexInfo & ); + + /** Called only by MultiLock & MultiUnlock to pass a result through an + error checking policy. + @param result What error condition to check. + @return Result or assertion or an exception - depending on error policy. + */ + virtual MutexErrors::Type DoErrorCheck( MutexErrors::Type result ) const volatile = 0; + + /// Called only by MultiLock to Lock each particular mutex within a container. + virtual MutexErrors::Type LockThis( void ) volatile = 0; + + /** Called only by MultiLock to lock each particular mutex within a container. + @param milliSeconds How much time to wait before giving up on locking a mutex. + */ + virtual MutexErrors::Type LockThis( unsigned int milliSeconds ) volatile = 0; + + /// Called only by MultiUnlock to unlock each particular mutex within a container. + virtual MutexErrors::Type UnlockThis( void ) volatile = 0; + + /// Pointer to singly-linked list of mutexes locked by the current thread. + static LOKI_THREAD_LOCAL volatile LevelMutexInfo * s_currentMutex; + + /// Level of this mutex. + const unsigned int m_level; + + /// How many times this mutex got locked. + unsigned int m_count; + + /// Pointer to mutex locked before this one. + volatile LevelMutexInfo * m_previous; + +}; + +// ---------------------------------------------------------------------------- + +/** @class ThrowOnAnyMutexError + Implements the ErrorPolicy for LevelMutex and throws an exception for any + error condition. Only allows MutexErrors::Success and MutexErrors::NoProblem + to get through. Useful for release builds. + */ +class ThrowOnAnyMutexError +{ +public: + static MutexErrors::Type CheckError( MutexErrors::Type error, + unsigned int level ); +}; + +// ---------------------------------------------------------------------------- + +/** @class ThrowOnBadDesignMutexError + Implements the ErrorPolicy for LevelMutex and throws an exception if the error + indicates the programmer did not levelize the calls to mutexes. Otherwise + returns the error result. Useful for release builds. + */ +class ThrowOnBadDesignMutexError +{ +public: + static MutexErrors::Type CheckError( MutexErrors::Type error, + unsigned int level ); +}; + +// ---------------------------------------------------------------------------- + +/** @class AssertAnyMutexError + Implements the ErrorPolicy for LevelMutex and asserts for any error condition. + Only allows MutexErrors::Success and MutexErrors::NoProblem to get through. + Useful for testing mutexes in debug builds. + */ +class AssertAnyMutexError +{ +public: + static inline MutexErrors::Type CheckError( MutexErrors::Type error, + unsigned int level ) + { + (void)level; + assert( ( error == MutexErrors::Success ) + || ( error == MutexErrors::NoProblem ) ); + return error; + } +}; + +// ---------------------------------------------------------------------------- + +/** @class AssertBadDesignMutexError + Implements the ErrorPolicy for LevelMutex and asserts if the error + indicates the programmer did not levelize the calls to mutexes. Otherwise + returns the error result. Useful for testing mutexes in debug builds. + */ +class AssertBadDesignMutexError +{ +public: + static inline MutexErrors::Type CheckError( MutexErrors::Type error, + unsigned int level ) + { + (void)level; + assert( ( error != MutexErrors::LevelTooHigh ) + && ( error != MutexErrors::LevelTooLow ) ); + return error; + } +}; + +// ---------------------------------------------------------------------------- + +/** @class JustReturnMutexError + Implements the ErrorPolicy for LevelMutex and does nothing no matter how bad + the error condition. Only recommended use is for automated unit-testing of + mutex policies. + */ +class JustReturnMutexError +{ +public: + static inline MutexErrors::Type CheckError( MutexErrors::Type error, + unsigned int level ) + { + (void)level; + return error; + } +}; + +// ---------------------------------------------------------------------------- + +/** @class NoMutexWait + Implements the WaitPolicy for LevelMutex. Does nothing at all so it turns + all wait loops into spin loops. Useful for low-level mutexes. + */ +class NoMutexWait +{ +public: + static inline void Wait( void ) {} +}; + +// ---------------------------------------------------------------------------- + +/** @class MutexSleepWaits + Implements the WaitPolicy for LevelMutex. Sleeps for a moment so thread won't + consume idle CPU cycles. Useful for high-level mutexes. + */ +class MutexSleepWaits +{ +public: + static void Wait( void ); + static unsigned int sleepTime; +}; + +// ---------------------------------------------------------------------------- + +/** @class SpinLevelMutex + Implements a spin-loop to wait for the mutex to unlock. Since this class makes + the thread wait in a tight spin-loop, it can cause the thread to remain busy + while waiting and thus consume CPU cycles. For that reason, this mutex is best + used only for very low-level resources - especially resources which do not + require much CPU time to exercise. Rule of thumb: Use this only if all actions + on the resource consume a very small number of CPU cycles. Otherwise, use the + SleepLevelMutex instead. + */ +class SpinLevelMutex +{ +public: + + /// Constructs a spin-level mutex. + explicit SpinLevelMutex( unsigned int level ); + + /// Destructs the mutex. + virtual ~SpinLevelMutex( void ); + + virtual MutexErrors::Type Lock( void ) volatile; + + virtual MutexErrors::Type TryLock( void ) volatile; + + virtual MutexErrors::Type Unlock( void ) volatile; + + inline unsigned int GetLevel( void ) const volatile { return m_level; } + +private: + + /// Copy constructor is not implemented. + SpinLevelMutex( const SpinLevelMutex & ); + /// Copy-assignment operator is not implemented. + SpinLevelMutex & operator = ( const SpinLevelMutex & ); + +#if defined( _MSC_VER ) + #if ( _MSC_VER >= 1300 ) + /// The actual mutex. + CRITICAL_SECTION m_mutex; + #else + #error "Only Visual Studio versions 7.0 and after supported." + #endif + +#elif ( __GNUC__ ) + /// The actual mutex. + pthread_mutex_t m_mutex; + +#else + #error "Check if any mutex libraries are compatible with your compiler." +#endif + + /// Keep a copy of the mutex level around for error reporting. + const unsigned int m_level; + +}; // end class SpinLevelMutex + +// ---------------------------------------------------------------------------- + +/** @class SleepLevelMutex + Implements a sleeping loop to wait for the mutex to unlock. + + @par Purpose + Since this class puts the thread to sleep for short intervals, you can use this + class for most of your mutexes. Especially for locking any high level resources + where any one operation on the resouce consumes many CPU cycles. The purpose of + this mutex is to reduce the number of CPU cycles spent in idle loops. All + SleepLevelMutex's should have higher levels than all your SpinLevelMutex's. + + @par Dependence on SpinLevelMutex + This utilizes SpinLevelMutex so it does not have to re-implement the DoTryLock + and DoUnlock functions the same way. All it really needs is a DoLock function + and the amount of time it should sleep if an attempt to lock a function fails. + */ +class SleepLevelMutex : public SpinLevelMutex +{ +public: + + /** Constructs a levelized mutex that puts threads to sleep while they wait + for another thread to unlock the mutex. + @param level Level of this mutex. + */ + explicit SleepLevelMutex( unsigned int level ); + + SleepLevelMutex( unsigned int level, unsigned int sleepTime ); + + /// Destructs the mutex. + virtual ~SleepLevelMutex( void ); + + inline unsigned int GetSleepTime( void ) const volatile { return m_sleepTime; } + + inline void SetSleepTime( unsigned int sleepTime ) volatile + { + if ( 0 != sleepTime ) + m_sleepTime = sleepTime; + } + +#if defined( _MSC_VER ) + inline bool GetWakable( void ) const volatile { return m_wakable; } + inline void SetWakable( bool wakable ) volatile { m_wakable = wakable; } +#endif + + /** Attempts to lock a mutex, and if it fails, then sleeps for a while + before attempting again. + */ + virtual MutexErrors::Type Lock( void ) volatile; + +private: + + /// Default constructor is not implemented. + SleepLevelMutex( void ); + /// Copy constructor is not implemented. + SleepLevelMutex( const SleepLevelMutex & ); + /// Copy-assignment operator is not implemented. + SleepLevelMutex & operator = ( const SleepLevelMutex & ); + +#if defined( _MSC_VER ) + #if ( _MSC_VER >= 1300 ) + /// True if operating system may wake thread to respond to events. + bool m_wakable; + #else + #error "Only Visual Studio versions 7.0 and after supported." + #endif +#endif + + /// How many milli-seconds to sleep before trying to lock mutex again. + unsigned int m_sleepTime; + +}; // end class SleepLevelMutex + +// ---------------------------------------------------------------------------- + +/** @class LevelMutex + Levelized mutex class prevents deadlocks by requiring programs to lock mutexes in + the same order, and unlock them in reverse order. This is accomplished by forcing + each mutex to have a level and forcing code to lock mutexes with higher levels + before locking mutexes at lower levels. If you want to lock several mutexes, they + must be locked in decreasing order by level, or if they are all of the same level, + then locked by LevelMutex::MultiLock. + + @par Features + - Immune: Very unlikely to deadlock since all mutexes are locked in the same + order and unlocked in reverse order. + - Scalable: Can handle any number of mutexes. + - Efficient: Many operations occur in constant time, and most operations require + no more than O(m) steps. + - Exception safe: All operations provide strong safety or don't throw. + - Extendable: Can work with existing mutexes through policy-based design. + - Easily Extended: Derived classes only need to implement 5 functions and a mutex + to get all the features of this class. + - Re-Entrant: Allows for re-entrancy even if mutexes in policy classes don't. + - Cost-Free: No resource allocations occur in LevelMutex - although user-defined + policy classes may allocate resources. + - Compact: Each LevelMutex object is small. + - Portable: As long as your compiler and libraries can meet the requirements. + - Robust: Maintains data integrity even if exceptions occur in policy classes. + - Affording: Several functions provide information about a mutex which allows + client code to easily choose correct actions. + + @par Requirements + - Your compiler must allow for thread-specific data. + - You must have a threading or mutex library. + + @par Policy-Based Design + This class hosts 3 policies and a default level. The policy-based design allows + users to write their own policies to extend the behaviors of LevelMutex. The + paragraphs below say how to design a class for each policy. + - MutexPolicy The mutex policy class. + - defaultLevel A level for existing client code that calls a default constructor. + - ErrorPolicy How the mutex should handle error conditions. + - WaitPolicy Whether a thread should wait, and how long in some internal loops. + + @par MutexPolicy + A policy class that wraps a low-level mutex. Loki provides two policy classes + for the actual mutex (SpinLevelMutex and SleepLevelMutex), both of which wrap + either pthreads or the Windows CRITICAL_SECTION. If you want to use a mutex + mechanism besides one of those, then all you have to do is provide a class + which wraps the mutex and implements these functions. + explicit SpinLevelMutex( unsigned int level ); + virtual ~SpinLevelMutex( void ); + virtual MutexErrors::Type Lock( void ) volatile; + virtual MutexErrors::Type TryLock( void ) volatile; + virtual MutexErrors::Type Unlock( void ) volatile; + Indeed, since the base class does most of the work, and provides all the interace + and functionality to client classes, a derived class has very few requirements. + It only needs to implement a single constructor, the destructor, some virtual + functions, and whatever data members it requires. You don't actually need to + declare those functions as virtual if the policy class is not a base or child + class. In the parlance of design patterns, LevelMutex is a Template, and the + MutexPolicy is a Strategy. + + @par DefaultLevel + The template class requires a default level to use inside the default constructor. + Some existing code calls instantiates mutexes with a default constructor, so the + mutex must know what level to use there. Please do not use zero or UnlockedLevel + as the default level. + + @par ErrorPolicy + This policy specifies how to handle error conditions. The mutexes can return + errors, assert, or throw exceptions. I recommend that debug code use asserts, + release code use exceptions, and unit-testing code just return errors. The + error policy class only needs to implement one function: + static MutexErrors::Type CheckError( MutexErrors::Type error, unsigned int level ); + + @par WaitPolicy + This states whether the mutex should wait within some tight internal loops, + how the waiting is done, and for how long. A wait policy class could sleep, + do nothing, check if other objects need attention, or check if the program + received events or notices from the operating system. It only needs to + implement one function: + static void Wait( void ); + + @par Per-Function Usage + If you implement a function with a static local mutex, then you have to insure + the function is not called from a lower level via call-backs, virtual functions in + interface classes. If the function does get called from a lower level, you are + setting up a potential deadlock. LevelMutex will detect that by checking the + current level and the local mutex's level, so it will refuse to lock the local mutex. + + @par Per-Object Usage + If you use a mutex as a data member of an object to protect that object, then I + recommend specifying which functions are volatile and which are not, and then only + use the mutex within the volatile functions. You may also want to provide accessor + functions so that client code can lock and unlock the mutex either to allow for + calling multiple operations without having to lock and unlock before and after each + operation, or so they can lock it along with several other objects at the same + level. + + @par Per-Class Usage + If you make a static data member within a class, you can use that to lock any + resources shared by those objects, or to require threads to act on only one object + at a time. You may also want to provide static accessor functions so that client + code can lock several other resources at the same level. + */ + +template +< + class MutexPolicy, + unsigned int DefaultLevel, + class ErrorPolicy = ::Loki::ThrowOnBadDesignMutexError, + class WaitPolicy = ::Loki::NoMutexWait +> +class LevelMutex : public LevelMutexInfo +{ +public: + + typedef ErrorPolicy EP; + typedef WaitPolicy WP; + typedef MutexPolicy MP; + + /** This constructor allows callers to replace the default level with another + value. It also acts as the default constructor for existing code which uses + default construction for mutexes. This is the only time the DefaultLevel + template parameter gets used. + */ + explicit LevelMutex( unsigned int level = DefaultLevel ) : + LevelMutexInfo( level ), + m_mutex( level ) + { + assert( IsValid() ); + } + + /// The destructor. + ~LevelMutex( void ) + { + assert( IsValid() ); + } + + /** These functions allow callers to access the mutex in case they need to + modify specific values in the MutexPolicy (e.g. - sleep time, functors to + call as tasks, etc...) There is one function for every combination of + const and volatile qualifiers so callers get a reference to a MutexPolicy + with the proper qualifiers. + */ + inline const volatile MutexPolicy & GetMutexPolicy( void ) const volatile { return m_mutex; } + inline volatile MutexPolicy & GetMutexPolicy( void ) volatile { return m_mutex; } + inline const MutexPolicy & GetMutexPolicy( void ) const { return m_mutex; } + inline MutexPolicy & GetMutexPolicy( void ) { return m_mutex; } + + virtual MutexErrors::Type TryLock( void ) volatile + { + assert( IsValid() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + + MutexErrors::Type result = LevelMutexInfo::PreLockCheck( true ); + if ( MutexErrors::Success == result ) + return MutexErrors::Success; + else if ( MutexErrors::AlreadyLocked == result ) + return result; + else if ( MutexErrors::NoProblem != result ) + return EP::CheckError( result, GetLevel() ); + + assert( 0 == LevelMutexInfo::GetLockCount() ); + result = m_mutex.TryLock(); + if ( MutexErrors::Success != result ) + return EP::CheckError( result, GetLevel() ); + LevelMutexInfo::PostLock(); + + return MutexErrors::Success; + } + + virtual MutexErrors::Type Lock( void ) volatile + { + assert( IsValid() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + + MutexErrors::Type result = LevelMutexInfo::PreLockCheck( false ); + if ( MutexErrors::Success == result ) + return MutexErrors::Success; + else if ( MutexErrors::NoProblem != result ) + return EP::CheckError( result, GetLevel() ); + + assert( !LevelMutexInfo::IsLockedByCurrentThread() ); + result = m_mutex.Lock(); + if ( MutexErrors::Success != result ) + return EP::CheckError( result, GetLevel() ); + PostLock(); + + return MutexErrors::Success; + } + + virtual MutexErrors::Type Lock( unsigned int milliSeconds ) volatile + { + assert( IsValid() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + + MutexErrors::Type result = LevelMutexInfo::PreLockCheck( false ); + if ( MutexErrors::Success == result ) + return MutexErrors::Success; + else if ( MutexErrors::NoProblem != result ) + return EP::CheckError( result, GetLevel() ); + + assert( !LevelMutexInfo::IsLockedByCurrentThread() ); + clock_t timeOut = clock() + milliSeconds; + while ( clock() < timeOut ) + { + WP::Wait(); + result = m_mutex.TryLock(); + switch ( result ) + { + case MutexErrors::Success: + { + PostLock(); + return MutexErrors::Success; + } + case MutexErrors::AlreadyLocked: + return MutexErrors::AlreadyLocked; + case MutexErrors::TryFailed: + break; + default: + return EP::CheckError( result, GetLevel() ); + } + } + + return MutexErrors::TimedOut; + } + + virtual MutexErrors::Type Unlock( void ) volatile + { + assert( IsValid() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + + MutexErrors::Type result = LevelMutexInfo::PreUnlockCheck(); + if ( MutexErrors::Success == result ) + return MutexErrors::Success; + else if ( MutexErrors::NoProblem != result ) + return EP::CheckError( result, GetLevel() ); + + LevelMutexInfo::PreUnlock(); + result = MutexErrors::OtherError; + try + { + result = m_mutex.Unlock(); + if ( MutexErrors::Success != result ) + PostLock(); + } + catch ( ... ) + { + PostLock(); + result = MutexErrors::ExceptionThrown; + } + + return result; + } + +private: + + /// Copy constructor is not implemented since mutexes don't get copied. + LevelMutex( const LevelMutex & ); + /// Copy-assignment operator is not implemented since mutexes don't get copied. + LevelMutex & operator = ( const LevelMutex & ); + + virtual MutexErrors::Type DoErrorCheck( MutexErrors::Type result ) const volatile + { + return EP::CheckError( result, GetLevel() ); + } + + /** Called only by MultiLock to lock each particular mutex within a container. + This does not do pre-lock error checking since MultiLock does that. Since + this skips the error checking, that means that callers of LevelMutex should + not call this function directly, and so this will not be publicly available. + @return Error status indicating success or reason for failure. + */ + virtual MutexErrors::Type LockThis( void ) volatile + { + assert( IsValid() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + assert( this != LevelMutexInfo::GetCurrentMutex() ); + + const MutexErrors::Type result = m_mutex.Lock(); + if ( MutexErrors::Success != result ) + return result; + PostLock(); + + return MutexErrors::Success; + } + + /** Called only by MultiLock to lock each particular mutex within a container. + This does not do pre-lock error checking since MultiLock does that. Since + this skips the error checking, callers of LevelMutex should not call this + function directly, and so this will not be publicly available. + @param milliSeconds How much time to wait before giving up on locking a mutex. + @return Error status indicating success or reason for failure. + */ + virtual MutexErrors::Type LockThis( unsigned int milliSeconds ) volatile + { + assert( IsValid() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + + clock_t timeOut = clock() + milliSeconds; + while ( clock() < timeOut ) + { + WP::Wait(); + const bool locked = ( MutexErrors::Success == m_mutex.TryLock() ); + if ( locked ) + { + PostLock(); + return MutexErrors::Success; + } + } + + return MutexErrors::TimedOut; + } + + /** Called only by MultiUnlock to unlock each mutex within a container. + This does not do pre-unlock error checking since MultiLock does that. Since + this skips the error checking, callers of LevelMutex should not call this + function directly, and so this will not be publicly available. + @return Error status indicating success or reason for failure. + */ + virtual MutexErrors::Type UnlockThis( void ) volatile + { + assert( IsValid() ); + assert( NULL != LevelMutexInfo::GetCurrentMutex() ); + LOKI_MUTEX_DEBUG_CODE( Checker checker( this ); (void)checker; ) + + if ( 1 < LevelMutexInfo::GetLockCount() ) + { + LevelMutexInfo::DecrementCount(); + return MutexErrors::Success; + } + + LevelMutexInfo::PreUnlock(); + MutexErrors::Type result = m_mutex.Unlock(); + + return result; + } + + /// An instance of an unleveled mutex wrapped to match LevelMutex's needs. + MutexPolicy m_mutex; + +}; // end class LevelMutex + +// ---------------------------------------------------------------------------- + +/** Returns level of most recently locked mutex by this thread, or UnlockedLevel + if no mutexes are locked. Runs in constant time, and never throws exceptions. + */ +unsigned int GetCurrentThreadsLevel( void ); + +/** Returns count of how mutexes the current thread locked. Requires O(m) + actions where m is the number of mutexes in the thread. Never throws exceptions. + */ +unsigned int CountMutexesInCurrentThread( void ); + +/** Returns count of how mutexes the current thread locked. The lock count + exceeds the number of mutexes locked by current thread if any mutex got locked + more than once. Requires O(m) actions where m is the number of mutexes in the + thread. Never throws exceptions. + */ +unsigned int CountLocksInCurrentThread( void ); + +/** Returns count of mutexes locked by current thread which have the same level + as GetCurrentThreadsLevel. Requires O(m) actions where m is the number of + mutexes in the thread at current level. Never throws exceptions. + */ +unsigned int CountMutexesAtCurrentLevel( void ); + +/** Determines if container of mutexes matches the recently locked mutexes. + If they do match, it returns success, otherwise an error condition. + */ +MutexErrors::Type DoMutexesMatchContainer( const LevelMutexInfo::MutexContainer & mutexes ); + +// ---------------------------------------------------------------------------- + +/** @class MutexException + Exception class used to throw error statuses about LevelMutex's up to code that + can respond to mutex problems. This class exists because it conveys more info + about the error condition than just ::std::exception. + */ +class MutexException : public ::std::exception +{ +public: + + /** Constructs an exception which stores information about a mutex and the + reason an attempt to use a mutex failed. + */ + MutexException( const char * message, unsigned int level, MutexErrors::Type reason ); + + /// Copy constructor performs a member-by-member copy of an exception. + MutexException( const MutexException & that ) throw (); + + /// Copy-assignment operator performs a member-by-member copy of an exception. + MutexException & operator = ( const MutexException & that ) throw (); + + /// Destroys the exception. + virtual ~MutexException( void ) throw(); + + /// Returns a simple message about which operation failed. + virtual const char * what( void ) const throw(); + + /// Returns level of mutex(es) used when problem occurred. + unsigned int GetLevel( void ) const { return m_level; } + + /// Returns an error status for why operation failed. + MutexErrors::Type GetReason( void ) const { return m_reason; } + +private: + + /// Default constructor is not implemented. + MutexException( void ) throw (); + + /// Simple message about operation that failed. + const char * m_message; + /// Level of mutex(es) used when problem occurred. + unsigned int m_level; + /// Error status for why operation failed. + MutexErrors::Type m_reason; + +}; // end class MutexException + +// ---------------------------------------------------------------------------- + +/** @class MutexLocker + You can place an instance of this as a local variable inside a function to lock + a single mutex. It will lock the mutex if no error occurs, or throw if one + does happen. When the function ends, the destructor will determine if it needs + to unlock the mutex. This RAII technique insures the mutex gets unlocked even + when exceptions occur. + */ +class MutexLocker +{ +public: + + /** Creates an object to lock an unlock a mutex for a function. This + will throw if an attempt to lock the mutex fails. + @param mutex Reference to the mutex. + @param lock True if function wants to lock the mutex as this gets + constructed. + */ + explicit MutexLocker( volatile LevelMutexInfo & mutex, bool lock = true ); + + /** Creates an object to lock an unlock a mutex for a function. This waits + a specified amount of time for another thread to unlock the mutex if it is + locked. This will throw if an attempt to lock the mutex fails. + @param mutex Reference to the mutex. + @param milliSeconds Amount of time to wait for another thread to unlock + the mutex. + @param lock True if function wants to lock the mutex as this gets + constructed. + */ + MutexLocker( volatile LevelMutexInfo & mutex, unsigned int milliSeconds, + bool lock = true ); + + /// Destructs the locker, and determines if it needs to unlock the mutex. + ~MutexLocker( void ); + + /** You can call this to lock (or relock) a mutex. In theory, you can lock + and unlock a mutex several times within a function in order to give other + threads access to a resource while this function does not need it. + @return True if mutex is locked by this, else false if not locked. + */ + bool Lock( void ); + + /** You can call this to unlock a mutex before the destructor does it. + By unlocking the mutexes before returning, the function can do other + operations without making other threads wait too long. + @return True if unlocked by this, else false if not unlocked by this. + (Which is not the same as whether the mutex itself is locked or not by + another thread.) + */ + bool Unlock( void ); + + /// Returns true if the mutex is locked by this object. + inline bool IsLocked( void ) const { return m_locked; } + + /// Provides access to mutex controlled by this. + const volatile LevelMutexInfo & GetMutex( void ) const { return m_mutex; } + +private: + + /// Default constructor is not implemented. + MutexLocker( void ); + /// Copy constructor is not implemented. + MutexLocker( const MutexLocker & ); + /// Copy-assignment operator is not implemented. + MutexLocker & operator = ( const MutexLocker & ); + + /// True if mutex got locked. + bool m_locked; + + /// Reference to mutex. + volatile LevelMutexInfo & m_mutex; +}; + +// ---------------------------------------------------------------------------- + +/** @class MultiMutexLocker + You can place an instance of this as a local variable inside a function to lock + a collection of mutexes. It locks them if no error occurs, or throws an + exception if one does happen. When the function ends, the destructor determines + if it needs to unlock the mutexes. This RAII technique insures the mutexes get + unlocked even when exceptions occur. You will also have to construct a + MutexContainer as a local object within the same function. + */ +class MultiMutexLocker +{ +public: + + /** Creates an object to lock and unlock a collection of mutexes for a function. + This will throw if an attempt to lock any mutex fails. If an exception occurs, + it unlocks mutexes it previously locked. + @param mutex Reference to a collection of mutexes. + @param lock True if function wants to lock the mutex as this gets + constructed. + */ + explicit MultiMutexLocker( LevelMutexInfo::MutexContainer & mutexes, + bool lock = true ); + + /** Creates an object to lock and unlock a collection of mutexes for a function. + This waits a specified amount of time for other threads to unlock each mutex + that is locked. This will throw if an attempt to lock any mutex fails. If an + exception occurs, it unlocks mutexes it previously locked. + @param mutexes Reference to a collection of mutexes. + @param milliSeconds Amount of time to wait for another thread to unlock + the mutex. + @param lock True if function wants to lock the mutexes as this gets + constructed. + */ + MultiMutexLocker( LevelMutexInfo::MutexContainer & mutexes, + unsigned int milliSeconds, bool lock = true ); + + /// Destructs the locker, and determines if it needs to unlock the mutexes. + ~MultiMutexLocker( void ); + + /** You can call this to lock (or relock) the mutexes. In theory, you can lock + and unlock mutexes several times within a function in order to give other + threads access to resources while this function does not need them. + @return True if mutex is locked by this, else false if not locked. + */ + bool Lock( void ); + + /** You can call this to unlock the mutexes before the destructor does it. + By unlocking the mutexes before returning, the function can do other + operations without making other threads wait too long. + @return True if unlocked by this, else false if not unlocked by this. + (Which is not the same as whether the mutex itself is locked or not by + another thread.) + */ + bool Unlock( void ); + + /// Returns true if the mutexes are locked by this object. + inline bool IsLocked( void ) const { return m_locked; } + + /// Provides access to the collection of mutexes controlled by this. + const LevelMutexInfo::MutexContainer & GetMutexes( void ) const { return m_mutexes; } + +private: + + /// Default constructor is not implemented. + MultiMutexLocker( void ); + /// Copy constructor is not implemented. + MultiMutexLocker( const MultiMutexLocker & ); + /// Copy-assignment operator is not implemented. + MultiMutexLocker & operator = ( const MultiMutexLocker & ); + + /// True if mutexes got locked. + bool m_locked; + + /// Reference to external container of mutexes; + LevelMutexInfo::MutexContainer & m_mutexes; +}; + +// ---------------------------------------------------------------------------- + +} // end namespace Loki + +#endif // end file guardian diff --git a/shared/loki/LockingPtr.h b/shared/loki/LockingPtr.h new file mode 100644 index 00000000..a50f5d6d --- /dev/null +++ b/shared/loki/LockingPtr.h @@ -0,0 +1,110 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code is from the article: +// "Generic<Programming>: volatile — Multithreaded Programmer’s Best Friend +// Volatile-Correctness or How to Have Your Compiler Detect Race Conditions +// for You" by Alexandrescu, Andrei. +// Published in the February 2001 issue of the C/C++ Users Journal. +// http://www.cuj.com/documents/s=7998/cujcexp1902alexandr/ +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// Prepared for Loki library by Richard Sposato +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_LOCKING_PTR_INC_ +#define LOKI_LOCKING_PTR_INC_ + +// $Id: LockingPtr.h 840 2008-03-19 19:44:38Z rich_sposato $ + + +#include <loki/ConstPolicy.h> +#include <loki/Threads.h> + + +namespace Loki +{ + /** @class LockingPtr + Locks a volatile object and casts away volatility so that the object + can be safely used in a single-threaded region of code. + Original version of LockingPtr had only one template - for the shared + object, but not the mutex type. This version allows users to specify a + the mutex type as a LockingPolicy class. The only requirements for a + LockingPolicy class are to provide Lock and Unlock methods. + */ + template < typename SharedObject, typename LockingPolicy = LOKI_DEFAULT_MUTEX, + template<class> class ConstPolicy = LOKI_DEFAULT_CONSTNESS > + class LockingPtr + { + public: + + typedef typename ConstPolicy<SharedObject>::Type ConstOrNotType; + + /** Constructor locks mutex associated with an object. + @param object Reference to object. + @param mutex Mutex used to control thread access to object. + */ + LockingPtr( volatile ConstOrNotType & object, LockingPolicy & mutex ) + : pObject_( const_cast< SharedObject * >( &object ) ), + pMutex_( &mutex ) + { + mutex.Lock(); + } + + typedef typename std::pair<volatile ConstOrNotType *, LockingPolicy *> Pair; + + /** Constructor locks mutex associated with an object. + @param lockpair a std::pair of pointers to the object and the mutex + */ + LockingPtr( Pair lockpair ) + : pObject_( const_cast< SharedObject * >( lockpair.first ) ), + pMutex_( lockpair.second ) + { + lockpair.second->Lock(); + } + + /// Destructor unlocks the mutex. + ~LockingPtr() + { + pMutex_->Unlock(); + } + + /// Star-operator dereferences pointer. + ConstOrNotType & operator * () + { + return *pObject_; + } + + /// Point-operator returns pointer to object. + ConstOrNotType * operator -> () + { + return pObject_; + } + + private: + + /// Default constructor is not implemented. + LockingPtr(); + + /// Copy-constructor is not implemented. + LockingPtr( const LockingPtr & ); + + /// Copy-assignment-operator is not implemented. + LockingPtr & operator = ( const LockingPtr & ); + + /// Pointer to the shared object. + ConstOrNotType * pObject_; + + /// Pointer to the mutex. + LockingPolicy * pMutex_; + + }; // end class LockingPtr + +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/LokiExport.h b/shared/loki/LokiExport.h new file mode 100644 index 00000000..625449f2 --- /dev/null +++ b/shared/loki/LokiExport.h @@ -0,0 +1,69 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 by Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_LOKIEXPORT_INC_ +#define LOKI_LOKIEXPORT_INC_ + +// $Id: LokiExport.h 748 2006-10-17 19:49:08Z syntheticpp $ + + +#ifdef __GNUC__ + +#ifdef _HAVE_GCC_VISIBILITY +#define LOKI_EXPORT_SPEC __attribute__ ((visibility("default"))) +#define LOKI_IMPORT_SPEC +#else +#define LOKI_EXPORT_SPEC +#define LOKI_IMPORT_SPEC +#endif + +#else + +#ifdef _WIN32 +#define LOKI_EXPORT_SPEC __declspec(dllexport) +#define LOKI_IMPORT_SPEC __declspec(dllimport) +#else +#define LOKI_EXPORT_SPEC +#define LOKI_IMPORT_SPEC +#endif + +#endif + + +#if (defined(LOKI_MAKE_DLL) && defined(LOKI_DLL)) || \ + (defined(LOKI_MAKE_DLL) && defined(LOKI_STATIC)) || \ + (defined(LOKI_DLL) && defined(LOKI_STATIC)) +#error export macro error: you could not build AND use the library +#endif + +#ifdef LOKI_MAKE_DLL +#define LOKI_EXPORT LOKI_EXPORT_SPEC +#endif + +#ifdef LOKI_DLL +#define LOKI_EXPORT LOKI_IMPORT_SPEC +#endif + +#ifdef LOKI_STATIC +#define LOKI_EXPORT +#endif + +#if !defined(LOKI_EXPORT) && !defined(EXPLICIT_EXPORT) +#define LOKI_EXPORT +#endif + +#ifndef LOKI_EXPORT +#error export macro error: LOKI_EXPORT was not defined, disable EXPLICIT_EXPORT or define a export specification +#endif + + +#endif // end file guardian + diff --git a/shared/loki/LokiTypeInfo.h b/shared/loki/LokiTypeInfo.h new file mode 100644 index 00000000..715dab1a --- /dev/null +++ b/shared/loki/LokiTypeInfo.h @@ -0,0 +1,103 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_LOKITYPEINFO_INC_ +#define LOKI_LOKITYPEINFO_INC_ + +// $Id: LokiTypeInfo.h 748 2006-10-17 19:49:08Z syntheticpp $ + + +#include <typeinfo> +#include <cassert> +#include "Typelist.h" + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class TypeInfo +// Purpose: offer a first-class, comparable wrapper over std::type_info +//////////////////////////////////////////////////////////////////////////////// + + class TypeInfo + { + public: + // Constructors + TypeInfo(); // needed for containers + TypeInfo(const std::type_info&); // non-explicit + + // Access for the wrapped std::type_info + const std::type_info& Get() const; + // Compatibility functions + bool before(const TypeInfo& rhs) const; + const char* name() const; + + private: + const std::type_info* pInfo_; + }; + +// Implementation + + inline TypeInfo::TypeInfo() + { + class Nil {}; + pInfo_ = &typeid(Nil); + assert(pInfo_); + } + + inline TypeInfo::TypeInfo(const std::type_info& ti) + : pInfo_(&ti) + { assert(pInfo_); } + + inline bool TypeInfo::before(const TypeInfo& rhs) const + { + assert(pInfo_); + // type_info::before return type is int in some VC libraries + return pInfo_->before(*rhs.pInfo_) != 0; + } + + inline const std::type_info& TypeInfo::Get() const + { + assert(pInfo_); + return *pInfo_; + } + + inline const char* TypeInfo::name() const + { + assert(pInfo_); + return pInfo_->name(); + } + +// Comparison operators + + inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs) + // type_info::operator== return type is int in some VC libraries + { return (lhs.Get() == rhs.Get()) != 0; } + + inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs) + { return lhs.before(rhs); } + + inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs) + { return !(lhs == rhs); } + + inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs) + { return rhs < lhs; } + + inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs) + { return !(lhs > rhs); } + + inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs) + { return !(lhs < rhs); } +} + +#endif // end file guardian diff --git a/shared/loki/MultiMethods.h b/shared/loki/MultiMethods.h new file mode 100644 index 00000000..d095cfae --- /dev/null +++ b/shared/loki/MultiMethods.h @@ -0,0 +1,415 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_MULTIMETHODS_INC_ +#define LOKI_MULTIMETHODS_INC_ + +// $Id: MultiMethods.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +#include "Typelist.h" +#include "LokiTypeInfo.h" +#include "Functor.h" +#include "AssocVector.h" + +//////////////////////////////////////////////////////////////////////////////// +// IMPORTANT NOTE: +// The double dispatchers implemented below differ from the excerpts shown in +// the book - they are simpler while respecting the same interface. +//////////////////////////////////////////////////////////////////////////////// + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class template InvocationTraits (helper) +// Helps implementing optional symmetry +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class SomeLhs, class SomeRhs, + class Executor, typename ResultType> + struct InvocationTraits + { + static ResultType + DoDispatch(SomeLhs& lhs, SomeRhs& rhs, + Executor& exec, Int2Type<false>) + { + return exec.Fire(lhs, rhs); + } + static ResultType + DoDispatch(SomeLhs& lhs, SomeRhs& rhs, + Executor& exec, Int2Type<true>) + { + return exec.Fire(rhs, lhs); + } + }; + } + +//////////////////////////////////////////////////////////////////////////////// +// class template StaticDispatcher +// Implements an automatic static double dispatcher based on two typelists +//////////////////////////////////////////////////////////////////////////////// + + template + < + class Executor, + class BaseLhs, + class TypesLhs, + bool symmetric = true, + class BaseRhs = BaseLhs, + class TypesRhs = TypesLhs, + typename ResultType = void + > + class StaticDispatcher + { + template <class SomeLhs> + static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs, + Executor exec, NullType) + { return exec.OnError(lhs, rhs); } + + template <class Head, class Tail, class SomeLhs> + static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs, + Executor exec, Typelist<Head, Tail>) + { + if (Head* p2 = dynamic_cast<Head*>(&rhs)) + { + Int2Type<(symmetric && + int(TL::IndexOf<TypesRhs, Head>::value) < + int(TL::IndexOf<TypesLhs, SomeLhs>::value))> i2t; + + typedef Private::InvocationTraits< + SomeLhs, Head, Executor, ResultType> CallTraits; + + return CallTraits::DoDispatch(lhs, *p2, exec, i2t); + } + return DispatchRhs(lhs, rhs, exec, Tail()); + } + + static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs, + Executor exec, NullType) + { return exec.OnError(lhs, rhs); } + + template <class Head, class Tail> + static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs, + Executor exec, Typelist<Head, Tail>) + { + if (Head* p1 = dynamic_cast<Head*>(&lhs)) + { + return DispatchRhs(*p1, rhs, exec, TypesRhs()); + } + return DispatchLhs(lhs, rhs, exec, Tail()); + } + + public: + static ResultType Go(BaseLhs& lhs, BaseRhs& rhs, + Executor exec) + { return DispatchLhs(lhs, rhs, exec, TypesLhs()); } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template BasicDispatcher +// Implements a logarithmic double dispatcher for functors (or functions) +// Doesn't offer automated casts or symmetry +//////////////////////////////////////////////////////////////////////////////// + + template + < + class BaseLhs, + class BaseRhs = BaseLhs, + typename ResultType = void, + typename CallbackType = ResultType (*)(BaseLhs&, BaseRhs&) + > + class BasicDispatcher + { + typedef std::pair<TypeInfo,TypeInfo> KeyType; + typedef CallbackType MappedType; + typedef AssocVector<KeyType, MappedType> MapType; + MapType callbackMap_; + + void DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun); + bool DoRemove(TypeInfo lhs, TypeInfo rhs); + + public: + template <class SomeLhs, class SomeRhs> + void Add(CallbackType fun) + { + DoAdd(typeid(SomeLhs), typeid(SomeRhs), fun); + } + + template <class SomeLhs, class SomeRhs> + bool Remove() + { + return DoRemove(typeid(SomeLhs), typeid(SomeRhs)); + } + + ResultType Go(BaseLhs& lhs, BaseRhs& rhs); + }; + + // Non-inline to reduce compile time overhead... + template <class BaseLhs, class BaseRhs, + typename ResultType, typename CallbackType> + void BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType> + ::DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun) + { + callbackMap_[KeyType(lhs, rhs)] = fun; + } + + template <class BaseLhs, class BaseRhs, + typename ResultType, typename CallbackType> + bool BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType> + ::DoRemove(TypeInfo lhs, TypeInfo rhs) + { + return callbackMap_.erase(KeyType(lhs, rhs)) == 1; + } + + template <class BaseLhs, class BaseRhs, + typename ResultType, typename CallbackType> + ResultType BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType> + ::Go(BaseLhs& lhs, BaseRhs& rhs) + { + typename MapType::key_type k(typeid(lhs),typeid(rhs)); + typename MapType::iterator i = callbackMap_.find(k); + if (i == callbackMap_.end()) + { + throw std::runtime_error("Function not found"); + } + return (i->second)(lhs, rhs); + } + +//////////////////////////////////////////////////////////////////////////////// +// class template StaticCaster +// Implementation of the CastingPolicy used by FunctorDispatcher +//////////////////////////////////////////////////////////////////////////////// + + template <class To, class From> + struct StaticCaster + { + static To& Cast(From& obj) + { + return static_cast<To&>(obj); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template DynamicCaster +// Implementation of the CastingPolicy used by FunctorDispatcher +//////////////////////////////////////////////////////////////////////////////// + + template <class To, class From> + struct DynamicCaster + { + static To& Cast(From& obj) + { + return dynamic_cast<To&>(obj); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Private::FnDispatcherHelper +// Implements trampolines and argument swapping used by FnDispatcher +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class BaseLhs, class BaseRhs, + class SomeLhs, class SomeRhs, + typename ResultType, + class CastLhs, class CastRhs, + ResultType (*Callback)(SomeLhs&, SomeRhs&)> + struct FnDispatcherHelper + { + static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs) + { + return Callback(CastLhs::Cast(lhs), CastRhs::Cast(rhs)); + } + static ResultType TrampolineR(BaseRhs& rhs, BaseLhs& lhs) + { + return Trampoline(lhs, rhs); + } + }; + } + +//////////////////////////////////////////////////////////////////////////////// +// class template FnDispatcher +// Implements an automatic logarithmic double dispatcher for functions +// Features automated conversions +//////////////////////////////////////////////////////////////////////////////// + + template <class BaseLhs, class BaseRhs = BaseLhs, + typename ResultType = void, + template <class, class> class CastingPolicy = DynamicCaster, + template <class, class, class, class> + class DispatcherBackend = BasicDispatcher> + class FnDispatcher + { + DispatcherBackend<BaseLhs, BaseRhs, ResultType, + ResultType (*)(BaseLhs&, BaseRhs&)> backEnd_; + + public: + template <class SomeLhs, class SomeRhs> + void Add(ResultType (*pFun)(BaseLhs&, BaseRhs&)) + { + return backEnd_.template Add<SomeLhs, SomeRhs>(pFun); + } + + template <class SomeLhs, class SomeRhs, + ResultType (*callback)(SomeLhs&, SomeRhs&)> + void Add() + { + typedef Private::FnDispatcherHelper< + BaseLhs, BaseRhs, + SomeLhs, SomeRhs, + ResultType, + CastingPolicy<SomeLhs,BaseLhs>, + CastingPolicy<SomeRhs,BaseRhs>, + callback> Local; + + Add<SomeLhs, SomeRhs>(&Local::Trampoline); + } + + template <class SomeLhs, class SomeRhs, + ResultType (*callback)(SomeLhs&, SomeRhs&), + bool symmetric> + void Add(bool = true) // [gcc] dummy bool + { + typedef Private::FnDispatcherHelper< + BaseLhs, BaseRhs, + SomeLhs, SomeRhs, + ResultType, + CastingPolicy<SomeLhs,BaseLhs>, + CastingPolicy<SomeRhs,BaseRhs>, + callback> Local; + + Add<SomeLhs, SomeRhs>(&Local::Trampoline); + if (symmetric) + { + Add<SomeRhs, SomeLhs>(&Local::TrampolineR); + } + } + + template <class SomeLhs, class SomeRhs> + void Remove() + { + backEnd_.template Remove<SomeLhs, SomeRhs>(); + } + + ResultType Go(BaseLhs& lhs, BaseRhs& rhs) + { + return backEnd_.Go(lhs, rhs); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorDispatcherAdaptor +// permits use of FunctorDispatcher under gcc.2.95.2/3 +/////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class BaseLhs, class BaseRhs, + class SomeLhs, class SomeRhs, + typename ResultType, + class CastLhs, class CastRhs, + class Fun, bool SwapArgs> + class FunctorDispatcherHelper + { + Fun fun_; + ResultType Fire(BaseLhs& lhs, BaseRhs& rhs,Int2Type<false>) + { + return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs)); + } + ResultType Fire(BaseLhs& rhs, BaseRhs& lhs,Int2Type<true>) + { + return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs)); + } + public: + FunctorDispatcherHelper(const Fun& fun) : fun_(fun) {} + + ResultType operator()(BaseLhs& lhs, BaseRhs& rhs) + { + return Fire(lhs,rhs,Int2Type<SwapArgs>()); + } + }; + } + +//////////////////////////////////////////////////////////////////////////////// +// class template FunctorDispatcher +// Implements a logarithmic double dispatcher for functors +// Features automated casting +//////////////////////////////////////////////////////////////////////////////// + + template <class BaseLhs, class BaseRhs = BaseLhs, + typename ResultType = void, + template <class, class> class CastingPolicy = DynamicCaster, + template <class, class, class, class> + class DispatcherBackend = BasicDispatcher> + class FunctorDispatcher + { + typedef LOKI_TYPELIST_2(BaseLhs&, BaseRhs&) ArgsList; + typedef Functor<ResultType, ArgsList, LOKI_DEFAULT_THREADING> FunctorType; + + DispatcherBackend<BaseLhs, BaseRhs, ResultType, FunctorType> backEnd_; + + public: + template <class SomeLhs, class SomeRhs, class Fun> + void Add(const Fun& fun) + { + typedef Private::FunctorDispatcherHelper< + BaseLhs, BaseRhs, + SomeLhs, SomeRhs, + ResultType, + CastingPolicy<SomeLhs, BaseLhs>, + CastingPolicy<SomeRhs, BaseRhs>, + Fun, false> Adapter; + + backEnd_.template Add<SomeLhs, SomeRhs>(FunctorType(Adapter(fun))); + } + template <class SomeLhs, class SomeRhs, bool symmetric, class Fun> + void Add(const Fun& fun) + { + Add<SomeLhs,SomeRhs>(fun); + + if (symmetric) + { + // Note: symmetry only makes sense where BaseLhs==BaseRhs + typedef Private::FunctorDispatcherHelper< + BaseLhs, BaseLhs, + SomeLhs, SomeRhs, + ResultType, + CastingPolicy<SomeLhs, BaseLhs>, + CastingPolicy<SomeRhs, BaseLhs>, + Fun, true> AdapterR; + + backEnd_.template Add<SomeRhs, SomeLhs>(FunctorType(AdapterR(fun))); + } + } + + template <class SomeLhs, class SomeRhs> + void Remove() + { + backEnd_.template Remove<SomeLhs, SomeRhs>(); + } + + ResultType Go(BaseLhs& lhs, BaseRhs& rhs) + { + return backEnd_.Go(lhs, rhs); + } + }; +} // namespace Loki + + + +#endif // end file guardian + diff --git a/shared/loki/NullType.h b/shared/loki/NullType.h new file mode 100644 index 00000000..9403901a --- /dev/null +++ b/shared/loki/NullType.h @@ -0,0 +1,34 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_NULLTYPE_INC_ +#define LOKI_NULLTYPE_INC_ + +// $Id: NullType.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class NullType +// Used as a placeholder for "no type here" +// Useful as an end marker in typelists +//////////////////////////////////////////////////////////////////////////////// + + class NullType {}; + +} // namespace Loki + + +#endif // end file guardian diff --git a/shared/loki/OrderedStatic.h b/shared/loki/OrderedStatic.h new file mode 100644 index 00000000..6eaa20b9 --- /dev/null +++ b/shared/loki/OrderedStatic.h @@ -0,0 +1,225 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2005 Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_ORDEREDSTATIC_INC_ +#define LOKI_ORDEREDSTATIC_INC_ + +// $Id: OrderedStatic.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +#include <vector> +#include <iostream> + +#include "LokiExport.h" +#include "Singleton.h" +#include "Typelist.h" +#include "Sequence.h" + +// usage: see test/OrderedStatic + +namespace Loki +{ + namespace Private + { + //////////////////////////////////////////////////////////////////////////////// + // polymorph base class for OrderedStatic template, + // necessary because of the creator + //////////////////////////////////////////////////////////////////////////////// + class LOKI_EXPORT OrderedStaticCreatorFunc + { + public: + virtual void createObject() = 0; + + protected: + OrderedStaticCreatorFunc(); + virtual ~OrderedStaticCreatorFunc(); + + private: + OrderedStaticCreatorFunc(const OrderedStaticCreatorFunc&); + }; + + //////////////////////////////////////////////////////////////////////////////// + // template base clase for OrderedStatic template, + // common for all specializations + //////////////////////////////////////////////////////////////////////////////// + template<class T> + class OrderedStaticBase : public OrderedStaticCreatorFunc + { + public: + T& operator*() + { + return *val_; + } + + T* operator->() + { + return val_; + } + + protected: + + OrderedStaticBase(unsigned int longevity) : val_(0), longevity_(longevity) + { + } + + virtual ~OrderedStaticBase() + { + } + + void SetLongevity(T* ptr) + { + val_=ptr; + Loki::SetLongevity(val_,longevity_); + } + + private: + OrderedStaticBase(); + OrderedStaticBase(const OrderedStaticBase&); + OrderedStaticBase& operator=(const OrderedStaticBase&); + T* val_; + unsigned int longevity_; + + }; + + //////////////////////////////////////////////////////////////////////////////// + // OrderedStaticManagerClass implements details + // OrderedStaticManager is then defined as a Singleton + //////////////////////////////////////////////////////////////////////////////// + class LOKI_EXPORT OrderedStaticManagerClass + { + public: + OrderedStaticManagerClass(); + virtual ~OrderedStaticManagerClass(); + + typedef void (OrderedStaticCreatorFunc::*Creator)(); + + void createObjects(); + void registerObject(unsigned int longevity,OrderedStaticCreatorFunc*,Creator); + + private: + OrderedStaticManagerClass(const OrderedStaticManagerClass&); + OrderedStaticManagerClass& operator=(const OrderedStaticManagerClass&); + + struct Data + { + Data(unsigned int,OrderedStaticCreatorFunc*, Creator); + unsigned int longevity; + OrderedStaticCreatorFunc* object; + Creator creator; + }; + + std::vector<Data> staticObjects_; + unsigned int max_longevity_; + unsigned int min_longevity_; + }; + + }// namespace Private + + //////////////////////////////////////////////////////////////////////////////// + // OrderedStaticManager is only a Singleton typedef + //////////////////////////////////////////////////////////////////////////////// + + typedef Loki::SingletonHolder + < + Loki::Private::OrderedStaticManagerClass, + Loki::CreateUsingNew, + Loki::NoDestroy, + Loki::SingleThreaded + > + OrderedStaticManager; + + //////////////////////////////////////////////////////////////////////////////// + // template OrderedStatic template: + // L : longevity + // T : object type + // TList : creator parameters + //////////////////////////////////////////////////////////////////////////////// + + template<unsigned int L, class T, class TList = Loki::NullType> + class OrderedStatic; + + + //////////////////////////////////////////////////////////////////////////////// + // OrderedStatic specializations + //////////////////////////////////////////////////////////////////////////////// + + template<unsigned int L, class T> + class OrderedStatic<L, T, Loki::NullType> : public Private::OrderedStaticBase<T> + { + public: + OrderedStatic() : Private::OrderedStaticBase<T>(L) + { + OrderedStaticManager::Instance().registerObject + (L,this,&Private::OrderedStaticCreatorFunc::createObject); + } + + void createObject() + { + Private::OrderedStaticBase<T>::SetLongevity(new T); + } + + private: + OrderedStatic(const OrderedStatic&); + OrderedStatic& operator=(const OrderedStatic&); + }; + + template<unsigned int L, class T, typename P1> + class OrderedStatic<L, T, Loki::Seq<P1> > : public Private::OrderedStaticBase<T> + { + public: + OrderedStatic(P1 p) : Private::OrderedStaticBase<T>(L), para_(p) + { + OrderedStaticManager::Instance().registerObject + (L,this,&Private::OrderedStaticCreatorFunc::createObject); + } + + void createObject() + { + Private::OrderedStaticBase<T>::SetLongevity(new T(para_)); + } + + private: + OrderedStatic(); + OrderedStatic(const OrderedStatic&); + OrderedStatic& operator=(const OrderedStatic&); + P1 para_; + }; + + template<unsigned int L, class T, typename P1> + class OrderedStatic<L, T, P1(*)() > : public Private::OrderedStaticBase<T> + { + public: + + typedef P1(*Func)(); + + OrderedStatic(Func p) : Private::OrderedStaticBase<T>(L), para_(p) + { + OrderedStaticManager::Instance().registerObject + (L,this,&Private::OrderedStaticCreatorFunc::createObject); + } + + void createObject() + { + Private::OrderedStaticBase<T>::SetLongevity(new T(para_())); + } + + private: + OrderedStatic(); + OrderedStatic(const OrderedStatic&); + OrderedStatic& operator=(const OrderedStatic&); + Func para_; + }; + +}// namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/Pimpl.h b/shared/loki/Pimpl.h new file mode 100644 index 00000000..ed0d1c7b --- /dev/null +++ b/shared/loki/Pimpl.h @@ -0,0 +1,198 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_PIMPL_INC_ +#define LOKI_PIMPL_INC_ + +// $Id: Pimpl.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +/// \defgroup PimplGroup Pimpl + +#ifndef LOKI_INHERITED_PIMPL_NAME +#define LOKI_INHERITED_PIMPL_NAME d +#endif + +#ifndef LOKI_INHERITED_RIMPL_NAME +#define LOKI_INHERITED_RIMPL_NAME d +#endif + +namespace Loki +{ + + ////////////////////////////////////////// + /// \class ConstPropPtr + /// + /// \ingroup PimplGroup + /// Simple const propagating smart pointer + /// Is the default smart pointer of Pimpl. + ////////////////////////////////////////// + + template<class T> + struct ConstPropPtr + { + explicit ConstPropPtr(T* p) : ptr_(p) {} + ~ConstPropPtr() { delete ptr_; ptr_ = 0; } + T* operator->() { return ptr_; } + T& operator*() { return *ptr_; } + const T* operator->() const { return ptr_; } + const T& operator*() const { return *ptr_; } + + private: + ConstPropPtr(); + ConstPropPtr(const ConstPropPtr&); + ConstPropPtr& operator=(const ConstPropPtr&); + T* ptr_; + }; + + + //////////////////////////////////////////////////////////////////////////////// + /// \class Pimpl + /// + /// \ingroup PimplGroup + /// + /// Implements the Pimpl idiom. It's a wrapper for a smart pointer which + /// automatically creates and deletes the implementation object and adds + /// const propagation to the smart pointer. + /// + /// \par Usage + /// see test/Pimpl + //////////////////////////////////////////////////////////////////////////////// + + template + < + class T, + typename Pointer = ConstPropPtr<T> + > + class Pimpl + { + public: + + typedef T Impl; + + Pimpl() : ptr_(new T) + {} + + ~Pimpl() + { + // Don't compile with incomplete type + // + // If compilation breaks here make sure + // the compiler does not auto-generate the + // destructor of the class hosting the pimpl: + // - implement the destructor of the class + // - don't inline the destructor + typedef char T_must_be_defined[sizeof(T) ? 1 : -1 ]; + } + + + T* operator->() + { + return ptr_.operator->(); + } + + T& operator*() + { + return ptr_.operator*(); + } + + const T* operator->() const + { + return ptr_.operator->(); + } + + const T& operator*() const + { + return ptr_.operator*(); + } + + Pointer& wrapped() + { + return ptr_; + } + + const Pointer& wrapped() const + { + return ptr_; + } + + + private: + Pimpl(const Pimpl&); + Pimpl& operator=(const Pimpl&); + + Pointer ptr_; + }; + + + template<class T, typename Pointer = ConstPropPtr<T> > + struct PimplOwner + { + Pimpl<T,Pointer> LOKI_INHERITED_PIMPL_NAME; + }; + + + ////////////////////////////////////////// + /// \class ImplOf + /// + /// \ingroup PimplGroup + /// Convenience template for the + /// implementations which Pimpl points to. + ////////////////////////////////////////// + + template<class T> + struct ImplOf; + + + ////////////////////////////////////////// + /// \class PImplOf + /// + /// \ingroup PimplGroup + /// Convenience template which uses ImplOf + /// as implementation structure + ////////////////////////////////////////// + + + template<class T, template<class> class Ptr = ConstPropPtr> + struct PimplOf + { + typedef T Impl; + + // declare pimpl + typedef Pimpl<ImplOf<T>, Ptr<ImplOf<T> > > Type; + + // inherit pimpl + typedef PimplOwner<ImplOf<T>, Ptr<ImplOf<T> > > Owner; + }; + + + template<class T, class UsedPimpl = typename PimplOf<T>::Type > + struct RimplOf + { + typedef typename UsedPimpl::Impl & Type; + + class Owner + { + UsedPimpl pimpl; + + public: + Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl) + {} + + Type LOKI_INHERITED_RIMPL_NAME; + }; + + }; + +} + +#endif // end file guardian + diff --git a/shared/loki/RefToValue.h b/shared/loki/RefToValue.h new file mode 100644 index 00000000..248de792 --- /dev/null +++ b/shared/loki/RefToValue.h @@ -0,0 +1,70 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 Richard Sposato +// Copyright (c) 2006 Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The authors make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_REFTOVALUE_INC_ +#define LOKI_REFTOVALUE_INC_ + +// $Id: RefToValue.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +namespace Loki +{ + + //////////////////////////////////////////////////////////////////////////////// + /// \class RefToValue + /// + /// \ingroup SmartPointerGroup + /// Transports a reference as a value + /// Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard + //////////////////////////////////////////////////////////////////////////////// + + template <class T> + class RefToValue + { + public: + + RefToValue(T& ref) : ref_(ref) + {} + + RefToValue(const RefToValue& rhs) : ref_(rhs.ref_) + {} + + operator T& () const + { + return ref_; + } + + private: + // Disable - not implemented + RefToValue(); + RefToValue& operator=(const RefToValue&); + + T& ref_; + }; + + + //////////////////////////////////////////////////////////////////////////////// + /// \ingroup ExceptionGroup + /// RefToValue creator. + //////////////////////////////////////////////////////////////////////////////// + + template <class T> + inline RefToValue<T> ByRef(T& t) + { + return RefToValue<T>(t); + } + +} + + +#endif // end file guardian + diff --git a/shared/loki/Register.h b/shared/loki/Register.h new file mode 100644 index 00000000..0ad014ab --- /dev/null +++ b/shared/loki/Register.h @@ -0,0 +1,134 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_REGISTER_INC_ +#define LOKI_REGISTER_INC_ + +// $Id: Register.h 776 2006-11-09 13:12:57Z syntheticpp $ + + +#include "TypeManip.h" +#include "HierarchyGenerators.h" + +/// \defgroup RegisterGroup Register + +namespace Loki +{ + + //////////////////////////////////////////////////////////////////////////////// + // + // Helper classes/functions for RegisterByCreateSet + // + //////////////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////////////// + /// \ingroup RegisterGroup + /// Must be specialized be the user + //////////////////////////////////////////////////////////////////////////////// + template<class t> bool RegisterFunction(); + + //////////////////////////////////////////////////////////////////////////////// + /// \ingroup RegisterGroup + /// Must be specialized be the user + //////////////////////////////////////////////////////////////////////////////// + template<class t> bool UnRegisterFunction(); + + namespace Private + { + template<class T> + struct RegisterOnCreate + { + RegisterOnCreate() { RegisterFunction<T>(); } + }; + + template<class T> + struct UnRegisterOnDelete + { + ~UnRegisterOnDelete() { UnRegisterFunction<T>(); } + }; + + template<class T> + struct RegisterOnCreateElement + { + RegisterOnCreate<T> registerObj; + }; + + template<class T> + struct UnRegisterOnDeleteElement + { + UnRegisterOnDelete<T> unregisterObj; + }; + } + + //////////////////////////////////////////////////////////////////////////////// + /// \class RegisterOnCreateSet + /// + /// \ingroup RegisterGroup + /// Implements a generic register class which registers classes of a typelist + /// + /// \par Usage + /// see test/Register + //////////////////////////////////////////////////////////////////////////////// + + template<typename ElementList> + struct RegisterOnCreateSet + : GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement> + {}; + + //////////////////////////////////////////////////////////////////////////////// + /// \class UnRegisterOnDeleteSet + /// + /// \ingroup RegisterGroup + /// Implements a generic register class which unregisters classes of a typelist + /// + /// \par Usage + /// see test/Register + //////////////////////////////////////////////////////////////////////////////// + template<typename ElementList> + struct UnRegisterOnDeleteSet + : GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement> + {}; + + + //////////////////////////////////////////////////////////////////////////////// + /// \def LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST ) + /// + /// \ingroup RegisterGroup + /// Check if CLASS is in the typelist LIST. + /// + /// \par Usage + /// see test/Register + //////////////////////////////////////////////////////////////////////////////// + + +#define LOKI_CONCATE(a,b,c,d) a ## b ## c ## d +#define LOKI_CONCAT(a,b,c,d) LOKI_CONCATE(a,b,c,d) + +#define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST ) \ + \ + struct LOKI_CONCAT(check_,CLASS,_isInList_,LIST) \ + { \ + typedef int LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST); \ + }; \ + typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1, \ + CLASS, \ + LOKI_CONCAT(check_,CLASS,_isInList_,LIST)> \ + ::Result LOKI_CONCAT(CLASS,isInList,LIST,result); \ + typedef LOKI_CONCAT(CLASS,isInList,LIST,result):: \ + LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList_,LIST) \ + LOKI_CONCAT(ERROR_class_,CLASS,_isNotInList__,LIST); + + +} // namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/SPCachedFactory.h b/shared/loki/SPCachedFactory.h new file mode 100644 index 00000000..71c72644 --- /dev/null +++ b/shared/loki/SPCachedFactory.h @@ -0,0 +1,204 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 by Guillaume Chatelet +// +// Code covered by the MIT License +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// +// The authors make no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied warranty. +// +// This code DOES NOT accompany the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// +//////////////////////////////////////////////////////////////////////////////// + +// $Id: SPCachedFactory.h 896 2008-08-08 22:20:05Z syntheticpp $ + +#ifndef SPCACHEDFACTORY_H_ +#define SPCACHEDFACTORY_H_ + +/** + * This file is intented to be used if you want a CachedFactory with + * a SmartPointer encapsulation policy. + * It as been defined in a separate file because of the many introduced + * dependencies (SmartPtr.h would depend on Functor.h and CachedFactory.h + * would depend on SmartPtr.h). By defining another header you pay for those + * extra dependencies only if you need it. + * + * This file defines FunctionStorage a new SmartPointer storage policy and + * SmartPointer a new CachedFactory encapsulation policy. + */ + +#include <loki/Functor.h> +#include <loki/SmartPtr.h> +#include <loki/CachedFactory.h> + +namespace Loki +{ + +//////////////////////////////////////////////////////////////////////////////// +/// \class FunctionStorage +/// +/// \ingroup SmartPointerStorageGroup +/// \brief Implementation of the StoragePolicy used by SmartPtr. +/// +/// This storage policy is used by SmartPointer CachedFactory's encapsulation +/// policy. It's purpose is to call a Functor instead of deleting the +/// underlying pointee object. You have to set the callback functor by calling +/// SetCallBackFunction(const FunctorType &functor). +/// +/// Unfortunately, the functor argument is not a reference to the SmartPtr but +/// a void *. Making functor argument a reference to the pointer would require +/// the FunctionStorage template to know the full definition of the SmartPtr. +//////////////////////////////////////////////////////////////////////////////// + + template <class T> + class FunctionStorage + { + public: + /// the type of the pointee_ object + typedef T* StoredType; + /// type used to declare OwnershipPolicy type. + typedef T* InitPointerType; + /// type returned by operator-> + typedef T* PointerType; + /// type returned by operator* + typedef T& ReferenceType; + /// type of the Functor to set + typedef Functor< void , Seq< void* > > FunctorType; + + FunctionStorage() : pointee_(Default()), functor_() + {} + + // The storage policy doesn't initialize the stored pointer + // which will be initialized by the OwnershipPolicy's Clone fn + FunctionStorage(const FunctionStorage& rsh) : pointee_(0), functor_(rsh.functor_) + {} + + template <class U> + FunctionStorage(const FunctionStorage<U>& rsh) : pointee_(0), functor_(rsh.functor_) + {} + + FunctionStorage(const StoredType& p) : pointee_(p), functor_() {} + + PointerType operator->() const { return pointee_; } + + ReferenceType operator*() const { return *pointee_; } + + void Swap(FunctionStorage& rhs) + { + std::swap(pointee_, rhs.pointee_); + std::swap(functor_, rhs.functor_); + } + + /// Sets the callback function to call. You have to specify it or + /// the smartPtr will throw a bad_function_call exception. + void SetCallBackFunction(const FunctorType &functor) + { + functor_ = functor; + } + + // Accessors + template <class F> + friend typename FunctionStorage<F>::PointerType GetImpl(const FunctionStorage<F>& sp); + + template <class F> + friend const typename FunctionStorage<F>::StoredType& GetImplRef(const FunctionStorage<F>& sp); + + template <class F> + friend typename FunctionStorage<F>::StoredType& GetImplRef(FunctionStorage<F>& sp); + + protected: + // Destroys the data stored + // (Destruction might be taken over by the OwnershipPolicy) + void Destroy() + { + functor_(this); + } + + // Default value to initialize the pointer + static StoredType Default() + { return 0; } + + private: + // Data + StoredType pointee_; + FunctorType functor_; + }; + + template <class T> + inline typename FunctionStorage<T>::PointerType GetImpl(const FunctionStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline const typename FunctionStorage<T>::StoredType& GetImplRef(const FunctionStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline typename FunctionStorage<T>::StoredType& GetImplRef(FunctionStorage<T>& sp) + { return sp.pointee_; } + + /** + * \class SmartPointer + * \ingroup EncapsulationPolicyCachedFactoryGroup + * \brief Encapsulate the object in a SmartPtr with FunctionStorage policy. + * + * The object will come back to the Cache as soon as no more SmartPtr are + * referencing this object. You can customize the SmartPointer with the standard + * SmartPtr policies (OwnershipPolicy, ConversionPolicy, CheckingPolicy, + * ConstnessPolicy) but StoragePolicy is forced to FunctionStorage. + */ + template + < + class AbstractProduct, + template <class> class OwnershipPolicy = RefCounted, + class ConversionPolicy = DisallowConversion, + template <class> class CheckingPolicy = AssertCheck, + template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS + > + class SmartPointer + { + private: + typedef SmartPtr< AbstractProduct,OwnershipPolicy, + ConversionPolicy, CheckingPolicy, + FunctionStorage, ConstnessPolicy > CallBackSP; + protected: + typedef CallBackSP ProductReturn; + SmartPointer() : fun(this, &SmartPointer::smartPointerCallbackFunction) {} + virtual ~SmartPointer(){} + + ProductReturn encapsulate(AbstractProduct* pProduct) + { + CallBackSP SP(pProduct); + SP.SetCallBackFunction(fun); + return SP; + } + + AbstractProduct* release(ProductReturn &pProduct) + { + return GetImpl(pProduct); + } + + const char* name(){return "smart pointer";} + + private: + SmartPointer& operator=(const SmartPointer&); + SmartPointer(const SmartPointer&); + void smartPointerCallbackFunction(void* pSP) + { + CallBackSP &SP(*reinterpret_cast<CallBackSP*>(pSP)); + ReleaseObject(SP); + } + virtual void ReleaseObject(ProductReturn &object)=0; + const typename CallBackSP::FunctorType fun; + }; + +} // namespace Loki + +#endif /*SPCACHEDFACTORY_H_*/ diff --git a/shared/loki/SafeBits.h b/shared/loki/SafeBits.h new file mode 100644 index 00000000..f45065ed --- /dev/null +++ b/shared/loki/SafeBits.h @@ -0,0 +1,514 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2009 by Fedor Pikus & Rich Sposato +// The copyright on this file is protected under the terms of the MIT license. +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// +// The author makes no claims about the suitability of this software for any +// purpose. It is provided "as is" without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// + +// $Id$ + + +#ifndef LOKI_INCLUDED_SAFE_BIT_FIELDS_H +#define LOKI_INCLUDED_SAFE_BIT_FIELDS_H + +#include <cstdlib> +#include <assert.h> +#include <loki/static_check.h> + + +namespace Loki +{ + +/* + ========================================================================================================================================== + SafeBitField - type-safe class for bit fields. + SafeBitConst - type-safe class for bit constants. + SafeBitField is designed to be a [almost] drop-in replacement for integer flags and bit fields where individual bits are set and checked + using symbolic names for flags: + + typedef unsigned long Labels_t; + Labels_t labels; + const Labels_t Label_A = 0x00000001; + const Labels_t Label_B = 0x00000002; + ... + labels |= Label_B; + if ( labels & Label_A ) { ... } + + Such code offers no protection against mismatching bit constants and bit fields: + + typedef unsigned long Kinds_t; + Kinds_t kinds; + const Kinds_t Kind_A = 0x00000004; + ... + if ( kinds & Label_A ) { ... } // Error but compiles + + SafeBitField is a drop-in replacement which generates a unique type for each bit field. Bit fields of different types cannot be applied + to each other: + + LOKI_BIT_FIELD( unsigned long ) Labels_t; + Labels_t labels; + LOKI_BIT_CONST( Labels_t, Label_A, 1 ); // 0x0001 - 1st bit is set + LOKI_BIT_CONST( Labels_t, Label_B, 2 ); // 0x0002 - 1st bit is set + ... + LOKI_BIT_FIELD( unsigned long ) Kinds_t; + Kinds_t kinds; + LOKI_BIT_CONST( Kinds_t, Kind_A, 3 ); // 0x0004 - 1st bit is set + ... + if ( kinds & Label_A ) { ... } // Does not compile + + Several other kinds of bit field misuse are caught by safe bit fields: + + if ( kinds & Kind_A == 0 ) { ... } + if ( kinds && Kind_A ) { ... } + + There are few cases where drop-in replacement does not work: + + 1. Operations involving bit fields and unnamed integers. Usually the integer in question is 0: + + Labels_t labels = 0; // No longer compiles + if ( ( labels & Label_A ) == 0 ) { ... } // Also does not compile + + The solution is to use named bit constants, including the one for 0: + + LOKI_BIT_CONST( Labels_t, Label_None, 0 ); // 0x0000 - No bit is set + Labels_t labels = Label_None; // Or just Labels_t labels; - constructor initializes to 0 + if ( ( labels & Label_A ) == Label_None ) { ... } // // Or just if ( labels & Label_A ) { ... } + + 2. I/O and other operations which require integer variables and cannot be modified: + + void write_to_db( unsigned int word ); + Labels_t labels; + write_to_db( labels ); // No longer compiles + + This problem is solved by reinterpreting the bit fields as an integer, the user is responsible for using the right + type of integer: + + write_to_db( *((Labels_t::bit_word_t*)(&labels)) ); + + ========================================================================================================================================== +*/ + +/// @par Non-Templated Initialization. +/// Not all compilers support template member functions where the template +/// arguments are not deduced but explicitly specified. For these broken +/// compilers, a non-template make_bit_const() function is provided instead of +/// the template one. The only downside is that instead of compile-time checking +/// of the index argument, it does runtime checking. +#if defined(__SUNPRO_CC) || ( defined(__GNUC__) && (__GNUC__ < 3) ) + #define LOKI_BIT_FIELD_NONTEMPLATE_INIT +#endif + +/// @par Forbidding Conversions. +/// This incomplete type prevents compilers from instantiating templates for +/// type conversions which should not happen. This incomplete type must be a +/// template: if the type is incomplete at the point of template definition, +/// the template is illegal (although the standard allows compilers to accept +/// or reject such code, §14.6/, so some compilers will not issue diagnostics +/// unless template is instantiated). The standard-compliant way is to defer +/// binding to the point of instantiation by making the incomplete type itself +/// a template. +template < typename > struct Forbidden_conversion; // This struct must not be defined! + +/// Forward declaration of the field type. +template < + unsigned int unique_index, + typename word_t = unsigned long +> class SafeBitField; + +//////////////////////////////////////////////////////////////////////////////// +/// \class SafeBitConst Bit constants. +/// This class defines a bit-field constant - a collection of unchanging bits +/// used to compare to bit-fields. Instances of this class are intended to act +/// as labels for bit-fields. +/// +/// \par Safety +/// - This class provides operations used for comparisons and conversions, but +/// no operations which may modify the value. +/// - As a templated class, it provides type-safety so bit values and constants +/// used for different reasons may not be unknowingly compared to each other. +/// - The unique_index template parameter insures the unique type of each bit +/// bit-field. It shares the unique_index with a similar SafeBitField. +/// - Its operations only allow comparisons to other bit-constants and +/// bit-fields of the same type. +//////////////////////////////////////////////////////////////////////////////// + +template +< + unsigned int unique_index, + typename word_t = unsigned long +> +class SafeBitConst +{ +public: + + /// Type of the bit field is available if needed. + typedef word_t bit_word_t; + /// Corresponding field type. + typedef SafeBitField< unique_index, word_t > field_t; + /// Typedef is not allowed in friendship declaration. + friend class SafeBitField< unique_index, word_t >; + + // Static factory constructor, creates a bit constant with one bit set. The position of the bit is given by the template parameter, + // bit 1 is the junior bit, i.e. make_bit_const<1>() returns 1. Bit index 0 is a special case and returns 0. + // This function should be used only to initialize the static bit constant objects. + // This function will not compile if the bit index is outside the vaild range. + // There is also a compile-time assert to make sure the size of the class is the same as the size of the underlaying integer type. + // This assert could go into the constructor, but aCC does not seem to understand sizeof(SafeBitConst) in the constructor. + // +#ifndef LOKI_BIT_FIELD_NONTEMPLATE_INIT + template < unsigned int i > static SafeBitConst make_bit_const() + { + LOKI_STATIC_CHECK( i <= ( 8 * sizeof(word_t) ), Index_is_beyond_size_of_data ); + LOKI_STATIC_CHECK( sizeof(SafeBitConst) == sizeof(word_t), Object_size_does_not_match_data_size ); + // Why check for ( i > 0 ) again inside the shift if the shift + // can never be evaluated for i == 0? Some compilers see shift by ( i - 1 ) + // and complain that for i == 0 the number is invalid, without + // checking that shift needs evaluating. + return SafeBitConst( ( i > 0 ) ? ( word_t(1) << ( ( i > 0 ) ? ( i - 1 ) : 0 ) ) : 0 ); + } +#else + static SafeBitConst make_bit_const( unsigned int i ) + { + LOKI_STATIC_CHECK( sizeof(SafeBitConst) == sizeof(word_t), Object_size_does_not_match_data_size ); + assert( i <= ( 8 * sizeof(word_t) ) ); // Index is beyond size of data. + // Why check for ( i > 0 ) again inside the shift if the shift + // can never be evaluated for i == 0? Some compilers see shift by ( i - 1 ) + // and complain that for i == 0 the number is invalid, without + // checking that shift needs evaluating. + return SafeBitConst( ( i > 0 ) ? ( word_t(1) << ( ( i > 0 ) ? ( i - 1 ) : 0 ) ) : 0 ); + } +#endif + + /// Default constructor allows client code to construct bit fields on the stack. + SafeBitConst() : word( 0 ) {} + + /// Copy constructor. + SafeBitConst( const SafeBitConst& rhs ) : word( rhs.word ) {} + + /// Comparison operators which take a constant bit value. + bool operator == ( const SafeBitConst & rhs ) const { return word == rhs.word; } + bool operator != ( const SafeBitConst & rhs ) const { return word != rhs.word; } + bool operator < ( const SafeBitConst & rhs ) const { return word < rhs.word; } + bool operator > ( const SafeBitConst & rhs ) const { return word > rhs.word; } + bool operator <= ( const SafeBitConst & rhs ) const { return word <= rhs.word; } + bool operator >= ( const SafeBitConst & rhs ) const { return word >= rhs.word; } + + /// Comparision operators for mutable bit fields. + bool operator == ( const field_t & rhs ) const { return word == rhs.word; } + bool operator != ( const field_t & rhs ) const { return word != rhs.word; } + bool operator < ( const field_t & rhs ) const { return word < rhs.word; } + bool operator > ( const field_t & rhs ) const { return word > rhs.word; } + bool operator <= ( const field_t & rhs ) const { return word <= rhs.word; } + bool operator >= ( const field_t & rhs ) const { return word >= rhs.word; } + + /// Bitwise operations. Operation-assignment operators are not needed, + /// since bit constants cannot be changed after they are initialized. + const SafeBitConst operator | ( const SafeBitConst & rhs ) const { return SafeBitConst( word | rhs.word ); } + const SafeBitConst operator & ( const SafeBitConst & rhs ) const { return SafeBitConst( word & rhs.word ); } + const SafeBitConst operator ^ ( const SafeBitConst & rhs ) const { return SafeBitConst( word ^ rhs.word ); } + const SafeBitConst operator ~ ( void ) const { return SafeBitConst( ~word ); } + + /// These bitwise operators return a bit-field instead of a bit-const. + field_t operator | ( const field_t & rhs ) const { return field_t( word | rhs.word ); } + field_t operator & ( const field_t & rhs ) const { return field_t( word & rhs.word ); } + field_t operator ^ ( const field_t & rhs ) const { return field_t( word ^ rhs.word ); } + + /// The shift operators move bits inside the bit field. These are useful in + /// loops which act over bit fields and increment them. + const SafeBitConst operator << ( unsigned int s ) const { return SafeBitConst( word << s ); } + const SafeBitConst operator >> ( unsigned int s ) const { return SafeBitConst( word >> s ); } + + /// Word size is also the maximum number of different bit fields for a given word type. + static size_t size() { return ( 8 * sizeof( word_t ) ); } + +private: + + /// Copy-assignment operator is not implemented since it does not make sense + /// for a constant object. + SafeBitConst operator = ( const SafeBitConst & rhs ); + + // Private constructor from an integer type. + explicit SafeBitConst( word_t init ) : word( init ) {} + + /// This data stores a single bit value. It is declared const to enforce + // constness for all functions of this class. + const word_t word; + + // Here comes the interesting stuff: all the operators designed to + // trap unintended conversions and make them not compile. + // Operators below handle code like this: + // SafeBitField<1> label1; + // SafeBitField<2> label2; + // if ( label1 & label2 ) { ... } + + // These operators are private, and will not instantiate in any + // event because of the incomplete Forbidden_conversion struct. + template < typename T > SafeBitConst operator|( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitConst operator&( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitConst operator^( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitConst operator|=( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitConst operator&=( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitConst operator^=( T ) const { Forbidden_conversion< T > wrong; return *this; } + + // And the same thing for comparisons: private and unusable. + // if ( label1 == label2 ) { ... } + template < typename T > bool operator==( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator!=( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator<( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator>( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator<=( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator>=( const T ) const { Forbidden_conversion< T > wrong; return true; } +}; + + +//////////////////////////////////////////////////////////////////////////////// +/// \class SafeBitConst Bit constants. +/// This class defines a bit-field constant - a collection of unchanging bits +/// used to compare to bit-fields. Instances of this class are intended to +/// store bit values. +/// +/// \par Safety +/// - This class provides operations used for comparisons and conversions, and +/// also operations which may safely modify the value. +/// - As a templated class, it provides type-safety so bit values and constants +/// used for different reasons may not be unknowingly compared to each other. +/// - The unique_index template parameter insures the unique type of each bit +/// bit-field. It shares the unique_index with a similar SafeBitConst. +/// - Its operations only allow comparisons to other bit-constants and +/// bit-fields of the same type. +//////////////////////////////////////////////////////////////////////////////// + +template +< + unsigned int unique_index, + typename word_t +> +class SafeBitField +{ +public: + + /// Type of the bit field is available if needed. + typedef word_t bit_word_t; + /// Corresponding field type. + typedef SafeBitConst< unique_index, word_t > const_t; + /// Typedef is not allowed in friendship declaration. + friend class SafeBitConst<unique_index, word_t>; + + /// Default constructor allows client code to construct bit fields on the stack. + SafeBitField() : word( 0 ) {} + + /// Copy constructor and assignment operators. + SafeBitField( const SafeBitField & rhs ) : word( rhs.word ) {} + SafeBitField & operator = ( const SafeBitField & rhs ) { word = rhs.word; return *this; } + + /// Copy constructor and assignment operators from constant bit fields. + SafeBitField( const const_t & rhs ) : word( rhs.word ) {} + SafeBitField & operator = ( const const_t & rhs ) { word = rhs.word; return *this; } + + /// These comparison operators act on bit-fields of the same type. + bool operator == ( const SafeBitField & rhs ) const { return word == rhs.word; } + bool operator != ( const SafeBitField & rhs ) const { return word != rhs.word; } + bool operator < ( const SafeBitField & rhs ) const { return word < rhs.word; } + bool operator > ( const SafeBitField & rhs ) const { return word > rhs.word; } + bool operator <= ( const SafeBitField & rhs ) const { return word <= rhs.word; } + bool operator >= ( const SafeBitField & rhs ) const { return word >= rhs.word; } + + /// These comparison operators act on bit-constants of a similar type. + bool operator == ( const const_t & rhs ) const { return word == rhs.word; } + bool operator != ( const const_t & rhs ) const { return word != rhs.word; } + bool operator < ( const const_t & rhs ) const { return word < rhs.word; } + bool operator > ( const const_t & rhs ) const { return word > rhs.word; } + bool operator <= ( const const_t & rhs ) const { return word <= rhs.word; } + bool operator >= ( const const_t & rhs ) const { return word >= rhs.word; } + + /// Bitwise operations that use bit-fields. + SafeBitField operator | ( const SafeBitField & rhs ) const { return SafeBitField( word | rhs.word ); } + SafeBitField operator & ( const SafeBitField & rhs ) const { return SafeBitField( word & rhs.word ); } + SafeBitField operator ^ ( const SafeBitField & rhs ) const { return SafeBitField( word ^ rhs.word ); } + SafeBitField operator ~ ( void ) const { return SafeBitField( ~word ); } + SafeBitField operator |= ( const SafeBitField & rhs ) { word |= rhs.word; return SafeBitField( *this ); } + SafeBitField operator &= ( const SafeBitField & rhs ) { word &= rhs.word; return SafeBitField( *this ); } + SafeBitField operator ^= ( const SafeBitField & rhs ) { word ^= rhs.word; return SafeBitField( *this ); } + + /// Bitwise operators that use bit-constants. + SafeBitField operator | ( const_t rhs ) const { return SafeBitField( word | rhs.word ); } + SafeBitField operator & ( const_t rhs ) const { return SafeBitField( word & rhs.word ); } + SafeBitField operator ^ ( const_t rhs ) const { return SafeBitField( word ^ rhs.word ); } + SafeBitField operator |= ( const_t rhs ) { word |= rhs.word; return SafeBitField( *this ); } + SafeBitField operator &= ( const_t rhs ) { word &= rhs.word; return SafeBitField( *this ); } + SafeBitField operator ^= ( const_t rhs ) { word ^= rhs.word; return SafeBitField( *this ); } + + // Conversion to bool. + // This is a major source of headaches, but it's required to support code like this: + // const static SafeBitConst<1> Label_value = SafeBitConst<1>::make_bit_const<1>(); + // SafeBitField<1> label; + // if ( label & Label_value ) { ... } // Nice... + // + // The downside is that this allows all sorts of nasty conversions. Without additional precautions, bit fields of different types + // can be converted to bool and then compared or operated on: + // SafeBitField<1> label1; + // SafeBitField<2> label2; + // if ( label1 == label2 ) { ... } // Yuck! + // if ( label1 & label2 ) { ... } // Blech! + // + // It is somewhat safer to convert to a pointer, at least pointers to different types cannot be readilly compared, and there are no + // bitwise operations on pointers, but the conversion from word_t to a pointer can have run-time cost if they are of different size. + // + operator const bool() const { return ( 0 != word ); } + + // Shift operators shift bits inside the bit field. Does not make + // sense, most of the time, except perhaps to loop over labels and + // increment them. + SafeBitField operator << ( unsigned int s ) { return SafeBitField( word << s ); } + SafeBitField operator >> ( unsigned int s ) { return SafeBitField( word >> s ); } + SafeBitField operator <<= ( unsigned int s ) { word <<= s; return *this; } + SafeBitField operator >>= ( unsigned int s ) { word >>= s; return *this; } + + // Word size is also the maximum number of different bit fields for + // a given word type. + static size_t size( void ) { return ( 8 * sizeof( word_t ) ); } + +private: + + /// Private constructor from an integer type. Don't put too much stock into + /// explicit declaration, it's better than nothing but does not solve all + /// problems with undesired conversions because SafeBitField coverts to bool. + explicit SafeBitField( word_t init ) : word( init ) {} + + /// This stores the bits. + word_t word; + + // Here comes the interesting stuff: all the operators designed to + // trap unintended conversions and make them not compile. + // Operators below handle code like this: + // SafeBitField<1> label1; + // SafeBitField<2> label2; + // if ( label1 & label2 ) { ... } + + // These operators are private, and will not instantiate in any + // event because of the incomplete Forbidden_conversion struct. + template < typename T > SafeBitField operator | ( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitField operator & ( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitField operator ^ ( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitField operator |= ( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitField operator &= ( T ) const { Forbidden_conversion< T > wrong; return *this; } + template < typename T > SafeBitField operator ^= ( T ) const { Forbidden_conversion< T > wrong; return *this; } + + // And the same thing for comparisons: + // if ( label1 == label2 ) { ... } + template < typename T > bool operator == ( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator != ( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator < ( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator > ( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator <= ( const T ) const { Forbidden_conversion< T > wrong; return true; } + template < typename T > bool operator >= ( const T ) const { Forbidden_conversion< T > wrong; return true; } +}; + +// The above template member operators catch errors when the first +// argument to a binary operator is a label, but they don't work when +// the first argument is an integer and the second one is a label: the +// label converts to bool and the operator is performed on two integers. +// These operators catch errors like this: +// SafeBitField<1> label1; +// SafeBitField<2> label2; +// if ( !label1 & label2 ) { ... } +// where the first label is converted to bool (these errors cannot be +// caught by member operators of SafeBitField class because the first +// argument is not SafeBitField but bool. +// +// If used, these operators will not instantiate because of the +// incomplete Forbidden_conversion struct. + +template < unsigned int unique_index, typename word_t > +inline SafeBitField< unique_index, word_t > operator & ( bool, SafeBitField< unique_index, word_t > rhs ) +{ + Forbidden_conversion<word_t> wrong; + return rhs; +} + +template < unsigned int unique_index, typename word_t > +inline SafeBitField< unique_index, word_t > operator | ( bool, SafeBitField< unique_index, word_t > rhs ) +{ + Forbidden_conversion< word_t > wrong; + return rhs; +} + +template < unsigned int unique_index, typename word_t > +inline SafeBitField< unique_index, word_t > operator ^ ( bool, SafeBitField< unique_index, word_t > rhs ) +{ + Forbidden_conversion< word_t > wrong; + return rhs; +} + +template < unsigned int unique_index, typename word_t > +inline SafeBitField< unique_index, word_t > operator == ( bool, SafeBitField< unique_index, word_t > rhs ) +{ + Forbidden_conversion< word_t > wrong; + return rhs; +} + +template < unsigned int unique_index, typename word_t > +inline SafeBitField< unique_index, word_t > operator != ( bool, SafeBitField< unique_index, word_t > rhs ) +{ + Forbidden_conversion< word_t > wrong; + return rhs; +} + +// Finally, few macros. All macros are conditionally defined to use the SafeBitField classes if LOKI_SAFE_BIT_FIELD is defined. Otherwise, +// the macros fall back on the use of typedefs and integer constants. This provides no addititonal safety but allows the code to support the +// mixture of compilers which are broken to different degrees. +#define LOKI_SAFE_BIT_FIELD + +// The first macro helps to declare new bit field types: +// LOKI_BIT_FIELD( ulong ) field_t; +// This creates a typedef field_t for SafeBitField<unique_index, ulong> where index is the current line number. Since line numbers __LINE__ are counted +// separately for all header files, this ends up being the same type in all files using the header which defines field_t. +#ifdef LOKI_SAFE_BIT_FIELD + #define LOKI_BIT_FIELD( word_t ) typedef SafeBitField<__LINE__, word_t> +#else + #define LOKI_BIT_FIELD( word_t ) typedef word_t +#endif // LOKI_SAFE_BIT_FIELD + +// The second macro helps to declare static bit constants: +// LOKI_BIT_CONST( field_t, Label_1, 1 ); +// creates new bit field object named Label_1 of type field_t which represents the field with the 1st (junior) bit set. +#ifdef LOKI_SAFE_BIT_FIELD + #ifndef LOKI_BIT_FIELD_NONTEMPLATE_INIT + #define LOKI_BIT_CONST( field_t, label, bit_index ) \ + static const field_t::const_t label = field_t::const_t::make_bit_const<bit_index>() + #else + #define LOKI_BIT_CONST( field_t, label, bit_index ) \ + static const field_t::const_t label = field_t::const_t::make_bit_const( bit_index ) + #endif // LOKI_BIT_FIELD_NONTEMPLATE_INIT +#else + inline size_t make_bit_const( size_t i ) { return ( i > 0 ) ? ( size_t(1) << ( ( i > 0 ) ? ( i - 1 ) : 0 ) ) : 0; } + #define LOKI_BIT_CONST( field_t, label, bit_index ) static const field_t label = make_bit_const( bit_index ) +#endif // LOKI_SAFE_BIT_FIELD + +// The third macro helps to declare complex bit constants which are combination of several bits: +// LOKI_BIT_CONSTS( field_t, Label12 ) = Label_1 | Label_2; +#ifdef LOKI_SAFE_BIT_FIELD + #define LOKI_BIT_CONSTS( field_t, label ) static const field_t::const_t label +#else + #define LOKI_BIT_CONSTS( field_t, label ) static const field_t label +#endif // LOKI_SAFE_BIT_FIELD + +// The fourth macro helps to declare the maximum number of bit constants for a given type: +// static const size_t count = LOKI_BIT_FIELD_COUNT( field_t ); +// declared a variable "count" initialized to field_t::size() +#ifdef LOKI_SAFE_BIT_FIELD + #define LOKI_BIT_FIELD_COUNT( field_t ) field_t::size() +#else + #define LOKI_BIT_FIELD_COUNT( field_t ) ( 8 * sizeof(field_t) ) +#endif // LOKI_SAFE_BIT_FIELD + +} // namespace Loki + +#endif // LOKI_INCLUDED_SAFE_BIT_FIELDS_H diff --git a/shared/loki/SafeFormat.h b/shared/loki/SafeFormat.h new file mode 100644 index 00000000..9d948581 --- /dev/null +++ b/shared/loki/SafeFormat.h @@ -0,0 +1,590 @@ +//////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2005 by Andrei Alexandrescu +// Copyright (c) 2006 Peter Kümmel +// Permission to use, copy, modify, distribute, and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the suitability of this software +// for any purpose. It is provided "as is" without express or implied +// warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_SAFEFORMAT_INC_ +#define LOKI_SAFEFORMAT_INC_ + +// $Id: SafeFormat.h 911 2008-12-15 20:55:24Z syntheticpp $ + + +//////////////////////////////////////////////////////////////////////////////// +// This file contains definitions for SafePrintf. SafeScanf coming soon (the +// design is similar). +// See Alexandrescu, Andrei: Type-safe Formatting, C/C++ Users Journal, Aug 2005 +//////////////////////////////////////////////////////////////////////////////// + +#include <cstdio> +#include <climits> +#include <string> +#include <cstring> +#include <stdexcept> +#include <utility> +#include <cassert> +#include <locale> +#include <iostream> + +#include <loki/LokiExport.h> + + +// long is 32 bit on 64-bit Windows! +// intptr_t used to get 64 bit on Win64 +#if defined(_WIN32) || defined(_WIN64) +# define LOKI_SAFEFORMAT_SIGNED_LONG intptr_t +# define LOKI_SAFEFORMAT_UNSIGNED_LONG uintptr_t +#else +# define LOKI_SAFEFORMAT_SIGNED_LONG signed long +# define LOKI_SAFEFORMAT_UNSIGNED_LONG unsigned long +#endif + +// Windows headers could have min/max defined +#ifdef max +# undef max +#endif +#ifdef min +# undef min +#endif + +namespace Loki +{ + + // Crude writing method: writes straight to the file, unbuffered + // Must be combined with a buffer to work properly (and efficiently) + LOKI_EXPORT + void write(std::FILE* f, const char* from, const char* to); + + // Write to an ostream + LOKI_EXPORT + void write(std::ostream& f, const char* from, const char* to); + + // Write to a string + LOKI_EXPORT + void write(std::string& s, const char* from, const char* to); + + // Write to a fixed-size buffer + template <class Char> + void write(std::pair<Char*, std::size_t>& s, const Char* from, const Char* to) { + assert(from <= to); + if(from + s.second < to) + throw std::overflow_error(""); + // s.first: position one past the final copied element + s.first = std::copy(from, to, s.first); + // remaining buffer size + s.second -= to - from; + } + + //////////////////////////////////////////////////////////////////////////////// + // PrintfState class template + // Holds the formatting state, and implements operator() to format stuff + // Todo: make sure errors are handled properly + //////////////////////////////////////////////////////////////////////////////// + + template <class Device, class Char> + struct PrintfState { + PrintfState(Device dev, const Char * format) + : device_(dev) + , format_(format) + , width_(0) + , prec_(0) + , flags_(0) + , result_(0) { + Advance(); + } + + ~PrintfState() { + } + + #define LOKI_PRINTF_STATE_FORWARD(type) \ + PrintfState& operator()(type par) {\ + return (*this)(static_cast< LOKI_SAFEFORMAT_UNSIGNED_LONG >(par)); \ + } + + LOKI_PRINTF_STATE_FORWARD(bool) + LOKI_PRINTF_STATE_FORWARD(char) + LOKI_PRINTF_STATE_FORWARD(signed char) + LOKI_PRINTF_STATE_FORWARD(unsigned char) + LOKI_PRINTF_STATE_FORWARD(signed short) + LOKI_PRINTF_STATE_FORWARD(unsigned short) + LOKI_PRINTF_STATE_FORWARD(signed int) + LOKI_PRINTF_STATE_FORWARD(signed long) +#if (defined(_WIN32) || defined(_WIN64)) + LOKI_PRINTF_STATE_FORWARD(unsigned long) +#else + // on Windows already defined by uintptr_t + LOKI_PRINTF_STATE_FORWARD(unsigned int) +#endif + + // Print (or gobble in case of the "*" specifier) an int + PrintfState& operator()(LOKI_SAFEFORMAT_UNSIGNED_LONG i) { + if (result_ == -1) return *this; // don't even bother + // % [flags] [width] [.prec] [modifier] type_char + // Fetch the flags + ReadFlags(); + if (*format_ == '*') { + // read the width and get out + SetWidth(static_cast<size_t>(i)); + ++format_; + return *this; + } + ReadWidth(); + // precision + if (*format_ == '.') { + // deal with precision + if (format_[1] == '*') { + // read the precision and get out + SetPrec(static_cast<size_t>(i)); + format_ += 2; + return *this; + } + ReadPrecision(); + } + ReadModifiers(); + // input size modifier + if (ForceShort()) { + // short int + const Char c = *format_; + if (c == 'x' || c == 'X' || c == 'u' || c == 'o') { + i = static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(static_cast<unsigned short>(i)); + } + } + FormatWithCurrentFlags(i); + return *this; + } + + PrintfState& operator()(void* n) { + if (result_ == -1) return *this; // don't even bother + PrintUsing_snprintf(n,"p"); + return *this; + } + + PrintfState& operator()(double n) { + if (result_ == -1) return *this; // don't even bother + PrintUsing_snprintf(n,"eEfgG"); + return *this; + } + + PrintfState& operator()(long double n) { + if (result_ == -1) return *this; // don't even bother + PrintUsing_snprintf(n,"eEfgG"); + return *this; + } + + // Store the number of characters printed so far + PrintfState& operator()(int * pi) { + return StoreCountHelper(pi); + } + + // Store the number of characters printed so far + PrintfState& operator()(short * pi) { + return StoreCountHelper(pi); + } + + // Store the number of characters printed so far + PrintfState& operator()(long * pi) { + return StoreCountHelper(pi); + } + + PrintfState& operator()(const std::string& stdstr) { + return operator()(stdstr.c_str()); + } + + PrintfState& operator()(const char *const s) { + if (result_ == -1) return *this; + ReadLeaders(); + const char fmt = *format_; + if (fmt == 'p') { + FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(s)); + return *this; + } + if (fmt != 's') { + result_ = -1; + return *this; + } + const size_t len = std::min(std::strlen(s), prec_); + if (width_ > len) { + if (LeftJustify()) { + Write(s, s + len); + Fill(' ', width_ - len); + } else { + Fill(' ', width_ - len); + Write(s, s + len); + } + } else { + Write(s, s + len); + } + Next(); + return *this; + } + + PrintfState& operator()(const void *const p) { + return (*this)(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(p)); + } + + // read the result + operator int() const { + return static_cast<int>(result_); + } + + private: + PrintfState& operator=(const PrintfState&); + template <typename T> + PrintfState& StoreCountHelper(T *const pi) { + if (result_ == -1) return *this; // don't even bother + ReadLeaders(); + const char fmt = *format_; + if (fmt == 'p') { // pointer + FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(pi)); + return *this; + } + if (fmt != 'n') { + result_ = -1; + return *this; + } + assert(pi != 0); + *pi = result_; + Next(); + return *this; + } + + void FormatWithCurrentFlags(const LOKI_SAFEFORMAT_UNSIGNED_LONG i) { + // look at the format character + Char formatChar = *format_; + bool isSigned = formatChar == 'd' || formatChar == 'i'; + if (formatChar == 'p') { + formatChar = 'x'; // pointers go to hex + SetAlternateForm(); // printed with '0x' in front + isSigned = true; // that's what gcc does + } + if (!strchr("cdiuoxX", formatChar)) { + result_ = -1; + return; + } + Char buf[ + sizeof(LOKI_SAFEFORMAT_UNSIGNED_LONG) * 3 // digits + + 1 // sign or ' ' + + 2 // 0x or 0X + + 1]; // terminating zero + const Char *const bufEnd = buf + (sizeof(buf) / sizeof(Char)); + Char * bufLast = buf + (sizeof(buf) / sizeof(Char) - 1); + Char signChar = 0; + unsigned int base = 10; + + if (formatChar == 'c') { + // Format only one character + // The 'fill with zeros' flag is ignored + ResetFillZeros(); + *bufLast = static_cast<char>(i); + } else { + // TODO: inefficient code, refactor + const bool negative = isSigned && static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i) < 0; + if (formatChar == 'o') base = 8; + else if (formatChar == 'x' || formatChar == 'X') base = 16; + bufLast = isSigned + ? RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i), bufLast, base, + formatChar == 'X') + : RenderWithoutSign(i, bufLast, base, + formatChar == 'X'); + // Add the sign + if (isSigned) { + negative ? signChar = '-' + : ShowSignAlways() ? signChar = '+' + : Blank() ? signChar = ' ' + : 0; + } + } + // precision + size_t + countDigits = bufEnd - bufLast, + countZeros = prec_ != size_t(-1) && countDigits < prec_ && + formatChar != 'c' + ? prec_ - countDigits + : 0, + countBase = base != 10 && AlternateForm() && i != 0 + ? (base == 16 ? 2 : countZeros > 0 ? 0 : 1) + : 0, + countSign = (signChar != 0), + totalPrintable = countDigits + countZeros + countBase + countSign; + size_t countPadLeft = 0, countPadRight = 0; + if (width_ > totalPrintable) { + if (LeftJustify()) { + countPadRight = width_ - totalPrintable; + countPadLeft = 0; + } else { + countPadLeft = width_ - totalPrintable; + countPadRight = 0; + } + } + if (FillZeros() && prec_ == size_t(-1)) { + // pad with zeros and no precision - transfer padding to precision + countZeros = countPadLeft; + countPadLeft = 0; + } + // ok, all computed, ready to print to device + Fill(' ', countPadLeft); + if (signChar != 0) Write(&signChar, &signChar + 1); + if (countBase > 0) Fill('0', 1); + if (countBase == 2) Fill(formatChar, 1); + Fill('0', countZeros); + Write(bufLast, bufEnd); + Fill(' ', countPadRight); + // done, advance + Next(); + } + + void Write(const Char* b, const Char* e) { + if (result_ < 0) return; + const LOKI_SAFEFORMAT_SIGNED_LONG x = e - b; + write(device_, b, e); + result_ += x; + } + + template <class Value> + void PrintUsing_snprintf(Value n, const char* check_fmt_char) { + const Char *const fmt = format_ - 1; + assert(*fmt == '%'); + // enforce format string validity + ReadLeaders(); + // enforce format spec + if (!strchr(check_fmt_char, *format_)) { + result_ = -1; + return; + } + // format char validated, copy it to a temp and use legacy sprintf + ++format_; + Char fmtBuf[128], resultBuf[1024]; + if (format_ >= fmt + sizeof(fmtBuf) / sizeof(Char)) { + result_ = -1; + return; + } + memcpy(fmtBuf, fmt, (format_ - fmt) * sizeof(Char)); + fmtBuf[format_ - fmt] = 0; + + const int stored = +#ifdef _MSC_VER +#if _MSC_VER < 1400 + _snprintf +#else + _snprintf_s +#endif +#else + snprintf +#endif + (resultBuf, sizeof(resultBuf) / sizeof(Char), fmtBuf, n); + + if (stored < 0) { + result_ = -1; + return; + } + Write(resultBuf, resultBuf + strlen(resultBuf)); + Advance(); // output stuff to the next format directive + } + + void Fill(const Char c, size_t n) { + for (; n > 0; --n) { + Write(&c, &c + 1); + } + } + + Char* RenderWithoutSign(LOKI_SAFEFORMAT_UNSIGNED_LONG n, char* bufLast, + unsigned int base, bool uppercase) { + const Char hex1st = uppercase ? 'A' : 'a'; + for (;;) { + const LOKI_SAFEFORMAT_UNSIGNED_LONG next = n / base; + Char c = static_cast<Char>(n - next * base); + c = static_cast<Char>(c + (c <= 9 ? '0' : static_cast<Char>(hex1st - 10))); + *bufLast = c; + n = next; + if (n == 0) break; + --bufLast; + } + return bufLast; + } + + char* RenderWithoutSign(LOKI_SAFEFORMAT_SIGNED_LONG n, char* bufLast, unsigned int base, + bool uppercase) { + if (n != LONG_MIN) { + return RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n < 0 ? -n : n), + bufLast, base, uppercase); + } + // annoying corner case + char* save = bufLast; + ++n; + bufLast = RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n), + bufLast, base, uppercase); + --(*save); + return bufLast; + } + + void Next() { + ++format_; + Advance(); + } + + void Advance() { + ResetAll(); + const Char* begin = format_; + for (;;) { + if (*format_ == '%') { + if (format_[1] != '%') { // It's a format specifier + Write(begin, format_); + ++format_; + break; + } + // It's a "%%" + Write(begin, ++format_); + begin = ++format_; + continue; + } + if (*format_ == 0) { + Write(begin, format_); + break; + } + ++format_; + } + } + + void ReadFlags() { + for (;; ++format_) { + switch (*format_) { + case '-': SetLeftJustify(); break; + case '+': SetShowSignAlways(); break; + case ' ': SetBlank(); break; + case '#': SetAlternateForm(); break; + case '0': SetFillZeros(); break; + default: return; + } + } + } + + void ParseDecimalSizeT(size_t& dest) { + if (!std::isdigit(*format_, std::locale())) return; + size_t r = 0; + do { + // TODO: inefficient - rewrite + r *= 10; + r += *format_ - '0'; + ++format_; + } while (std::isdigit(*format_, std::locale())); + dest = r; + } + + void ReadWidth() { + ParseDecimalSizeT(width_); + } + + void ReadPrecision() { + assert(*format_ == '.'); + ++format_; + ParseDecimalSizeT(prec_); + } + + void ReadModifiers() { + switch (*format_) { + case 'h': SetForceShort(); ++format_; break; + case 'l': ++format_; break; + // more (C99 and platform-specific modifiers) to come + } + } + + void ReadLeaders() { + ReadFlags(); + ReadWidth(); + if (*format_ == '.') ReadPrecision(); + ReadModifiers(); + } + + enum { + leftJustify = 1, + showSignAlways = 2, + blank = 4, + alternateForm = 8, + fillZeros = 16, + forceShort = 32 + }; + + bool LeftJustify() const { return (flags_ & leftJustify) != 0; } + bool ShowSignAlways() const { return (flags_ & showSignAlways) != 0; } + void SetWidth(size_t w) { width_ = w; } + void SetLeftJustify() { flags_ |= leftJustify; } + void SetShowSignAlways() { flags_ |= showSignAlways; } + bool Blank() const { return (flags_ & blank) != 0; } + bool AlternateForm() const { return (flags_ & alternateForm) != 0; } + bool FillZeros() const { return (flags_ & fillZeros) != 0; } + bool ForceShort() const { return (flags_ & forceShort) != 0; } + + void SetPrec(size_t p) { prec_ = p; } + void SetBlank() { flags_ |= blank; } + void SetAlternateForm() { flags_ |= alternateForm; } + void SetFillZeros() { flags_ |= fillZeros; } + void ResetFillZeros() { flags_ &= ~fillZeros; } + void SetForceShort() { flags_ |= forceShort; } + + void ResetAll() { + assert(result_ != EOF); + width_ = 0; + prec_ = size_t(-1); + flags_ = 0; + } + + // state + Device device_; + const Char* format_; + size_t width_; + size_t prec_; + unsigned int flags_; + LOKI_SAFEFORMAT_SIGNED_LONG result_; + }; + + LOKI_EXPORT + PrintfState<std::FILE*, char> Printf(const char* format); + + LOKI_EXPORT + PrintfState<std::FILE*, char> Printf(const std::string& format); + + LOKI_EXPORT + PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const char* format); + + LOKI_EXPORT + PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const std::string& format); + + LOKI_EXPORT + PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const char* format); + + LOKI_EXPORT + PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const std::string& format); + + LOKI_EXPORT + PrintfState<std::string&, char> SPrintf(std::string& s, const char* format); + + LOKI_EXPORT + PrintfState<std::string&, char> SPrintf(std::string& s, const std::string& format); + + template <class T, class Char> + PrintfState<T&, Char> XPrintf(T& device, const Char* format) { + return PrintfState<T&, Char>(device, format); + } + + template <class T> + PrintfState<T&, char> XPrintf(T& device, const std::string& format) { + return PrintfState<T&, char>(device, format.c_str()); + } + + template <class Char, std::size_t N> + PrintfState<std::pair<Char*, std::size_t>, Char> + BufPrintf(Char (&buf)[N], const Char* format) { + std::pair<Char*, std::size_t> temp(buf, N); + return PrintfState<std::pair<Char*, std::size_t>, Char>(temp, format); + } + +}// namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/ScopeGuard.h b/shared/loki/ScopeGuard.h new file mode 100644 index 00000000..a7e61ddd --- /dev/null +++ b/shared/loki/ScopeGuard.h @@ -0,0 +1,666 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2000 Andrei Alexandrescu +// Copyright (c) 2000 Petru Marginean +// Copyright (c) 2005 Joshua Lehrer +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_SCOPEGUARD_INC_ +#define LOKI_SCOPEGUARD_INC_ + +// $Id: ScopeGuard.h 799 2006-12-20 00:37:13Z rich_sposato $ + + +#include <loki/RefToValue.h> + +/// \defgroup ExceptionGroup Exception-safe code + +namespace Loki +{ + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImplBase + /// \ingroup ExceptionGroup + /// + /// Base class used by all ScopeGuard implementations. All commonly used + /// functions are in this class (e.g. - Dismiss and SafeExecute). + /// + /// See Andrei's and Petru Marginean's CUJ article + /// http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/alexandr.htm + /// + /// Changes to the original code by Joshua Lehrer: + /// http://www.lehrerfamily.com/scopeguard.html + //////////////////////////////////////////////////////////////// + + class ScopeGuardImplBase + { + /// Copy-assignment operator is not implemented and private. + ScopeGuardImplBase& operator =(const ScopeGuardImplBase&); + + protected: + + ~ScopeGuardImplBase() + {} + + /// Copy-constructor takes over responsibility from other ScopeGuard. + ScopeGuardImplBase(const ScopeGuardImplBase& other) throw() + : dismissed_(other.dismissed_) + { + other.Dismiss(); + } + + template <typename J> + static void SafeExecute(J& j) throw() + { + if (!j.dismissed_) + try + { + j.Execute(); + } + catch(...) + {} + } + + mutable bool dismissed_; + + public: + ScopeGuardImplBase() throw() : dismissed_(false) + {} + + void Dismiss() const throw() + { + dismissed_ = true; + } + }; + + //////////////////////////////////////////////////////////////// + /// + /// \typedef typedef const ScopeGuardImplBase& ScopeGuard + /// \ingroup ExceptionGroup + /// + //////////////////////////////////////////////////////////////// + + typedef const ScopeGuardImplBase& ScopeGuard; + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImpl0 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a standalone function or class static function + /// with no parameters. ScopeGuard ignores any value returned from the + /// call within the Execute function. + /// + /// This class has a single standalone helper function, MakeGuard which + /// creates and returns a ScopeGuard. + /// + //////////////////////////////////////////////////////////////// + + template <typename F> + class ScopeGuardImpl0 : public ScopeGuardImplBase + { + public: + static ScopeGuardImpl0<F> MakeGuard(F fun) + { + return ScopeGuardImpl0<F>(fun); + } + + ~ScopeGuardImpl0() throw() + { + SafeExecute(*this); + } + + void Execute() + { + fun_(); + } + + protected: + ScopeGuardImpl0(F fun) : fun_(fun) + {} + + F fun_; + }; + + template <typename F> + inline ScopeGuardImpl0<F> MakeGuard(F fun) + { + return ScopeGuardImpl0<F>::MakeGuard(fun); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImpl1 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a standalone function or class static function + /// with one parameter. Each parameter is copied by value - use + /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores + /// any value returned from the call within the Execute function. + /// + /// This class has a single standalone helper function, MakeGuard which + /// creates and returns a ScopeGuard. + /// + //////////////////////////////////////////////////////////////// + + template <typename F, typename P1> + class ScopeGuardImpl1 : public ScopeGuardImplBase + { + public: + static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) + { + return ScopeGuardImpl1<F, P1>(fun, p1); + } + + ~ScopeGuardImpl1() throw() + { + SafeExecute(*this); + } + + void Execute() + { + fun_(p1_); + } + + protected: + ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1) + {} + + F fun_; + const P1 p1_; + }; + + template <typename F, typename P1> + inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) + { + return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImpl2 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a standalone function or class static function + /// with two parameters. Each parameter is copied by value - use + /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores + /// any value returned from the call within the Execute function. + /// + /// This class has a single standalone helper function, MakeGuard which + /// creates and returns a ScopeGuard. + /// + //////////////////////////////////////////////////////////////// + + template <typename F, typename P1, typename P2> + class ScopeGuardImpl2: public ScopeGuardImplBase + { + public: + static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) + { + return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2); + } + + ~ScopeGuardImpl2() throw() + { + SafeExecute(*this); + } + + void Execute() + { + fun_(p1_, p2_); + } + + protected: + ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + }; + + template <typename F, typename P1, typename P2> + inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) + { + return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImpl3 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a standalone function or class static function + /// with three parameters. Each parameter is copied by value - use + /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores + /// any value returned from the call within the Execute function. + /// + /// This class has a single standalone helper function, MakeGuard which + /// creates and returns a ScopeGuard. + /// + //////////////////////////////////////////////////////////////// + + template <typename F, typename P1, typename P2, typename P3> + class ScopeGuardImpl3 : public ScopeGuardImplBase + { + public: + static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) + { + return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3); + } + + ~ScopeGuardImpl3() throw() + { + SafeExecute(*this); + } + + void Execute() + { + fun_(p1_, p2_, p3_); + } + + protected: + ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + }; + + template <typename F, typename P1, typename P2, typename P3> + inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) + { + return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImpl4 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a standalone function or class static function + /// with four parameters. Each parameter is copied by value - use + /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores + /// any value returned from the call within the Execute function. + /// + /// This class has a single standalone helper function, MakeGuard which + /// creates and returns a ScopeGuard. + /// + //////////////////////////////////////////////////////////////// + + template < typename F, typename P1, typename P2, typename P3, typename P4 > + class ScopeGuardImpl4 : public ScopeGuardImplBase + { + public: + static ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( + F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) + { + return ScopeGuardImpl4< F, P1, P2, P3, P4 >( fun, p1, p2, p3, p4 ); + } + + ~ScopeGuardImpl4() throw() + { + SafeExecute( *this ); + } + + void Execute() + { + fun_( p1_, p2_, p3_, p4_ ); + } + + protected: + ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) : + fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + const P4 p4_; + }; + + template < typename F, typename P1, typename P2, typename P3, typename P4 > + inline ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) + { + return ScopeGuardImpl4< F, P1, P2, P3, P4 >::MakeGuard( fun, p1, p2, p3, p4 ); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ScopeGuardImpl5 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a standalone function or class static function + /// with five parameters. Each parameter is copied by value - use + /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores + /// any value returned from the call within the Execute function. + /// + /// This class has a single standalone helper function, MakeGuard which + /// creates and returns a ScopeGuard. + /// + //////////////////////////////////////////////////////////////// + + template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > + class ScopeGuardImpl5 : public ScopeGuardImplBase + { + public: + static ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( + F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) + { + return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >( fun, p1, p2, p3, p4, p5 ); + } + + ~ScopeGuardImpl5() throw() + { + SafeExecute( *this ); + } + + void Execute() + { + fun_( p1_, p2_, p3_, p4_, p5_ ); + } + + protected: + ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) : + fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 ) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + const P4 p4_; + const P5 p5_; + }; + + template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > + inline ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) + { + return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >::MakeGuard( fun, p1, p2, p3, p4, p5 ); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ObjScopeGuardImpl0 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a class per-instance member function with no + /// parameters. ScopeGuard ignores any value returned from the call within + /// the Execute function. + /// + /// This class has 3 standalone helper functions which create a ScopeGuard. + /// One is MakeObjGuard, which is deprecated but provided for older code. + /// The other two are MakeGuard overloads, one which takes a pointer to an + /// object, and the other which takes a reference. + /// + //////////////////////////////////////////////////////////////// + + template <class Obj, typename MemFun> + class ObjScopeGuardImpl0 : public ScopeGuardImplBase + { + public: + static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) + { + return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun); + } + + ~ObjScopeGuardImpl0() throw() + { + SafeExecute(*this); + } + + void Execute() + { + (obj_.*memFun_)(); + } + + protected: + ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun) + {} + + Obj& obj_; + MemFun memFun_; + }; + + template <class Obj, typename MemFun> + inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) + { + return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun); + } + + template <typename Ret, class Obj1, class Obj2> + inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 &obj) + { + return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(obj,memFun); + } + + template <typename Ret, class Obj1, class Obj2> + inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 *obj) + { + return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(*obj,memFun); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ObjScopeGuardImpl1 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a class per-instance member function with one + /// parameter. The parameter is copied by value - use ::Loki::ByRef if you + /// must use a reference instead. ScopeGuard ignores any value returned + /// from the call within the Execute function. + /// + /// This class has 3 standalone helper functions which create a ScopeGuard. + /// One is MakeObjGuard, which is deprecated but provided for older code. + /// The other two are MakeGuard overloads, one which takes a pointer to an + /// object, and the other which takes a reference. + /// + //////////////////////////////////////////////////////////////// + + template <class Obj, typename MemFun, typename P1> + class ObjScopeGuardImpl1 : public ScopeGuardImplBase + { + public: + static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) + { + return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1); + } + + ~ObjScopeGuardImpl1() throw() + { + SafeExecute(*this); + } + + void Execute() + { + (obj_.*memFun_)(p1_); + } + + protected: + ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1) + {} + + Obj& obj_; + MemFun memFun_; + const P1 p1_; + }; + + template <class Obj, typename MemFun, typename P1> + inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) + { + return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1); + } + + template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> + inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 &obj, P1b p1) + { + return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(obj,memFun,p1); + } + + template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> + inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 *obj, P1b p1) + { + return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(*obj,memFun,p1); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ObjScopeGuardImpl2 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a class per-instance member function with two + /// parameters. Each parameter is copied by value - use ::Loki::ByRef if you + /// must use a reference instead. ScopeGuard ignores any value returned + /// from the call within the Execute function. + /// + /// This class has 3 standalone helper functions which create a ScopeGuard. + /// One is MakeObjGuard, which is deprecated but provided for older code. + /// The other two are MakeGuard overloads, one which takes a pointer to an + /// object, and the other which takes a reference. + /// + //////////////////////////////////////////////////////////////// + + template <class Obj, typename MemFun, typename P1, typename P2> + class ObjScopeGuardImpl2 : public ScopeGuardImplBase + { + public: + static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) + { + return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2); + } + + ~ObjScopeGuardImpl2() throw() + { + SafeExecute(*this); + } + + void Execute() + { + (obj_.*memFun_)(p1_, p2_); + } + + protected: + ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) + {} + + Obj& obj_; + MemFun memFun_; + const P1 p1_; + const P2 p2_; + }; + + template <class Obj, typename MemFun, typename P1, typename P2> + inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) + { + return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2); + } + + template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> + inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 &obj, P1b p1, P2b p2) + { + return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(obj,memFun,p1,p2); + } + + template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> + inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 *obj, P1b p1, P2b p2) + { + return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(*obj,memFun,p1,p2); + } + + //////////////////////////////////////////////////////////////// + /// + /// \class ObjScopeGuardImpl3 + /// \ingroup ExceptionGroup + /// + /// Implementation class for a class per-instance member function with three + /// parameters. Each parameter is copied by value - use ::Loki::ByRef if you + /// must use a reference instead. ScopeGuard ignores any value returned + /// from the call within the Execute function. + /// + /// This class has 3 standalone helper functions which create a ScopeGuard. + /// One is MakeObjGuard, which is deprecated but provided for older code. + /// The other two are MakeGuard overloads, one which takes a pointer to an + /// object, and the other which takes a reference. + /// + //////////////////////////////////////////////////////////////// + + template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > + class ObjScopeGuardImpl3 : public ScopeGuardImplBase + { + public: + static ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( + Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) + { + return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >( obj, memFun, p1, p2, p3 ); + } + + ~ObjScopeGuardImpl3() throw() + { + SafeExecute( *this ); + } + + void Execute() + { + ( obj_.*memFun_ )( p1_, p2_, p3_ ); + } + + protected: + ObjScopeGuardImpl3( Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) : + obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 ) + {} + + Obj& obj_; + MemFun memFun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + }; + + template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > + inline ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( + Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) + { + return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >::MakeObjGuard( + obj, memFun, p1, p2, p3 ); + } + + template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, + typename P2a, typename P2b, typename P3a, typename P3b > + inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > + MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 & obj, P1b p1, P2b p2, P3b p3 ) + { + return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > + ::MakeObjGuard( obj, memFun, p1, p2, p3 ); + } + + template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, + typename P2a, typename P2b, typename P3a, typename P3b > + inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > + MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 * obj, P1b p1, P2b p2, P3b p3 ) + { + return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > + ::MakeObjGuard( *obj, memFun, p1, p2, p3 ); + } + +} // namespace Loki + +#define LOKI_CONCATENATE_DIRECT(s1, s2) s1##s2 +#define LOKI_CONCATENATE(s1, s2) LOKI_CONCATENATE_DIRECT(s1, s2) +#define LOKI_ANONYMOUS_VARIABLE(str) LOKI_CONCATENATE(str, __LINE__) + +#define LOKI_ON_BLOCK_EXIT ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeGuard +#define LOKI_ON_BLOCK_EXIT_OBJ ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeObjGuard + +#endif // end file guardian + diff --git a/shared/loki/Sequence.h b/shared/loki/Sequence.h new file mode 100644 index 00000000..4e5bd235 --- /dev/null +++ b/shared/loki/Sequence.h @@ -0,0 +1,49 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2005 by Peter Kümmel +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_SEQUENCE_INC_ +#define LOKI_SEQUENCE_INC_ + +// $Id: Sequence.h 768 2006-10-25 20:40:40Z syntheticpp $ + + +#include "Typelist.h" + +namespace Loki +{ + + template + < + class T01=NullType,class T02=NullType,class T03=NullType,class T04=NullType,class T05=NullType, + class T06=NullType,class T07=NullType,class T08=NullType,class T09=NullType,class T10=NullType, + class T11=NullType,class T12=NullType,class T13=NullType,class T14=NullType,class T15=NullType, + class T16=NullType,class T17=NullType,class T18=NullType,class T19=NullType,class T20=NullType + > + struct Seq + { + private: + typedef typename Seq< T02, T03, T04, T05, T06, T07, T08, T09, T10, + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>::Type + TailResult; + public: + typedef Typelist<T01, TailResult> Type; + }; + + template<> + struct Seq<> + { + typedef NullType Type; + }; + +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/Singleton.h b/shared/loki/Singleton.h new file mode 100644 index 00000000..42d6eb0d --- /dev/null +++ b/shared/loki/Singleton.h @@ -0,0 +1,889 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_SINGLETON_INC_ +#define LOKI_SINGLETON_INC_ + +// $Id: Singleton.h 834 2007-08-02 19:36:10Z syntheticpp $ + + +#include "LokiExport.h" +#include "Threads.h" +#include <algorithm> +#include <stdexcept> +#include <cassert> +#include <cstdlib> +#include <new> +#include <vector> +#include <list> +#include <memory> + +#ifdef _MSC_VER +#define LOKI_C_CALLING_CONVENTION_QUALIFIER __cdecl +#else +#define LOKI_C_CALLING_CONVENTION_QUALIFIER +#endif + +/// \defgroup SingletonGroup Singleton +/// \defgroup CreationGroup Creation policies +/// \ingroup SingletonGroup +/// \defgroup LifetimeGroup Lifetime policies +/// \ingroup SingletonGroup +/// The lifetimes of the singleton. +/// \par Special lifetime for SmallObjects +/// When the holded object is a Small(Value)Object or the holded object +/// uses objects which are or inherit from Small(Value)Object +/// then you can't use the default lifetime: you must use the lifetime +/// \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode +/// Be aware of this when you use Loki::Factory, Loki::Functor, or Loki::Function. + + + +namespace Loki +{ + typedef void (LOKI_C_CALLING_CONVENTION_QUALIFIER *atexit_pfn_t)(); + + namespace Private + { + +#ifndef LOKI_MAKE_DLL + void LOKI_C_CALLING_CONVENTION_QUALIFIER AtExitFn(); // declaration needed below +#else + void LOKI_EXPORT AtExitFn(); +#endif + + class LifetimeTracker; + +#define LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL +#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL + + // Helper data + // std::list because of the inserts + typedef std::list<LifetimeTracker*> TrackerArray; + extern LOKI_EXPORT TrackerArray* pTrackerArray; +#else + // Helper data + typedef LifetimeTracker** TrackerArray; + extern TrackerArray pTrackerArray; + extern unsigned int elements; +#endif + + //////////////////////////////////////////////////////////////////////////////// + // class LifetimeTracker + // Helper class for SetLongevity + //////////////////////////////////////////////////////////////////////////////// + + class LifetimeTracker + { + public: + LifetimeTracker(unsigned int x) : longevity_(x) + {} + + virtual ~LifetimeTracker() = 0; + + static bool Compare(const LifetimeTracker* lhs, + const LifetimeTracker* rhs) + { + return lhs->longevity_ > rhs->longevity_; + } + + private: + unsigned int longevity_; + }; + + // Definition required + inline LifetimeTracker::~LifetimeTracker() {} + + // Helper destroyer function + template <typename T> + struct Deleter + { + typedef void (*Type)(T*); + static void Delete(T* pObj) + { delete pObj; } + }; + + // Concrete lifetime tracker for objects of type T + template <typename T, typename Destroyer> + class ConcreteLifetimeTracker : public LifetimeTracker + { + public: + ConcreteLifetimeTracker(T* p,unsigned int longevity, Destroyer d) + : LifetimeTracker(longevity) + , pTracked_(p) + , destroyer_(d) + {} + + ~ConcreteLifetimeTracker() + { destroyer_(pTracked_); } + + private: + T* pTracked_; + Destroyer destroyer_; + }; + + } // namespace Private + + //////////////////////////////////////////////////////////////////////////////// + /// \ingroup LifetimeGroup + /// + /// Assigns an object a longevity; ensures ordered destructions of objects + /// registered thusly during the exit sequence of the application + //////////////////////////////////////////////////////////////////////////////// + +#ifdef LOKI_ENABLE_NEW_SETLONGLIVITY_HELPER_DATA_IMPL + + template <typename T, typename Destroyer> + void SetLongevity(T* pDynObject, unsigned int longevity, + Destroyer d) + { + using namespace Private; + + // manage lifetime of stack manually + if(pTrackerArray==0) + pTrackerArray = new TrackerArray; + + // automatically delete the ConcreteLifetimeTracker object when a exception is thrown + std::auto_ptr<LifetimeTracker> + p( new ConcreteLifetimeTracker<T, Destroyer>(pDynObject, longevity, d) ); + + // Find correct position + TrackerArray::iterator pos = std::upper_bound( + pTrackerArray->begin(), + pTrackerArray->end(), + p.get(), + LifetimeTracker::Compare); + + // Insert the pointer to the ConcreteLifetimeTracker object into the queue + pTrackerArray->insert(pos, p.get()); + + // nothing has thrown: don't delete the ConcreteLifetimeTracker object + p.release(); + + // Register a call to AtExitFn + std::atexit(Private::AtExitFn); + } + +#else + + template <typename T, typename Destroyer> + void SetLongevity(T* pDynObject, unsigned int longevity, + Destroyer d) + { + using namespace Private; + + TrackerArray pNewArray = static_cast<TrackerArray>( + std::realloc(pTrackerArray, + sizeof(*pTrackerArray) * (elements + 1))); + if (!pNewArray) throw std::bad_alloc(); + + // Delayed assignment for exception safety + pTrackerArray = pNewArray; + + LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>( + pDynObject, longevity, d); + + // Insert a pointer to the object into the queue + TrackerArray pos = std::upper_bound( + pTrackerArray, + pTrackerArray + elements, + p, + LifetimeTracker::Compare); + std::copy_backward( + pos, + pTrackerArray + elements, + pTrackerArray + elements + 1); + *pos = p; + ++elements; + + // Register a call to AtExitFn + std::atexit(Private::AtExitFn); + } + +#endif + + template <typename T> + void SetLongevity(T* pDynObject, unsigned int longevity, + typename Private::Deleter<T>::Type d = Private::Deleter<T>::Delete) + { + SetLongevity<T, typename Private::Deleter<T>::Type>(pDynObject, longevity, d); + } + + //////////////////////////////////////////////////////////////////////////////// + /// \struct CreateUsingNew + /// + /// \ingroup CreationGroup + /// Implementation of the CreationPolicy used by SingletonHolder + /// Creates objects using a straight call to the new operator + //////////////////////////////////////////////////////////////////////////////// + template <class T> struct CreateUsingNew + { + static T* Create() + { return new T; } + + static void Destroy(T* p) + { delete p; } + }; + + //////////////////////////////////////////////////////////////////////////////// + /// \struct CreateUsing + /// + /// \ingroup CreationGroup + /// Implementation of the CreationPolicy used by SingletonHolder + /// Creates objects using a custom allocater. + /// Usage: e.g. CreateUsing<std::allocator>::Allocator + //////////////////////////////////////////////////////////////////////////////// + template<template<class> class Alloc> + struct CreateUsing + { + template <class T> + struct Allocator + { + static Alloc<T> allocator; + + static T* Create() + { + return new (allocator.allocate(1)) T; + } + + static void Destroy(T* p) + { + //allocator.destroy(p); + p->~T(); + allocator.deallocate(p,1); + } + }; + }; + + //////////////////////////////////////////////////////////////////////////////// + /// \struct CreateUsingMalloc + /// + /// \ingroup CreationGroup + /// Implementation of the CreationPolicy used by SingletonHolder + /// Creates objects using a call to std::malloc, followed by a call to the + /// placement new operator + //////////////////////////////////////////////////////////////////////////////// + template <class T> struct CreateUsingMalloc + { + static T* Create() + { + void* p = std::malloc(sizeof(T)); + if (!p) return 0; + return new(p) T; + } + + static void Destroy(T* p) + { + p->~T(); + std::free(p); + } + }; + + + //////////////////////////////////////////////////////////////////////////////// + /// \struct CreateStatic + /// + /// \ingroup CreationGroup + /// Implementation of the CreationPolicy used by SingletonHolder + /// Creates an object in static memory + /// Implementation is slightly nonportable because it uses the MaxAlign trick + /// (an union of all types to ensure proper memory alignment). This trick is + /// nonportable in theory but highly portable in practice. + //////////////////////////////////////////////////////////////////////////////// + template <class T> struct CreateStatic + { + +#ifdef _MSC_VER +#pragma warning( push ) +#pragma warning( disable : 4121 ) +// alignment of a member was sensitive to packing +#endif // _MSC_VER + + union MaxAlign + { + char t_[sizeof(T)]; + short int shortInt_; + int int_; + long int longInt_; + float float_; + double double_; + long double longDouble_; + struct Test; + int Test::* pMember_; + int (Test::*pMemberFn_)(int); + }; + +#ifdef _MSC_VER +#pragma warning( pop ) +#endif // _MSC_VER + + static T* Create() + { + static MaxAlign staticMemory_; + return new(&staticMemory_) T; + } + + static void Destroy(T* p) + { + p->~T(); + } + }; + + //////////////////////////////////////////////////////////////////////////////// + /// \struct DefaultLifetime + /// + /// \ingroup LifetimeGroup + /// Implementation of the LifetimePolicy used by SingletonHolder + /// Schedules an object's destruction as per C++ rules + /// Forwards to std::atexit + //////////////////////////////////////////////////////////////////////////////// + template <class T> + struct DefaultLifetime + { + static void ScheduleDestruction(T*, atexit_pfn_t pFun) + { std::atexit(pFun); } + + static void OnDeadReference() + { throw std::logic_error("Dead Reference Detected"); } + }; + + //////////////////////////////////////////////////////////////////////////////// + /// \struct PhoenixSingleton + /// + /// \ingroup LifetimeGroup + /// Implementation of the LifetimePolicy used by SingletonHolder + /// Schedules an object's destruction as per C++ rules, and it allows object + /// recreation by not throwing an exception from OnDeadReference + //////////////////////////////////////////////////////////////////////////////// + template <class T> + class PhoenixSingleton + { + public: + static void ScheduleDestruction(T*, atexit_pfn_t pFun) + { +#ifndef ATEXIT_FIXED + if (!destroyedOnce_) +#endif + std::atexit(pFun); + } + + static void OnDeadReference() + { +#ifndef ATEXIT_FIXED + destroyedOnce_ = true; +#endif + } + + private: +#ifndef ATEXIT_FIXED + static bool destroyedOnce_; +#endif + }; + +#ifndef ATEXIT_FIXED + template <class T> bool PhoenixSingleton<T>::destroyedOnce_ = false; +#endif + + //////////////////////////////////////////////////////////////////////////////// + // Copyright (c) 2004 by Curtis Krauskopf - curtis@decompile.com + /// + /// \struct DeletableSingleton + /// + /// \ingroup LifetimeGroup + /// + /// A DeletableSingleton allows the instantiated singleton to be + /// destroyed at any time. The singleton can be reinstantiated at + /// any time, even during program termination. + /// If the singleton exists when the program terminates, it will + /// be automatically deleted. + /// + /// \par Usage: + /// The singleton can be deleted manually: + /// + /// DeletableSingleton<MyClass>::GracefulDelete(); + //////////////////////////////////////////////////////////////////////////////// + template <class T> + class DeletableSingleton + { + public: + + static void ScheduleDestruction(T*, atexit_pfn_t pFun) + { + static bool firstPass = true; + isDead = false; + deleter = pFun; + if (firstPass || needCallback) + { + std::atexit(atexitCallback); + firstPass = false; + needCallback = false; + } + } + + static void OnDeadReference() + { + } + /// delete singleton object manually + static void GracefulDelete() + { + if (isDead) + return; + isDead = true; + deleter(); + } + + protected: + static atexit_pfn_t deleter; + static bool isDead; + static bool needCallback; + + static void atexitCallback() + { +#ifdef ATEXIT_FIXED + needCallback = true; +#else + needCallback = false; +#endif + GracefulDelete(); + } + }; + + template <class T> + atexit_pfn_t DeletableSingleton<T>::deleter = 0; + + template <class T> + bool DeletableSingleton<T>::isDead = true; + + template <class T> + bool DeletableSingleton<T>::needCallback = true; + + //////////////////////////////////////////////////////////////////////////////// + // class template Adapter + // Helper for SingletonWithLongevity below + //////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class T> + struct Adapter + { + void operator()(T*) { return pFun_(); } + atexit_pfn_t pFun_; + }; + } + + //////////////////////////////////////////////////////////////////////////////// + /// \struct SingletonWithLongevity + /// + /// \ingroup LifetimeGroup + /// Implementation of the LifetimePolicy used by SingletonHolder + /// Schedules an object's destruction in order of their longevities + /// Assumes a visible function GetLongevity(T*) that returns the longevity of the + /// object. + //////////////////////////////////////////////////////////////////////////////// + template <class T> + class SingletonWithLongevity + { + public: + static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun) + { + Private::Adapter<T> adapter = { pFun }; + SetLongevity(pObj, GetLongevity(pObj), adapter); + } + + static void OnDeadReference() + { throw std::logic_error("Dead Reference Detected"); } + }; + + //////////////////////////////////////////////////////////////////////////////// + /// \struct NoDestroy + /// + /// \ingroup LifetimeGroup + /// Implementation of the LifetimePolicy used by SingletonHolder + /// Never destroys the object + //////////////////////////////////////////////////////////////////////////////// + template <class T> + struct NoDestroy + { + static void ScheduleDestruction(T*, atexit_pfn_t) + {} + + static void OnDeadReference() + {} + }; + + + //////////////////////////////////////////////////////////////////////////////// + /// \defgroup LongevityLifetimeGroup LongevityLifetime + /// \ingroup LifetimeGroup + /// + /// \namespace LongevityLifetime + /// + /// \ingroup LongevityLifetimeGroup + /// \brief In this namespace are special lifetime policies to manage lifetime + /// dependencies. + //////////////////////////////////////////////////////////////////////////////// + namespace LongevityLifetime + { + //////////////////////////////////////////////////////////////////////////////// + /// \struct SingletonFixedLongevity + /// + /// \ingroup LongevityLifetimeGroup + /// Add your own lifetimes into the namespace 'LongevityLifetime' + /// with your prefered lifetime by adding a struct like this: + /// + /// template<class T> + /// struct MyLifetime : SingletonFixedLongevity< MyLifetimeNumber ,T> {} + //////////////////////////////////////////////////////////////////////////////// + template <unsigned int Longevity, class T> + class SingletonFixedLongevity + { + public: + virtual ~SingletonFixedLongevity() {} + + static void ScheduleDestruction(T* pObj, atexit_pfn_t pFun) + { + Private::Adapter<T> adapter = { pFun }; + SetLongevity(pObj, Longevity , adapter); + } + + static void OnDeadReference() + { throw std::logic_error("Dead Reference Detected"); } + }; + + /// \struct DieLast + /// \ingroup LongevityLifetimeGroup + /// \brief Longest possible SingletonWithLongevity lifetime: 0xFFFFFFFF + template <class T> + struct DieLast : SingletonFixedLongevity<0xFFFFFFFF ,T> + {}; + + /// \struct DieDirectlyBeforeLast + /// \ingroup LongevityLifetimeGroup + /// \brief Lifetime is a one less than DieLast: 0xFFFFFFFF-1 + template <class T> + struct DieDirectlyBeforeLast : SingletonFixedLongevity<0xFFFFFFFF-1 ,T> + {}; + + /// \struct DieFirst + /// \ingroup LongevityLifetimeGroup + /// \brief Shortest possible SingletonWithLongevity lifetime: 0 + template <class T> + struct DieFirst : SingletonFixedLongevity<0,T> + {}; + + }//namespace LongevityLifetime + + //////////////////////////////////////////////////////////////////////////////// + /// \class FollowIntoDeath + /// + /// \ingroup LifetimeGroup + /// + /// Lifetime policyfor the SingletonHolder tempalte. + /// Followers will die after the master dies Followers will not die, if + /// - master never dies (NoDestroy policy) + /// - master never created + /// - master dies not in the function registered with atexit + /// - master dies not by a call of a the atexit registerd function (DeletableSingleton::GracefulDelete) + /// + /// \par Usage: + /// + /// Lifetimes of the master and the follower singletons, e.g. with a M and a F class: + /// \code SingletonHolder< M , FollowIntoDeath::With<DefaultLifetime>::AsMasterLifetime > MasterSingleton; \endcode + /// \code SingletonHolder< F , CreateUsingNew, FollowIntoDeath::AfterMaster< MasterSingleton >::IsDestroyed > FollowerSingleton \endcode + //////////////////////////////////////////////////////////////////////////////// + class FollowIntoDeath + { + template<class T> + class Followers + { + typedef std::vector<atexit_pfn_t> Container; + typedef typename Container::iterator iterator; + static Container* followers_; + + public: + static void Init() + { + static bool done = false; + if(!done) + { + followers_ = new Container; + done = true; + } + } + + static void AddFollower(atexit_pfn_t ae) + { + Init(); + followers_->push_back(ae); + } + + static void DestroyFollowers() + { + Init(); + for(iterator it = followers_->begin();it != followers_->end();++it) + (*it)(); + delete followers_; + } + }; + + public: + + /// \struct With + /// Template for the master + /// \param Lifetime Lifetime policy for the master + template<template <class> class Lifetime> + struct With + { + /// \struct AsMasterLifetime + /// Policy for master + template<class Master> + struct AsMasterLifetime + { + static void ScheduleDestruction(Master* pObj, atexit_pfn_t pFun) + { + Followers<Master>::Init(); + Lifetime<Master>::ScheduleDestruction(pObj, pFun); + + // use same policy for the followers and force a new + // template instantiation, this adds a additional atexit entry + // does not work with SetLonlevity, but there you can control + // the lifetime with the GetLongevity function. + Lifetime<Followers<Master> >::ScheduleDestruction(0,Followers<Master>::DestroyFollowers); + } + + static void OnDeadReference() + { + throw std::logic_error("Dead Reference Detected"); + } + }; + }; + + /// \struct AfterMaster + /// Template for the follower + /// \param Master Master to follow into death + template<class Master> + struct AfterMaster + { + /// \struct IsDestroyed + /// Policy for followers + template<class F> + struct IsDestroyed + { + static void ScheduleDestruction(F*, atexit_pfn_t pFun) + { + Followers<Master>::AddFollower(pFun); + } + + static void OnDeadReference() + { + throw std::logic_error("Dead Reference Detected"); + } + }; + }; + }; + + template<class T> + typename FollowIntoDeath::Followers<T>::Container* + FollowIntoDeath::Followers<T>::followers_ = 0; + + + + //////////////////////////////////////////////////////////////////////////////// + /// \class SingletonHolder + /// + /// \ingroup SingletonGroup + /// + /// Provides Singleton amenities for a type T + /// To protect that type from spurious instantiations, + /// you have to protect it yourself. + /// + /// \param CreationPolicy Creation policy, default: CreateUsingNew + /// \param LifetimePolicy Lifetime policy, default: DefaultLifetime, + /// \param ThreadingModel Threading policy, + /// default: LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL + //////////////////////////////////////////////////////////////////////////////// + template + < + typename T, + template <class> class CreationPolicy = CreateUsingNew, + template <class> class LifetimePolicy = DefaultLifetime, + template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, + class MutexPolicy = LOKI_DEFAULT_MUTEX + > + class SingletonHolder + { + public: + + /// Type of the singleton object + typedef T ObjectType; + + /// Returns a reference to singleton object + static T& Instance(); + + private: + // Helpers + static void MakeInstance(); + static void LOKI_C_CALLING_CONVENTION_QUALIFIER DestroySingleton(); + + // Protection + SingletonHolder(); + + // Data + typedef typename ThreadingModel<T*,MutexPolicy>::VolatileType PtrInstanceType; + static PtrInstanceType pInstance_; + static bool destroyed_; + }; + + //////////////////////////////////////////////////////////////////////////////// + // SingletonHolder's data + //////////////////////////////////////////////////////////////////////////////// + + template + < + class T, + template <class> class C, + template <class> class L, + template <class, class> class M, + class X + > + typename SingletonHolder<T, C, L, M, X>::PtrInstanceType + SingletonHolder<T, C, L, M, X>::pInstance_ = 0; + + template + < + class T, + template <class> class C, + template <class> class L, + template <class, class> class M, + class X + > + bool SingletonHolder<T, C, L, M, X>::destroyed_ = false; + + //////////////////////////////////////////////////////////////////////////////// + // SingletonHolder::Instance + //////////////////////////////////////////////////////////////////////////////// + + template + < + class T, + template <class> class CreationPolicy, + template <class> class LifetimePolicy, + template <class, class> class ThreadingModel, + class MutexPolicy + > + inline T& SingletonHolder<T, CreationPolicy, + LifetimePolicy, ThreadingModel, MutexPolicy>::Instance() + { + if (!pInstance_) + { + MakeInstance(); + } + return *pInstance_; + } + + //////////////////////////////////////////////////////////////////////////////// + // SingletonHolder::MakeInstance (helper for Instance) + //////////////////////////////////////////////////////////////////////////////// + + template + < + class T, + template <class> class CreationPolicy, + template <class> class LifetimePolicy, + template <class, class> class ThreadingModel, + class MutexPolicy + > + void SingletonHolder<T, CreationPolicy, + LifetimePolicy, ThreadingModel, MutexPolicy>::MakeInstance() + { + typename ThreadingModel<SingletonHolder,MutexPolicy>::Lock guard; + (void)guard; + + if (!pInstance_) + { + if (destroyed_) + { + destroyed_ = false; + LifetimePolicy<T>::OnDeadReference(); + } + pInstance_ = CreationPolicy<T>::Create(); + LifetimePolicy<T>::ScheduleDestruction(pInstance_, + &DestroySingleton); + } + } + + template + < + class T, + template <class> class CreationPolicy, + template <class> class L, + template <class, class> class M, + class X + > + void LOKI_C_CALLING_CONVENTION_QUALIFIER + SingletonHolder<T, CreationPolicy, L, M, X>::DestroySingleton() + { + assert(!destroyed_); + CreationPolicy<T>::Destroy(pInstance_); + pInstance_ = 0; + destroyed_ = true; + } + + + //////////////////////////////////////////////////////////////////////////////// + /// \class Singleton + /// + /// \ingroup SingletonGroup + /// + /// Convenience template to implement a getter function for a singleton object. + /// Often needed in a shared library which hosts singletons. + /// + /// \par Usage + /// + /// see test/SingletonDll + /// + //////////////////////////////////////////////////////////////////////////////// + +#ifndef LOKI_SINGLETON_EXPORT +#define LOKI_SINGLETON_EXPORT +#endif + + template<class T> + class LOKI_SINGLETON_EXPORT Singleton + { + public: + static T& Instance(); + }; + +} // namespace Loki + + +/// \def LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER) +/// Convenience macro for the definition of the static Instance member function +/// Put this macro called with a SingletonHolder typedef into your cpp file. + +#define LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER) \ +namespace Loki \ +{ \ + template<> \ + SHOLDER::ObjectType& Singleton<SHOLDER::ObjectType>::Instance() \ + { \ + return SHOLDER::Instance(); \ + } \ +} + + +#endif // end file guardian + diff --git a/shared/loki/SmallObj.cpp b/shared/loki/SmallObj.cpp new file mode 100644 index 00000000..a2911bb1 --- /dev/null +++ b/shared/loki/SmallObj.cpp @@ -0,0 +1,1226 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// + +// $Id: SmallObj.cpp 823 2007-05-08 10:48:40Z lfittl $ + + +#include <loki/SmallObj.h> + +#include <cassert> +#include <climits> +#include <vector> +#include <bitset> + +//#define DO_EXTRA_LOKI_TESTS +//#define USE_NEW_TO_ALLOCATE +//#define LOKI_CHECK_FOR_CORRUPTION + +#ifdef DO_EXTRA_LOKI_TESTS + #include <iostream> +#endif + +namespace Loki +{ + + /** @struct Chunk + @ingroup SmallObjectGroupInternal + Contains info about each allocated Chunk - which is a collection of + contiguous blocks. Each block is the same size, as specified by the + FixedAllocator. The number of blocks in a Chunk depends upon page size. + This is a POD-style struct with value-semantics. All functions and data + are private so that they can not be changed by anything other than the + FixedAllocator which owns the Chunk. + + @par Minimal Interface + For the sake of runtime efficiency, no constructor, destructor, or + copy-assignment operator is defined. The inline functions made by the + compiler should be sufficient, and perhaps faster than hand-crafted + functions. The lack of these functions allows vector to create and copy + Chunks as needed without overhead. The Init and Release functions do + what the default constructor and destructor would do. A Chunk is not in + a usable state after it is constructed and before calling Init. Nor is + a Chunk usable after Release is called, but before the destructor. + + @par Efficiency + Down near the lowest level of the allocator, runtime efficiencies trump + almost all other considerations. Each function does the minimum required + of it. All functions should execute in constant time to prevent higher- + level code from unwittingly using a version of Shlemiel the Painter's + Algorithm. + + @par Stealth Indexes + The first char of each empty block contains the index of the next empty + block. These stealth indexes form a singly-linked list within the blocks. + A Chunk is corrupt if this singly-linked list has a loop or is shorter + than blocksAvailable_. Much of the allocator's time and space efficiency + comes from how these stealth indexes are implemented. + */ + class Chunk + { + private: + friend class FixedAllocator; + + /** Initializes a just-constructed Chunk. + @param blockSize Number of bytes per block. + @param blocks Number of blocks per Chunk. + @return True for success, false for failure. + */ + bool Init( std::size_t blockSize, unsigned char blocks ); + + /** Allocate a block within the Chunk. Complexity is always O(1), and + this will never throw. Does not actually "allocate" by calling + malloc, new, or any other function, but merely adjusts some internal + indexes to indicate an already allocated block is no longer available. + @return Pointer to block within Chunk. + */ + void * Allocate( std::size_t blockSize ); + + /** Deallocate a block within the Chunk. Complexity is always O(1), and + this will never throw. For efficiency, this assumes the address is + within the block and aligned along the correct byte boundary. An + assertion checks the alignment, and a call to HasBlock is done from + within VicinityFind. Does not actually "deallocate" by calling free, + delete, or other function, but merely adjusts some internal indexes to + indicate a block is now available. + */ + void Deallocate( void * p, std::size_t blockSize ); + + /** Resets the Chunk back to pristine values. The available count is + set back to zero, and the first available index is set to the zeroth + block. The stealth indexes inside each block are set to point to the + next block. This assumes the Chunk's data was already using Init. + */ + void Reset( std::size_t blockSize, unsigned char blocks ); + + /// Releases the allocated block of memory. + void Release(); + + /** Determines if the Chunk has been corrupted. + @param numBlocks Total # of blocks in the Chunk. + @param blockSize # of bytes in each block. + @param checkIndexes True if caller wants to check indexes of available + blocks for corruption. If false, then caller wants to skip some + tests tests just to run faster. (Debug version does more checks, but + release version runs faster.) + @return True if Chunk is corrupt. + */ + bool IsCorrupt( unsigned char numBlocks, std::size_t blockSize, + bool checkIndexes ) const; + + /** Determines if block is available. + @param p Address of block managed by Chunk. + @param numBlocks Total # of blocks in the Chunk. + @param blockSize # of bytes in each block. + @return True if block is available, else false if allocated. + */ + bool IsBlockAvailable( void * p, unsigned char numBlocks, + std::size_t blockSize ) const; + + /// Returns true if block at address P is inside this Chunk. + inline bool HasBlock( void * p, std::size_t chunkLength ) const + { + unsigned char * pc = static_cast< unsigned char * >( p ); + return ( pData_ <= pc ) && ( pc < pData_ + chunkLength ); + } + + inline bool HasAvailable( unsigned char numBlocks ) const + { return ( blocksAvailable_ == numBlocks ); } + + inline bool IsFilled( void ) const + { return ( 0 == blocksAvailable_ ); } + + /// Pointer to array of allocated blocks. + unsigned char * pData_; + /// Index of first empty block. + unsigned char firstAvailableBlock_; + /// Count of empty blocks. + unsigned char blocksAvailable_; + }; + + /** @class FixedAllocator + @ingroup SmallObjectGroupInternal + Offers services for allocating fixed-sized objects. It has a container + of "containers" of fixed-size blocks. The outer container has all the + Chunks. The inner container is a Chunk which owns some blocks. + + @par Class Level Invariants + - There is always either zero or one Chunk which is empty. + - If this has no empty Chunk, then emptyChunk_ is NULL. + - If this has an empty Chunk, then emptyChunk_ points to it. + - If the Chunk container is empty, then deallocChunk_ and allocChunk_ + are NULL. + - If the Chunk container is not-empty, then deallocChunk_ and allocChunk_ + are either NULL or point to Chunks within the container. + - allocChunk_ will often point to the last Chunk in the container since + it was likely allocated most recently, and therefore likely to have an + available block. + */ + class FixedAllocator + { + private: + + /** Deallocates the block at address p, and then handles the internal + bookkeeping needed to maintain class invariants. This assumes that + deallocChunk_ points to the correct chunk. + */ + void DoDeallocate( void * p ); + + /** Creates an empty Chunk and adds it to the end of the ChunkList. + All calls to the lower-level memory allocation functions occur inside + this function, and so the only try-catch block is inside here. + @return true for success, false for failure. + */ + bool MakeNewChunk( void ); + + /** Finds the Chunk which owns the block at address p. It starts at + deallocChunk_ and searches in both forwards and backwards directions + from there until it finds the Chunk which owns p. This algorithm + should find the Chunk quickly if it is deallocChunk_ or is close to it + in the Chunks container. This goes both forwards and backwards since + that works well for both same-order and opposite-order deallocations. + (Same-order = objects are deallocated in the same order in which they + were allocated. Opposite order = objects are deallocated in a last to + first order. Complexity is O(C) where C is count of all Chunks. This + never throws. + @return Pointer to Chunk that owns p, or NULL if no owner found. + */ + Chunk * VicinityFind( void * p ) const; + + /// Not implemented. + FixedAllocator(const FixedAllocator&); + /// Not implemented. + FixedAllocator& operator=(const FixedAllocator&); + + /// Type of container used to hold Chunks. + typedef std::vector< Chunk > Chunks; + /// Iterator through container of Chunks. + typedef Chunks::iterator ChunkIter; + /// Iterator through const container of Chunks. + typedef Chunks::const_iterator ChunkCIter; + + /// Fewest # of objects managed by a Chunk. + static unsigned char MinObjectsPerChunk_; + + /// Most # of objects managed by a Chunk - never exceeds UCHAR_MAX. + static unsigned char MaxObjectsPerChunk_; + + /// Number of bytes in a single block within a Chunk. + std::size_t blockSize_; + /// Number of blocks managed by each Chunk. + unsigned char numBlocks_; + + /// Container of Chunks. + Chunks chunks_; + /// Pointer to Chunk used for last or next allocation. + Chunk * allocChunk_; + /// Pointer to Chunk used for last or next deallocation. + Chunk * deallocChunk_; + /// Pointer to the only empty Chunk if there is one, else NULL. + Chunk * emptyChunk_; + + public: + /// Create a FixedAllocator which manages blocks of 'blockSize' size. + FixedAllocator(); + + /// Destroy the FixedAllocator and release all its Chunks. + ~FixedAllocator(); + + /// Initializes a FixedAllocator by calculating # of blocks per Chunk. + void Initialize( std::size_t blockSize, std::size_t pageSize ); + + /** Returns pointer to allocated memory block of fixed size - or NULL + if it failed to allocate. + */ + void * Allocate( void ); + + /** Deallocate a memory block previously allocated with Allocate. If + the block is not owned by this FixedAllocator, it returns false so + that SmallObjAllocator can call the default deallocator. If the + block was found, this returns true. + */ + bool Deallocate( void * p, Chunk * hint ); + + /// Returns block size with which the FixedAllocator was initialized. + inline std::size_t BlockSize() const { return blockSize_; } + + /** Releases the memory used by the empty Chunk. This will take + constant time under any situation. + @return True if empty chunk found and released, false if none empty. + */ + bool TrimEmptyChunk( void ); + + /** Releases unused spots from ChunkList. This takes constant time + with respect to # of Chunks, but actual time depends on underlying + memory allocator. + @return False if no unused spots, true if some found and released. + */ + bool TrimChunkList( void ); + + /** Returns count of empty Chunks held by this allocator. Complexity + is O(C) where C is the total number of Chunks - empty or used. + */ + std::size_t CountEmptyChunks( void ) const; + + /** Determines if FixedAllocator is corrupt. Checks data members to + see if any have erroneous values, or violate class invariants. It + also checks if any Chunk is corrupt. Complexity is O(C) where C is + the number of Chunks. If any data is corrupt, this will return true + in release mode, or assert in debug mode. + */ + bool IsCorrupt( void ) const; + + /** Returns true if the block at address p is within a Chunk owned by + this FixedAllocator. Complexity is O(C) where C is the total number + of Chunks - empty or used. + */ + const Chunk * HasBlock( void * p ) const; + inline Chunk * HasBlock( void * p ) + { + return const_cast< Chunk * >( + const_cast< const FixedAllocator * >( this )->HasBlock( p ) ); + } + + }; + + unsigned char FixedAllocator::MinObjectsPerChunk_ = 8; + unsigned char FixedAllocator::MaxObjectsPerChunk_ = UCHAR_MAX; + +// Chunk::Init ---------------------------------------------------------------- + +bool Chunk::Init( std::size_t blockSize, unsigned char blocks ) +{ + assert(blockSize > 0); + assert(blocks > 0); + // Overflow check + const std::size_t allocSize = blockSize * blocks; + assert( allocSize / blockSize == blocks); + +#ifdef USE_NEW_TO_ALLOCATE + // If this new operator fails, it will throw, and the exception will get + // caught one layer up. + pData_ = static_cast< unsigned char * >( ::operator new ( allocSize ) ); +#else + // malloc can't throw, so its only way to indicate an error is to return + // a NULL pointer, so we have to check for that. + pData_ = static_cast< unsigned char * >( ::std::malloc( allocSize ) ); + if ( NULL == pData_ ) return false; +#endif + + Reset( blockSize, blocks ); + return true; +} + +// Chunk::Reset --------------------------------------------------------------- + +void Chunk::Reset(std::size_t blockSize, unsigned char blocks) +{ + assert(blockSize > 0); + assert(blocks > 0); + // Overflow check + assert((blockSize * blocks) / blockSize == blocks); + + firstAvailableBlock_ = 0; + blocksAvailable_ = blocks; + + unsigned char i = 0; + for ( unsigned char * p = pData_; i != blocks; p += blockSize ) + { + *p = ++i; + } +} + +// Chunk::Release ------------------------------------------------------------- + +void Chunk::Release() +{ + assert( NULL != pData_ ); +#ifdef USE_NEW_TO_ALLOCATE + ::operator delete ( pData_ ); +#else + ::std::free( static_cast< void * >( pData_ ) ); +#endif +} + +// Chunk::Allocate ------------------------------------------------------------ + +void* Chunk::Allocate(std::size_t blockSize) +{ + if ( IsFilled() ) return NULL; + + assert((firstAvailableBlock_ * blockSize) / blockSize == + firstAvailableBlock_); + unsigned char * pResult = pData_ + (firstAvailableBlock_ * blockSize); + firstAvailableBlock_ = *pResult; + --blocksAvailable_; + + return pResult; +} + +// Chunk::Deallocate ---------------------------------------------------------- + +void Chunk::Deallocate(void* p, std::size_t blockSize) +{ + assert(p >= pData_); + + unsigned char* toRelease = static_cast<unsigned char*>(p); + // Alignment check + assert((toRelease - pData_) % blockSize == 0); + unsigned char index = static_cast< unsigned char >( + ( toRelease - pData_ ) / blockSize); + +#if defined(DEBUG) || defined(_DEBUG) + // Check if block was already deleted. Attempting to delete the same + // block more than once causes Chunk's linked-list of stealth indexes to + // become corrupt. And causes count of blocksAvailable_ to be wrong. + if ( 0 < blocksAvailable_ ) + assert( firstAvailableBlock_ != index ); +#endif + + *toRelease = firstAvailableBlock_; + firstAvailableBlock_ = index; + // Truncation check + assert(firstAvailableBlock_ == (toRelease - pData_) / blockSize); + + ++blocksAvailable_; +} + +// Chunk::IsCorrupt ----------------------------------------------------------- + +bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize, + bool checkIndexes ) const +{ + + if ( numBlocks < blocksAvailable_ ) + { + // Contents at this Chunk corrupted. This might mean something has + // overwritten memory owned by the Chunks container. + assert( false ); + return true; + } + if ( IsFilled() ) + // Useless to do further corruption checks if all blocks allocated. + return false; + unsigned char index = firstAvailableBlock_; + if ( numBlocks <= index ) + { + // Contents at this Chunk corrupted. This might mean something has + // overwritten memory owned by the Chunks container. + assert( false ); + return true; + } + if ( !checkIndexes ) + // Caller chose to skip more complex corruption tests. + return false; + + /* If the bit at index was set in foundBlocks, then the stealth index was + found on the linked-list. + */ + std::bitset< UCHAR_MAX > foundBlocks; + unsigned char * nextBlock = NULL; + + /* The loop goes along singly linked-list of stealth indexes and makes sure + that each index is within bounds (0 <= index < numBlocks) and that the + index was not already found while traversing the linked-list. The linked- + list should have exactly blocksAvailable_ nodes, so the for loop will not + check more than blocksAvailable_. This loop can't check inside allocated + blocks for corruption since such blocks are not within the linked-list. + Contents of allocated blocks are not changed by Chunk. + + Here are the types of corrupted link-lists which can be verified. The + corrupt index is shown with asterisks in each example. + + Type 1: Index is too big. + numBlocks == 64 + blocksAvailable_ == 7 + firstAvailableBlock_ -> 17 -> 29 -> *101* + There should be no indexes which are equal to or larger than the total + number of blocks. Such an index would refer to a block beyond the + Chunk's allocated domain. + + Type 2: Index is repeated. + numBlocks == 64 + blocksAvailable_ == 5 + firstAvailableBlock_ -> 17 -> 29 -> 53 -> *17* -> 29 -> 53 ... + No index should be repeated within the linked-list since that would + indicate the presence of a loop in the linked-list. + */ + for ( unsigned char cc = 0; ; ) + { + nextBlock = pData_ + ( index * blockSize ); + foundBlocks.set( index, true ); + ++cc; + if ( cc >= blocksAvailable_ ) + // Successfully counted off number of nodes in linked-list. + break; + index = *nextBlock; + if ( numBlocks <= index ) + { + /* This catches Type 1 corruptions as shown in above comments. + This implies that a block was corrupted due to a stray pointer + or an operation on a nearby block overran the size of the block. + */ + assert( false ); + return true; + } + if ( foundBlocks.test( index ) ) + { + /* This catches Type 2 corruptions as shown in above comments. + This implies that a block was corrupted due to a stray pointer + or an operation on a nearby block overran the size of the block. + Or perhaps the program tried to delete a block more than once. + */ + assert( false ); + return true; + } + } + if ( foundBlocks.count() != blocksAvailable_ ) + { + /* This implies that the singly-linked-list of stealth indexes was + corrupted. Ideally, this should have been detected within the loop. + */ + assert( false ); + return true; + } + + return false; +} + +// Chunk::IsBlockAvailable ---------------------------------------------------- + +bool Chunk::IsBlockAvailable( void * p, unsigned char numBlocks, + std::size_t blockSize ) const +{ + (void) numBlocks; + + if ( IsFilled() ) + return false; + + unsigned char * place = static_cast< unsigned char * >( p ); + // Alignment check + assert( ( place - pData_ ) % blockSize == 0 ); + unsigned char blockIndex = static_cast< unsigned char >( + ( place - pData_ ) / blockSize ); + + unsigned char index = firstAvailableBlock_; + assert( numBlocks > index ); + if ( index == blockIndex ) + return true; + + /* If the bit at index was set in foundBlocks, then the stealth index was + found on the linked-list. + */ + std::bitset< UCHAR_MAX > foundBlocks; + unsigned char * nextBlock = NULL; + for ( unsigned char cc = 0; ; ) + { + nextBlock = pData_ + ( index * blockSize ); + foundBlocks.set( index, true ); + ++cc; + if ( cc >= blocksAvailable_ ) + // Successfully counted off number of nodes in linked-list. + break; + index = *nextBlock; + if ( index == blockIndex ) + return true; + assert( numBlocks > index ); + assert( !foundBlocks.test( index ) ); + } + + return false; +} + +// FixedAllocator::FixedAllocator --------------------------------------------- + +FixedAllocator::FixedAllocator() + : blockSize_( 0 ) + , numBlocks_( 0 ) + , chunks_( 0 ) + , allocChunk_( NULL ) + , deallocChunk_( NULL ) + , emptyChunk_( NULL ) +{ +} + +// FixedAllocator::~FixedAllocator -------------------------------------------- + +FixedAllocator::~FixedAllocator() +{ +#ifdef DO_EXTRA_LOKI_TESTS + TrimEmptyChunk(); + assert( chunks_.empty() && "Memory leak detected!" ); +#endif + for ( ChunkIter i( chunks_.begin() ); i != chunks_.end(); ++i ) + i->Release(); +} + +// FixedAllocator::Initialize ------------------------------------------------- + +void FixedAllocator::Initialize( std::size_t blockSize, std::size_t pageSize ) +{ + assert( blockSize > 0 ); + assert( pageSize >= blockSize ); + blockSize_ = blockSize; + + std::size_t numBlocks = pageSize / blockSize; + if ( numBlocks > MaxObjectsPerChunk_ ) numBlocks = MaxObjectsPerChunk_; + else if ( numBlocks < MinObjectsPerChunk_ ) numBlocks = MinObjectsPerChunk_; + + numBlocks_ = static_cast<unsigned char>(numBlocks); + assert(numBlocks_ == numBlocks); +} + +// FixedAllocator::CountEmptyChunks ------------------------------------------- + +std::size_t FixedAllocator::CountEmptyChunks( void ) const +{ +#ifdef DO_EXTRA_LOKI_TESTS + // This code is only used for specialized tests of the allocator. + // It is #ifdef-ed so that its O(C) complexity does not overwhelm the + // functions which call it. + std::size_t count = 0; + for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it ) + { + const Chunk & chunk = *it; + if ( chunk.HasAvailable( numBlocks_ ) ) + ++count; + } + return count; +#else + return ( NULL == emptyChunk_ ) ? 0 : 1; +#endif +} + +// FixedAllocator::IsCorrupt -------------------------------------------------- + +bool FixedAllocator::IsCorrupt( void ) const +{ + const bool isEmpty = chunks_.empty(); + ChunkCIter start( chunks_.begin() ); + ChunkCIter last( chunks_.end() ); + const size_t emptyChunkCount = CountEmptyChunks(); + + if ( isEmpty ) + { + if ( start != last ) + { + assert( false ); + return true; + } + if ( 0 < emptyChunkCount ) + { + assert( false ); + return true; + } + if ( NULL != deallocChunk_ ) + { + assert( false ); + return true; + } + if ( NULL != allocChunk_ ) + { + assert( false ); + return true; + } + if ( NULL != emptyChunk_ ) + { + assert( false ); + return true; + } + } + + else + { + const Chunk * front = &chunks_.front(); + const Chunk * back = &chunks_.back(); + if ( start >= last ) + { + assert( false ); + return true; + } + if ( back < deallocChunk_ ) + { + assert( false ); + return true; + } + if ( back < allocChunk_ ) + { + assert( false ); + return true; + } + if ( front > deallocChunk_ ) + { + assert( false ); + return true; + } + if ( front > allocChunk_ ) + { + assert( false ); + return true; + } + + switch ( emptyChunkCount ) + { + case 0: + if ( emptyChunk_ != NULL ) + { + assert( false ); + return true; + } + break; + case 1: + if ( emptyChunk_ == NULL ) + { + assert( false ); + return true; + } + if ( back < emptyChunk_ ) + { + assert( false ); + return true; + } + if ( front > emptyChunk_ ) + { + assert( false ); + return true; + } + if ( !emptyChunk_->HasAvailable( numBlocks_ ) ) + { + // This may imply somebody tried to delete a block twice. + assert( false ); + return true; + } + break; + default: + assert( false ); + return true; + } + for ( ChunkCIter it( start ); it != last; ++it ) + { + const Chunk & chunk = *it; + if ( chunk.IsCorrupt( numBlocks_, blockSize_, true ) ) + return true; + } + } + + return false; +} + +// FixedAllocator::HasBlock --------------------------------------------------- + +const Chunk * FixedAllocator::HasBlock( void * p ) const +{ + const std::size_t chunkLength = numBlocks_ * blockSize_; + for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it ) + { + const Chunk & chunk = *it; + if ( chunk.HasBlock( p, chunkLength ) ) + return &chunk; + } + return NULL; +} + +// FixedAllocator::TrimEmptyChunk --------------------------------------------- + +bool FixedAllocator::TrimEmptyChunk( void ) +{ + // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. + assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); + if ( NULL == emptyChunk_ ) return false; + + // If emptyChunk_ points to valid Chunk, then chunk list is not empty. + assert( !chunks_.empty() ); + // And there should be exactly 1 empty Chunk. + assert( 1 == CountEmptyChunks() ); + + Chunk * lastChunk = &chunks_.back(); + if ( lastChunk != emptyChunk_ ) + std::swap( *emptyChunk_, *lastChunk ); + assert( lastChunk->HasAvailable( numBlocks_ ) ); + lastChunk->Release(); + chunks_.pop_back(); + + if ( chunks_.empty() ) + { + allocChunk_ = NULL; + deallocChunk_ = NULL; + } + else + { + if ( deallocChunk_ == emptyChunk_ ) + { + deallocChunk_ = &chunks_.front(); + assert( deallocChunk_->blocksAvailable_ < numBlocks_ ); + } + if ( allocChunk_ == emptyChunk_ ) + { + allocChunk_ = &chunks_.back(); + assert( allocChunk_->blocksAvailable_ < numBlocks_ ); + } + } + + emptyChunk_ = NULL; + assert( 0 == CountEmptyChunks() ); + + return true; +} + +// FixedAllocator::TrimChunkList ---------------------------------------------- + +bool FixedAllocator::TrimChunkList( void ) +{ + if ( chunks_.empty() ) + { + assert( NULL == allocChunk_ ); + assert( NULL == deallocChunk_ ); + } + + if ( chunks_.size() == chunks_.capacity() ) + return false; + // Use the "make-a-temp-and-swap" trick to remove excess capacity. + Chunks( chunks_ ).swap( chunks_ ); + + return true; +} + +// FixedAllocator::MakeNewChunk ----------------------------------------------- + +bool FixedAllocator::MakeNewChunk( void ) +{ + bool allocated = false; + try + { + std::size_t size = chunks_.size(); + // Calling chunks_.reserve *before* creating and initializing the new + // Chunk means that nothing is leaked by this function in case an + // exception is thrown from reserve. + if ( chunks_.capacity() == size ) + { + if ( 0 == size ) size = 4; + chunks_.reserve( size * 2 ); + } + Chunk newChunk; + allocated = newChunk.Init( blockSize_, numBlocks_ ); + if ( allocated ) + chunks_.push_back( newChunk ); + } + catch ( ... ) + { + allocated = false; + } + if ( !allocated ) return false; + + allocChunk_ = &chunks_.back(); + deallocChunk_ = &chunks_.front(); + return true; +} + +// FixedAllocator::Allocate --------------------------------------------------- + +void * FixedAllocator::Allocate( void ) +{ + // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. + assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); + assert( CountEmptyChunks() < 2 ); + + if ( ( NULL == allocChunk_ ) || allocChunk_->IsFilled() ) + { + if ( NULL != emptyChunk_ ) + { + allocChunk_ = emptyChunk_; + emptyChunk_ = NULL; + } + else + { + for ( ChunkIter i( chunks_.begin() ); ; ++i ) + { + if ( chunks_.end() == i ) + { + if ( !MakeNewChunk() ) + return NULL; + break; + } + if ( !i->IsFilled() ) + { + allocChunk_ = &*i; + break; + } + } + } + } + else if ( allocChunk_ == emptyChunk_) + // detach emptyChunk_ from allocChunk_, because after + // calling allocChunk_->Allocate(blockSize_); the chunk + // is no longer empty. + emptyChunk_ = NULL; + + assert( allocChunk_ != NULL ); + assert( !allocChunk_->IsFilled() ); + void * place = allocChunk_->Allocate( blockSize_ ); + + // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. + assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); + assert( CountEmptyChunks() < 2 ); +#ifdef LOKI_CHECK_FOR_CORRUPTION + if ( allocChunk_->IsCorrupt( numBlocks_, blockSize_, true ) ) + { + assert( false ); + return NULL; + } +#endif + + return place; +} + +// FixedAllocator::Deallocate ------------------------------------------------- + +bool FixedAllocator::Deallocate( void * p, Chunk * hint ) +{ + assert(!chunks_.empty()); + assert(&chunks_.front() <= deallocChunk_); + assert(&chunks_.back() >= deallocChunk_); + assert( &chunks_.front() <= allocChunk_ ); + assert( &chunks_.back() >= allocChunk_ ); + assert( CountEmptyChunks() < 2 ); + + Chunk * foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint; + if ( NULL == foundChunk ) + return false; + + assert( foundChunk->HasBlock( p, numBlocks_ * blockSize_ ) ); +#ifdef LOKI_CHECK_FOR_CORRUPTION + if ( foundChunk->IsCorrupt( numBlocks_, blockSize_, true ) ) + { + assert( false ); + return false; + } + if ( foundChunk->IsBlockAvailable( p, numBlocks_, blockSize_ ) ) + { + assert( false ); + return false; + } +#endif + deallocChunk_ = foundChunk; + DoDeallocate(p); + assert( CountEmptyChunks() < 2 ); + + return true; +} + +// FixedAllocator::VicinityFind ----------------------------------------------- + +Chunk * FixedAllocator::VicinityFind( void * p ) const +{ + if ( chunks_.empty() ) return NULL; + assert(deallocChunk_); + + const std::size_t chunkLength = numBlocks_ * blockSize_; + Chunk * lo = deallocChunk_; + Chunk * hi = deallocChunk_ + 1; + const Chunk * loBound = &chunks_.front(); + const Chunk * hiBound = &chunks_.back() + 1; + + // Special case: deallocChunk_ is the last in the array + if (hi == hiBound) hi = NULL; + + for (;;) + { + if (lo) + { + if ( lo->HasBlock( p, chunkLength ) ) return lo; + if ( lo == loBound ) + { + lo = NULL; + if ( NULL == hi ) break; + } + else --lo; + } + + if (hi) + { + if ( hi->HasBlock( p, chunkLength ) ) return hi; + if ( ++hi == hiBound ) + { + hi = NULL; + if ( NULL == lo ) break; + } + } + } + + return NULL; +} + +// FixedAllocator::DoDeallocate ----------------------------------------------- + +void FixedAllocator::DoDeallocate(void* p) +{ + // Show that deallocChunk_ really owns the block at address p. + assert( deallocChunk_->HasBlock( p, numBlocks_ * blockSize_ ) ); + // Either of the next two assertions may fail if somebody tries to + // delete the same block twice. + assert( emptyChunk_ != deallocChunk_ ); + assert( !deallocChunk_->HasAvailable( numBlocks_ ) ); + // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. + assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); + + // call into the chunk, will adjust the inner list but won't release memory + deallocChunk_->Deallocate(p, blockSize_); + + if ( deallocChunk_->HasAvailable( numBlocks_ ) ) + { + assert( emptyChunk_ != deallocChunk_ ); + // deallocChunk_ is empty, but a Chunk is only released if there are 2 + // empty chunks. Since emptyChunk_ may only point to a previously + // cleared Chunk, if it points to something else besides deallocChunk_, + // then FixedAllocator currently has 2 empty Chunks. + if ( NULL != emptyChunk_ ) + { + // If last Chunk is empty, just change what deallocChunk_ + // points to, and release the last. Otherwise, swap an empty + // Chunk with the last, and then release it. + Chunk * lastChunk = &chunks_.back(); + if ( lastChunk == deallocChunk_ ) + deallocChunk_ = emptyChunk_; + else if ( lastChunk != emptyChunk_ ) + std::swap( *emptyChunk_, *lastChunk ); + assert( lastChunk->HasAvailable( numBlocks_ ) ); + lastChunk->Release(); + chunks_.pop_back(); + if ( ( allocChunk_ == lastChunk ) || allocChunk_->IsFilled() ) + allocChunk_ = deallocChunk_; + } + emptyChunk_ = deallocChunk_; + } + + // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk. + assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) ); +} + +// GetOffset ------------------------------------------------------------------ +/// @ingroup SmallObjectGroupInternal +/// Calculates index into array where a FixedAllocator of numBytes is located. +inline std::size_t GetOffset( std::size_t numBytes, std::size_t alignment ) +{ + const std::size_t alignExtra = alignment-1; + return ( numBytes + alignExtra ) / alignment; +} + +// DefaultAllocator ----------------------------------------------------------- +/** @ingroup SmallObjectGroupInternal + Calls the default allocator when SmallObjAllocator decides not to handle a + request. SmallObjAllocator calls this if the number of bytes is bigger than + the size which can be handled by any FixedAllocator. + @param numBytes number of bytes + @param doThrow True if this function should throw an exception, or false if it + should indicate failure by returning a NULL pointer. +*/ +void * DefaultAllocator( std::size_t numBytes, bool doThrow ) +{ +#ifdef USE_NEW_TO_ALLOCATE + return doThrow ? ::operator new( numBytes ) : + ::operator new( numBytes, std::nothrow_t() ); +#else + void * p = ::std::malloc( numBytes ); + if ( doThrow && ( NULL == p ) ) + throw std::bad_alloc(); + return p; +#endif +} + +// DefaultDeallocator --------------------------------------------------------- +/** @ingroup SmallObjectGroupInternal + Calls default deallocator when SmallObjAllocator decides not to handle a + request. The default deallocator could be the global delete operator or the + free function. The free function is the preferred default deallocator since + it matches malloc which is the preferred default allocator. SmallObjAllocator + will call this if an address was not found among any of its own blocks. + */ +void DefaultDeallocator( void * p ) +{ +#ifdef USE_NEW_TO_ALLOCATE + ::operator delete( p ); +#else + ::std::free( p ); +#endif +} + +// SmallObjAllocator::SmallObjAllocator --------------------------------------- + +SmallObjAllocator::SmallObjAllocator( std::size_t pageSize, + std::size_t maxObjectSize, std::size_t objectAlignSize ) : + pool_( NULL ), + maxSmallObjectSize_( maxObjectSize ), + objectAlignSize_( objectAlignSize ) +{ +#ifdef DO_EXTRA_LOKI_TESTS + std::cout << "SmallObjAllocator " << this << std::endl; +#endif + assert( 0 != objectAlignSize ); + const std::size_t allocCount = GetOffset( maxObjectSize, objectAlignSize ); + pool_ = new FixedAllocator[ allocCount ]; + for ( std::size_t i = 0; i < allocCount; ++i ) + pool_[ i ].Initialize( ( i+1 ) * objectAlignSize, pageSize ); +} + +// SmallObjAllocator::~SmallObjAllocator -------------------------------------- + +SmallObjAllocator::~SmallObjAllocator( void ) +{ +#ifdef DO_EXTRA_LOKI_TESTS + std::cout << "~SmallObjAllocator " << this << std::endl; +#endif + delete [] pool_; +} + +// SmallObjAllocator::TrimExcessMemory ---------------------------------------- + +bool SmallObjAllocator::TrimExcessMemory( void ) +{ + bool found = false; + const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); + std::size_t i = 0; + for ( ; i < allocCount; ++i ) + { + if ( pool_[ i ].TrimEmptyChunk() ) + found = true; + } + for ( i = 0; i < allocCount; ++i ) + { + if ( pool_[ i ].TrimChunkList() ) + found = true; + } + + return found; +} + +// SmallObjAllocator::Allocate ------------------------------------------------ + +void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow ) +{ + if ( numBytes > GetMaxObjectSize() ) + return DefaultAllocator( numBytes, doThrow ); + + assert( NULL != pool_ ); + if ( 0 == numBytes ) numBytes = 1; + const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1; + const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); + (void) allocCount; + assert( index < allocCount ); + + FixedAllocator & allocator = pool_[ index ]; + assert( allocator.BlockSize() >= numBytes ); + assert( allocator.BlockSize() < numBytes + GetAlignment() ); + void * place = allocator.Allocate(); + + if ( ( NULL == place ) && TrimExcessMemory() ) + place = allocator.Allocate(); + + if ( ( NULL == place ) && doThrow ) + { +#ifdef _MSC_VER + throw std::bad_alloc( "could not allocate small object" ); +#else + // GCC did not like a literal string passed to std::bad_alloc. + // so just throw the default-constructed exception. + throw std::bad_alloc(); +#endif + } + return place; +} + +// SmallObjAllocator::Deallocate ---------------------------------------------- + +void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes ) +{ + if ( NULL == p ) return; + if ( numBytes > GetMaxObjectSize() ) + { + DefaultDeallocator( p ); + return; + } + assert( NULL != pool_ ); + if ( 0 == numBytes ) numBytes = 1; + const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1; + const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); + (void) allocCount; + assert( index < allocCount ); + FixedAllocator & allocator = pool_[ index ]; + assert( allocator.BlockSize() >= numBytes ); + assert( allocator.BlockSize() < numBytes + GetAlignment() ); + const bool found = allocator.Deallocate( p, NULL ); + (void) found; + assert( found ); +} + +// SmallObjAllocator::Deallocate ---------------------------------------------- + +void SmallObjAllocator::Deallocate( void * p ) +{ + if ( NULL == p ) return; + assert( NULL != pool_ ); + FixedAllocator * pAllocator = NULL; + const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); + Chunk * chunk = NULL; + + for ( std::size_t ii = 0; ii < allocCount; ++ii ) + { + chunk = pool_[ ii ].HasBlock( p ); + if ( NULL != chunk ) + { + pAllocator = &pool_[ ii ]; + break; + } + } + if ( NULL == pAllocator ) + { + DefaultDeallocator( p ); + return; + } + + assert( NULL != chunk ); + const bool found = pAllocator->Deallocate( p, chunk ); + (void) found; + assert( found ); +} + +// SmallObjAllocator::IsCorrupt ----------------------------------------------- + +bool SmallObjAllocator::IsCorrupt( void ) const +{ + if ( NULL == pool_ ) + { + assert( false ); + return true; + } + if ( 0 == GetAlignment() ) + { + assert( false ); + return true; + } + if ( 0 == GetMaxObjectSize() ) + { + assert( false ); + return true; + } + const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() ); + for ( std::size_t ii = 0; ii < allocCount; ++ii ) + { + if ( pool_[ ii ].IsCorrupt() ) + return true; + } + return false; +} + +} // end namespace Loki + diff --git a/shared/loki/SmallObj.h b/shared/loki/SmallObj.h new file mode 100644 index 00000000..65828bf2 --- /dev/null +++ b/shared/loki/SmallObj.h @@ -0,0 +1,644 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_SMALLOBJ_INC_ +#define LOKI_SMALLOBJ_INC_ + +// $Id: SmallObj.h 806 2007-02-03 00:01:52Z rich_sposato $ + + +#include "LokiExport.h" +#include "Threads.h" +#include "Singleton.h" +#include <cstddef> +#include <new> // needed for std::nothrow_t parameter. + +#ifndef LOKI_DEFAULT_CHUNK_SIZE +#define LOKI_DEFAULT_CHUNK_SIZE 4096 +#endif + +#ifndef LOKI_MAX_SMALL_OBJECT_SIZE +#define LOKI_MAX_SMALL_OBJECT_SIZE 256 +#endif + +#ifndef LOKI_DEFAULT_OBJECT_ALIGNMENT +#define LOKI_DEFAULT_OBJECT_ALIGNMENT 4 +#endif + +#ifndef LOKI_DEFAULT_SMALLOBJ_LIFETIME +#define LOKI_DEFAULT_SMALLOBJ_LIFETIME ::Loki::LongevityLifetime::DieAsSmallObjectParent +#endif + +#if defined(LOKI_SMALL_OBJECT_USE_NEW_ARRAY) && defined(_MSC_VER) +#pragma message("Don't define LOKI_SMALL_OBJECT_USE_NEW_ARRAY when using a Microsoft compiler to prevent memory leaks.") +#pragma message("now calling '#undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY'") +#undef LOKI_SMALL_OBJECT_USE_NEW_ARRAY +#endif + +/// \defgroup SmallObjectGroup Small objects +/// +/// \defgroup SmallObjectGroupInternal Internals +/// \ingroup SmallObjectGroup + +namespace Loki +{ + namespace LongevityLifetime + { + /** @struct DieAsSmallObjectParent + @ingroup SmallObjectGroup + Lifetime policy to manage lifetime dependencies of + SmallObject base and child classes. + The Base class should have this lifetime + */ + template <class T> + struct DieAsSmallObjectParent : DieLast<T> {}; + + /** @struct DieAsSmallObjectChild + @ingroup SmallObjectGroup + Lifetime policy to manage lifetime dependencies of + SmallObject base and child classes. + The Child class should have this lifetime + */ + template <class T> + struct DieAsSmallObjectChild : DieDirectlyBeforeLast<T> {}; + + } + + class FixedAllocator; + + /** @class SmallObjAllocator + @ingroup SmallObjectGroupInternal + Manages pool of fixed-size allocators. + Designed to be a non-templated base class of AllocatorSingleton so that + implementation details can be safely hidden in the source code file. + */ + class LOKI_EXPORT SmallObjAllocator + { + protected: + /** The only available constructor needs certain parameters in order to + initialize all the FixedAllocator's. This throws only if + @param pageSize # of bytes in a page of memory. + @param maxObjectSize Max # of bytes which this may allocate. + @param objectAlignSize # of bytes between alignment boundaries. + */ + SmallObjAllocator( std::size_t pageSize, std::size_t maxObjectSize, + std::size_t objectAlignSize ); + + /** Destructor releases all blocks, all Chunks, and FixedAllocator's. + Any outstanding blocks are unavailable, and should not be used after + this destructor is called. The destructor is deliberately non-virtual + because it is protected, not public. + */ + ~SmallObjAllocator( void ); + + public: + /** Allocates a block of memory of requested size. Complexity is often + constant-time, but might be O(C) where C is the number of Chunks in a + FixedAllocator. + + @par Exception Safety Level + Provides either strong-exception safety, or no-throw exception-safety + level depending upon doThrow parameter. The reason it provides two + levels of exception safety is because it is used by both the nothrow + and throwing new operators. The underlying implementation will never + throw of its own accord, but this can decide to throw if it does not + allocate. The only exception it should emit is std::bad_alloc. + + @par Allocation Failure + If it does not allocate, it will call TrimExcessMemory and attempt to + allocate again, before it decides to throw or return NULL. Many + allocators loop through several new_handler functions, and terminate + if they can not allocate, but not this one. It only makes one attempt + using its own implementation of the new_handler, and then returns NULL + or throws so that the program can decide what to do at a higher level. + (Side note: Even though the C++ Standard allows allocators and + new_handlers to terminate if they fail, the Loki allocator does not do + that since that policy is not polite to a host program.) + + @param size # of bytes needed for allocation. + @param doThrow True if this should throw if unable to allocate, false + if it should provide no-throw exception safety level. + @return NULL if nothing allocated and doThrow is false. Else the + pointer to an available block of memory. + */ + void * Allocate( std::size_t size, bool doThrow ); + + /** Deallocates a block of memory at a given place and of a specific + size. Complexity is almost always constant-time, and is O(C) only if + it has to search for which Chunk deallocates. This never throws. + */ + void Deallocate( void * p, std::size_t size ); + + /** Deallocates a block of memory at a given place but of unknown size + size. Complexity is O(F + C) where F is the count of FixedAllocator's + in the pool, and C is the number of Chunks in all FixedAllocator's. This + does not throw exceptions. This overloaded version of Deallocate is + called by the nothow delete operator - which is called when the nothrow + new operator is used, but a constructor throws an exception. + */ + void Deallocate( void * p ); + + /// Returns max # of bytes which this can allocate. + inline std::size_t GetMaxObjectSize() const + { return maxSmallObjectSize_; } + + /// Returns # of bytes between allocation boundaries. + inline std::size_t GetAlignment() const { return objectAlignSize_; } + + /** Releases empty Chunks from memory. Complexity is O(F + C) where F + is the count of FixedAllocator's in the pool, and C is the number of + Chunks in all FixedAllocator's. This will never throw. This is called + by AllocatorSingleto::ClearExtraMemory, the new_handler function for + Loki's allocator, and is called internally when an allocation fails. + @return True if any memory released, or false if none released. + */ + bool TrimExcessMemory( void ); + + /** Returns true if anything in implementation is corrupt. Complexity + is O(F + C + B) where F is the count of FixedAllocator's in the pool, + C is the number of Chunks in all FixedAllocator's, and B is the number + of blocks in all Chunks. If it determines any data is corrupted, this + will return true in release version, but assert in debug version at + the line where it detects the corrupted data. If it does not detect + any corrupted data, it returns false. + */ + bool IsCorrupt( void ) const; + + private: + /// Default-constructor is not implemented. + SmallObjAllocator( void ); + /// Copy-constructor is not implemented. + SmallObjAllocator( const SmallObjAllocator & ); + /// Copy-assignment operator is not implemented. + SmallObjAllocator & operator = ( const SmallObjAllocator & ); + + /// Pointer to array of fixed-size allocators. + Loki::FixedAllocator * pool_; + + /// Largest object size supported by allocators. + const std::size_t maxSmallObjectSize_; + + /// Size of alignment boundaries. + const std::size_t objectAlignSize_; + }; + + + /** @class AllocatorSingleton + @ingroup SmallObjectGroupInternal + This template class is derived from + SmallObjAllocator in order to pass template arguments into it, and still + have a default constructor for the singleton. Each instance is a unique + combination of all the template parameters, and hence is singleton only + with respect to those parameters. The template parameters have default + values and the class has typedefs identical to both SmallObject and + SmallValueObject so that this class can be used directly instead of going + through SmallObject or SmallValueObject. That design feature allows + clients to use the new_handler without having the name of the new_handler + function show up in classes derived from SmallObject or SmallValueObject. + Thus, the only functions in the allocator which show up in SmallObject or + SmallValueObject inheritance hierarchies are the new and delete + operators. + */ + template + < + template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, + std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE, + std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE, + std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT, + template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME, + class MutexPolicy = LOKI_DEFAULT_MUTEX + > + class AllocatorSingleton : public SmallObjAllocator + { + public: + + /// Defines type of allocator. + typedef AllocatorSingleton< ThreadingModel, chunkSize, + maxSmallObjectSize, objectAlignSize, LifetimePolicy > MyAllocator; + + /// Defines type for thread-safety locking mechanism. + typedef ThreadingModel< MyAllocator, MutexPolicy > MyThreadingModel; + + /// Defines singleton made from allocator. + typedef Loki::SingletonHolder< MyAllocator, Loki::CreateStatic, + LifetimePolicy, ThreadingModel > MyAllocatorSingleton; + + /// Returns reference to the singleton. + inline static AllocatorSingleton & Instance( void ) + { + return MyAllocatorSingleton::Instance(); + } + + /// The default constructor is not meant to be called directly. + inline AllocatorSingleton() : + SmallObjAllocator( chunkSize, maxSmallObjectSize, objectAlignSize ) + {} + + /// The destructor is not meant to be called directly. + inline ~AllocatorSingleton( void ) {} + + /** Clears any excess memory used by the allocator. Complexity is + O(F + C) where F is the count of FixedAllocator's in the pool, and C + is the number of Chunks in all FixedAllocator's. This never throws. + @note This function can be used as a new_handler when Loki and other + memory allocators can no longer allocate. Although the C++ Standard + allows new_handler functions to terminate the program when they can + not release any memory, this will not do so. + */ + static void ClearExtraMemory( void ); + + /** Returns true if anything in implementation is corrupt. Complexity + is O(F + C + B) where F is the count of FixedAllocator's in the pool, + C is the number of Chunks in all FixedAllocator's, and B is the number + of blocks in all Chunks. If it determines any data is corrupted, this + will return true in release version, but assert in debug version at + the line where it detects the corrupted data. If it does not detect + any corrupted data, it returns false. + */ + static bool IsCorrupted( void ); + + private: + /// Copy-constructor is not implemented. + AllocatorSingleton( const AllocatorSingleton & ); + /// Copy-assignment operator is not implemented. + AllocatorSingleton & operator = ( const AllocatorSingleton & ); + }; + + template + < + template <class, class> class T, + std::size_t C, + std::size_t M, + std::size_t O, + template <class> class L, + class X + > + void AllocatorSingleton< T, C, M, O, L, X >::ClearExtraMemory( void ) + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + Instance().TrimExcessMemory(); + } + + template + < + template <class, class> class T, + std::size_t C, + std::size_t M, + std::size_t O, + template <class> class L, + class X + > + bool AllocatorSingleton< T, C, M, O, L, X >::IsCorrupted( void ) + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + return Instance().IsCorrupt(); + } + + /** This standalone function provides the longevity level for Small-Object + Allocators which use the Loki::SingletonWithLongevity policy. The + SingletonWithLongevity class can find this function through argument- + dependent lookup. + + @par Longevity Levels + No Small-Object Allocator depends on any other Small-Object allocator, so + this does not need to calculate dependency levels among allocators, and + it returns just a constant. All allocators must live longer than the + objects which use the allocators, it must return a longevity level higher + than any such object. + */ + template + < + template <class, class> class T, + std::size_t C, + std::size_t M, + std::size_t O, + template <class> class L, + class X + > + inline unsigned int GetLongevity( + AllocatorSingleton< T, C, M, O, L, X > * ) + { + // Returns highest possible value. + return 0xFFFFFFFF; + } + + + /** @class SmallObjectBase + @ingroup SmallObjectGroup + Base class for small object allocation classes. + The shared implementation of the new and delete operators are here instead + of being duplicated in both SmallObject or SmallValueObject, later just + called Small-Objects. This class is not meant to be used directly by clients, + or derived from by clients. Class has no data members so compilers can + use Empty-Base-Optimization. + + @par ThreadingModel + This class doesn't support ObjectLevelLockable policy for ThreadingModel. + The allocator is a singleton, so a per-instance mutex is not necessary. + Nor is using ObjectLevelLockable recommended with SingletonHolder since + the SingletonHolder::MakeInstance function requires a mutex that exists + prior to when the object is created - which is not possible if the mutex + is inside the object, such as required for ObjectLevelLockable. If you + attempt to use ObjectLevelLockable, the compiler will emit errors because + it can't use the default constructor in ObjectLevelLockable. If you need + a thread-safe allocator, use the ClassLevelLockable policy. + + @par Lifetime Policy + + The SmallObjectBase template needs a lifetime policy because it owns + a singleton of SmallObjAllocator which does all the low level functions. + When using a Small-Object in combination with the SingletonHolder template + you have to choose two lifetimes, that of the Small-Object and that of + the singleton. The rule is: The Small-Object lifetime must be greater than + the lifetime of the singleton hosting the Small-Object. Violating this rule + results in a crash on exit, because the hosting singleton tries to delete + the Small-Object which is then already destroyed. + + The lifetime policies recommended for use with Small-Objects hosted + by a SingletonHolder template are + - LongevityLifetime::DieAsSmallObjectParent / LongevityLifetime::DieAsSmallObjectChild + - SingletonWithLongevity + - FollowIntoDeath (not supported by MSVC 7.1) + - NoDestroy + + The default lifetime of Small-Objects is + LongevityLifetime::DieAsSmallObjectParent to + insure that memory is not released before a object with the lifetime + LongevityLifetime::DieAsSmallObjectChild using that + memory is destroyed. The LongevityLifetime::DieAsSmallObjectParent + lifetime has the highest possible value of a SetLongevity lifetime, so + you can use it in combination with your own lifetime not having also + the highest possible value. + + The DefaultLifetime and PhoenixSingleton policies are *not* recommended + since they can cause the allocator to be destroyed and release memory + for singletons hosting a object which inherit from either SmallObject + or SmallValueObject. + + @par Lifetime usage + + - LongevityLifetime: The Small-Object has + LongevityLifetime::DieAsSmallObjectParent policy and the Singleton + hosting the Small-Object has LongevityLifetime::DieAsSmallObjectChild. + The child lifetime has a hard coded SetLongevity lifetime which is + shorter than the lifetime of the parent, thus the child dies + before the parent. + + - Both Small-Object and Singleton use SingletonWithLongevity policy. + The longevity level for the singleton must be lower than that for the + Small-Object. This is why the AllocatorSingleton's GetLongevity function + returns the highest value. + + - FollowIntoDeath lifetime: The Small-Object has + FollowIntoDeath::With<LIFETIME>::AsMasterLiftime + policy and the Singleton has + FollowIntoDeath::AfterMaster<MASTERSINGLETON>::IsDestroyed policy, + where you could choose the LIFETIME. + + - Both Small-Object and Singleton use NoDestroy policy. + Since neither is ever destroyed, the destruction order does not matter. + Note: you will get memory leaks! + + - The Small-Object has NoDestroy policy but the Singleton has + SingletonWithLongevity policy. Note: you will get memory leaks! + + + You should *not* use NoDestroy for the singleton, and then use + SingletonWithLongevity for the Small-Object. + + @par Examples: + + - test/SmallObj/SmallSingleton.cpp + - test/Singleton/Dependencies.cpp + */ + template + < + template <class, class> class ThreadingModel, + std::size_t chunkSize, + std::size_t maxSmallObjectSize, + std::size_t objectAlignSize, + template <class> class LifetimePolicy, + class MutexPolicy + > + class SmallObjectBase + { + +#if (LOKI_MAX_SMALL_OBJECT_SIZE != 0) && (LOKI_DEFAULT_CHUNK_SIZE != 0) && (LOKI_DEFAULT_OBJECT_ALIGNMENT != 0) + + public: + /// Defines type of allocator singleton, must be public + /// to handle singleton lifetime dependencies. + typedef AllocatorSingleton< ThreadingModel, chunkSize, + maxSmallObjectSize, objectAlignSize, LifetimePolicy > ObjAllocatorSingleton; + + private: + + /// Defines type for thread-safety locking mechanism. + typedef ThreadingModel< ObjAllocatorSingleton, MutexPolicy > MyThreadingModel; + + /// Use singleton defined in AllocatorSingleton. + typedef typename ObjAllocatorSingleton::MyAllocatorSingleton MyAllocatorSingleton; + + public: + + /// Throwing single-object new throws bad_alloc when allocation fails. +#ifdef _MSC_VER + /// @note MSVC complains about non-empty exception specification lists. + static void * operator new ( std::size_t size ) +#else + static void * operator new ( std::size_t size ) throw ( std::bad_alloc ) +#endif + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + return MyAllocatorSingleton::Instance().Allocate( size, true ); + } + + /// Non-throwing single-object new returns NULL if allocation fails. + static void * operator new ( std::size_t size, const std::nothrow_t & ) throw () + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + return MyAllocatorSingleton::Instance().Allocate( size, false ); + } + + /// Placement single-object new merely calls global placement new. + inline static void * operator new ( std::size_t size, void * place ) + { + return ::operator new( size, place ); + } + + /// Single-object delete. + static void operator delete ( void * p, std::size_t size ) throw () + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + MyAllocatorSingleton::Instance().Deallocate( p, size ); + } + + /** Non-throwing single-object delete is only called when nothrow + new operator is used, and the constructor throws an exception. + */ + static void operator delete ( void * p, const std::nothrow_t & ) throw() + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + MyAllocatorSingleton::Instance().Deallocate( p ); + } + + /// Placement single-object delete merely calls global placement delete. + inline static void operator delete ( void * p, void * place ) + { + ::operator delete ( p, place ); + } + +#ifdef LOKI_SMALL_OBJECT_USE_NEW_ARRAY + + /// Throwing array-object new throws bad_alloc when allocation fails. +#ifdef _MSC_VER + /// @note MSVC complains about non-empty exception specification lists. + static void * operator new [] ( std::size_t size ) +#else + static void * operator new [] ( std::size_t size ) + throw ( std::bad_alloc ) +#endif + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + return MyAllocatorSingleton::Instance().Allocate( size, true ); + } + + /// Non-throwing array-object new returns NULL if allocation fails. + static void * operator new [] ( std::size_t size, + const std::nothrow_t & ) throw () + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + return MyAllocatorSingleton::Instance().Allocate( size, false ); + } + + /// Placement array-object new merely calls global placement new. + inline static void * operator new [] ( std::size_t size, void * place ) + { + return ::operator new( size, place ); + } + + /// Array-object delete. + static void operator delete [] ( void * p, std::size_t size ) throw () + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + MyAllocatorSingleton::Instance().Deallocate( p, size ); + } + + /** Non-throwing array-object delete is only called when nothrow + new operator is used, and the constructor throws an exception. + */ + static void operator delete [] ( void * p, + const std::nothrow_t & ) throw() + { + typename MyThreadingModel::Lock lock; + (void)lock; // get rid of warning + MyAllocatorSingleton::Instance().Deallocate( p ); + } + + /// Placement array-object delete merely calls global placement delete. + inline static void operator delete [] ( void * p, void * place ) + { + ::operator delete ( p, place ); + } +#endif // #if use new array functions. + +#endif // #if default template parameters are not zero + + protected: + inline SmallObjectBase( void ) {} + inline SmallObjectBase( const SmallObjectBase & ) {} + inline SmallObjectBase & operator = ( const SmallObjectBase & ) + { return *this; } + inline ~SmallObjectBase() {} + }; // end class SmallObjectBase + + + /** @class SmallObject + @ingroup SmallObjectGroup + SmallObject Base class for polymorphic small objects, offers fast + allocations & deallocations. Destructor is virtual and public. Default + constructor is trivial. Copy-constructor and copy-assignment operator are + not implemented since polymorphic classes almost always disable those + operations. Class has no data members so compilers can use + Empty-Base-Optimization. + */ + template + < + template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, + std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE, + std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE, + std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT, + template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME, + class MutexPolicy = LOKI_DEFAULT_MUTEX + > + class SmallObject : public SmallObjectBase< ThreadingModel, chunkSize, + maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > + { + + public: + virtual ~SmallObject() {} + protected: + inline SmallObject( void ) {} + + private: + /// Copy-constructor is not implemented. + SmallObject( const SmallObject & ); + /// Copy-assignment operator is not implemented. + SmallObject & operator = ( const SmallObject & ); + }; // end class SmallObject + + + /** @class SmallValueObject + @ingroup SmallObjectGroup + SmallValueObject Base class for small objects with value-type + semantics - offers fast allocations & deallocations. Destructor is + non-virtual, inline, and protected to prevent unintentional destruction + through base class. Default constructor is trivial. Copy-constructor + and copy-assignment operator are trivial since value-types almost always + need those operations. Class has no data members so compilers can use + Empty-Base-Optimization. + */ + template + < + template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, + std::size_t chunkSize = LOKI_DEFAULT_CHUNK_SIZE, + std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE, + std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT, + template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME, + class MutexPolicy = LOKI_DEFAULT_MUTEX + > + class SmallValueObject : public SmallObjectBase< ThreadingModel, chunkSize, + maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > + { + protected: + inline SmallValueObject( void ) {} + inline SmallValueObject( const SmallValueObject & ) {} + inline SmallValueObject & operator = ( const SmallValueObject & ) + { return *this; } + inline ~SmallValueObject() {} + }; // end class SmallValueObject + +} // namespace Loki + +#endif // end file guardian + diff --git a/shared/loki/SmartPtr.h b/shared/loki/SmartPtr.h new file mode 100644 index 00000000..df548553 --- /dev/null +++ b/shared/loki/SmartPtr.h @@ -0,0 +1,1778 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_SMARTPTR_INC_ +#define LOKI_SMARTPTR_INC_ + +// $Id: SmartPtr.h 903 2008-11-10 05:55:12Z rich_sposato $ + + +/// \defgroup SmartPointerGroup Smart pointers +/// Policy based implementation of a smart pointer +/// \defgroup SmartPointerOwnershipGroup Ownership policies +/// \ingroup SmartPointerGroup +/// \defgroup SmartPointerStorageGroup Storage policies +/// \ingroup SmartPointerGroup +/// \defgroup SmartPointerConversionGroup Conversion policies +/// \ingroup SmartPointerGroup +/// \defgroup SmartPointerCheckingGroup Checking policies +/// \ingroup SmartPointerGroup + +#include "LokiExport.h" +#include "SmallObj.h" +#include "TypeManip.h" +#include "static_check.h" +#include "RefToValue.h" +#include "ConstPolicy.h" + +#include <functional> +#include <stdexcept> +#include <cassert> +#include <string> + +#if !defined(_MSC_VER) +# if defined(__sparc__) +# include <inttypes.h> +# else +# include <stdint.h> +# endif +#endif + +#if defined(_MSC_VER) || defined(__GNUC__) +// GCC>=4.1 must use -ffriend-injection due to a bug in GCC +#define LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND +#endif + + +namespace Loki +{ + +//////////////////////////////////////////////////////////////////////////////// +/// \class HeapStorage +/// +/// \ingroup SmartPointerStorageGroup +/// Implementation of the StoragePolicy used by SmartPtr. Uses explicit call +/// to T's destructor followed by call to free. +//////////////////////////////////////////////////////////////////////////////// + + + template <class T> + class HeapStorage + { + public: + typedef T* StoredType; /// the type of the pointee_ object + typedef T* InitPointerType; /// type used to declare OwnershipPolicy type. + typedef T* PointerType; /// type returned by operator-> + typedef T& ReferenceType; /// type returned by operator* + + HeapStorage() : pointee_(Default()) + {} + + // The storage policy doesn't initialize the stored pointer + // which will be initialized by the OwnershipPolicy's Clone fn + HeapStorage(const HeapStorage&) : pointee_(0) + {} + + template <class U> + HeapStorage(const HeapStorage<U>&) : pointee_(0) + {} + + HeapStorage(const StoredType& p) : pointee_(p) {} + + PointerType operator->() const { return pointee_; } + + ReferenceType operator*() const { return *pointee_; } + + void Swap(HeapStorage& rhs) + { std::swap(pointee_, rhs.pointee_); } + + // Accessors + template <class F> + friend typename HeapStorage<F>::PointerType GetImpl(const HeapStorage<F>& sp); + + template <class F> + friend const typename HeapStorage<F>::StoredType& GetImplRef(const HeapStorage<F>& sp); + + template <class F> + friend typename HeapStorage<F>::StoredType& GetImplRef(HeapStorage<F>& sp); + + protected: + // Destroys the data stored + // (Destruction might be taken over by the OwnershipPolicy) + void Destroy() + { + if ( 0 != pointee_ ) + { + pointee_->~T(); + ::free( pointee_ ); + } + } + + // Default value to initialize the pointer + static StoredType Default() + { return 0; } + + private: + // Data + StoredType pointee_; + }; + + template <class T> + inline typename HeapStorage<T>::PointerType GetImpl(const HeapStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline const typename HeapStorage<T>::StoredType& GetImplRef(const HeapStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline typename HeapStorage<T>::StoredType& GetImplRef(HeapStorage<T>& sp) + { return sp.pointee_; } + + +//////////////////////////////////////////////////////////////////////////////// +/// \class DefaultSPStorage +/// +/// \ingroup SmartPointerStorageGroup +/// Implementation of the StoragePolicy used by SmartPtr +//////////////////////////////////////////////////////////////////////////////// + + + template <class T> + class DefaultSPStorage + { + public: + typedef T* StoredType; // the type of the pointee_ object + typedef T* InitPointerType; /// type used to declare OwnershipPolicy type. + typedef T* PointerType; // type returned by operator-> + typedef T& ReferenceType; // type returned by operator* + + DefaultSPStorage() : pointee_(Default()) + {} + + // The storage policy doesn't initialize the stored pointer + // which will be initialized by the OwnershipPolicy's Clone fn + DefaultSPStorage(const DefaultSPStorage&) : pointee_(0) + {} + + template <class U> + DefaultSPStorage(const DefaultSPStorage<U>&) : pointee_(0) + {} + + DefaultSPStorage(const StoredType& p) : pointee_(p) {} + + PointerType operator->() const { return pointee_; } + + ReferenceType operator*() const { return *pointee_; } + + void Swap(DefaultSPStorage& rhs) + { std::swap(pointee_, rhs.pointee_); } + + // Accessors + template <class F> + friend typename DefaultSPStorage<F>::PointerType GetImpl(const DefaultSPStorage<F>& sp); + + template <class F> + friend const typename DefaultSPStorage<F>::StoredType& GetImplRef(const DefaultSPStorage<F>& sp); + + template <class F> + friend typename DefaultSPStorage<F>::StoredType& GetImplRef(DefaultSPStorage<F>& sp); + + protected: + // Destroys the data stored + // (Destruction might be taken over by the OwnershipPolicy) + // + // If your compiler gives you a warning in this area while + // compiling the tests, it is on purpose, please ignore it. + void Destroy() + { + delete pointee_; + } + + // Default value to initialize the pointer + static StoredType Default() + { return 0; } + + private: + // Data + StoredType pointee_; + }; + + template <class T> + inline typename DefaultSPStorage<T>::PointerType GetImpl(const DefaultSPStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline const typename DefaultSPStorage<T>::StoredType& GetImplRef(const DefaultSPStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline typename DefaultSPStorage<T>::StoredType& GetImplRef(DefaultSPStorage<T>& sp) + { return sp.pointee_; } + + +//////////////////////////////////////////////////////////////////////////////// +/// \class LockedStorage +/// +/// \ingroup SmartPointerStorageGroup +/// Implementation of the StoragePolicy used by SmartPtr. +/// +/// Each call to operator-> locks the object for the duration of a call to a +/// member function of T. +/// +/// \par How It Works +/// LockedStorage has a helper class called Locker, which acts as a smart +/// pointer with limited abilities. LockedStorage::operator-> returns an +/// unnamed temporary of type Locker<T> that exists for the duration of the +/// call to a member function of T. The unnamed temporary locks the object +/// when it is constructed by operator-> and unlocks the object when it is +/// destructed. +/// +/// \note This storage policy requires class T to have member functions Lock +/// and Unlock. If your class does not have Lock or Unlock functions, you may +/// either make a child class which does, or make a policy class similar to +/// LockedStorage which calls other functions to lock the object. +//////////////////////////////////////////////////////////////////////////////// + + template <class T> + class Locker + { + public: + Locker( const T * p ) : pointee_( const_cast< T * >( p ) ) + { + if ( pointee_ != 0 ) + pointee_->Lock(); + } + + ~Locker( void ) + { + if ( pointee_ != 0 ) + pointee_->Unlock(); + } + + operator T * () + { + return pointee_; + } + + T * operator->() + { + return pointee_; + } + + private: + Locker( void ); + Locker & operator = ( const Locker & ); + T * pointee_; + }; + + template <class T> + class LockedStorage + { + public: + + typedef T* StoredType; /// the type of the pointee_ object + typedef T* InitPointerType; /// type used to declare OwnershipPolicy type. + typedef Locker< T > PointerType; /// type returned by operator-> + typedef T& ReferenceType; /// type returned by operator* + + LockedStorage() : pointee_( Default() ) {} + + ~LockedStorage( void ) {} + + LockedStorage( const LockedStorage&) : pointee_( 0 ) {} + + LockedStorage( const StoredType & p ) : pointee_( p ) {} + + PointerType operator->() + { + return Locker< T >( pointee_ ); + } + + void Swap(LockedStorage& rhs) + { + std::swap( pointee_, rhs.pointee_ ); + } + + // Accessors + template <class F> + friend typename LockedStorage<F>::InitPointerType GetImpl(const LockedStorage<F>& sp); + + template <class F> + friend const typename LockedStorage<F>::StoredType& GetImplRef(const LockedStorage<F>& sp); + + template <class F> + friend typename LockedStorage<F>::StoredType& GetImplRef(LockedStorage<F>& sp); + + protected: + // Destroys the data stored + // (Destruction might be taken over by the OwnershipPolicy) + void Destroy() + { + delete pointee_; + } + + // Default value to initialize the pointer + static StoredType Default() + { return 0; } + + private: + /// Dereference operator is not implemented. + ReferenceType operator*(); + + // Data + StoredType pointee_; + }; + + template <class T> + inline typename LockedStorage<T>::InitPointerType GetImpl(const LockedStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline const typename LockedStorage<T>::StoredType& GetImplRef(const LockedStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline typename LockedStorage<T>::StoredType& GetImplRef(LockedStorage<T>& sp) + { return sp.pointee_; } + + +//////////////////////////////////////////////////////////////////////////////// +/// \class ArrayStorage +/// +/// \ingroup SmartPointerStorageGroup +/// Implementation of the ArrayStorage used by SmartPtr +//////////////////////////////////////////////////////////////////////////////// + + + template <class T> + class ArrayStorage + { + public: + typedef T* StoredType; // the type of the pointee_ object + typedef T* InitPointerType; /// type used to declare OwnershipPolicy type. + typedef T* PointerType; // type returned by operator-> + typedef T& ReferenceType; // type returned by operator* + + ArrayStorage() : pointee_(Default()) + {} + + // The storage policy doesn't initialize the stored pointer + // which will be initialized by the OwnershipPolicy's Clone fn + ArrayStorage(const ArrayStorage&) : pointee_(0) + {} + + template <class U> + ArrayStorage(const ArrayStorage<U>&) : pointee_(0) + {} + + ArrayStorage(const StoredType& p) : pointee_(p) {} + + PointerType operator->() const { return pointee_; } + + ReferenceType operator*() const { return *pointee_; } + + void Swap(ArrayStorage& rhs) + { std::swap(pointee_, rhs.pointee_); } + + // Accessors + template <class F> + friend typename ArrayStorage<F>::PointerType GetImpl(const ArrayStorage<F>& sp); + + template <class F> + friend const typename ArrayStorage<F>::StoredType& GetImplRef(const ArrayStorage<F>& sp); + + template <class F> + friend typename ArrayStorage<F>::StoredType& GetImplRef(ArrayStorage<F>& sp); + + protected: + // Destroys the data stored + // (Destruction might be taken over by the OwnershipPolicy) + void Destroy() + { delete [] pointee_; } + + // Default value to initialize the pointer + static StoredType Default() + { return 0; } + + private: + // Data + StoredType pointee_; + }; + + template <class T> + inline typename ArrayStorage<T>::PointerType GetImpl(const ArrayStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline const typename ArrayStorage<T>::StoredType& GetImplRef(const ArrayStorage<T>& sp) + { return sp.pointee_; } + + template <class T> + inline typename ArrayStorage<T>::StoredType& GetImplRef(ArrayStorage<T>& sp) + { return sp.pointee_; } + + +//////////////////////////////////////////////////////////////////////////////// +/// \class RefCounted +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Provides a classic external reference counting implementation +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + class RefCounted + { + public: + RefCounted() + : pCount_(static_cast<uintptr_t*>( + SmallObject<>::operator new(sizeof(uintptr_t)))) + { + assert(pCount_!=0); + *pCount_ = 1; + } + + RefCounted(const RefCounted& rhs) + : pCount_(rhs.pCount_) + {} + + // MWCW lacks template friends, hence the following kludge + template <typename P1> + RefCounted(const RefCounted<P1>& rhs) + : pCount_(reinterpret_cast<const RefCounted&>(rhs).pCount_) + {} + + P Clone(const P& val) + { + ++*pCount_; + return val; + } + + bool Release(const P&) + { + if (!--*pCount_) + { + SmallObject<>::operator delete(pCount_, sizeof(uintptr_t)); + pCount_ = NULL; + return true; + } + return false; + } + + void Swap(RefCounted& rhs) + { std::swap(pCount_, rhs.pCount_); } + + enum { destructiveCopy = false }; + + private: + // Data + uintptr_t* pCount_; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct RefCountedMT +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Implements external reference counting for multithreaded programs +/// Policy Usage: RefCountedMTAdj<ThreadingModel>::RefCountedMT +/// +/// \par Warning +/// There could be a race condition, see bug "Race condition in RefCountedMTAdj::Release" +/// http://sourceforge.net/tracker/index.php?func=detail&aid=1408845&group_id=29557&atid=396644 +/// As stated in bug 1408845, the Release function is not thread safe if a +/// SmartPtr copy-constructor tries to copy the last pointer to an object in +/// one thread, while the destructor is acting on the last pointer in another +/// thread. The existence of a race between a copy-constructor and destructor +/// implies a design flaw at a higher level. That race condition must be +/// fixed at a higher design level, and no change to this class could fix it. +//////////////////////////////////////////////////////////////////////////////// + + template <template <class, class> class ThreadingModel, + class MX = LOKI_DEFAULT_MUTEX > + struct RefCountedMTAdj + { + template <class P> + class RefCountedMT : public ThreadingModel< RefCountedMT<P>, MX > + { + typedef ThreadingModel< RefCountedMT<P>, MX > base_type; + typedef typename base_type::IntType CountType; + typedef volatile CountType *CountPtrType; + + public: + RefCountedMT() + { + pCount_ = static_cast<CountPtrType>( + SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator new( + sizeof(*pCount_))); + assert(pCount_); + //*pCount_ = 1; + ThreadingModel<RefCountedMT, MX>::AtomicAssign(*pCount_, 1); + } + + RefCountedMT(const RefCountedMT& rhs) + : pCount_(rhs.pCount_) + {} + + //MWCW lacks template friends, hence the following kludge + template <typename P1> + RefCountedMT(const RefCountedMT<P1>& rhs) + : pCount_(reinterpret_cast<const RefCountedMT<P>&>(rhs).pCount_) + {} + + P Clone(const P& val) + { + ThreadingModel<RefCountedMT, MX>::AtomicIncrement(*pCount_); + return val; + } + + bool Release(const P&) + { + bool isZero = false; + ThreadingModel< RefCountedMT, MX >::AtomicDecrement( *pCount_, 0, isZero ); + if ( isZero ) + { + SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator delete( + const_cast<CountType *>(pCount_), + sizeof(*pCount_)); + return true; + } + return false; + } + + void Swap(RefCountedMT& rhs) + { std::swap(pCount_, rhs.pCount_); } + + enum { destructiveCopy = false }; + + private: + // Data + CountPtrType pCount_; + }; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class COMRefCounted +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Adapts COM intrusive reference counting to OwnershipPolicy-specific syntax +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + class COMRefCounted + { + public: + COMRefCounted() + {} + + template <class U> + COMRefCounted(const COMRefCounted<U>&) + {} + + static P Clone(const P& val) + { + if(val!=0) + val->AddRef(); + return val; + } + + static bool Release(const P& val) + { + if(val!=0) + val->Release(); + return false; + } + + enum { destructiveCopy = false }; + + static void Swap(COMRefCounted&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct DeepCopy +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Implements deep copy semantics, assumes existence of a Clone() member +/// function of the pointee type +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct DeepCopy + { + DeepCopy() + {} + + template <class P1> + DeepCopy(const DeepCopy<P1>&) + {} + + static P Clone(const P& val) + { return val->Clone(); } + + static bool Release(const P&) + { return true; } + + static void Swap(DeepCopy&) + {} + + enum { destructiveCopy = false }; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class RefLinked +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Implements reference linking +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + class LOKI_EXPORT RefLinkedBase + { + public: + RefLinkedBase() + { prev_ = next_ = this; } + + RefLinkedBase(const RefLinkedBase& rhs); + + bool Release(); + + void Swap(RefLinkedBase& rhs); + + bool Merge( RefLinkedBase & rhs ); + + enum { destructiveCopy = false }; + + private: + static unsigned int CountPrevCycle( const RefLinkedBase * pThis ); + static unsigned int CountNextCycle( const RefLinkedBase * pThis ); + bool HasPrevNode( const RefLinkedBase * p ) const; + bool HasNextNode( const RefLinkedBase * p ) const; + + mutable const RefLinkedBase* prev_; + mutable const RefLinkedBase* next_; + }; + } + + template <class P> + class RefLinked : public Private::RefLinkedBase + { + public: + RefLinked() + {} + + template <class P1> + RefLinked(const RefLinked<P1>& rhs) + : Private::RefLinkedBase(rhs) + {} + + static P Clone(const P& val) + { return val; } + + bool Release(const P&) + { return Private::RefLinkedBase::Release(); } + + template < class P1 > + bool Merge( RefLinked< P1 > & rhs ) + { + return Private::RefLinkedBase::Merge( rhs ); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class DestructiveCopy +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Implements destructive copy semantics (a la std::auto_ptr) +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + class DestructiveCopy + { + public: + DestructiveCopy() + {} + + template <class P1> + DestructiveCopy(const DestructiveCopy<P1>&) + {} + + template <class P1> + static P Clone(P1& val) + { + P result(val); + val = P1(); + return result; + } + + static bool Release(const P&) + { return true; } + + static void Swap(DestructiveCopy&) + {} + + enum { destructiveCopy = true }; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class NoCopy +/// +/// \ingroup SmartPointerOwnershipGroup +/// Implementation of the OwnershipPolicy used by SmartPtr +/// Implements a policy that doesn't allow copying objects +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + class NoCopy + { + public: + NoCopy() + {} + + template <class P1> + NoCopy(const NoCopy<P1>&) + {} + + static P Clone(const P&) + { + // Make it depended on template parameter + static const bool DependedFalse = sizeof(P*) == 0; + + LOKI_STATIC_CHECK(DependedFalse, This_Policy_Disallows_Value_Copying); + } + + static bool Release(const P&) + { return true; } + + static void Swap(NoCopy&) + {} + + enum { destructiveCopy = false }; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct AllowConversion +/// +/// \ingroup SmartPointerConversionGroup +/// Implementation of the ConversionPolicy used by SmartPtr +/// Allows implicit conversion from SmartPtr to the pointee type +//////////////////////////////////////////////////////////////////////////////// + + struct AllowConversion + { + enum { allow = true }; + + void Swap(AllowConversion&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct DisallowConversion +/// +/// \ingroup SmartPointerConversionGroup +/// Implementation of the ConversionPolicy used by SmartPtr +/// Does not allow implicit conversion from SmartPtr to the pointee type +/// You can initialize a DisallowConversion with an AllowConversion +//////////////////////////////////////////////////////////////////////////////// + + struct DisallowConversion + { + DisallowConversion() + {} + + DisallowConversion(const AllowConversion&) + {} + + enum { allow = false }; + + void Swap(DisallowConversion&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct NoCheck +/// +/// \ingroup SmartPointerCheckingGroup +/// Implementation of the CheckingPolicy used by SmartPtr +/// Well, it's clear what it does :o) +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct NoCheck + { + NoCheck() + {} + + template <class P1> + NoCheck(const NoCheck<P1>&) + {} + + static void OnDefault(const P&) + {} + + static void OnInit(const P&) + {} + + static void OnDereference(const P&) + {} + + static void Swap(NoCheck&) + {} + }; + + +//////////////////////////////////////////////////////////////////////////////// +/// \struct AssertCheck +/// +/// \ingroup SmartPointerCheckingGroup +/// Implementation of the CheckingPolicy used by SmartPtr +/// Checks the pointer before dereference +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct AssertCheck + { + AssertCheck() + {} + + template <class P1> + AssertCheck(const AssertCheck<P1>&) + {} + + template <class P1> + AssertCheck(const NoCheck<P1>&) + {} + + static void OnDefault(const P&) + {} + + static void OnInit(const P&) + {} + + static void OnDereference(P val) + { assert(val); (void)val; } + + static void Swap(AssertCheck&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct AssertCheckStrict +/// +/// \ingroup SmartPointerCheckingGroup +/// Implementation of the CheckingPolicy used by SmartPtr +/// Checks the pointer against zero upon initialization and before dereference +/// You can initialize an AssertCheckStrict with an AssertCheck +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct AssertCheckStrict + { + AssertCheckStrict() + {} + + template <class U> + AssertCheckStrict(const AssertCheckStrict<U>&) + {} + + template <class U> + AssertCheckStrict(const AssertCheck<U>&) + {} + + template <class P1> + AssertCheckStrict(const NoCheck<P1>&) + {} + + static void OnDefault(P val) + { assert(val); } + + static void OnInit(P val) + { assert(val); } + + static void OnDereference(P val) + { assert(val); } + + static void Swap(AssertCheckStrict&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct NullPointerException +/// +/// \ingroup SmartPointerGroup +/// Used by some implementations of the CheckingPolicy used by SmartPtr +//////////////////////////////////////////////////////////////////////////////// + + struct NullPointerException : public std::runtime_error + { + NullPointerException() : std::runtime_error(std::string("")) + { } + const char* what() const throw() + { return "Null Pointer Exception"; } + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct RejectNullStatic +/// +/// \ingroup SmartPointerCheckingGroup +/// Implementation of the CheckingPolicy used by SmartPtr +/// Checks the pointer upon initialization and before dereference +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct RejectNullStatic + { + RejectNullStatic() + {} + + template <class P1> + RejectNullStatic(const RejectNullStatic<P1>&) + {} + + template <class P1> + RejectNullStatic(const NoCheck<P1>&) + {} + + template <class P1> + RejectNullStatic(const AssertCheck<P1>&) + {} + + template <class P1> + RejectNullStatic(const AssertCheckStrict<P1>&) + {} + + static void OnDefault(const P&) + { + // Make it depended on template parameter + static const bool DependedFalse = sizeof(P*) == 0; + + LOKI_STATIC_CHECK(DependedFalse, ERROR_This_Policy_Does_Not_Allow_Default_Initialization); + } + + static void OnInit(const P& val) + { if (!val) throw NullPointerException(); } + + static void OnDereference(const P& val) + { if (!val) throw NullPointerException(); } + + static void Swap(RejectNullStatic&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct RejectNull +/// +/// \ingroup SmartPointerCheckingGroup +/// Implementation of the CheckingPolicy used by SmartPtr +/// Checks the pointer before dereference +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct RejectNull + { + RejectNull() + {} + + template <class P1> + RejectNull(const RejectNull<P1>&) + {} + + static void OnInit(P) + {} + + static void OnDefault(P) + {} + + void OnDereference(P val) + { if (!val) throw NullPointerException(); } + + void OnDereference(P val) const + { if (!val) throw NullPointerException(); } + + void Swap(RejectNull&) + {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \struct RejectNullStrict +/// +/// \ingroup SmartPointerCheckingGroup +/// Implementation of the CheckingPolicy used by SmartPtr +/// Checks the pointer upon initialization and before dereference +//////////////////////////////////////////////////////////////////////////////// + + template <class P> + struct RejectNullStrict + { + RejectNullStrict() + {} + + template <class P1> + RejectNullStrict(const RejectNullStrict<P1>&) + {} + + template <class P1> + RejectNullStrict(const RejectNull<P1>&) + {} + + static void OnInit(P val) + { if (!val) throw NullPointerException(); } + + void OnDereference(P val) + { OnInit(val); } + + void OnDereference(P val) const + { OnInit(val); } + + void Swap(RejectNullStrict&) + {} + }; + + +//////////////////////////////////////////////////////////////////////////////// +// class template SmartPtr (declaration) +// The reason for all the fuss above +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OwnershipPolicy = RefCounted, + class ConversionPolicy = DisallowConversion, + template <class> class CheckingPolicy = AssertCheck, + template <class> class StoragePolicy = DefaultSPStorage, + template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS + > + class SmartPtr; + +//////////////////////////////////////////////////////////////////////////////// +// class template SmartPtrDef (definition) +// this class added to unify the usage of SmartPtr +// instead of writing SmartPtr<T,OP,CP,KP,SP> write SmartPtrDef<T,OP,CP,KP,SP>::type +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OwnershipPolicy = RefCounted, + class ConversionPolicy = DisallowConversion, + template <class> class CheckingPolicy = AssertCheck, + template <class> class StoragePolicy = DefaultSPStorage, + template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS + > + struct SmartPtrDef + { + typedef SmartPtr + < + T, + OwnershipPolicy, + ConversionPolicy, + CheckingPolicy, + StoragePolicy, + ConstnessPolicy + > + type; + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class SmartPtr +/// +/// \ingroup SmartPointerGroup +/// +/// \param OwnershipPolicy default = RefCounted, +/// \param ConversionPolicy default = DisallowConversion, +/// \param CheckingPolicy default = AssertCheck, +/// \param StoragePolicy default = DefaultSPStorage +/// \param ConstnessPolicy default = LOKI_DEFAULT_CONSTNESS +/// +/// \par IMPORTANT NOTE +/// Due to threading issues, the OwnershipPolicy has been changed as follows: +/// +/// - Release() returns a boolean saying if that was the last release +/// so the pointer can be deleted by the StoragePolicy +/// - IsUnique() was removed +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OwnershipPolicy, + class ConversionPolicy, + template <class> class CheckingPolicy, + template <class> class StoragePolicy, + template <class> class ConstnessPolicy + > + class SmartPtr + : public StoragePolicy<T> + , public OwnershipPolicy<typename StoragePolicy<T>::InitPointerType> + , public CheckingPolicy<typename StoragePolicy<T>::StoredType> + , public ConversionPolicy + { + typedef StoragePolicy<T> SP; + typedef OwnershipPolicy<typename StoragePolicy<T>::InitPointerType> OP; + typedef CheckingPolicy<typename StoragePolicy<T>::StoredType> KP; + typedef ConversionPolicy CP; + + public: + typedef typename ConstnessPolicy<T>::Type* ConstPointerType; + typedef typename ConstnessPolicy<T>::Type& ConstReferenceType; + + typedef typename SP::PointerType PointerType; + typedef typename SP::StoredType StoredType; + typedef typename SP::ReferenceType ReferenceType; + + typedef typename Select<OP::destructiveCopy,SmartPtr, const SmartPtr>::Result + CopyArg; + + private: + struct NeverMatched {}; + +#ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY + typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg; + typedef typename Select<!CP::allow, const StoredType&, NeverMatched>::Result ExplicitArg; +#else + typedef const StoredType& ImplicitArg; + typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg; +#endif + + public: + + SmartPtr() + { + KP::OnDefault(GetImpl(*this)); + } + + explicit + SmartPtr(ExplicitArg p) : SP(p) + { + KP::OnInit(GetImpl(*this)); + } + + SmartPtr(ImplicitArg p) : SP(p) + { + KP::OnInit(GetImpl(*this)); + } + + SmartPtr(CopyArg& rhs) : SP(rhs), OP(rhs), KP(rhs), CP(rhs) + { + GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); + } + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + SmartPtr(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) + : SP(rhs), OP(rhs), KP(rhs), CP(rhs) + { GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); } + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + SmartPtr(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) + : SP(rhs), OP(rhs), KP(rhs), CP(rhs) + { + GetImplRef(*this) = OP::Clone(GetImplRef(rhs)); + } + + SmartPtr(RefToValue<SmartPtr> rhs) + : SP(rhs), OP(rhs), KP(rhs), CP(rhs) + {} + + operator RefToValue<SmartPtr>() + { return RefToValue<SmartPtr>(*this); } + + SmartPtr& operator=(CopyArg& rhs) + { + SmartPtr temp(rhs); + temp.Swap(*this); + return *this; + } + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + SmartPtr& operator=(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) + { + SmartPtr temp(rhs); + temp.Swap(*this); + return *this; + } + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + SmartPtr& operator=(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) + { + SmartPtr temp(rhs); + temp.Swap(*this); + return *this; + } + + void Swap(SmartPtr& rhs) + { + OP::Swap(rhs); + CP::Swap(rhs); + KP::Swap(rhs); + SP::Swap(rhs); + } + + ~SmartPtr() + { + if (OP::Release(GetImpl(*static_cast<SP*>(this)))) + { + SP::Destroy(); + } + } + +#ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND + + // old non standard in class definition of friends + friend inline void Release(SmartPtr& sp, typename SP::StoredType& p) + { + p = GetImplRef(sp); + GetImplRef(sp) = SP::Default(); + } + + friend inline void Reset(SmartPtr& sp, typename SP::StoredType p) + { SmartPtr(p).Swap(sp); } + +#else + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + friend void Release(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1>& sp, + typename SP1<T1>::StoredType& p); + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + friend void Reset(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1>& sp, + typename SP1<T1>::StoredType p); +#endif + + + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + bool Merge( SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs ) + { + if ( GetImpl( *this ) != GetImpl( rhs ) ) + { + return false; + } + return OP::template Merge( rhs ); + } + + PointerType operator->() + { + KP::OnDereference(GetImplRef(*this)); + return SP::operator->(); + } + + ConstPointerType operator->() const + { + KP::OnDereference(GetImplRef(*this)); + return SP::operator->(); + } + + ReferenceType operator*() + { + KP::OnDereference(GetImplRef(*this)); + return SP::operator*(); + } + + ConstReferenceType operator*() const + { + KP::OnDereference(GetImplRef(*this)); + return SP::operator*(); + } + + bool operator!() const // Enables "if (!sp) ..." + { return GetImpl(*this) == 0; } + + static inline T * GetPointer( const SmartPtr & sp ) + { return GetImpl( sp ); } + + // Ambiguity buster + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + bool operator==(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const + { return GetImpl(*this) == GetImpl(rhs); } + + // Ambiguity buster + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + bool operator!=(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const + { return !(*this == rhs); } + + // Ambiguity buster + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + bool operator<(const SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs) const + { return GetImpl(*this) < GetImpl(rhs); } + + // Ambiguity buster + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + inline bool operator > ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs ) + { + return ( GetImpl( rhs ) < GetImpl( *this ) ); + } + + // Ambiguity buster + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + inline bool operator <= ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs ) + { + return !( GetImpl( rhs ) < GetImpl( *this ) ); + } + + // Ambiguity buster + template + < + typename T1, + template <class> class OP1, + class CP1, + template <class> class KP1, + template <class> class SP1, + template <class> class CNP1 + > + inline bool operator >= ( const SmartPtr< T1, OP1, CP1, KP1, SP1, CNP1 > & rhs ) + { + return !( GetImpl( *this ) < GetImpl( rhs ) ); + } + + private: + // Helper for enabling 'if (sp)' + struct Tester + { + Tester(int) {} + void dummy() {} + }; + + typedef void (Tester::*unspecified_boolean_type_)(); + + typedef typename Select<CP::allow, Tester, unspecified_boolean_type_>::Result + unspecified_boolean_type; + + public: + // enable 'if (sp)' + operator unspecified_boolean_type() const + { + return !*this ? 0 : &Tester::dummy; + } + + private: + // Helper for disallowing automatic conversion + struct Insipid + { + Insipid(PointerType) {} + }; + + typedef typename Select<CP::allow, PointerType, Insipid>::Result + AutomaticConversionResult; + + public: + operator AutomaticConversionResult() const + { return GetImpl(*this); } + }; + + +//////////////////////////////////////////////////////////////////////////////// +// friends +//////////////////////////////////////////////////////////////////////////////// + +#ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP + > + inline void Release(SmartPtr<T, OP, CP, KP, SP, CNP>& sp, + typename SP<T>::StoredType& p) + { + p = GetImplRef(sp); + GetImplRef(sp) = SP<T>::Default(); + } + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP + > + inline void Reset(SmartPtr<T, OP, CP, KP, SP, CNP>& sp, + typename SP<T>::StoredType p) + { SmartPtr<T, OP, CP, KP, SP, CNP>(p).Swap(sp); } + +#endif + +//////////////////////////////////////////////////////////////////////////////// +// free comparison operators for class template SmartPtr +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// operator== for lhs = SmartPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP1, + typename U + > + inline bool operator==(const SmartPtr<T, OP, CP, KP, SP, CNP1 >& lhs, + U* rhs) + { return GetImpl(lhs) == rhs; } + +//////////////////////////////////////////////////////////////////////////////// +/// operator== for lhs = raw pointer, rhs = SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP1, + typename U + > + inline bool operator==(U* lhs, + const SmartPtr<T, OP, CP, KP, SP, CNP1 >& rhs) + { return rhs == lhs; } + +//////////////////////////////////////////////////////////////////////////////// +/// operator!= for lhs = SmartPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator!=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs, + U* rhs) + { return !(lhs == rhs); } + +//////////////////////////////////////////////////////////////////////////////// +/// operator!= for lhs = raw pointer, rhs = SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator!=(U* lhs, + const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) + { return rhs != lhs; } + +//////////////////////////////////////////////////////////////////////////////// +/// operator< for lhs = SmartPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator<(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs, + U* rhs) + { + return ( GetImpl( lhs ) < rhs ); + } + +//////////////////////////////////////////////////////////////////////////////// +/// operator< for lhs = raw pointer, rhs = SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator<(U* lhs, + const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) + { + return ( GetImpl( rhs ) < lhs ); + } + +//////////////////////////////////////////////////////////////////////////////// +// operator> for lhs = SmartPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator>(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs, + U* rhs) + { return rhs < lhs; } + +//////////////////////////////////////////////////////////////////////////////// +/// operator> for lhs = raw pointer, rhs = SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator>(U* lhs, + const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) + { return rhs < lhs; } + +//////////////////////////////////////////////////////////////////////////////// +/// operator<= for lhs = SmartPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator<=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs, + U* rhs) + { return !(rhs < lhs); } + +//////////////////////////////////////////////////////////////////////////////// +/// operator<= for lhs = raw pointer, rhs = SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator<=(U* lhs, + const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) + { return !(rhs < lhs); } + +//////////////////////////////////////////////////////////////////////////////// +/// operator>= for lhs = SmartPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator>=(const SmartPtr<T, OP, CP, KP, SP, CNP >& lhs, + U* rhs) + { return !(lhs < rhs); } + +//////////////////////////////////////////////////////////////////////////////// +/// operator>= for lhs = raw pointer, rhs = SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP, + typename U + > + inline bool operator>=(U* lhs, + const SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) + { return !(lhs < rhs); } + +} // namespace Loki + +//////////////////////////////////////////////////////////////////////////////// +/// specialization of std::less for SmartPtr +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + +namespace std +{ + template + < + typename T, + template <class> class OP, + class CP, + template <class> class KP, + template <class> class SP, + template <class> class CNP + > + struct less< Loki::SmartPtr<T, OP, CP, KP, SP, CNP > > + : public binary_function<Loki::SmartPtr<T, OP, CP, KP, SP, CNP >, + Loki::SmartPtr<T, OP, CP, KP, SP, CNP >, bool> + { + bool operator()(const Loki::SmartPtr<T, OP, CP, KP, SP, CNP >& lhs, + const Loki::SmartPtr<T, OP, CP, KP, SP, CNP >& rhs) const + { return less<T*>()(GetImpl(lhs), GetImpl(rhs)); } + }; +} + +#endif // end file guardian + diff --git a/shared/loki/StrongPtr.h b/shared/loki/StrongPtr.h new file mode 100644 index 00000000..7ec9766f --- /dev/null +++ b/shared/loki/StrongPtr.h @@ -0,0 +1,1697 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2006 Rich Sposato +// The copyright on this file is protected under the terms of the MIT license. +// +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_STRONG_PTR_INC_ +#define LOKI_STRONG_PTR_INC_ + +// $Id: StrongPtr.h 914 2008-12-19 00:39:29Z rich_sposato $ + + +#include <loki/SmartPtr.h> +#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING) + #include <loki/Threads.h> +#endif + + +//////////////////////////////////////////////////////////////////////////////// +/// +/// \par Terminology +/// These terms are used within this file's comments. +/// -# StrongPtr : Class used to implement both strong and weak pointers. The +/// second template parameter determines if a StrongPtr is weak or strong. +/// -# Strong pointer : A pointer that claims ownership of a shared object. +/// When the last strong copointer dies, the object is destroyed even if +/// there are weak copointers. +/// -# Weak pointer : A pointer that does not own the shared object it points +/// to. It only destroys the shared object if there no strong copointers +/// exist when it dies. +/// -# Copointers : All the pointers that refer to the same shared object. +/// The copointers must have the same ownership policy, but the other +/// policies may be different. +/// -# Pointee : The shared object. +/// +/// \par OwnershipPolicy +/// The ownership policy has the pointer to the actual object, and it also +/// keeps track of the strong and weak copointers so that it can know if any +/// strong copointers remain. The plain pointer it maintains is stored as a +/// void pointer, which allows the ownership policy classes to be monolithic +/// classes instead of template classes. As monolithic classes, they reduce +/// amount of code-bloat. +/// +/// \par Writing Your Own OwnershipPolicy +/// If you write your own policy, you must implement these 12 functions: +/// -# explicit YourPolicy( bool strong ) +/// -# YourPolicy( void * p, bool strong ) +/// -# YourPolicy( const YourPolicy & rhs, bool strong ) +/// -# bool Release( bool strong ) +/// -# void Increment( bool strong ) +/// -# bool Decrement( bool strong ) +/// -# bool HasStrongPointer( void ) const +/// -# void Swap( YourPolicy & rhs ) +/// -# void SetPointer( void * p ) +/// -# void ZapPointer( void ) +/// -# void * GetPointer( void ) const +/// -# void * & GetPointerRef( void ) const +/// It is strongly recommended that all 12 of these functions be protected +/// instead of public. These two functions are optional for single-threaded +/// policies, but required for multi-threaded policies: +/// -# void Lock( void ) const +/// -# void Unlock( void ) const +/// This function is entirely optional: +/// -# bool Merge( TwoRefLinks & rhs ) +/// +/// \par DeletePolicy +/// The delete policy provides a mechanism to destroy an object and a default +/// value for an uninitialized pointer. You can override this policy with +/// your own when using the Singleton, NullObject, or Prototype design +/// patterns. +/// +/// \par Writing Your Own DeletePolicy +/// If you write your own policy, you must implement these 3 functions: +/// -# void static Delete( const P * p ) +/// -# static P * Default( void ) +/// -# void Swap( YourResetPolicy & ) +/// +/// \par ResetPolicy +/// A reset policy tells the ReleaseAll and ResetAll functions whether they +/// should release or reset the StrongPtr copointers. These functions do +/// not affect just one StrongPtr, but all copointers. That is unlike +/// SmartPtr where the Release and Reset functions only affect 1 SmartPtr, +/// and leave all copointers untouched. A useful trick you can do with the +/// ResetPolicy is to not allow reset when a strong pointer exists, and then +/// use the NoCheck policy for all strong pointers. The reset policy +/// guarantees the strong pointers always have a valid pointee, so checking +/// is not required; but weak pointers may still require checking. +/// +/// \par Writing Your Own ResetPolicy +/// If you write your own policy, you must implement these 2 functions: +/// -# bool OnReleaseAll( bool ) const +/// -# bool OnResetAll( bool ) const +/// The bool parameter means that this was called with a strong pointer or +/// one of its copointers is strong. The return value means the pointer +/// can be reset or released. +/// +/// \defgroup StrongPointerOwnershipGroup StrongPtr Ownership policies +/// \ingroup SmartPointerGroup +/// \defgroup StrongPointerDeleteGroup Delete policies +/// \ingroup SmartPointerGroup +/// \defgroup StrongPointerResetGroup Reset policies +/// \ingroup SmartPointerGroup +//////////////////////////////////////////////////////////////////////////////// + + +namespace Loki +{ + + +//////////////////////////////////////////////////////////////////////////////// +/// \class DeleteUsingFree +/// +/// \ingroup StrongPointerDeleteGroup +/// Implementation of the DeletePolicy used by StrongPtr. Uses explicit call +/// to T's destructor followed by call to free. This policy is useful for +/// managing the lifetime of pointers to structs returned by C functions. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +class DeleteUsingFree +{ +public: + inline void static Delete( const P * p ) + { + if ( 0 != p ) + { + p->~P(); + ::free( p ); + } + } + + /// Provides default value to initialize the pointer + inline static P * Default( void ) + { + return 0; + } + + inline void Swap( DeleteUsingFree & ) {} +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class DeleteNothing +/// +/// \ingroup StrongPointerDeleteGroup +/// Implementation of the DeletePolicy used by StrongPtr. This will never +/// delete anything. You can use this policy with pointers to an undefined +/// type or a pure interface class with a protected destructor. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +class DeleteNothing +{ +public: + inline static void Delete( const P * ) + { + // Do nothing at all! + } + + inline static P * Default( void ) + { + return 0; + } + + inline void Swap( DeleteNothing & ) {} +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class DeleteSingle +/// +/// \ingroup StrongPointerDeleteGroup +/// Implementation of the DeletePolicy used by StrongPtr. This deletes just +/// one shared object. This is the default class for the DeletePolicy. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +class DeleteSingle +{ +public: + inline static void Delete( const P * p ) + { + /** @note If you see an error message about a negative subscript, that + means your are attempting to use Loki to delete an incomplete type. + Please don't use this policy with incomplete types; you may want to + use DeleteNothing instead. + */ + typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ]; + delete p; + } + + inline static P * Default( void ) + { + return 0; + } + + inline void Swap( DeleteSingle & ) {} +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class DeleteArray +/// +/// \ingroup StrongPointerDeleteGroup +/// Implementation of the DeletePolicy used by StrongPtr. This deletes an +/// array of shared objects. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +class DeleteArray +{ +public: + inline static void Delete( const P * p ) + { + /** @note If you see an error message about a negative subscript, that + means your are attempting to use Loki to delete an incomplete type. + Please don't use this policy with incomplete types; you may want to + use DeleteNothing instead. + */ + typedef char Type_Must_Be_Defined[ sizeof(P) ? 1 : -1 ]; + delete [] p; + } + + inline static P * Default( void ) + { + return 0; + } + + inline void Swap( DeleteArray & ) {} +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class CantResetWithStrong +/// +/// \ingroup StrongPointerResetGroup +/// Implementation of the ResetPolicy used by StrongPtr. This is the default +/// ResetPolicy for StrongPtr. It forbids reset and release only if a strong +/// copointer exists. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +struct CantResetWithStrong +{ + inline bool OnReleaseAll( bool hasStrongPtr ) const + { + return ! hasStrongPtr; + } + + inline bool OnResetAll( bool hasStrongPtr ) const + { + return ! hasStrongPtr; + } +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class AllowReset +/// +/// \ingroup StrongPointerResetGroup +/// Implementation of the ResetPolicy used by StrongPtr. It allows reset and +/// release under any circumstance. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +struct AllowReset +{ + inline bool OnReleaseAll( bool ) const + { + return true; + } + inline bool OnResetAll( bool ) const + { + return true; + } +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class NeverReset +/// +/// \ingroup StrongPointerResetGroup +/// Implementation of the ResetPolicy used by StrongPtr. It forbids reset and +/// release under any circumstance. +//////////////////////////////////////////////////////////////////////////////// + +template < class P > +struct NeverReset +{ + inline bool OnReleaseAll( bool ) const + { + return false; + } + inline bool OnResetAll( bool ) const + { + return false; + } +}; + +// ---------------------------------------------------------------------------- + +namespace Private +{ + +//////////////////////////////////////////////////////////////////////////////// +/// \class TwoRefCountInfo +/// +/// \ingroup StrongPointerOwnershipGroup +/// Implementation detail for reference counting strong and weak pointers. +/// It maintains a void pointer and 2 reference counts. Since it is just a +/// class for managing implementation details, it is not intended to be used +/// directly - which is why it is in a private namespace. Each instance is a +/// shared resource for all copointers, and there should be only one of these +/// for each set of copointers. This class is small, trivial, and inline. +//////////////////////////////////////////////////////////////////////////////// + +class LOKI_EXPORT TwoRefCountInfo +{ +public: + + inline explicit TwoRefCountInfo( bool strong ) + : m_pointer( 0 ) + , m_strongCount( strong ? 1 : 0 ) + , m_weakCount( strong ? 0 : 1 ) + { + } + + inline TwoRefCountInfo( void * p, bool strong ) + : m_pointer( p ) + , m_strongCount( strong ? 1 : 0 ) + , m_weakCount( strong ? 0 : 1 ) + { + } + + inline ~TwoRefCountInfo( void ) + { + assert( 0 == m_strongCount ); + assert( 0 == m_weakCount ); + } + + inline bool HasStrongPointer( void ) const + { + return ( 0 < m_strongCount ); + } + + inline bool HasWeakPointer( void ) const + { + return ( 0 < m_weakCount ); + } + + inline void IncStrongCount( void ) + { + ++m_strongCount; + } + + inline void IncWeakCount( void ) + { + ++m_weakCount; + } + + inline bool DecStrongCount( void ) + { + assert( 0 < m_strongCount ); + --m_strongCount; + const bool isZero = ( 0 == m_strongCount ); + return isZero; + } + + inline void DecWeakCount( void ) + { + assert( 0 < m_weakCount ); + --m_weakCount; + } + + inline void ZapPointer( void ) + { + m_pointer = 0; + } + + void SetPointer( void * p ) + { + m_pointer = p; + } + + inline void * GetPointer( void ) const + { + return m_pointer; + } + + inline void * & GetPointerRef( void ) const + { + return const_cast< void * & >( m_pointer ); + } + +private: + /// Copy-constructor not implemented. + TwoRefCountInfo( const TwoRefCountInfo & ); + /// Copy-assignment operator not implemented. + TwoRefCountInfo & operator = ( const TwoRefCountInfo & ); + + void * m_pointer; + unsigned int m_strongCount; + unsigned int m_weakCount; +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class LockableTwoRefCountInfo +/// +/// \ingroup StrongPointerOwnershipGroup +/// Implementation detail for thread-safe reference counting for strong and +/// weak pointers. It uses TwoRefCountInfo to manage the pointer and counts. +/// All this does is provide a thread safety mechanism. Since it is just a +/// class for managing implementation details, it is not intended to be used +/// directly - which is why it is in a private namespace. Each instance is a +/// shared resource for all copointers, and there should be only one of these +/// for each set of copointers. This class is small, trivial, and inline. +/// +/// \note This class is not designed for use with a single-threaded model. +/// Tests using a single-threaded model will not run properly, but tests in a +/// multi-threaded model with either class-level-locking or object-level-locking +/// do run properly. +//////////////////////////////////////////////////////////////////////////////// + +#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING) + +class LOKI_EXPORT LockableTwoRefCountInfo + : private Loki::Private::TwoRefCountInfo +{ +public: + + inline explicit LockableTwoRefCountInfo( bool strong ) + : TwoRefCountInfo( strong ) + , m_Mutex() + { + } + + LockableTwoRefCountInfo( void * p, bool strong ) + : TwoRefCountInfo( p, strong ) + , m_Mutex() + { + } + + inline ~LockableTwoRefCountInfo( void ) + { + } + + inline void Lock( void ) const + { + m_Mutex.Lock(); + } + + inline void Unlock( void ) const + { + m_Mutex.Unlock(); + } + + inline bool HasStrongPointer( void ) const + { + m_Mutex.Lock(); + const bool has = TwoRefCountInfo::HasStrongPointer(); + m_Mutex.Unlock(); + return has; + } + + inline bool HasWeakPointer( void ) const + { + m_Mutex.Lock(); + const bool has = TwoRefCountInfo::HasWeakPointer(); + m_Mutex.Unlock(); + return has; + } + + inline void IncStrongCount( void ) + { + m_Mutex.Lock(); + TwoRefCountInfo::IncStrongCount(); + m_Mutex.Unlock(); + } + + inline void IncWeakCount( void ) + { + m_Mutex.Lock(); + TwoRefCountInfo::IncWeakCount(); + m_Mutex.Unlock(); + } + + inline bool DecStrongCount( void ) + { + m_Mutex.Lock(); + const bool isZero = TwoRefCountInfo::DecStrongCount(); + m_Mutex.Unlock(); + return isZero; + } + + inline void DecWeakCount( void ) + { + m_Mutex.Lock(); + TwoRefCountInfo::DecWeakCount(); + m_Mutex.Unlock(); + } + + inline void ZapPointer( void ) + { + m_Mutex.Lock(); + TwoRefCountInfo::ZapPointer(); + m_Mutex.Unlock(); + } + + void SetPointer( void * p ) + { + m_Mutex.Lock(); + TwoRefCountInfo::SetPointer( p ); + m_Mutex.Unlock(); + } + + inline void * GetPointer( void ) const + { + return TwoRefCountInfo::GetPointer(); + } + + inline void * & GetPointerRef( void ) const + { + return TwoRefCountInfo::GetPointerRef(); + } + +private: + /// Default constructor is not available. + LockableTwoRefCountInfo( void ); + /// Copy constructor is not available. + LockableTwoRefCountInfo( const LockableTwoRefCountInfo & ); + /// Copy-assignment operator is not available. + LockableTwoRefCountInfo & operator = ( const LockableTwoRefCountInfo & ); + + mutable LOKI_DEFAULT_MUTEX m_Mutex; +}; + +#endif // if object-level-locking or class-level-locking + +} // end namespace Private + +//////////////////////////////////////////////////////////////////////////////// +/// \class TwoRefCounts +/// +/// \ingroup StrongPointerOwnershipGroup +/// This implementation of StrongPtr's OwnershipPolicy uses a pointer to a +/// shared instance of TwoRefCountInfo. This is the default policy for +/// OwnershipPolicy. Some functions are trivial enough to be inline, while +/// others are implemented elsewhere. It is not thread safe, and is intended +/// for single-threaded environments. +//////////////////////////////////////////////////////////////////////////////// + +class LOKI_EXPORT TwoRefCounts +{ +protected: + + explicit TwoRefCounts( bool strong ); + + TwoRefCounts( const void * p, bool strong ); + + TwoRefCounts( const TwoRefCounts & rhs, bool strong ) : + m_counts( rhs.m_counts ) + { + Increment( strong ); + } + + /** The destructor does not need to do anything since the call to + ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which + this dtor would have done. + */ + inline ~TwoRefCounts( void ) {} + + inline bool Release( bool strong ) + { + return Decrement( strong ); + } + + bool HasStrongPointer( void ) const + { + return m_counts->HasStrongPointer(); + } + + void Swap( TwoRefCounts & rhs ); + + void SetPointer( void * p ) + { + m_counts->SetPointer( p ); + } + + void ZapPointer( void ); + + inline void * & GetPointerRef( void ) const + { + return m_counts->GetPointerRef(); + } + + inline void * GetPointer( void ) const + { + return m_counts->GetPointer(); + } + +private: + TwoRefCounts( void ); + TwoRefCounts & operator = ( const TwoRefCounts & ); + + void Increment( bool strong ); + + bool Decrement( bool strong ); + + /// Pointer to all shared data. + Loki::Private::TwoRefCountInfo * m_counts; +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class LockableTwoRefCounts +/// +/// \ingroup StrongPointerOwnershipGroup +/// This implementation of StrongPtr's OwnershipPolicy uses a pointer to a +/// shared instance of LockableTwoRefCountInfo. It behaves very similarly to +/// TwoRefCounts, except that it provides thread-safety. Some functions are +/// trivial enough to be inline, while others are implemented elsewhere. +/// +/// \note This class is not designed for use with a single-threaded model. +/// Tests using a single-threaded model will not run properly, but tests in a +/// multi-threaded model with either class-level-locking or object-level-locking +/// do run properly. +//////////////////////////////////////////////////////////////////////////////// + +#if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING) + +class LOKI_EXPORT LockableTwoRefCounts +{ + typedef SmallValueObject< ::Loki::ClassLevelLockable > ThreadSafePointerAllocator; + +protected: + + explicit LockableTwoRefCounts( bool strong ) + : m_counts( NULL ) + { + void * temp = ThreadSafePointerAllocator::operator new( + sizeof(Loki::Private::LockableTwoRefCountInfo) ); +#ifdef DO_EXTRA_LOKI_TESTS + assert( temp != 0 ); +#endif + m_counts = new ( temp ) Loki::Private::LockableTwoRefCountInfo( strong ); + } + + LockableTwoRefCounts( const void * p, bool strong ) + : m_counts( NULL ) + { + void * temp = ThreadSafePointerAllocator::operator new( + sizeof(Loki::Private::LockableTwoRefCountInfo) ); +#ifdef DO_EXTRA_LOKI_TESTS + assert( temp != 0 ); +#endif + void * p2 = const_cast< void * >( p ); + m_counts = new ( temp ) + Loki::Private::LockableTwoRefCountInfo( p2, strong ); + } + + LockableTwoRefCounts( const LockableTwoRefCounts & rhs, bool strong ) : + m_counts( rhs.m_counts ) + { + Increment( strong ); + } + + /** The destructor does not need to do anything since the call to + ZapPointer inside StrongPtr::~StrongPtr will do the cleanup which + this dtor would have done. + */ + inline ~LockableTwoRefCounts( void ) {} + + inline void Lock( void ) const + { + m_counts->Lock(); + } + + inline void Unlock( void ) const + { + m_counts->Unlock(); + } + + inline bool Release( bool strong ) + { + return Decrement( strong ); + } + + void Increment( bool strong ) + { + if ( strong ) + { + m_counts->IncStrongCount(); + } + else + { + m_counts->IncWeakCount(); + } + } + + bool Decrement( bool strong ) + { + bool noStrongPointers = false; + if ( strong ) + { + noStrongPointers = m_counts->DecStrongCount(); + } + else + { + m_counts->DecWeakCount(); + noStrongPointers = !m_counts->HasStrongPointer(); + } + return noStrongPointers; + } + + bool HasStrongPointer( void ) const + { + return m_counts->HasStrongPointer(); + } + + void Swap( LockableTwoRefCounts & rhs ) + { + std::swap( m_counts, rhs.m_counts ); + } + + void SetPointer( void * p ) + { + m_counts->SetPointer( p ); + } + + void ZapPointer( void ) + { +#ifdef DO_EXTRA_LOKI_TESTS + assert( !m_counts->HasStrongPointer() ); +#endif + if ( m_counts->HasWeakPointer() ) + { + m_counts->ZapPointer(); + } + else + { + ThreadSafePointerAllocator::operator delete ( m_counts, + sizeof(Loki::Private::LockableTwoRefCountInfo) ); + m_counts = NULL; + } + } + + inline void * GetPointer( void ) const + { + return m_counts->GetPointer(); + } + + inline void * & GetPointerRef( void ) const + { + return m_counts->GetPointerRef(); + } + +private: + LockableTwoRefCounts( void ); + LockableTwoRefCounts & operator = ( const LockableTwoRefCounts & ); + + /// Pointer to all shared data. + Loki::Private::LockableTwoRefCountInfo * m_counts; +}; + +#endif // if object-level-locking or class-level-locking + +//////////////////////////////////////////////////////////////////////////////// +/// \class TwoRefLinks +/// +/// \ingroup StrongPointerOwnershipGroup +/// This implementation of StrongPtr's OwnershipPolicy uses a doubly-linked +/// cycle of copointers to a shared object. Some functions are trivial enough +/// to be inline, while others are implemented in elsewhere. It is not thread +/// safe, and is intended for single-threaded environments. +//////////////////////////////////////////////////////////////////////////////// + +class LOKI_EXPORT TwoRefLinks +{ +protected: + + inline explicit TwoRefLinks( bool strong ) + : m_pointer( 0 ) + , m_strong( strong ) + { + m_prev = m_next = this; + } + + TwoRefLinks( const void * p, bool strong ); + + TwoRefLinks( const TwoRefLinks & rhs, bool strong ); + + bool Release( bool strong ); + + void Swap( TwoRefLinks & rhs ); + + bool Merge( TwoRefLinks & rhs ); + + bool HasStrongPointer( void ) const; + + inline void ZapPointer( void ) + { + ZapAllNodes(); + } + + void SetPointer( void * p ); + + inline void * GetPointer( void ) const + { + return m_pointer; + } + + inline void * & GetPointerRef( void ) const + { + return const_cast< void * & >( m_pointer ); + } + +private: + static unsigned int CountPrevCycle( const TwoRefLinks * pThis ); + static unsigned int CountNextCycle( const TwoRefLinks * pThis ); + + /// Not implemented. + TwoRefLinks( void ); + /// Not implemented. + TwoRefLinks & operator = ( const TwoRefLinks & ); + + bool HasPrevNode( const TwoRefLinks * p ) const; + bool HasNextNode( const TwoRefLinks * p ) const; + bool AllNodesHaveSamePointer( void ) const; + void ZapAllNodes( void ); + + void * m_pointer; + mutable TwoRefLinks * m_prev; + mutable TwoRefLinks * m_next; + const bool m_strong; +}; + +//////////////////////////////////////////////////////////////////////////////// +/// \class StrongPtr +/// +/// \ingroup SmartPointerGroup +/// +/// \param Strong default = true, +/// \param OwnershipPolicy default = TwoRefCounts, +/// \param ConversionPolicy default = DisallowConversion, +/// \param CheckingPolicy default = AssertCheck, +/// \param ResetPolicy default = CantResetWithStrong, +/// \param DeletePolicy default = DeleteSingle +/// \param ConstnessPolicy default = LOKI_DEFAULT_CONSTNESS +//////////////////////////////////////////////////////////////////////////////// + +template +< + typename T, + bool Strong = true, + class OwnershipPolicy = Loki::TwoRefCounts, + class ConversionPolicy = Loki::DisallowConversion, + template < class > class CheckingPolicy = Loki::AssertCheck, + template < class > class ResetPolicy = Loki::CantResetWithStrong, + template < class > class DeletePolicy = Loki::DeleteSingle, + template < class > class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS +> +class StrongPtr + : public OwnershipPolicy + , public ConversionPolicy + , public CheckingPolicy< T * > + , public ResetPolicy< T > + , public DeletePolicy< T > +{ + typedef ConversionPolicy CP; + typedef CheckingPolicy< T * > KP; + typedef ResetPolicy< T > RP; + typedef DeletePolicy< T > DP; + +public: + + typedef OwnershipPolicy OP; + + typedef T * StoredType; // the type of the pointer + typedef T * PointerType; // type returned by operator-> + typedef T & ReferenceType; // type returned by operator* + + typedef typename ConstnessPolicy< T >::Type * ConstPointerType; + typedef typename ConstnessPolicy< T >::Type & ConstReferenceType; + +private: + struct NeverMatched {}; + +#ifdef LOKI_SMARTPTR_CONVERSION_CONSTRUCTOR_POLICY + typedef typename Select< CP::allow, const StoredType&, NeverMatched>::Result ImplicitArg; + typedef typename Select<!CP::allow, const StoredType&, NeverMatched>::Result ExplicitArg; +#else + typedef const StoredType& ImplicitArg; + typedef typename Select<false, const StoredType&, NeverMatched>::Result ExplicitArg; +#endif + +public: + + StrongPtr( void ) : OP( Strong ) + { + KP::OnDefault( GetPointer() ); + } + + explicit StrongPtr( ExplicitArg p ) : OP( p, Strong ) + { + KP::OnInit( GetPointer() ); + } + + StrongPtr( ImplicitArg p ) : OP( p, Strong ) + { + KP::OnInit( GetPointer() ); + } + + StrongPtr( const StrongPtr & rhs ) + : OP( rhs, Strong ), CP( rhs ), KP( rhs ), DP( rhs ) + { + } + + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + StrongPtr( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) + : OP( rhs, Strong ) + { + } + + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + StrongPtr( + StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) + : OP( rhs, Strong ) + { + } + + StrongPtr( RefToValue< StrongPtr > rhs ) + : OP( rhs, Strong ), KP( rhs ), CP( rhs ), DP( rhs ) + { + } + + operator RefToValue< StrongPtr >( void ) + { + return RefToValue< StrongPtr >( *this ); + } + + StrongPtr & operator = ( const StrongPtr & rhs ) + { + if ( GetPointer() != rhs.GetPointer() ) + { + StrongPtr temp( rhs ); + temp.Swap( *this ); + } + return *this; + } + + StrongPtr & operator = ( T * p ) + { + if ( GetPointer() != p ) + { + StrongPtr temp( p ); + Swap( temp ); + } + return *this; + } + + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + StrongPtr & operator = ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) + { + if ( !rhs.Equals( GetPointer() ) ) + { + StrongPtr temp( rhs ); + temp.Swap( *this ); + } + return *this; + } + + bool IsStrong( void ) const + { + return Strong; + } + + void Swap( StrongPtr & rhs ) + { + OP::Swap( rhs ); + CP::Swap( rhs ); + KP::Swap( rhs ); + DP::Swap( rhs ); + } + + ~StrongPtr() + { + if ( OP::Release( Strong ) ) + { + // Must zap the pointer before deleteing the object. Otherwise a + // cycle of weak pointers will lead to recursion, which leads to + // to deleting the shared object multiple times, which leads to + // undefined behavior. Therefore, this must get pointer before + // zapping it, and then delete the temp pointer. + T * p = GetPointer(); + OP::ZapPointer(); + if ( p != 0 ) + { + DP::Delete( p ); + } + } + } + +#ifdef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND + + // old non standard in class definition of friends + friend bool ReleaseAll( StrongPtr & sp, + typename StrongPtr::StoredType & p ) + { + if ( !sp.RP::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) ) + { + return false; + } + p = sp.GetPointer(); + sp.OP::SetPointer( sp.DP::Default() ); + return true; + } + + friend bool ResetAll( StrongPtr & sp, + typename StrongPtr::StoredType p ) + { + if ( sp.OP::GetPointer() == p ) + { + return true; + } + if ( !sp.RP::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) ) + { + return false; + } + sp.DP::Delete( sp.GetPointer() ); + sp.OP::SetPointer( p ); + return true; + } + +#else + + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + friend bool ReleaseAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp, + typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType & p ); + + + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + friend bool ResetAll( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & sp, + typename StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 >::StoredType p ); + +#endif + + + /** Merges ownership of two StrongPtr's that point to same shared object + but are not copointers. Requires Merge function in OwnershipPolicy. + \return True for success, false if not pointer to same object. + */ + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + bool Merge( StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) + { + if ( OP::GetPointer() != rhs.OP::GetPointer() ) + { + return false; + } + return OP::Merge( rhs ); + } + + /** Locks StrongPtr so other threads can't affect pointer. Requires the + OwnershipPolicy to have Lock function. + */ + void Lock( void ) + { + OP::Lock(); + } + + /** Unlocks StrongPtr so other threads can affect pointer. Requires the + OwnershipPolicy to have Unlock function. + */ + void Unlock( void ) + { + OP::Unlock(); + } + + PointerType operator -> () + { + KP::OnDereference( GetPointer() ); + return GetPointer(); + } + + ConstPointerType operator -> () const + { + KP::OnDereference( GetPointer() ); + return GetPointer(); + } + + ReferenceType operator * () + { + KP::OnDereference( GetPointer() ); + return * GetPointer(); + } + + ConstReferenceType operator * () const + { + KP::OnDereference( GetPointer() ); + return * GetPointer(); + } + + /// Helper function which can be called to avoid exposing GetPointer function. + template < class T1 > + bool Equals( const T1 * p ) const + { + return ( GetPointer() == p ); + } + + /// Helper function which can be called to avoid exposing GetPointer function. + template < class T1 > + bool LessThan( const T1 * p ) const + { + return ( GetPointer() < p ); + } + + /// Helper function which can be called to avoid exposing GetPointer function. + template < class T1 > + bool GreaterThan( const T1 * p ) const + { + return ( GetPointer() > p ); + } + + /// Equality comparison operator is templated to handle ambiguity. + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + bool operator == ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const + { + return ( rhs.Equals( GetPointer() ) ); + } + + /// Inequality comparison operator is templated to handle ambiguity. + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + bool operator != ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const + { + return !( rhs.Equals( GetPointer() ) ); + } + + /// Less-than comparison operator is templated to handle ambiguity. + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + bool operator < ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const + { + return ( rhs.GreaterThan( GetPointer() ) ); + } + + /// Greater-than comparison operator is templated to handle ambiguity. + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + inline bool operator > ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const + { + return ( rhs.LessThan( GetPointer() ) ); + } + + /// Less-than-or-equal-to operator is templated to handle ambiguity. + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + inline bool operator <= ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const + { + return !( rhs.LessThan( GetPointer() ) ); + } + + /// Greater-than-or-equal-to operator is templated to handle ambiguity. + template + < + typename T1, + bool S1, + class OP1, + class CP1, + template < class > class KP1, + template < class > class RP1, + template < class > class DP1, + template < class > class CNP1 + > + inline bool operator >= ( + const StrongPtr< T1, S1, OP1, CP1, KP1, RP1, DP1, CNP1 > & rhs ) const + { + return !( rhs.GreaterThan( GetPointer() ) ); + } + + inline bool operator ! () const // Enables "if ( !sp ) ..." + { + return ( 0 == OP::GetPointer() ); + } + +protected: + + inline PointerType GetPointer( void ) + { + return reinterpret_cast< PointerType >( OP::GetPointer() ); + } + + inline ConstPointerType GetPointer( void ) const + { + return reinterpret_cast< ConstPointerType >( OP::GetPointer() ); + } + +private: + + inline ReferenceType GetPointerRef( void ) + { + return reinterpret_cast< ReferenceType >( OP::GetPointerRef() ); + } + + inline ConstReferenceType GetPointerRef( void ) const + { + return reinterpret_cast< ConstReferenceType >( OP::GetPointerRef() ); + } + + // Helper for enabling 'if (sp)' + struct Tester + { + Tester(int) {} + void dummy() {} + }; + + typedef void (Tester::*unspecified_boolean_type_)(); + + typedef typename Select< CP::allow, Tester, unspecified_boolean_type_ >::Result + unspecified_boolean_type; + +public: + // enable 'if (sp)' + operator unspecified_boolean_type() const + { + return !*this ? 0 : &Tester::dummy; + } + +private: + // Helper for disallowing automatic conversion + struct Insipid + { + Insipid(PointerType) {} + }; + + typedef typename Select< CP::allow, PointerType, Insipid >::Result + AutomaticConversionResult; + +public: + operator AutomaticConversionResult() const + { + return GetPointer(); + } + +}; + +// ---------------------------------------------------------------------------- + +// friend functions + +#ifndef LOKI_ENABLE_FRIEND_TEMPLATE_TEMPLATE_PARAMETER_WORKAROUND + +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +bool ReleaseAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp, + typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType & p ) +{ + if ( !sp.RP<T>::OnReleaseAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) ) + { + return false; + } + p = sp.GetPointer(); + sp.OP::SetPointer( sp.DP<T>::Default() ); + return true; +} + +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +bool ResetAll( StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & sp, + typename StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >::StoredType p ) +{ + if ( sp.OP::GetPointer() == p ) + { + return true; + } + if ( !sp.RP<T>::OnResetAll( sp.IsStrong() || sp.OP::HasStrongPointer() ) ) + { + return false; + } + sp.DP<T>::Delete( sp.GetPointer() ); + sp.OP::SetPointer( p ); + return true; +} +#endif + + +// free comparison operators for class template StrongPtr + +/// operator== for lhs = StrongPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator == ( + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs ) +{ + return ( lhs.Equals( rhs ) ); +} + +/// operator== for lhs = raw pointer, rhs = StrongPtr +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator == ( U * lhs, + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) +{ + return ( rhs.Equals( lhs ) ); +} + +/// operator!= for lhs = StrongPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator != ( + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs ) +{ + return !( lhs.Equals( rhs ) ); +} + +/// operator!= for lhs = raw pointer, rhs = StrongPtr +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator != ( U * lhs, + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) +{ + return !( rhs.Equals( lhs ) ); +} + +/// operator< for lhs = StrongPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator < ( + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs ) +{ + return ( lhs.LessThan( rhs ) ); +} + +/// operator< for lhs = raw pointer, rhs = StrongPtr +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator < ( U * lhs, + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) +{ + return ( rhs.GreaterThan( lhs ) ); +} + +// operator> for lhs = StrongPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator > ( + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs ) +{ + return ( lhs.GreaterThan( rhs ) ); +} + +/// operator> for lhs = raw pointer, rhs = StrongPtr +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator > ( U * lhs, + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) +{ + return ( rhs.LessThan( lhs ) ); +} + +/// operator<= for lhs = StrongPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator <= ( + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs ) +{ + return !( lhs.GreaterThan( rhs ) ); +} + +/// operator<= for lhs = raw pointer, rhs = StrongPtr +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator <= ( U * lhs, + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) +{ + return !( rhs.LessThan( lhs ) ); +} + +/// operator>= for lhs = StrongPtr, rhs = raw pointer +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator >= ( + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, U * rhs ) +{ + return !( lhs.LessThan( rhs ) ); +} + +/// operator>= for lhs = raw pointer, rhs = StrongPtr +/// \ingroup SmartPointerGroup +template +< + typename U, + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP +> +inline bool operator >= ( U * lhs, + const StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) +{ + return !( rhs.GreaterThan( lhs ) ); +} + +} // namespace Loki + +namespace std +{ + //////////////////////////////////////////////////////////////////////////////// + /// specialization of std::less for StrongPtr + /// \ingroup SmartPointerGroup + //////////////////////////////////////////////////////////////////////////////// + template + < + typename T, + bool S, + class OP, + class CP, + template < class > class KP, + template < class > class RP, + template < class > class DP, + template < class > class CNP + > + struct less< Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > > + : public binary_function< + Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >, + Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP >, bool > + { + bool operator () ( + const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & lhs, + const Loki::StrongPtr< T, S, OP, CP, KP, RP, DP, CNP > & rhs ) const + { + return ( lhs < rhs ); + } + }; +} + +//////////////////////////////////////////////////////////////////////////////// + +#endif // end file guardian + diff --git a/shared/loki/Threads.h b/shared/loki/Threads.h new file mode 100644 index 00000000..cb44f094 --- /dev/null +++ b/shared/loki/Threads.h @@ -0,0 +1,609 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_THREADS_INC_ +#define LOKI_THREADS_INC_ + +// $Id: Threads.h 902 2008-11-10 05:47:06Z rich_sposato $ + + +/// @defgroup ThreadingGroup Threading +/// Policies to for the threading model: +/// +/// - SingleThreaded +/// - ObjectLevelLockable +/// - ClassLevelLockable +/// +/// All classes in Loki have configurable threading model. +/// +/// The macro LOKI_DEFAULT_THREADING selects the default +/// threading model for certain components of Loki +/// (it affects only default template arguments) +/// +/// \par Usage: +/// +/// To use a specific threading model define +/// +/// - nothing, single-theading is default +/// - LOKI_OBJECT_LEVEL_THREADING for object-level-threading +/// - LOKI_CLASS_LEVEL_THREADING for class-level-threading +/// +/// \par Supported platfroms: +/// +/// - Windows (windows.h) +/// - POSIX (pthread.h): +/// No recursive mutex support with pthread. +/// This means: calling Lock() on a Loki::Mutex twice from the +/// same thread before unlocking the mutex deadlocks the system. +/// To avoid this redesign your synchronization. See also: +/// http://sourceforge.net/tracker/index.php?func=detail&aid=1516182&group_id=29557&atid=396647 + + +#include <cassert> + +#if defined(LOKI_CLASS_LEVEL_THREADING) || defined(LOKI_OBJECT_LEVEL_THREADING) + + #define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::ClassLevelLockable + + #if defined(LOKI_CLASS_LEVEL_THREADING) && !defined(LOKI_OBJECT_LEVEL_THREADING) + #define LOKI_DEFAULT_THREADING ::Loki::ClassLevelLockable + #else + #define LOKI_DEFAULT_THREADING ::Loki::ObjectLevelLockable + #endif + + #if defined(_WIN32) || defined(_WIN64) + #include <windows.h> + #define LOKI_WINDOWS_H + #else + #include <pthread.h> + #define LOKI_PTHREAD_H + #endif + +#else + + #define LOKI_DEFAULT_THREADING ::Loki::SingleThreaded + #define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::SingleThreaded + +#endif + +#ifndef LOKI_DEFAULT_MUTEX +#define LOKI_DEFAULT_MUTEX ::Loki::Mutex +#endif + +#ifdef LOKI_WINDOWS_H + +#define LOKI_THREADS_MUTEX(x) CRITICAL_SECTION (x); +#define LOKI_THREADS_MUTEX_INIT(x) ::InitializeCriticalSection (x) +#define LOKI_THREADS_MUTEX_DELETE(x) ::DeleteCriticalSection (x) +#define LOKI_THREADS_MUTEX_LOCK(x) ::EnterCriticalSection (x) +#define LOKI_THREADS_MUTEX_UNLOCK(x) ::LeaveCriticalSection (x) +#define LOKI_THREADS_LONG LONG +#define LOKI_THREADS_MUTEX_CTOR(x) + +#define LOKI_THREADS_ATOMIC_FUNCTIONS \ + static IntType AtomicMultiply(volatile IntType& lval, const IntType val) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + lval *= val; \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDivide(volatile IntType& lval, const IntType val) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + lval /= val; \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicIncrement(volatile IntType& lval) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + ++lval; \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDecrement(volatile IntType& lval) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + --lval; \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static void AtomicAssign(volatile IntType& lval, const IntType val) \ + { InterlockedExchange(&const_cast<IntType&>(lval), val); } \ + \ + static void AtomicAssign(IntType& lval, volatile const IntType& val) \ + { InterlockedExchange(&lval, val); } \ + \ + static IntType AtomicIncrement(volatile IntType& lval, const IntType compare, bool & matches ) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + ++lval; \ + matches = ( lval == compare ); \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDecrement(volatile IntType& lval, const IntType compare, bool & matches ) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + --lval; \ + matches = ( lval == compare ); \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicAdd(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + lval += val; \ + matches = ( lval == compare ); \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicSubtract(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + lval -= val; \ + matches = ( lval == compare ); \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicMultiply(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + lval *= val; \ + matches = ( lval == compare ); \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDivide(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \ + { \ + ::EnterCriticalSection( &atomic_mutex_ ); \ + lval /= val; \ + matches = ( lval == compare ); \ + ::LeaveCriticalSection( &atomic_mutex_ ); \ + return lval; \ + } + +#elif defined(LOKI_PTHREAD_H) + + +#define LOKI_THREADS_MUTEX(x) pthread_mutex_t (x); + +#define LOKI_THREADS_MUTEX_INIT(x) ::pthread_mutex_init(x, 0) + +// define to 1 to enable recursive mutex support +#if 0 +// experimental recursive mutex support +#define LOKI_THREADS_MUTEX_CTOR(x) : x(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) +#else +// no recursive mutex support +#define LOKI_THREADS_MUTEX_CTOR(x) +#endif + +#define LOKI_THREADS_MUTEX_DELETE(x) ::pthread_mutex_destroy (x) +#define LOKI_THREADS_MUTEX_LOCK(x) ::pthread_mutex_lock (x) +#define LOKI_THREADS_MUTEX_UNLOCK(x) ::pthread_mutex_unlock (x) +#define LOKI_THREADS_LONG long + +#define LOKI_THREADS_ATOMIC(x) \ + pthread_mutex_lock(&atomic_mutex_); \ + x; \ + pthread_mutex_unlock(&atomic_mutex_) + +#define LOKI_THREADS_ATOMIC_FUNCTIONS \ + private: \ + static pthread_mutex_t atomic_mutex_; \ + public: \ + static IntType AtomicMultiply(volatile IntType& lval, const IntType val) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + lval *= val; \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDivide(volatile IntType& lval, const IntType val) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + lval /= val; \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicIncrement(volatile IntType& lval) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + ++lval; \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDecrement(volatile IntType& lval) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + --lval; \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static void AtomicAssign(volatile IntType& lval, const IntType val) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + lval = val; \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static void AtomicAssign(IntType& lval, volatile const IntType& val) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + lval = val; \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicIncrement(volatile IntType& lval, const IntType compare, bool & matches ) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + ++lval; \ + matches = ( compare == lval ); \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDecrement(volatile IntType& lval, const IntType compare, bool & matches ) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + --lval; \ + matches = ( compare == lval ); \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + static IntType AtomicMultiply(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + lval *= val; \ + matches = ( lval == compare ); \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } \ + \ + static IntType AtomicDivide(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) \ + { \ + ::pthread_mutex_lock( &atomic_mutex_ ); \ + lval /= val; \ + matches = ( lval == compare ); \ + ::pthread_mutex_unlock( &atomic_mutex_ ); \ + return lval; \ + } + +#else // single threaded + +#define LOKI_THREADS_MUTEX(x) +#define LOKI_THREADS_MUTEX_INIT(x) +#define LOKI_THREADS_MUTEX_DELETE(x) +#define LOKI_THREADS_MUTEX_LOCK(x) +#define LOKI_THREADS_MUTEX_UNLOCK(x) +#define LOKI_THREADS_LONG +#define LOKI_THREADS_MUTEX_CTOR(x) + +#endif + + + +namespace Loki +{ + + //////////////////////////////////////////////////////////////////////////////// + /// \class Mutex + // + /// \ingroup ThreadingGroup + /// A simple and portable Mutex. A default policy class for locking objects. + //////////////////////////////////////////////////////////////////////////////// + + class Mutex + { + public: + Mutex() LOKI_THREADS_MUTEX_CTOR(mtx_) + { + LOKI_THREADS_MUTEX_INIT(&mtx_); + } + ~Mutex() + { + LOKI_THREADS_MUTEX_DELETE(&mtx_); + } + void Lock() + { + LOKI_THREADS_MUTEX_LOCK(&mtx_); + } + void Unlock() + { + LOKI_THREADS_MUTEX_UNLOCK(&mtx_); + } + private: + /// Copy-constructor not implemented. + Mutex(const Mutex &); + /// Copy-assignement operator not implemented. + Mutex & operator = (const Mutex &); + LOKI_THREADS_MUTEX(mtx_) + }; + + + //////////////////////////////////////////////////////////////////////////////// + /// \class SingleThreaded + /// + /// \ingroup ThreadingGroup + /// Implementation of the ThreadingModel policy used by various classes + /// Implements a single-threaded model; no synchronization + //////////////////////////////////////////////////////////////////////////////// + template <class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX> + class SingleThreaded + { + public: + /// \struct Lock + /// Dummy Lock class + struct Lock + { + Lock() {} + explicit Lock(const SingleThreaded&) {} + explicit Lock(const SingleThreaded*) {} + }; + + typedef Host VolatileType; + + typedef int IntType; + + static IntType AtomicAdd(volatile IntType& lval, const IntType val) + { return lval += val; } + + static IntType AtomicSubtract(volatile IntType& lval, const IntType val) + { return lval -= val; } + + static IntType AtomicMultiply(volatile IntType& lval, const IntType val) + { return lval *= val; } + + static IntType AtomicDivide(volatile IntType& lval, const IntType val) + { return lval /= val; } + + static IntType AtomicIncrement(volatile IntType& lval) + { return ++lval; } + + static IntType AtomicDecrement(volatile IntType& lval) + { return --lval; } + + static void AtomicAssign(volatile IntType & lval, const IntType val) + { lval = val; } + + static void AtomicAssign(IntType & lval, volatile IntType & val) + { lval = val; } + + static IntType AtomicAdd(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) + { + lval += val; + matches = ( lval == compare ); + return lval; + } + + static IntType AtomicSubtract(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) + { + lval -= val; + matches = ( lval == compare ); + return lval; + } + + static IntType AtomicMultiply(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) + { + lval *= val; + matches = ( lval == compare ); + return lval; + } + + static IntType AtomicDivide(volatile IntType& lval, const IntType val, const IntType compare, bool & matches ) + { + lval /= val; + matches = ( lval == compare ); + return lval; + } + + static IntType AtomicIncrement(volatile IntType& lval, const IntType compare, bool & matches ) + { + ++lval; + matches = ( lval == compare ); + return lval; + } + + static IntType AtomicDecrement(volatile IntType& lval, const IntType compare, bool & matches ) + { + --lval; + matches = ( lval == compare ); + return lval; + } + + }; + + +#if defined(LOKI_WINDOWS_H) || defined(LOKI_PTHREAD_H) + + //////////////////////////////////////////////////////////////////////////////// + /// \class ObjectLevelLockable + /// + /// \ingroup ThreadingGroup + /// Implementation of the ThreadingModel policy used by various classes + /// Implements a object-level locking scheme + //////////////////////////////////////////////////////////////////////////////// + template < class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX > + class ObjectLevelLockable + { + mutable MutexPolicy mtx_; + + public: + ObjectLevelLockable() : mtx_() {} + + ObjectLevelLockable(const ObjectLevelLockable&) : mtx_() {} + + ~ObjectLevelLockable() {} + + class Lock; + friend class Lock; + + /// \struct Lock + /// Lock class to lock on object level + class Lock + { + public: + + /// Lock object + explicit Lock(const ObjectLevelLockable& host) : host_(host) + { + host_.mtx_.Lock(); + } + + /// Lock object + explicit Lock(const ObjectLevelLockable* host) : host_(*host) + { + host_.mtx_.Lock(); + } + + /// Unlock object + ~Lock() + { + host_.mtx_.Unlock(); + } + + private: + /// private by design of the object level threading + Lock(); + Lock(const Lock&); + Lock& operator=(const Lock&); + const ObjectLevelLockable& host_; + }; + + typedef volatile Host VolatileType; + + typedef LOKI_THREADS_LONG IntType; + + LOKI_THREADS_ATOMIC_FUNCTIONS + + }; + +#ifdef LOKI_PTHREAD_H + template <class Host, class MutexPolicy> + pthread_mutex_t ObjectLevelLockable<Host, MutexPolicy>::atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER; +#endif + + //////////////////////////////////////////////////////////////////////////////// + /// \class ClassLevelLockable + /// + /// \ingroup ThreadingGroup + /// Implementation of the ThreadingModel policy used by various classes + /// Implements a class-level locking scheme + //////////////////////////////////////////////////////////////////////////////// + template <class Host, class MutexPolicy = LOKI_DEFAULT_MUTEX > + class ClassLevelLockable + { + struct Initializer + { + bool init_; + MutexPolicy mtx_; + + Initializer() : init_(false), mtx_() + { + init_ = true; + } + + ~Initializer() + { + assert(init_); + } + }; + + static Initializer initializer_; + + public: + + class Lock; + friend class Lock; + + /// \struct Lock + /// Lock class to lock on class level + class Lock + { + public: + + /// Lock class + Lock() + { + assert(initializer_.init_); + initializer_.mtx_.Lock(); + } + + /// Lock class + explicit Lock(const ClassLevelLockable&) + { + assert(initializer_.init_); + initializer_.mtx_.Lock(); + } + + /// Lock class + explicit Lock(const ClassLevelLockable*) + { + assert(initializer_.init_); + initializer_.mtx_.Lock(); + } + + /// Unlock class + ~Lock() + { + assert(initializer_.init_); + initializer_.mtx_.Unlock(); + } + + private: + Lock(const Lock&); + Lock& operator=(const Lock&); + }; + + typedef volatile Host VolatileType; + + typedef LOKI_THREADS_LONG IntType; + + LOKI_THREADS_ATOMIC_FUNCTIONS + + }; + +#ifdef LOKI_PTHREAD_H + template <class Host, class MutexPolicy> + pthread_mutex_t ClassLevelLockable<Host, MutexPolicy>::atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER; +#endif + + template < class Host, class MutexPolicy > + typename ClassLevelLockable< Host, MutexPolicy >::Initializer + ClassLevelLockable< Host, MutexPolicy >::initializer_; + +#endif // #if defined(LOKI_WINDOWS_H) || defined(LOKI_PTHREAD_H) + +} // namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/Tuple.h b/shared/loki/Tuple.h new file mode 100644 index 00000000..47fc19e2 --- /dev/null +++ b/shared/loki/Tuple.h @@ -0,0 +1,22 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// + +// Last update: June 20, 2001 + +//////////////////////////////////////////////////////////////////////////////// +// This file is intentionally left empty +// Due to compiler limitations, its contents has been moved to +// HierarchyGenerators.h +//////////////////////////////////////////////////////////////////////////////// diff --git a/shared/loki/TypeManip.h b/shared/loki/TypeManip.h new file mode 100644 index 00000000..e08b4e03 --- /dev/null +++ b/shared/loki/TypeManip.h @@ -0,0 +1,284 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Welsey Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_TYPEMANIP_INC_ +#define LOKI_TYPEMANIP_INC_ + +// $Id: TypeManip.h 749 2006-10-17 19:49:26Z syntheticpp $ + + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class template Int2Type +// Converts each integral constant into a unique type +// Invocation: Int2Type<v> where v is a compile-time constant integral +// Defines 'value', an enum that evaluates to v +//////////////////////////////////////////////////////////////////////////////// + + template <int v> + struct Int2Type + { + enum { value = v }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Type2Type +// Converts each type into a unique, insipid type +// Invocation Type2Type<T> where T is a type +// Defines the type OriginalType which maps back to T +//////////////////////////////////////////////////////////////////////////////// + + template <typename T> + struct Type2Type + { + typedef T OriginalType; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Select +// Selects one of two types based upon a boolean constant +// Invocation: Select<flag, T, U>::Result +// where: +// flag is a compile-time boolean constant +// T and U are types +// Result evaluates to T if flag is true, and to U otherwise. +//////////////////////////////////////////////////////////////////////////////// + + template <bool flag, typename T, typename U> + struct Select + { + typedef T Result; + }; + template <typename T, typename U> + struct Select<false, T, U> + { + typedef U Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template IsSameType +// Return true iff two given types are the same +// Invocation: SameType<T, U>::value +// where: +// T and U are types +// Result evaluates to true iff U == T (types equal) +//////////////////////////////////////////////////////////////////////////////// + + template <typename T, typename U> + struct IsSameType + { + enum { value = false }; + }; + + template <typename T> + struct IsSameType<T,T> + { + enum { value = true }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// Helper types Small and Big - guarantee that sizeof(Small) < sizeof(Big) +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { + template <class T, class U> + struct ConversionHelper + { + typedef char Small; + struct Big { char dummy[2]; }; + static Big Test(...); + static Small Test(U); + static T MakeT(); + }; + } + +//////////////////////////////////////////////////////////////////////////////// +// class template Conversion +// Figures out the conversion relationships between two types +// Invocations (T and U are types): +// a) Conversion<T, U>::exists +// returns (at compile time) true if there is an implicit conversion from T +// to U (example: Derived to Base) +// b) Conversion<T, U>::exists2Way +// returns (at compile time) true if there are both conversions from T +// to U and from U to T (example: int to char and back) +// c) Conversion<T, U>::sameType +// returns (at compile time) true if T and U represent the same type +// +// Caveat: might not work if T and U are in a private inheritance hierarchy. +//////////////////////////////////////////////////////////////////////////////// + + template <class T, class U> + struct Conversion + { + typedef Private::ConversionHelper<T, U> H; +#ifndef __MWERKS__ + enum { exists = sizeof(typename H::Small) == sizeof((H::Test(H::MakeT()))) }; +#else + enum { exists = false }; +#endif + enum { exists2Way = exists && Conversion<U, T>::exists }; + enum { sameType = false }; + }; + + template <class T> + struct Conversion<T, T> + { + enum { exists = 1, exists2Way = 1, sameType = 1 }; + }; + + template <class T> + struct Conversion<void, T> + { + enum { exists = 0, exists2Way = 0, sameType = 0 }; + }; + + template <class T> + struct Conversion<T, void> + { + enum { exists = 0, exists2Way = 0, sameType = 0 }; + }; + + template <> + struct Conversion<void, void> + { + public: + enum { exists = 1, exists2Way = 1, sameType = 1 }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template SuperSubclass +// Invocation: SuperSubclass<B, D>::value where B and D are types. +// Returns true if B is a public base of D, or if B and D are aliases of the +// same type. +// +// Caveat: might not work if T and U are in a private inheritance hierarchy. +//////////////////////////////////////////////////////////////////////////////// + +template <class T, class U> +struct SuperSubclass +{ + enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists && + !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) }; + + // Dummy enum to make sure that both classes are fully defined. + enum{ dontUseWithIncompleteTypes = ( sizeof (T) == sizeof (U) ) }; +}; + +template <> +struct SuperSubclass<void, void> +{ + enum { value = false }; +}; + +template <class U> +struct SuperSubclass<void, U> +{ + enum { value = (::Loki::Conversion<const volatile U*, const volatile void*>::exists && + !::Loki::Conversion<const volatile void*, const volatile void*>::sameType) }; + + // Dummy enum to make sure that both classes are fully defined. + enum{ dontUseWithIncompleteTypes = ( 0 == sizeof (U) ) }; +}; + +template <class T> +struct SuperSubclass<T, void> +{ + enum { value = (::Loki::Conversion<const volatile void*, const volatile T*>::exists && + !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) }; + + // Dummy enum to make sure that both classes are fully defined. + enum{ dontUseWithIncompleteTypes = ( sizeof (T) == 0 ) }; +}; + +//////////////////////////////////////////////////////////////////////////////// +// class template SuperSubclassStrict +// Invocation: SuperSubclassStrict<B, D>::value where B and D are types. +// Returns true if B is a public base of D. +// +// Caveat: might not work if T and U are in a private inheritance hierarchy. +//////////////////////////////////////////////////////////////////////////////// + +template<class T,class U> +struct SuperSubclassStrict +{ + enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists && + !::Loki::Conversion<const volatile T*, const volatile void*>::sameType && + !::Loki::Conversion<const volatile T*, const volatile U*>::sameType) }; + + // Dummy enum to make sure that both classes are fully defined. + enum{ dontUseWithIncompleteTypes = ( sizeof (T) == sizeof (U) ) }; +}; + +template<> +struct SuperSubclassStrict<void, void> +{ + enum { value = false }; +}; + +template<class U> +struct SuperSubclassStrict<void, U> +{ + enum { value = (::Loki::Conversion<const volatile U*, const volatile void*>::exists && + !::Loki::Conversion<const volatile void*, const volatile void*>::sameType && + !::Loki::Conversion<const volatile void*, const volatile U*>::sameType) }; + + // Dummy enum to make sure that both classes are fully defined. + enum{ dontUseWithIncompleteTypes = ( 0 == sizeof (U) ) }; +}; + +template<class T> +struct SuperSubclassStrict<T, void> +{ + enum { value = (::Loki::Conversion<const volatile void*, const volatile T*>::exists && + !::Loki::Conversion<const volatile T*, const volatile void*>::sameType && + !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) }; + + // Dummy enum to make sure that both classes are fully defined. + enum{ dontUseWithIncompleteTypes = ( sizeof (T) == 0 ) }; +}; + + +} // namespace Loki + +//////////////////////////////////////////////////////////////////////////////// +// macro SUPERSUBCLASS +// Invocation: SUPERSUBCLASS(B, D) where B and D are types. +// Returns true if B is a public base of D, or if B and D are aliases of the +// same type. +// +// Caveat: might not work if T and U are in a private inheritance hierarchy. +// Deprecated: Use SuperSubclass class template instead. +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_SUPERSUBCLASS(T, U) \ + ::Loki::SuperSubclass<T,U>::value + +//////////////////////////////////////////////////////////////////////////////// +// macro SUPERSUBCLASS_STRICT +// Invocation: SUPERSUBCLASS(B, D) where B and D are types. +// Returns true if B is a public base of D. +// +// Caveat: might not work if T and U are in a private inheritance hierarchy. +// Deprecated: Use SuperSubclassStrict class template instead. +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_SUPERSUBCLASS_STRICT(T, U) \ + ::Loki::SuperSubclassStrict<T,U>::value + + +#endif // end file guardian + diff --git a/shared/loki/TypeTraits.h b/shared/loki/TypeTraits.h new file mode 100644 index 00000000..a592cab9 --- /dev/null +++ b/shared/loki/TypeTraits.h @@ -0,0 +1,2228 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_TYPETRAITS_INC_ +#define LOKI_TYPETRAITS_INC_ + +// $Id: TypeTraits.h 835 2007-08-02 19:39:02Z syntheticpp $ + + +#include "Typelist.h" +#include "Sequence.h" + +#if (defined _MSC_VER) && (_MSC_VER < 1400) +#include <string> +#endif + + +#ifdef _MSC_VER +#pragma warning( push ) +#pragma warning( disable : 4180 ) //qualifier applied to function type has no meaning; ignored +#endif + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class template IsCustomUnsignedInt +// Offers a means to integrate nonstandard built-in unsigned integral types +// (such as unsigned __int64 or unsigned long long int) with the TypeTraits +// class template defined below. +// Invocation: IsCustomUnsignedInt<T> where T is any type +// Defines 'value', an enum that is 1 iff T is a custom built-in unsigned +// integral type +// Specialize this class template for nonstandard unsigned integral types +// and define value = 1 in those specializations +//////////////////////////////////////////////////////////////////////////////// + + template <typename T> + struct IsCustomUnsignedInt + { + enum { value = 0 }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template IsCustomSignedInt +// Offers a means to integrate nonstandard built-in unsigned integral types +// (such as unsigned __int64 or unsigned long long int) with the TypeTraits +// class template defined below. +// Invocation: IsCustomSignedInt<T> where T is any type +// Defines 'value', an enum that is 1 iff T is a custom built-in signed +// integral type +// Specialize this class template for nonstandard unsigned integral types +// and define value = 1 in those specializations +//////////////////////////////////////////////////////////////////////////////// + + template <typename T> + struct IsCustomSignedInt + { + enum { value = 0 }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template IsCustomFloat +// Offers a means to integrate nonstandard floating point types with the +// TypeTraits class template defined below. +// Invocation: IsCustomFloat<T> where T is any type +// Defines 'value', an enum that is 1 iff T is a custom built-in +// floating point type +// Specialize this class template for nonstandard unsigned integral types +// and define value = 1 in those specializations +//////////////////////////////////////////////////////////////////////////////// + + template <typename T> + struct IsCustomFloat + { + enum { value = 0 }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// Helper types for class template TypeTraits defined below +//////////////////////////////////////////////////////////////////////////////// + + namespace Private + { +#ifndef LOKI_DISABLE_TYPELIST_MACROS + typedef LOKI_TYPELIST_4(unsigned char, unsigned short int,unsigned int, unsigned long int) + StdUnsignedInts; + typedef LOKI_TYPELIST_4(signed char, short int,int, long int) + StdSignedInts; + typedef LOKI_TYPELIST_3(bool, char, wchar_t) + StdOtherInts; + typedef LOKI_TYPELIST_3(float, double, long double) + StdFloats; +#else + typedef Loki::Seq<unsigned char, unsigned short int,unsigned int, unsigned long int>::Type + StdUnsignedInts; + typedef Loki::Seq<signed char, short int,int, long int>::Type + StdSignedInts; + typedef Loki::Seq<bool, char, wchar_t>::Type + StdOtherInts; + typedef Loki::Seq<float, double, long double>::Type + StdFloats; + +#endif + template <typename U> struct AddPointer + { + typedef U* Result; + }; + + template <typename U> struct AddPointer<U&> + { + typedef U* Result; + }; + + template <class U> struct AddReference + { + typedef U & Result; + }; + + template <class U> struct AddReference<U &> + { + typedef U & Result; + }; + + template <> struct AddReference<void> + { + typedef NullType Result; + }; + + template <class U> struct AddParameterType + { + typedef const U & Result; + }; + + template <class U> struct AddParameterType<U &> + { + typedef U & Result; + }; + + template <> struct AddParameterType<void> + { + typedef NullType Result; + }; + + template <typename T> + struct IsFunctionPointerRaw + {enum{result = 0};}; + + template <typename T> + struct IsFunctionPointerRaw<T(*)()> + {enum {result = 1};}; + + template <typename T, + typename P01> + struct IsFunctionPointerRaw<T(*)(P01)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02> + struct IsFunctionPointerRaw<T(*)( + P01, P02)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20)> + {enum {result = 1};}; + + template <typename T> + struct IsFunctionPointerRaw<T(*)( + ...)> + {enum {result = 1};}; + + template <typename T, + typename P01> + struct IsFunctionPointerRaw<T(*)( + P01, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02> + struct IsFunctionPointerRaw<T(*)( + P01, P02, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, ...)> + {enum {result = 1};}; + + template <typename T, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsFunctionPointerRaw<T(*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20, + ...)> + {enum {result = 1};}; + + + template <typename T> + struct IsMemberFunctionPointerRaw + {enum{result = 0};}; + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)()> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)(P01)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20)> + {enum {result = 1};}; + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)( + ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, ...)> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20, + ...)> + {enum {result = 1};}; + + // Const versions + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)() const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)(P01) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20) const> + {enum {result = 1};}; + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)( + ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, ...) const> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20, + ...) const> + {enum {result = 1};}; + + // Volatile versions + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)() volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)(P01) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20) volatile> + {enum {result = 1};}; + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)( + ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, ...) volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20, + ...) volatile> + {enum {result = 1};}; + + // Const volatile versions + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)() const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)(P01) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20) const volatile> + {enum {result = 1};}; + + template <typename T, typename S> + struct IsMemberFunctionPointerRaw<T (S::*)( + ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, ...) const volatile> + {enum {result = 1};}; + + template <typename T, typename S, + typename P01, typename P02, typename P03, typename P04, typename P05, + typename P06, typename P07, typename P08, typename P09, typename P10, + typename P11, typename P12, typename P13, typename P14, typename P15, + typename P16, typename P17, typename P18, typename P19, typename P20> + struct IsMemberFunctionPointerRaw<T (S::*)( + P01, P02, P03, P04, P05, + P06, P07, P08, P09, P10, + P11, P12, P13, P14, P15, + P16, P17, P18, P19, P20, + ...) const volatile> + {enum {result = 1};}; + + }// namespace Private + +//////////////////////////////////////////////////////////////////////////////// +// class template TypeTraits +// +// Figures out at compile time various properties of any given type +// Invocations (T is a type, TypeTraits<T>::Property): +// +// - isPointer : returns true if T is a pointer type +// - PointeeType : returns the type to which T points if T is a pointer +// type, NullType otherwise +// - isReference : returns true if T is a reference type +// - ReferredType : returns the type to which T refers if T is a reference +// type, NullType otherwise +// - isMemberPointer : returns true if T is a pointer to member type +// - isStdUnsignedInt: returns true if T is a standard unsigned integral type +// - isStdSignedInt : returns true if T is a standard signed integral type +// - isStdIntegral : returns true if T is a standard integral type +// - isStdFloat : returns true if T is a standard floating-point type +// - isStdArith : returns true if T is a standard arithmetic type +// - isStdFundamental: returns true if T is a standard fundamental type +// - isUnsignedInt : returns true if T is a unsigned integral type +// - isSignedInt : returns true if T is a signed integral type +// - isIntegral : returns true if T is a integral type +// - isFloat : returns true if T is a floating-point type +// - isArith : returns true if T is a arithmetic type +// - isFundamental : returns true if T is a fundamental type +// - ParameterType : returns the optimal type to be used as a parameter for +// functions that take Ts +// - isConst : returns true if T is a const-qualified type +// - NonConstType : Type with removed 'const' qualifier from T, if any +// - isVolatile : returns true if T is a volatile-qualified type +// - NonVolatileType : Type with removed 'volatile' qualifier from T, if any +// - UnqualifiedType : Type with removed 'const' and 'volatile' qualifiers from +// T, if any +// - ParameterType : returns the optimal type to be used as a parameter +// for functions that take 'const T's +// +//////////////////////////////////////////////////////////////////////////////// + + template <typename T> + class TypeTraits + { + private: + + template <class U> struct ReferenceTraits + { + enum { result = false }; + typedef U ReferredType; + }; + + template <class U> struct ReferenceTraits<U&> + { + enum { result = true }; + typedef U ReferredType; + }; + + template <class U> struct PointerTraits + { + enum { result = false }; + typedef NullType PointeeType; + }; + + template <class U> struct PointerTraits<U*> + { + enum { result = true }; + typedef U PointeeType; + }; + + template <class U> struct PointerTraits<U*&> + { + enum { result = true }; + typedef U PointeeType; + }; + + template <class U> struct PToMTraits + { + enum { result = false }; + }; + + template <class U, class V> struct PToMTraits<U V::*> + { + enum { result = true }; + }; + + template <class U, class V> struct PToMTraits<U V::*&> + { + enum { result = true }; + }; + + template <class U> struct FunctionPointerTraits + { + enum{ result = Private::IsFunctionPointerRaw<U>::result }; + }; + + template <typename U> struct PToMFunctionTraits + { + enum{ result = Private::IsMemberFunctionPointerRaw<U>::result }; + }; + + template <class U> struct UnConst + { + typedef U Result; + enum { isConst = 0 }; + }; + + template <class U> struct UnConst<const U> + { + typedef U Result; + enum { isConst = 1 }; + }; + + template <class U> struct UnConst<const U&> + { + typedef U& Result; + enum { isConst = 1 }; + }; + + template <class U> struct UnVolatile + { + typedef U Result; + enum { isVolatile = 0 }; + }; + + template <class U> struct UnVolatile<volatile U> + { + typedef U Result; + enum { isVolatile = 1 }; + }; + + template <class U> struct UnVolatile<volatile U&> + { + typedef U& Result; + enum { isVolatile = 1 }; + }; + + public: + typedef typename UnConst<T>::Result + NonConstType; + typedef typename UnVolatile<T>::Result + NonVolatileType; + typedef typename UnVolatile<typename UnConst<T>::Result>::Result + UnqualifiedType; + typedef typename PointerTraits<UnqualifiedType>::PointeeType + PointeeType; + typedef typename ReferenceTraits<T>::ReferredType + ReferredType; + + enum { isConst = UnConst<T>::isConst }; + enum { isVolatile = UnVolatile<T>::isVolatile }; + enum { isReference = ReferenceTraits<UnqualifiedType>::result }; + enum { isFunction = FunctionPointerTraits<typename Private::AddPointer<T>::Result >::result }; + enum { isFunctionPointer= FunctionPointerTraits< + typename ReferenceTraits<UnqualifiedType>::ReferredType >::result }; + enum { isMemberFunctionPointer= PToMFunctionTraits< + typename ReferenceTraits<UnqualifiedType>::ReferredType >::result }; + enum { isMemberPointer = PToMTraits< + typename ReferenceTraits<UnqualifiedType>::ReferredType >::result || + isMemberFunctionPointer }; + enum { isPointer = PointerTraits< + typename ReferenceTraits<UnqualifiedType>::ReferredType >::result || + isFunctionPointer }; + + enum { isStdUnsignedInt = TL::IndexOf<Private::StdUnsignedInts, UnqualifiedType>::value >= 0 || + TL::IndexOf<Private::StdUnsignedInts, + typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0}; + enum { isStdSignedInt = TL::IndexOf<Private::StdSignedInts, UnqualifiedType>::value >= 0 || + TL::IndexOf<Private::StdSignedInts, + typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0}; + enum { isStdIntegral = isStdUnsignedInt || isStdSignedInt || + TL::IndexOf<Private::StdOtherInts, UnqualifiedType>::value >= 0 || + TL::IndexOf<Private::StdOtherInts, + typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0}; + enum { isStdFloat = TL::IndexOf<Private::StdFloats, UnqualifiedType>::value >= 0 || + TL::IndexOf<Private::StdFloats, + typename ReferenceTraits<UnqualifiedType>::ReferredType>::value >= 0}; + enum { isStdArith = isStdIntegral || isStdFloat }; + enum { isStdFundamental = isStdArith || isStdFloat || Conversion<T, void>::sameType }; + + enum { isUnsignedInt = isStdUnsignedInt || IsCustomUnsignedInt<UnqualifiedType>::value }; + enum { isSignedInt = isStdSignedInt || IsCustomSignedInt<UnqualifiedType>::value }; + enum { isIntegral = isStdIntegral || isUnsignedInt || isSignedInt }; + enum { isFloat = isStdFloat || IsCustomFloat<UnqualifiedType>::value }; + enum { isArith = isIntegral || isFloat }; + enum { isFundamental = isStdFundamental || isArith }; + + typedef typename Select<isStdArith || isPointer || isMemberPointer, T, + typename Private::AddParameterType<T>::Result>::Result + ParameterType; + }; +} + +#ifdef _MSC_VER +#pragma warning( pop ) +#endif // _MSC_VER + + +#endif // end file guardian + diff --git a/shared/loki/Typelist.h b/shared/loki/Typelist.h new file mode 100644 index 00000000..6a885927 --- /dev/null +++ b/shared/loki/Typelist.h @@ -0,0 +1,459 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Welsey Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_TYPELIST_INC_ +#define LOKI_TYPELIST_INC_ + +// $Id: Typelist.h 749 2006-10-17 19:49:26Z syntheticpp $ + + +#include "NullType.h" +#include "TypeManip.h" +#include "TypelistMacros.h" + + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// class template Typelist +// The building block of typelists of any length +// Use it through the LOKI_TYPELIST_NN macros +// Defines nested types: +// Head (first element, a non-typelist type by convention) +// Tail (second element, can be another typelist) +//////////////////////////////////////////////////////////////////////////////// + + template <class T, class U> + struct Typelist + { + typedef T Head; + typedef U Tail; + }; + +// Typelist utility algorithms + + namespace TL + { + +//////////////////////////////////////////////////////////////////////////////// +// class template MakeTypelist +// Takes a number of arguments equal to its numeric suffix +// The arguments are type names. +// MakeTypelist<T1, T2, ...>::Result +// returns a typelist that is of T1, T2, ... +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename T1 = NullType, typename T2 = NullType, typename T3 = NullType, + typename T4 = NullType, typename T5 = NullType, typename T6 = NullType, + typename T7 = NullType, typename T8 = NullType, typename T9 = NullType, + typename T10 = NullType, typename T11 = NullType, typename T12 = NullType, + typename T13 = NullType, typename T14 = NullType, typename T15 = NullType, + typename T16 = NullType, typename T17 = NullType, typename T18 = NullType + > + struct MakeTypelist + { + private: + typedef typename MakeTypelist + < + T2 , T3 , T4 , + T5 , T6 , T7 , + T8 , T9 , T10, + T11, T12, T13, + T14, T15, T16, + T17, T18 + > + ::Result TailResult; + + public: + typedef Typelist<T1, TailResult> Result; + }; + + template<> + struct MakeTypelist<> + { + typedef NullType Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Length +// Computes the length of a typelist +// Invocation (TList is a typelist): +// Length<TList>::value +// returns a compile-time constant containing the length of TList, not counting +// the end terminator (which by convention is NullType) +//////////////////////////////////////////////////////////////////////////////// + + template <class TList> struct Length; + template <> struct Length<NullType> + { + enum { value = 0 }; + }; + + template <class T, class U> + struct Length< Typelist<T, U> > + { + enum { value = 1 + Length<U>::value }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template TypeAt +// Finds the type at a given index in a typelist +// Invocation (TList is a typelist and index is a compile-time integral +// constant): +// TypeAt<TList, index>::Result +// returns the type in position 'index' in TList +// If you pass an out-of-bounds index, the result is a compile-time error +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, unsigned int index> struct TypeAt; + + template <class Head, class Tail> + struct TypeAt<Typelist<Head, Tail>, 0> + { + typedef Head Result; + }; + + template <class Head, class Tail, unsigned int i> + struct TypeAt<Typelist<Head, Tail>, i> + { + typedef typename TypeAt<Tail, i - 1>::Result Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template TypeAtNonStrict +// Finds the type at a given index in a typelist +// Invocations (TList is a typelist and index is a compile-time integral +// constant): +// a) TypeAt<TList, index>::Result +// returns the type in position 'index' in TList, or NullType if index is +// out-of-bounds +// b) TypeAt<TList, index, D>::Result +// returns the type in position 'index' in TList, or D if index is out-of-bounds +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, unsigned int index, + typename DefaultType = NullType> + struct TypeAtNonStrict + { + typedef DefaultType Result; + }; + + template <class Head, class Tail, typename DefaultType> + struct TypeAtNonStrict<Typelist<Head, Tail>, 0, DefaultType> + { + typedef Head Result; + }; + + template <class Head, class Tail, unsigned int i, typename DefaultType> + struct TypeAtNonStrict<Typelist<Head, Tail>, i, DefaultType> + { + typedef typename + TypeAtNonStrict<Tail, i - 1, DefaultType>::Result Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template IndexOf +// Finds the index of a type in a typelist +// Invocation (TList is a typelist and T is a type): +// IndexOf<TList, T>::value +// returns the position of T in TList, or NullType if T is not found in TList +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T> struct IndexOf; + + template <class T> + struct IndexOf<NullType, T> + { + enum { value = -1 }; + }; + + template <class T, class Tail> + struct IndexOf<Typelist<T, Tail>, T> + { + enum { value = 0 }; + }; + + template <class Head, class Tail, class T> + struct IndexOf<Typelist<Head, Tail>, T> + { + private: + enum { temp = IndexOf<Tail, T>::value }; + public: + enum { value = (temp == -1 ? -1 : 1 + temp) }; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Append +// Appends a type or a typelist to another +// Invocation (TList is a typelist and T is either a type or a typelist): +// Append<TList, T>::Result +// returns a typelist that is TList followed by T and NullType-terminated +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T> struct Append; + + template <> struct Append<NullType, NullType> + { + typedef NullType Result; + }; + + template <class T> struct Append<NullType, T> + { + typedef Typelist<T,NullType> Result; + }; + + template <class Head, class Tail> + struct Append<NullType, Typelist<Head, Tail> > + { + typedef Typelist<Head, Tail> Result; + }; + + template <class Head, class Tail, class T> + struct Append<Typelist<Head, Tail>, T> + { + typedef Typelist<Head, + typename Append<Tail, T>::Result> + Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Erase +// Erases the first occurence, if any, of a type in a typelist +// Invocation (TList is a typelist and T is a type): +// Erase<TList, T>::Result +// returns a typelist that is TList without the first occurence of T +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T> struct Erase; + + template <class T> // Specialization 1 + struct Erase<NullType, T> + { + typedef NullType Result; + }; + + template <class T, class Tail> // Specialization 2 + struct Erase<Typelist<T, Tail>, T> + { + typedef Tail Result; + }; + + template <class Head, class Tail, class T> // Specialization 3 + struct Erase<Typelist<Head, Tail>, T> + { + typedef Typelist<Head, + typename Erase<Tail, T>::Result> + Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template EraseAll +// Erases all first occurences, if any, of a type in a typelist +// Invocation (TList is a typelist and T is a type): +// EraseAll<TList, T>::Result +// returns a typelist that is TList without any occurence of T +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T> struct EraseAll; + template <class T> + struct EraseAll<NullType, T> + { + typedef NullType Result; + }; + template <class T, class Tail> + struct EraseAll<Typelist<T, Tail>, T> + { + // Go all the way down the list removing the type + typedef typename EraseAll<Tail, T>::Result Result; + }; + template <class Head, class Tail, class T> + struct EraseAll<Typelist<Head, Tail>, T> + { + // Go all the way down the list removing the type + typedef Typelist<Head, + typename EraseAll<Tail, T>::Result> + Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template NoDuplicates +// Removes all duplicate types in a typelist +// Invocation (TList is a typelist): +// NoDuplicates<TList, T>::Result +//////////////////////////////////////////////////////////////////////////////// + + template <class TList> struct NoDuplicates; + + template <> struct NoDuplicates<NullType> + { + typedef NullType Result; + }; + + template <class Head, class Tail> + struct NoDuplicates< Typelist<Head, Tail> > + { + private: + typedef typename NoDuplicates<Tail>::Result L1; + typedef typename Erase<L1, Head>::Result L2; + public: + typedef Typelist<Head, L2> Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Replace +// Replaces the first occurence of a type in a typelist, with another type +// Invocation (TList is a typelist, T, U are types): +// Replace<TList, T, U>::Result +// returns a typelist in which the first occurence of T is replaced with U +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T, class U> struct Replace; + + template <class T, class U> + struct Replace<NullType, T, U> + { + typedef NullType Result; + }; + + template <class T, class Tail, class U> + struct Replace<Typelist<T, Tail>, T, U> + { + typedef Typelist<U, Tail> Result; + }; + + template <class Head, class Tail, class T, class U> + struct Replace<Typelist<Head, Tail>, T, U> + { + typedef Typelist<Head, + typename Replace<Tail, T, U>::Result> + Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template ReplaceAll +// Replaces all occurences of a type in a typelist, with another type +// Invocation (TList is a typelist, T, U are types): +// Replace<TList, T, U>::Result +// returns a typelist in which all occurences of T is replaced with U +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T, class U> struct ReplaceAll; + + template <class T, class U> + struct ReplaceAll<NullType, T, U> + { + typedef NullType Result; + }; + + template <class T, class Tail, class U> + struct ReplaceAll<Typelist<T, Tail>, T, U> + { + typedef Typelist<U, typename ReplaceAll<Tail, T, U>::Result> Result; + }; + + template <class Head, class Tail, class T, class U> + struct ReplaceAll<Typelist<Head, Tail>, T, U> + { + typedef Typelist<Head, + typename ReplaceAll<Tail, T, U>::Result> + Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Reverse +// Reverses a typelist +// Invocation (TList is a typelist): +// Reverse<TList>::Result +// returns a typelist that is TList reversed +//////////////////////////////////////////////////////////////////////////////// + + template <class TList> struct Reverse; + + template <> + struct Reverse<NullType> + { + typedef NullType Result; + }; + + template <class Head, class Tail> + struct Reverse< Typelist<Head, Tail> > + { + typedef typename Append< + typename Reverse<Tail>::Result, Head>::Result Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template MostDerived +// Finds the type in a typelist that is the most derived from a given type +// Invocation (TList is a typelist, T is a type): +// MostDerived<TList, T>::Result +// returns the type in TList that's the most derived from T +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, class T> struct MostDerived; + + template <class T> + struct MostDerived<NullType, T> + { + typedef T Result; + }; + + template <class Head, class Tail, class T> + struct MostDerived<Typelist<Head, Tail>, T> + { + private: + typedef typename MostDerived<Tail, T>::Result Candidate; + public: + typedef typename Select< + SuperSubclass<Candidate,Head>::value, + Head, Candidate>::Result Result; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template DerivedToFront +// Arranges the types in a typelist so that the most derived types appear first +// Invocation (TList is a typelist): +// DerivedToFront<TList>::Result +// returns the reordered TList +//////////////////////////////////////////////////////////////////////////////// + + template <class TList> struct DerivedToFront; + + template <> + struct DerivedToFront<NullType> + { + typedef NullType Result; + }; + + template <class Head, class Tail> + struct DerivedToFront< Typelist<Head, Tail> > + { + private: + typedef typename MostDerived<Tail, Head>::Result + TheMostDerived; + typedef typename Replace<Tail, + TheMostDerived, Head>::Result Temp; + typedef typename DerivedToFront<Temp>::Result L; + public: + typedef Typelist<TheMostDerived, L> Result; + }; + + } // namespace TL +} // namespace Loki + + +#endif // end file guardian + diff --git a/shared/loki/TypelistMacros.h b/shared/loki/TypelistMacros.h new file mode 100644 index 00000000..6c14b348 --- /dev/null +++ b/shared/loki/TypelistMacros.h @@ -0,0 +1,353 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Welsey Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_TYPELISTMACROS_INC_ +#define LOKI_TYPELISTMACROS_INC_ + +// $Id: TypelistMacros.h 749 2006-10-17 19:49:26Z syntheticpp $ + + +//#define LOKI_DISABLE_TYPELIST_MACROS +#ifndef LOKI_DISABLE_TYPELIST_MACROS + +//////////////////////////////////////////////////////////////////////////////// +// macros LOKI_TYPELIST_1, LOKI_TYPELIST_2, ... LOKI_TYPELIST_50 +// Each takes a number of arguments equal to its numeric suffix +// The arguments are type names. LOKI_TYPELIST_NN generates a typelist containing +// all types passed as arguments, in that order. +// Example: LOKI_TYPELIST_2(char, int) generates a type containing char and int. +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_TYPELIST_1(T1) ::Loki::Typelist<T1, ::Loki::NullType> + +#define LOKI_TYPELIST_2(T1, T2) ::Loki::Typelist<T1, LOKI_TYPELIST_1(T2) > + +#define LOKI_TYPELIST_3(T1, T2, T3) ::Loki::Typelist<T1, LOKI_TYPELIST_2(T2, T3) > + +#define LOKI_TYPELIST_4(T1, T2, T3, T4) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_3(T2, T3, T4) > + +#define LOKI_TYPELIST_5(T1, T2, T3, T4, T5) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_4(T2, T3, T4, T5) > + +#define LOKI_TYPELIST_6(T1, T2, T3, T4, T5, T6) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_5(T2, T3, T4, T5, T6) > + +#define LOKI_TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_6(T2, T3, T4, T5, T6, T7) > + +#define LOKI_TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) > + +#define LOKI_TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) > + +#define LOKI_TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) > + +#define LOKI_TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) > + +#define LOKI_TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12) > + +#define LOKI_TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13) > + +#define LOKI_TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14) > + +#define LOKI_TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15) > + +#define LOKI_TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16) > + +#define LOKI_TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17) > + +#define LOKI_TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18) > + +#define LOKI_TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19) > + +#define LOKI_TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) > + +#define LOKI_TYPELIST_21(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_20(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) > + +#define LOKI_TYPELIST_22(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_21(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) > + +#define LOKI_TYPELIST_23(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_22(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) > + +#define LOKI_TYPELIST_24(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_23(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) > + +#define LOKI_TYPELIST_25(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_24(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25) > + +#define LOKI_TYPELIST_26(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_25(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26) > + +#define LOKI_TYPELIST_27(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_26(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27) > + +#define LOKI_TYPELIST_28(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_27(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28) > + +#define LOKI_TYPELIST_29(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_28(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29) > + +#define LOKI_TYPELIST_30(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_29(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) > + +#define LOKI_TYPELIST_31(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_30(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) > + +#define LOKI_TYPELIST_32(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_31(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) > + +#define LOKI_TYPELIST_33(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_32(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) > + +#define LOKI_TYPELIST_34(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_33(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) > + +#define LOKI_TYPELIST_35(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_34(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35) > + +#define LOKI_TYPELIST_36(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_35(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36) > + +#define LOKI_TYPELIST_37(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_36(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37) > + +#define LOKI_TYPELIST_38(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_37(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38) > + +#define LOKI_TYPELIST_39(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_38(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39) > + +#define LOKI_TYPELIST_40(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_39(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) > + +#define LOKI_TYPELIST_41(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_40(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) > + +#define LOKI_TYPELIST_42(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_41(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) > + +#define LOKI_TYPELIST_43(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_42(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) > + +#define LOKI_TYPELIST_44(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_43(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) > + +#define LOKI_TYPELIST_45(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_44(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45) > + +#define LOKI_TYPELIST_46(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_45(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46) > + +#define LOKI_TYPELIST_47(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_46(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47) > + +#define LOKI_TYPELIST_48(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47, T48) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_47(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47, T48) > + +#define LOKI_TYPELIST_49(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47, T48, T49) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_48(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47, T48, T49) > + +#define LOKI_TYPELIST_50(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) \ + ::Loki::Typelist<T1, LOKI_TYPELIST_49(T2, T3, T4, T5, T6, T7, T8, T9, T10, \ + T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \ + T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \ + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \ + T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) > + +#endif //LOKI_DISABLE_TYPELIST_MACROS + +#endif // end file guardian + diff --git a/shared/loki/Visitor.h b/shared/loki/Visitor.h new file mode 100644 index 00000000..4425a9fa --- /dev/null +++ b/shared/loki/Visitor.h @@ -0,0 +1,355 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_VISITOR_INC_ +#define LOKI_VISITOR_INC_ + +// $Id: Visitor.h 751 2006-10-17 19:50:37Z syntheticpp $ + + +/// \defgroup VisitorGroup Visitor + +#include "Typelist.h" +#include "HierarchyGenerators.h" + +namespace Loki +{ + +//////////////////////////////////////////////////////////////////////////////// +/// \class BaseVisitor +/// +/// \ingroup VisitorGroup +/// The base class of any Acyclic Visitor +//////////////////////////////////////////////////////////////////////////////// + + class BaseVisitor + { + public: + virtual ~BaseVisitor() {} + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \class Visitor +/// +/// \ingroup VisitorGroup +/// The building block of Acyclic Visitor +/// +/// \par Usage +/// +/// Defining the visitable class: +/// +/// \code +/// class RasterBitmap : public BaseVisitable<> +/// { +/// public: +/// LOKI_DEFINE_VISITABLE() +/// }; +/// \endcode +/// +/// Way 1 to define a visitor: +/// \code +/// class SomeVisitor : +/// public BaseVisitor // required +/// public Visitor<RasterBitmap>, +/// public Visitor<Paragraph> +/// { +/// public: +/// void Visit(RasterBitmap&); // visit a RasterBitmap +/// void Visit(Paragraph &); // visit a Paragraph +/// }; +/// \endcode +/// +/// Way 2 to define the visitor: +/// \code +/// class SomeVisitor : +/// public BaseVisitor // required +/// public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)> +/// { +/// public: +/// void Visit(RasterBitmap&); // visit a RasterBitmap +/// void Visit(Paragraph &); // visit a Paragraph +/// }; +/// \endcode +/// +/// Way 3 to define the visitor: +/// \code +/// class SomeVisitor : +/// public BaseVisitor // required +/// public Visitor<Seq<RasterBitmap, Paragraph>::Type> +/// { +/// public: +/// void Visit(RasterBitmap&); // visit a RasterBitmap +/// void Visit(Paragraph &); // visit a Paragraph +/// }; +/// \endcode +/// +/// \par Using const visit functions: +/// +/// Defining the visitable class (true for const): +/// +/// \code +/// class RasterBitmap : public BaseVisitable<void, DefaultCatchAll, true> +/// { +/// public: +/// LOKI_DEFINE_CONST_VISITABLE() +/// }; +/// \endcode +/// +/// Defining the visitor which only calls const member functions: +/// \code +/// class SomeVisitor : +/// public BaseVisitor // required +/// public Visitor<RasterBitmap, void, true>, +/// { +/// public: +/// void Visit(const RasterBitmap&); // visit a RasterBitmap by a const member function +/// }; +/// \endcode +/// +/// \par Example: +/// +/// test/Visitor/main.cpp +//////////////////////////////////////////////////////////////////////////////// + + template <class T, typename R = void, bool ConstVisit = false> + class Visitor; + + template <class T, typename R> + class Visitor<T, R, false> + { + public: + typedef R ReturnType; + typedef T ParamType; + virtual ~Visitor() {} + virtual ReturnType Visit(ParamType&) = 0; + }; + + template <class T, typename R> + class Visitor<T, R, true> + { + public: + typedef R ReturnType; + typedef const T ParamType; + virtual ~Visitor() {} + virtual ReturnType Visit(ParamType&) = 0; + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template Visitor (specialization) +// This specialization is not present in the book. It makes it easier to define +// Visitors for multiple types in a shot by using a typelist. Example: +// +// class SomeVisitor : +// public BaseVisitor // required +// public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)> +// { +// public: +// void Visit(RasterBitmap&); // visit a RasterBitmap +// void Visit(Paragraph &); // visit a Paragraph +// }; +//////////////////////////////////////////////////////////////////////////////// + + template <class Head, class Tail, typename R> + class Visitor<Typelist<Head, Tail>, R, false> + : public Visitor<Head, R, false>, public Visitor<Tail, R, false> + { + public: + typedef R ReturnType; + // using Visitor<Head, R>::Visit; + // using Visitor<Tail, R>::Visit; + }; + + template <class Head, typename R> + class Visitor<Typelist<Head, NullType>, R, false> : public Visitor<Head, R, false> + { + public: + typedef R ReturnType; + using Visitor<Head, R, false>::Visit; + }; + + template <class Head, class Tail, typename R> + class Visitor<Typelist<Head, Tail>, R, true> + : public Visitor<Head, R, true>, public Visitor<Tail, R, true> + { + public: + typedef R ReturnType; + // using Visitor<Head, R>::Visit; + // using Visitor<Tail, R>::Visit; + }; + + template <class Head, typename R> + class Visitor<Typelist<Head, NullType>, R, true> : public Visitor<Head, R, true> + { + public: + typedef R ReturnType; + using Visitor<Head, R, true>::Visit; + }; + + +//////////////////////////////////////////////////////////////////////////////// +// class template BaseVisitorImpl +// Implements non-strict visitation (you can implement only part of the Visit +// functions) +//////////////////////////////////////////////////////////////////////////////// + + template <class TList, typename R = void> class BaseVisitorImpl; + + template <class Head, class Tail, typename R> + class BaseVisitorImpl<Typelist<Head, Tail>, R> + : public Visitor<Head, R> + , public BaseVisitorImpl<Tail, R> + { + public: + // using BaseVisitorImpl<Tail, R>::Visit; + + virtual R Visit(Head&) + { return R(); } + }; + + template <class Head, typename R> + class BaseVisitorImpl<Typelist<Head, NullType>, R> + : public Visitor<Head, R> + { + public: + virtual R Visit(Head&) + { return R(); } + }; + +//////////////////////////////////////////////////////////////////////////////// +// class template BaseVisitable +//////////////////////////////////////////////////////////////////////////////// + +template <typename R, typename Visited> +struct DefaultCatchAll +{ + static R OnUnknownVisitor(Visited&, BaseVisitor&) + { return R(); } +}; + +//////////////////////////////////////////////////////////////////////////////// +// class template BaseVisitable +//////////////////////////////////////////////////////////////////////////////// + + template + < + typename R = void, + template <typename, class> class CatchAll = DefaultCatchAll, + bool ConstVisitable = false + > + class BaseVisitable; + + template<typename R,template <typename, class> class CatchAll> + class BaseVisitable<R, CatchAll, false> + { + public: + typedef R ReturnType; + virtual ~BaseVisitable() {} + virtual ReturnType Accept(BaseVisitor&) = 0; + + protected: // give access only to the hierarchy + template <class T> + static ReturnType AcceptImpl(T& visited, BaseVisitor& guest) + { + // Apply the Acyclic Visitor + if (Visitor<T,R>* p = dynamic_cast<Visitor<T,R>*>(&guest)) + { + return p->Visit(visited); + } + return CatchAll<R, T>::OnUnknownVisitor(visited, guest); + } + }; + + template<typename R,template <typename, class> class CatchAll> + class BaseVisitable<R, CatchAll, true> + { + public: + typedef R ReturnType; + virtual ~BaseVisitable() {} + virtual ReturnType Accept(BaseVisitor&) const = 0; + + protected: // give access only to the hierarchy + template <class T> + static ReturnType AcceptImpl(const T& visited, BaseVisitor& guest) + { + // Apply the Acyclic Visitor + if (Visitor<T,R,true>* p = dynamic_cast<Visitor<T,R,true>*>(&guest)) + { + return p->Visit(visited); + } + return CatchAll<R, T>::OnUnknownVisitor(const_cast<T&>(visited), guest); + } + }; + + +//////////////////////////////////////////////////////////////////////////////// +/// \def LOKI_DEFINE_VISITABLE() +/// \ingroup VisitorGroup +/// Put it in every class that you want to make visitable +/// (in addition to deriving it from BaseVisitable<R>) +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_DEFINE_VISITABLE() \ + virtual ReturnType Accept(::Loki::BaseVisitor& guest) \ + { return AcceptImpl(*this, guest); } + +//////////////////////////////////////////////////////////////////////////////// +/// \def LOKI_DEFINE_CONST_VISITABLE() +/// \ingroup VisitorGroup +/// Put it in every class that you want to make visitable by const member +/// functions (in addition to deriving it from BaseVisitable<R>) +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_DEFINE_CONST_VISITABLE() \ + virtual ReturnType Accept(::Loki::BaseVisitor& guest) const \ + { return AcceptImpl(*this, guest); } + +//////////////////////////////////////////////////////////////////////////////// +/// \class CyclicVisitor +/// +/// \ingroup VisitorGroup +/// Put it in every class that you want to make visitable (in addition to +/// deriving it from BaseVisitable<R> +//////////////////////////////////////////////////////////////////////////////// + + template <typename R, class TList> + class CyclicVisitor : public Visitor<TList, R> + { + public: + typedef R ReturnType; + // using Visitor<TList, R>::Visit; + + template <class Visited> + ReturnType GenericVisit(Visited& host) + { + Visitor<Visited, ReturnType>& subObj = *this; + return subObj.Visit(host); + } + }; + +//////////////////////////////////////////////////////////////////////////////// +/// \def LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor) +/// \ingroup VisitorGroup +/// Put it in every class that you want to make visitable by a cyclic visitor +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor) \ + virtual SomeVisitor::ReturnType Accept(SomeVisitor& guest) \ + { return guest.GenericVisit(*this); } + +} // namespace Loki + + + +#endif // end file guardian + diff --git a/shared/loki/readme.txt b/shared/loki/readme.txt new file mode 100644 index 00000000..a35cf387 --- /dev/null +++ b/shared/loki/readme.txt @@ -0,0 +1,12 @@ +// $Id: readme.txt 753 2006-10-17 19:54:22Z syntheticpp $ + +The Golden Code +KEEPEN DER DAMDDEN FUGGERMUTTENS OTTEN DIS CODDEN FIL + +A compliant C++ compiler will compile all of this code as is. +See the respective vendor directories for code that actually compiles & runs. + +Note: Right now, this code contains CodeWarrior & gcc modifications, +which may be removed at a future point in time +(by moving them to a vendor specific implementation). +MKH
\ No newline at end of file diff --git a/shared/loki/static_check.h b/shared/loki/static_check.h new file mode 100644 index 00000000..51ce389e --- /dev/null +++ b/shared/loki/static_check.h @@ -0,0 +1,45 @@ +//////////////////////////////////////////////////////////////////////////////// +// The Loki Library +// Copyright (c) 2001 by Andrei Alexandrescu +// This code accompanies the book: +// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design +// Patterns Applied". Copyright (c) 2001. Addison-Wesley. +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this +// permission notice appear in supporting documentation. +// The author or Addison-Wesley Longman make no representations about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +//////////////////////////////////////////////////////////////////////////////// +#ifndef LOKI_STATIC_CHECK_INC_ +#define LOKI_STATIC_CHECK_INC_ + +// $Id: static_check.h 752 2006-10-17 19:52:18Z syntheticpp $ + + +namespace Loki +{ +//////////////////////////////////////////////////////////////////////////////// +// Helper structure for the STATIC_CHECK macro +//////////////////////////////////////////////////////////////////////////////// + + template<int> struct CompileTimeError; + template<> struct CompileTimeError<true> {}; +} + +//////////////////////////////////////////////////////////////////////////////// +// macro STATIC_CHECK +// Invocation: STATIC_CHECK(expr, id) +// where: +// expr is a compile-time integral or pointer expression +// id is a C++ identifier that does not need to be defined +// If expr is zero, id will appear in a compile-time error message. +//////////////////////////////////////////////////////////////////////////////// + +#define LOKI_STATIC_CHECK(expr, msg) \ + { Loki::CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; } + + +#endif // end file guardian + diff --git a/shared/shadow.cpp b/shared/shadow.cpp index 02a6a522..da7cfd99 100644 --- a/shared/shadow.cpp +++ b/shared/shadow.cpp @@ -30,9 +30,9 @@ public: private: ShadowlDllHandler() : - createShadowCopy(NULL), - releaseShadowCopy(NULL), - hShadow(NULL) + createShadowCopy(NULL), + releaseShadowCopy(NULL), + hShadow(NULL) { //get a handle to the DLL module containing the required functionality hShadow = ::LoadLibrary(L"Shadow.dll"); @@ -53,7 +53,7 @@ private: ShadowCopy::ShadowCopy() : - backupHandle(NULL) {} + backupHandle(NULL) {} ShadowCopy::~ShadowCopy() diff --git a/shared/shadow.h b/shared/shadow.h index 15fd4d9d..8affdebf 100644 --- a/shared/shadow.h +++ b/shared/shadow.h @@ -11,21 +11,21 @@ header should be used in the windows build only! namespace FreeFileSync { - class ShadowCopy //buffer access to Windows Volume Shadow Copy Service - { - public: - ShadowCopy(); - ~ShadowCopy(); +class ShadowCopy //buffer access to Windows Volume Shadow Copy Service +{ +public: + ShadowCopy(); + ~ShadowCopy(); - Zstring makeShadowCopy(const Zstring& inputFile); //throw(FileError); returns filename on shadow copy + Zstring makeShadowCopy(const Zstring& inputFile); //throw(FileError); returns filename on shadow copy - private: - bool isOkay(); +private: + bool isOkay(); - Zstring realVolumeLast; //buffer last volume name - Zstring shadowVolumeLast; //buffer last created shadow volume - void* backupHandle; - }; + Zstring realVolumeLast; //buffer last volume name + Zstring shadowVolumeLast; //buffer last created shadow volume + void* backupHandle; +}; } #endif // SHADOW_H_INCLUDED diff --git a/shared/standardPaths.cpp b/shared/standardPaths.cpp index 54774673..3d5cfdb5 100644 --- a/shared/standardPaths.cpp +++ b/shared/standardPaths.cpp @@ -2,20 +2,23 @@ #include <wx/stdpaths.h> #include <wx/filename.h> #include "systemConstants.h" +#include "stringConv.h" + +using namespace FreeFileSync; wxString assembleFileForUserData(const wxString fileName) { - static const bool isPortableVersion = !wxFileExists(FreeFileSync::getInstallationDir() + globalFunctions::FILE_NAME_SEPARATOR + wxT("uninstall.exe")); //this check is a bit lame... + static const bool isPortableVersion = !wxFileExists(FreeFileSync::getInstallationDir() + zToWx(globalFunctions::FILE_NAME_SEPARATOR) + wxT("uninstall.exe")); //this check is a bit lame... if (isPortableVersion) //use current working directory - return wxString(wxT(".")) + globalFunctions::FILE_NAME_SEPARATOR + fileName; + return wxString(wxT(".")) + zToWx(globalFunctions::FILE_NAME_SEPARATOR) + fileName; else //usen OS' standard paths { wxString userDirectory = wxStandardPathsBase::Get().GetUserDataDir(); - if (!userDirectory.EndsWith(wxString(globalFunctions::FILE_NAME_SEPARATOR))) - userDirectory += globalFunctions::FILE_NAME_SEPARATOR; + if (!userDirectory.EndsWith(zToWx(globalFunctions::FILE_NAME_SEPARATOR))) + userDirectory += zToWx(globalFunctions::FILE_NAME_SEPARATOR); if (!wxDirExists(userDirectory)) ::wxMkdir(userDirectory); //only top directory needs to be created: no recursion necessary diff --git a/shared/standardPaths.h b/shared/standardPaths.h index 64811246..34f6ab48 100644 --- a/shared/standardPaths.h +++ b/shared/standardPaths.h @@ -9,11 +9,11 @@ namespace FreeFileSync //------------------------------------------------------------------------------ //global functions //------------------------------------------------------------------------------ - const wxString& getGlobalConfigFile(); - const wxString& getDefaultLogDirectory(); - const wxString& getLastErrorTxtFile(); - const wxString& getInstallationDir(); //FreeFileSync installation directory without path separator - const wxString& getConfigDir(); +const wxString& getGlobalConfigFile(); +const wxString& getDefaultLogDirectory(); +const wxString& getLastErrorTxtFile(); +const wxString& getInstallationDir(); //FreeFileSync installation directory without path separator +const wxString& getConfigDir(); //------------------------------------------------------------------------------ } diff --git a/shared/stringConv.h b/shared/stringConv.h new file mode 100644 index 00000000..f4048aab --- /dev/null +++ b/shared/stringConv.h @@ -0,0 +1,104 @@ +#ifndef STRINGCONV_H_INCLUDED +#define STRINGCONV_H_INCLUDED + +#include <wx/string.h> +#include "zstring.h" + +namespace FreeFileSync +{ +//conversion from Zstring to wxString +wxString zToWx(const Zstring& str); +wxString zToWx(const DefaultChar* str); +wxString zToWx(DefaultChar ch); +//conversion from wxString to Zstring +Zstring wxToZ(const wxString& str); +Zstring wxToZ(const wxChar* str); +Zstring wxToZ(wxChar ch); + + + + + + + + + + + + + + + + + + + + + + + + + + + + +//---------------Inline Implementation--------------------------------------------------- +inline +wxString zToWx(const Zstring& str) +{ +#ifdef ZSTRING_CHAR + return wxString::FromUTF8(str.c_str(), str.length()); +#elif defined ZSTRING_WIDE_CHAR + return wxString(str.c_str(), str.length()); +#endif +} + + +inline +wxString zToWx(const DefaultChar* str) +{ +#ifdef ZSTRING_CHAR + return wxString::FromUTF8(str); +#elif defined ZSTRING_WIDE_CHAR + return str; +#endif +} + + +inline +wxString zToWx(DefaultChar ch) +{ + return zToWx(Zstring() + ch); +} + +//----------------------------------------------------------------- +inline +Zstring wxToZ(const wxString& str) +{ +#ifdef ZSTRING_CHAR + return Zstring(str.ToUTF8()); +#elif defined ZSTRING_WIDE_CHAR + return Zstring(str.c_str(), str.length()); +#endif +} + + +inline +Zstring wxToZ(const wxChar* str) +{ +#ifdef ZSTRING_CHAR + return Zstring(wxString(str).ToUTF8()); +#elif defined ZSTRING_WIDE_CHAR + return str; +#endif +} + + +inline +Zstring wxToZ(wxChar ch) +{ + return wxToZ(wxString(ch)); +} +} + +#endif // STRINGCONV_H_INCLUDED diff --git a/shared/systemConstants.h b/shared/systemConstants.h index 84c1ae85..bae23d5a 100644 --- a/shared/systemConstants.h +++ b/shared/systemConstants.h @@ -2,7 +2,7 @@ #define SYSTEMCONSTANTS_H_INCLUDED #include "zstring.h" - +#include <wx/string.h> namespace globalFunctions { @@ -10,11 +10,11 @@ namespace globalFunctions // GLOBALS //------------------------------------------------ #ifdef FFS_WIN - const DefaultChar FILE_NAME_SEPARATOR = '\\'; - static const DefaultChar* const LINE_BREAK = L"\r\n"; //internal linkage +const DefaultChar FILE_NAME_SEPARATOR = '\\'; +static const wxChar* const LINE_BREAK = wxT("\r\n"); //internal linkage #elif defined FFS_LINUX - const DefaultChar FILE_NAME_SEPARATOR = '/'; - static const DefaultChar* const LINE_BREAK = "\n"; +const DefaultChar FILE_NAME_SEPARATOR = '/'; +static const wxChar* const LINE_BREAK = wxT("\n"); #endif } diff --git a/shared/systemFunctions.cpp b/shared/systemFunctions.cpp index 4fd17fc1..3d6915cd 100644 --- a/shared/systemFunctions.cpp +++ b/shared/systemFunctions.cpp @@ -11,27 +11,29 @@ #ifdef FFS_WIN -wxString FreeFileSync::getLastErrorFormatted(const unsigned long lastError) //try to get additional Windows error information +wxString FreeFileSync::getLastErrorFormatted(unsigned long lastError) //try to get additional Windows error information { //determine error code if none was specified - const unsigned long lastErrorCode = lastError == 0 ? ::GetLastError() : lastError; + if (lastError == 0) + lastError = ::GetLastError(); - wxString output = wxString(wxT("Windows Error Code ")) + wxString::Format(wxT("%u"), lastErrorCode); + wxString output = wxString(wxT("Windows Error Code ")) + wxString::Format(wxT("%u"), lastError); WCHAR buffer[1001]; - if (::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK, 0, lastErrorCode, 0, buffer, 1001, NULL) != 0) + if (::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK, 0, lastError, 0, buffer, 1001, NULL) != 0) output += wxString(wxT(": ")) + buffer; return output; } #elif defined FFS_LINUX -wxString FreeFileSync::getLastErrorFormatted(const int lastError) //try to get additional Linux error information +wxString FreeFileSync::getLastErrorFormatted(int lastError) //try to get additional Linux error information { //determine error code if none was specified - const int lastErrorCode = lastError == 0 ? errno : lastError; + if (lastError == 0) + lastError = errno; //don't use :: errno is a macro! - wxString output = wxString(wxT("Linux Error Code ")) + wxString::Format(wxT("%i"), lastErrorCode); - output += wxString(wxT(": ")) + ::strerror(lastErrorCode); + wxString output = wxString(wxT("Linux Error Code ")) + wxString::Format(wxT("%i"), lastError); + output += wxString(wxT(": ")) + wxString::FromUTF8(::strerror(lastError)); return output; } #endif diff --git a/shared/systemFunctions.h b/shared/systemFunctions.h index b449d8d2..bfeacdd4 100644 --- a/shared/systemFunctions.h +++ b/shared/systemFunctions.h @@ -8,9 +8,9 @@ namespace FreeFileSync { #ifdef FFS_WIN - wxString getLastErrorFormatted(const unsigned long lastError = 0); //try to get additional Windows error information +wxString getLastErrorFormatted(unsigned long lastError = 0); //try to get additional Windows error information #elif defined FFS_LINUX - wxString getLastErrorFormatted(const int lastError = 0); //try to get additional Linux error information +wxString getLastErrorFormatted(int lastError = 0); //try to get additional Linux error information #endif } diff --git a/shared/tinyxml/tinyxml.cpp b/shared/tinyxml/tinyxml.cpp index aa13deec..033d13be 100644 --- a/shared/tinyxml/tinyxml.cpp +++ b/shared/tinyxml/tinyxml.cpp @@ -504,7 +504,7 @@ const TiXmlDocument* TiXmlNode::GetDocument() const TiXmlElement::TiXmlElement (const char * _value) - : TiXmlNode( TiXmlNode::ELEMENT ) + : TiXmlNode( TiXmlNode::ELEMENT ) { firstChild = lastChild = 0; value = _value; @@ -513,7 +513,7 @@ TiXmlElement::TiXmlElement (const char * _value) #ifdef TIXML_USE_STL TiXmlElement::TiXmlElement( const std::string& _value ) - : TiXmlNode( TiXmlNode::ELEMENT ) + : TiXmlNode( TiXmlNode::ELEMENT ) { firstChild = lastChild = 0; value = _value; @@ -522,7 +522,7 @@ TiXmlElement::TiXmlElement( const std::string& _value ) TiXmlElement::TiXmlElement( const TiXmlElement& copy) - : TiXmlNode( TiXmlNode::ELEMENT ) + : TiXmlNode( TiXmlNode::ELEMENT ) { firstChild = lastChild = 0; copy.CopyTo( this ); @@ -1418,7 +1418,7 @@ TiXmlNode* TiXmlText::Clone() const TiXmlDeclaration::TiXmlDeclaration( const char * _version, const char * _encoding, const char * _standalone ) - : TiXmlNode( TiXmlNode::DECLARATION ) + : TiXmlNode( TiXmlNode::DECLARATION ) { version = _version; encoding = _encoding; @@ -1430,7 +1430,7 @@ TiXmlDeclaration::TiXmlDeclaration( const char * _version, TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, const std::string& _encoding, const std::string& _standalone ) - : TiXmlNode( TiXmlNode::DECLARATION ) + : TiXmlNode( TiXmlNode::DECLARATION ) { version = _version; encoding = _encoding; @@ -1440,7 +1440,7 @@ TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy ) - : TiXmlNode( TiXmlNode::DECLARATION ) + : TiXmlNode( TiXmlNode::DECLARATION ) { copy.CopyTo( this ); } diff --git a/shared/tinyxml/tinyxmlparser.cpp b/shared/tinyxml/tinyxmlparser.cpp index a601016a..503becde 100644 --- a/shared/tinyxml/tinyxmlparser.cpp +++ b/shared/tinyxml/tinyxmlparser.cpp @@ -433,11 +433,11 @@ const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncodi { const char* start = p; while ( p && *p - && ( IsAlphaNum( (unsigned char ) *p, encoding ) - || *p == '_' - || *p == '-' - || *p == '.' - || *p == ':' ) ) + && ( IsAlphaNum( (unsigned char ) *p, encoding ) + || *p == '_' + || *p == '-' + || *p == '.' + || *p == ':' ) ) { //(*name) += *p; // expensive ++p; @@ -588,11 +588,11 @@ bool TiXmlBase::StringEqual( const char* p, } const char* TiXmlBase::ReadText( const char* p, - TIXML_STRING * text, - bool trimWhiteSpace, - const char* endTag, - bool caseInsensitive, - TiXmlEncoding encoding ) + TIXML_STRING * text, + bool trimWhiteSpace, + const char* endTag, + bool caseInsensitive, + TiXmlEncoding encoding ) { *text = ""; if ( !trimWhiteSpace // certain tags always keep whitespace diff --git a/shared/toggleButton.h b/shared/toggleButton.h index b7475e0c..1110ad5d 100644 --- a/shared/toggleButton.h +++ b/shared/toggleButton.h @@ -14,8 +14,8 @@ public: long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = wxButtonNameStr) : - wxBitmapButton(parent, id, bitmap, pos, size, style, validator, name), - active(false) {} + wxBitmapButton(parent, id, bitmap, pos, size, style, validator, name), + active(false) {} void init(const wxBitmap& activeBmp, const wxString& activeTooltip, diff --git a/shared/xmlBase.cpp b/shared/xmlBase.cpp index ba96b663..c098f94a 100644 --- a/shared/xmlBase.cpp +++ b/shared/xmlBase.cpp @@ -43,7 +43,8 @@ xmlAccess::XmlType xmlAccess::getXmlType(const wxString& filename) return XML_OTHER; } catch (const std::exception&) - { //unfortunately TiXml isn't very smart and tries to allocate space for the complete file: length_error exception is thrown for large files! + { + //unfortunately TiXml isn't very smart and tries to allocate space for the complete file: length_error exception is thrown for large files! return XML_OTHER; } diff --git a/shared/xmlBase.h b/shared/xmlBase.h index ed838843..3a01c515 100644 --- a/shared/xmlBase.h +++ b/shared/xmlBase.h @@ -10,108 +10,108 @@ namespace xmlAccess { - enum XmlType - { - XML_GUI_CONFIG, - XML_BATCH_CONFIG, - XML_GLOBAL_SETTINGS, - XML_REAL_CONFIG, - XML_OTHER - }; +enum XmlType +{ + XML_GUI_CONFIG, + XML_BATCH_CONFIG, + XML_GLOBAL_SETTINGS, + XML_REAL_CONFIG, + XML_OTHER +}; - XmlType getXmlType(const wxString& filename); +XmlType getXmlType(const wxString& filename); - bool loadXmlDocument(const wxString& fileName, const XmlType type, TiXmlDocument& document); - void getDefaultXmlDocument(const XmlType type, TiXmlDocument& document); - bool saveXmlDocument(const wxString& fileName, const TiXmlDocument& document); +bool loadXmlDocument(const wxString& fileName, const XmlType type, TiXmlDocument& document); +void getDefaultXmlDocument(const XmlType type, TiXmlDocument& document); +bool saveXmlDocument(const wxString& fileName, const TiXmlDocument& document); //------------------------------------------------------------------------------------------ - //small helper functions - bool readXmlElement(const std::string& name, const TiXmlElement* parent, std::string& output); - bool readXmlElement(const std::string& name, const TiXmlElement* parent, wxString& output); - bool readXmlElement(const std::string& name, const TiXmlElement* parent, int& output); - bool readXmlElement(const std::string& name, const TiXmlElement* parent, unsigned int& output); - bool readXmlElement(const std::string& name, const TiXmlElement* parent, long& output); - bool readXmlElement(const std::string& name, const TiXmlElement* parent, bool& output); - bool readXmlElement(const std::string& name, const TiXmlElement* parent, std::vector<wxString>& output); - - bool readXmlAttribute(const std::string& name, const TiXmlElement* node, std::string& output); - bool readXmlAttribute(const std::string& name, const TiXmlElement* node, wxString& output); - bool readXmlAttribute(const std::string& name, const TiXmlElement* node, int& output); - bool readXmlAttribute(const std::string& name, const TiXmlElement* node, unsigned int& output); - bool readXmlAttribute(const std::string& name, const TiXmlElement* node, bool& output); - - void addXmlElement(const std::string& name, const std::string& value, TiXmlElement* parent); - void addXmlElement(const std::string& name, const wxString& value, TiXmlElement* parent); - void addXmlElement(const std::string& name, const int value, TiXmlElement* parent); - void addXmlElement(const std::string& name, const unsigned int value, TiXmlElement* parent); - void addXmlElement(const std::string& name, const long value, TiXmlElement* parent); - void addXmlElement(const std::string& name, const bool value, TiXmlElement* parent); - void addXmlElement(const std::string& name, const std::vector<wxString>& value, TiXmlElement* parent); - - void addXmlAttribute(const std::string& name, const std::string& value, TiXmlElement* node); - void addXmlAttribute(const std::string& name, const wxString& value, TiXmlElement* node); - void addXmlAttribute(const std::string& name, const int value, TiXmlElement* node); - void addXmlAttribute(const std::string& name, const unsigned int value, TiXmlElement* node); - void addXmlAttribute(const std::string& name, const bool value, TiXmlElement* node); - - - - class XmlParser +//small helper functions +bool readXmlElement(const std::string& name, const TiXmlElement* parent, std::string& output); +bool readXmlElement(const std::string& name, const TiXmlElement* parent, wxString& output); +bool readXmlElement(const std::string& name, const TiXmlElement* parent, int& output); +bool readXmlElement(const std::string& name, const TiXmlElement* parent, unsigned int& output); +bool readXmlElement(const std::string& name, const TiXmlElement* parent, long& output); +bool readXmlElement(const std::string& name, const TiXmlElement* parent, bool& output); +bool readXmlElement(const std::string& name, const TiXmlElement* parent, std::vector<wxString>& output); + +bool readXmlAttribute(const std::string& name, const TiXmlElement* node, std::string& output); +bool readXmlAttribute(const std::string& name, const TiXmlElement* node, wxString& output); +bool readXmlAttribute(const std::string& name, const TiXmlElement* node, int& output); +bool readXmlAttribute(const std::string& name, const TiXmlElement* node, unsigned int& output); +bool readXmlAttribute(const std::string& name, const TiXmlElement* node, bool& output); + +void addXmlElement(const std::string& name, const std::string& value, TiXmlElement* parent); +void addXmlElement(const std::string& name, const wxString& value, TiXmlElement* parent); +void addXmlElement(const std::string& name, const int value, TiXmlElement* parent); +void addXmlElement(const std::string& name, const unsigned int value, TiXmlElement* parent); +void addXmlElement(const std::string& name, const long value, TiXmlElement* parent); +void addXmlElement(const std::string& name, const bool value, TiXmlElement* parent); +void addXmlElement(const std::string& name, const std::vector<wxString>& value, TiXmlElement* parent); + +void addXmlAttribute(const std::string& name, const std::string& value, TiXmlElement* node); +void addXmlAttribute(const std::string& name, const wxString& value, TiXmlElement* node); +void addXmlAttribute(const std::string& name, const int value, TiXmlElement* node); +void addXmlAttribute(const std::string& name, const unsigned int value, TiXmlElement* node); +void addXmlAttribute(const std::string& name, const bool value, TiXmlElement* node); + + + +class XmlParser +{ +public: + XmlParser(const TiXmlElement* rootElement) : root(rootElement) {} + + void logError(const std::string& nodeName); + bool errorsOccured() const; + const wxString getErrorMessageFormatted() const; + +protected: + //another level of indirection: if errors occur during xml parsing they are logged + template <class T> + void readXmlElementLogging(const std::string& name, const TiXmlElement* parent, T& output) { - public: - XmlParser(const TiXmlElement* rootElement) : root(rootElement) {} - - void logError(const std::string& nodeName); - bool errorsOccured() const; - const wxString getErrorMessageFormatted() const; - - protected: - //another level of indirection: if errors occur during xml parsing they are logged - template <class T> - void readXmlElementLogging(const std::string& name, const TiXmlElement* parent, T& output) - { - if (!readXmlElement(name, parent, output)) - logError(name); - } - - template <class T> - void readXmlAttributeLogging(const std::string& name, const TiXmlElement* node, T& output) - { - if (!readXmlAttribute(name, node, output)) - logError(name); - } - - const TiXmlElement* const root; - std::vector<wxString> failedNodes; - }; + if (!readXmlElement(name, parent, output)) + logError(name); + } + template <class T> + void readXmlAttributeLogging(const std::string& name, const TiXmlElement* node, T& output) + { + if (!readXmlAttribute(name, node, output)) + logError(name); + } - class XmlError //Exception class + const TiXmlElement* const root; + std::vector<wxString> failedNodes; +}; + + +class XmlError //Exception class +{ +public: + enum Severity { - public: - enum Severity - { - WARNING = 77, - FATAL - }; - - XmlError(const wxString& message, Severity sev = FATAL) : errorMessage(message), m_severity(sev) {} - - const wxString& show() const - { - return errorMessage; - } - Severity getSeverity() const - { - return m_severity; - } - private: - const wxString errorMessage; - const Severity m_severity; + WARNING = 77, + FATAL }; + + XmlError(const wxString& message, Severity sev = FATAL) : errorMessage(message), m_severity(sev) {} + + const wxString& show() const + { + return errorMessage; + } + Severity getSeverity() const + { + return m_severity; + } +private: + const wxString errorMessage; + const Severity m_severity; +}; } diff --git a/shared/zstring.cpp b/shared/zstring.cpp index 6b2b68c6..9909abb9 100644 --- a/shared/zstring.cpp +++ b/shared/zstring.cpp @@ -1,8 +1,8 @@ #include "zstring.h" +#include <stdexcept> #ifdef FFS_WIN #include <wx/msw/wrapwin.h> //includes "windows.h" -#include <stdexcept> #endif //FFS_WIN #ifdef __WXDEBUG__ @@ -27,12 +27,12 @@ AllocationCount::~AllocationCount() leakingStrings += wxT("\"\n"); } - MessageBox(NULL, wxString(wxT("Memory leak detected! (No problem if it occurs while Unit testing only!)")) + wxT("\n\n") + MessageBox(NULL, wxString(wxT("Memory leak detected!")) + wxT("\n\n") + wxT("Candidates:\n") + leakingStrings, wxString::Format(wxT("%i"), activeStrings.size()), 0); } #else - std::abort(); + throw std::logic_error("Memory leak!"); #endif } @@ -198,7 +198,8 @@ Zstring& Zstring::Trim(bool fromRight) if (descr->refCount > 1) //allocate new string *this = Zstring(cursor, thisLen - diff); else - { //overwrite this string + { + //overwrite this string ::memmove(strBegin, cursor, (thisLen - diff + 1) * sizeof(DefaultChar)); //note: do not simply let data point to different location: this corrupts reserve()! descr->length -= diff; } @@ -307,7 +308,8 @@ Zstring& Zstring::replace(size_t pos1, size_t n1, const DefaultChar* str, size_t const size_t newLen = oldLen - n1 + n2; if (newLen > oldLen || descr->refCount > 1) - { //allocate a new string + { + //allocate a new string StringDescriptor* newDescr = allocate(newLen); //assemble new string with replacement @@ -342,7 +344,8 @@ Zstring& Zstring::operator=(const DefaultChar* source) if (descr->refCount > 1 || descr->capacity < sourceLen) //allocate new string *this = Zstring(source, sourceLen); else - { //overwrite this string + { + //overwrite this string ::memcpy(data(), source, (sourceLen + 1) * sizeof(DefaultChar)); //include null-termination descr->length = sourceLen; } @@ -355,7 +358,8 @@ Zstring& Zstring::assign(const DefaultChar* source, size_t len) if (descr->refCount > 1 || descr->capacity < len) //allocate new string *this = Zstring(source, len); else - { //overwrite this string + { + //overwrite this string ::memcpy(data(), source, len * sizeof(DefaultChar)); //don't know if source is null-terminated data()[len] = 0; //include null-termination descr->length = len; @@ -412,7 +416,8 @@ void Zstring::reserve(size_t capacityNeeded) //make unshared and check capacity assert(capacityNeeded != 0); if (descr->refCount > 1) - { //allocate a new string + { + //allocate a new string const size_t oldLength = length(); assert(oldLength <= getCapacityToAllocate(capacityNeeded)); @@ -425,7 +430,8 @@ void Zstring::reserve(size_t capacityNeeded) //make unshared and check capacity descr = newDescr; } else if (descr->capacity < capacityNeeded) - { //try to resize the current string (allocate anew if necessary) + { + //try to resize the current string (allocate anew if necessary) const size_t newCapacity = getCapacityToAllocate(capacityNeeded); #ifdef __WXDEBUG__ diff --git a/shared/zstring.h b/shared/zstring.h index 018ca42e..9c7c2245 100644 --- a/shared/zstring.h +++ b/shared/zstring.h @@ -13,6 +13,7 @@ #include <new> #include <stdlib.h> #include <vector> +#include <sstream> #ifdef __WXDEBUG__ #include <set> @@ -22,8 +23,10 @@ #ifdef ZSTRING_CHAR typedef char DefaultChar; //use char strings +#define DefaultStr(x) x // #elif defined ZSTRING_WIDE_CHAR typedef wchar_t DefaultChar; //use wide character strings +#define DefaultStr(x) L ## x // #endif @@ -123,6 +126,10 @@ private: }; +template <class T> +Zstring numberToZstring(const T& number); //convert number to Zstring + + //####################################################################################### //begin of implementation @@ -146,13 +153,13 @@ int defaultCompare(const char* str1, const char* str2, const size_t count) } inline -char* defaultStrFind(const char* str1, const char* str2) +const char* defaultStrFind(const char* str1, const char* str2) { return strstr(str1, str2); } inline -char* defaultStrFind(const char* str1, int ch) +const char* defaultStrFind(const char* str1, int ch) { return strchr(str1, ch); } @@ -236,6 +243,7 @@ public: private: AllocationCount() {} + AllocationCount(const AllocationCount&); ~AllocationCount(); wxCriticalSection lockActStrings; @@ -253,11 +261,12 @@ size_t getCapacityToAllocate(const size_t length) inline Zstring::StringDescriptor* Zstring::allocate(const size_t newLength) -{ //allocate and set data for new string +{ + //allocate and set data for new string const size_t newCapacity = getCapacityToAllocate(newLength); assert(newCapacity); - StringDescriptor* newDescr = static_cast<StringDescriptor*>(::malloc(sizeof(StringDescriptor) + (newCapacity + 1) * sizeof(DefaultChar))); //use C-memory functions because of realloc() + StringDescriptor* const newDescr = static_cast<StringDescriptor*>(::malloc(sizeof(StringDescriptor) + (newCapacity + 1) * sizeof(DefaultChar))); //use C-memory functions because of realloc() if (newDescr == NULL) throw std::bad_alloc(); @@ -288,6 +297,7 @@ Zstring::Zstring() inline + Zstring::Zstring(const DefaultChar* source) { initAndCopy(source, defaultLength(source)); @@ -671,4 +681,17 @@ const Zstring Zstring::operator+(const DefaultChar ch) const } +template <class T> +inline +Zstring numberToZstring(const T& number) //convert number to string the C++ way +{ +#ifdef ZSTRING_CHAR + std::stringstream ss; +#elif defined ZSTRING_WIDE_CHAR + std::wstringstream ss; +#endif + ss << number; + return Zstring(ss.str().c_str(), ss.str().length()); +} + #endif // ZSTRING_H_INCLUDED |