Tricks of the Windows Game Programming Gurus (2nd Edition)

home *** CD-ROM | disk | FTP | other *** search

/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / mfc / include / afx.h next >

Wrap

C/C++ Source or Header | 1998-06-16 | 58.7 KB | 1,987 lines

// This is a part of the Microsoft Foundation Classes C++ library. // Copyright (C) 1992-1998 Microsoft Corporation // All rights reserved. // // This source code is only intended as a supplement to the // Microsoft Foundation Classes Reference and related // electronic documentation provided with the library. // See these sources for detailed information regarding the // Microsoft Foundation Classes product. #ifndef __AFX_H__ #define __AFX_H__ #ifndef __cplusplus #error MFC requires C++ compilation (use a .cpp suffix) #endif ///////////////////////////////////////////////////////////////////////////// #ifdef _AFX_MINREBUILD #pragma component(minrebuild, off) #endif #ifndef _AFX_FULLTYPEINFO #pragma component(mintypeinfo, on) #endif #include <afxver_.h> // Target version control #ifndef _AFX_NOFORCE_LIBS ///////////////////////////////////////////////////////////////////////////// // Win32 libraries #ifndef _AFXDLL #ifndef _UNICODE #ifdef _DEBUG #pragma comment(lib, "nafxcwd.lib") #else #pragma comment(lib, "nafxcw.lib") #endif #else #ifdef _DEBUG #pragma comment(lib, "uafxcwd.lib") #else #pragma comment(lib, "uafxcw.lib") #endif #endif #else #ifndef _UNICODE #ifdef _DEBUG #pragma comment(lib, "mfc42d.lib") #pragma comment(lib, "mfcs42d.lib") #else #pragma comment(lib, "mfc42.lib") #pragma comment(lib, "mfcs42.lib") #endif #else #ifdef _DEBUG #pragma comment(lib, "mfc42ud.lib") #pragma comment(lib, "mfcs42ud.lib") #else #pragma comment(lib, "mfc42u.lib") #pragma comment(lib, "mfcs42u.lib") #endif #endif #endif #ifdef _DLL #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) #pragma comment(lib, "msvcrtd.lib") #else #pragma comment(lib, "msvcrt.lib") #endif #else #ifdef _MT #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) #pragma comment(lib, "libcmtd.lib") #else #pragma comment(lib, "libcmt.lib") #endif #else #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) #pragma comment(lib, "libcd.lib") #else #pragma comment(lib, "libc.lib") #endif #endif #endif #pragma comment(lib, "kernel32.lib") #pragma comment(lib, "user32.lib") #pragma comment(lib, "gdi32.lib") #pragma comment(lib, "comdlg32.lib") #pragma comment(lib, "winspool.lib") #pragma comment(lib, "advapi32.lib") #pragma comment(lib, "shell32.lib") #pragma comment(lib, "comctl32.lib") // force inclusion of NOLIB.OBJ for /disallowlib directives #pragma comment(linker, "/include:__afxForceEXCLUDE") // force inclusion of DLLMODUL.OBJ for _USRDLL #ifdef _USRDLL #pragma comment(linker, "/include:__afxForceUSRDLL") #endif // force inclusion of STDAFX.OBJ for precompiled types #ifdef _AFXDLL #pragma comment(linker, "/include:__afxForceSTDAFX") #endif #endif //!_AFX_NOFORCE_LIBS ///////////////////////////////////////////////////////////////////////////// // Classes declared in this file // in addition to standard primitive data types and various helper macros struct CRuntimeClass; // object type information class CObject; // the root of all objects classes class CException; // the root of all exceptions class CArchiveException; // archive exception class CFileException; // file exception class CSimpleException; class CMemoryException; // out-of-memory exception class CNotSupportedException; // feature not supported exception class CFile; // raw binary file class CStdioFile; // buffered stdio text/binary file class CMemFile; // memory based file // Non CObject classes class CString; // growable string type class CTimeSpan; // time/date difference class CTime; // absolute time/date struct CFileStatus; // file status information struct CMemoryState; // diagnostic memory support class CArchive; // object persistence tool class CDumpContext; // object diagnostic dumping ///////////////////////////////////////////////////////////////////////////// // Other includes from standard "C" runtimes #ifndef _INC_STRING #include <string.h> #endif #ifndef _INC_STDIO #include <stdio.h> #endif #ifndef _INC_STDLIB #include <stdlib.h> #endif #ifndef _INC_TIME #include <time.h> #endif #ifndef _INC_LIMITS #include <limits.h> #endif #ifndef _INC_STDDEF #include <stddef.h> #endif #ifndef _INC_STDARG #include <stdarg.h> #endif #ifndef _AFX_NO_DEBUG_CRT #ifndef _INC_CRTDBG #include <crtdbg.h> #endif #endif // _AFX_NO_DEBUG_CRT #ifdef _AFX_OLD_EXCEPTIONS // use setjmp and helper functions instead of C++ keywords #ifndef _INC_SETJMP #pragma warning(disable: 4611) #include <setjmp.h> #endif #endif #ifdef _AFX_PACKING #pragma pack(push, _AFX_PACKING) #endif ///////////////////////////////////////////////////////////////////////////// // Basic types // abstract iteration position struct __POSITION { }; typedef __POSITION* POSITION; struct _AFX_DOUBLE { BYTE doubleBits[sizeof(double)]; }; struct _AFX_FLOAT { BYTE floatBits[sizeof(float)]; }; // Standard constants #undef FALSE #undef TRUE #undef NULL #define FALSE 0 #define TRUE 1 #define NULL 0 ///////////////////////////////////////////////////////////////////////////// // Diagnostic support #ifdef _DEBUG BOOL AFXAPI AfxAssertFailedLine(LPCSTR lpszFileName, int nLine); void AFX_CDECL AfxTrace(LPCTSTR lpszFormat, ...); // Note: file names are still ANSI strings (filenames rarely need UNICODE) void AFXAPI AfxAssertValidObject(const CObject* pOb, LPCSTR lpszFileName, int nLine); void AFXAPI AfxDump(const CObject* pOb); // Dump an object from CodeView #define TRACE ::AfxTrace #define THIS_FILE __FILE__ #define ASSERT(f) \ do \ { \ if (!(f) && AfxAssertFailedLine(THIS_FILE, __LINE__)) \ AfxDebugBreak(); \ } while (0) \ #define VERIFY(f) ASSERT(f) #define ASSERT_VALID(pOb) (::AfxAssertValidObject(pOb, THIS_FILE, __LINE__)) #define DEBUG_ONLY(f) (f) // The following trace macros are provided for backward compatiblity // (they also take a fixed number of parameters which provides // some amount of extra error checking) #define TRACE0(sz) ::AfxTrace(_T("%s"), _T(sz)) #define TRACE1(sz, p1) ::AfxTrace(_T(sz), p1) #define TRACE2(sz, p1, p2) ::AfxTrace(_T(sz), p1, p2) #define TRACE3(sz, p1, p2, p3) ::AfxTrace(_T(sz), p1, p2, p3) // These AFX_DUMP macros also provided for backward compatibility #define AFX_DUMP0(dc, sz) dc << _T(sz) #define AFX_DUMP1(dc, sz, p1) dc << _T(sz) << p1 #else // _DEBUG #define ASSERT(f) ((void)0) #define VERIFY(f) ((void)(f)) #define ASSERT_VALID(pOb) ((void)0) #define DEBUG_ONLY(f) ((void)0) inline void AFX_CDECL AfxTrace(LPCTSTR, ...) { } #define TRACE 1 ? (void)0 : ::AfxTrace #define TRACE0(sz) #define TRACE1(sz, p1) #define TRACE2(sz, p1, p2) #define TRACE3(sz, p1, p2, p3) #endif // !_DEBUG #define ASSERT_POINTER(p, type) \ ASSERT(((p) != NULL) && AfxIsValidAddress((p), sizeof(type), FALSE)) #define ASSERT_NULL_OR_POINTER(p, type) \ ASSERT(((p) == NULL) || AfxIsValidAddress((p), sizeof(type), FALSE)) ///////////////////////////////////////////////////////////////////////////// // Turn off warnings for /W4 // To resume any of these warning: #pragma warning(default: 4xxx) // which should be placed after the AFX include files #ifndef ALL_WARNINGS // warnings generated with common MFC/Windows code #pragma warning(disable: 4127) // constant expression for TRACE/ASSERT #pragma warning(disable: 4134) // message map member fxn casts #pragma warning(disable: 4201) // nameless unions are part of C++ #pragma warning(disable: 4511) // private copy constructors are good to have #pragma warning(disable: 4512) // private operator= are good to have #pragma warning(disable: 4514) // unreferenced inlines are common #pragma warning(disable: 4710) // private constructors are disallowed #pragma warning(disable: 4705) // statement has no effect in optimized code #pragma warning(disable: 4191) // pointer-to-function casting // warnings caused by normal optimizations #ifndef _DEBUG #pragma warning(disable: 4701) // local variable *may* be used without init #pragma warning(disable: 4702) // unreachable code caused by optimizations #pragma warning(disable: 4791) // loss of debugging info in release version #pragma warning(disable: 4189) // initialized but unused variable #pragma warning(disable: 4390) // empty controlled statement #endif // warnings specific to _AFXDLL version #ifdef _AFXDLL #pragma warning(disable: 4204) // non-constant aggregate initializer #endif #ifdef _AFXDLL #pragma warning(disable: 4275) // deriving exported class from non-exported #pragma warning(disable: 4251) // using non-exported as public in exported #endif #endif //!ALL_WARNINGS #ifdef _DEBUG #define UNUSED(x) #else #define UNUSED(x) x #endif #define UNUSED_ALWAYS(x) x ///////////////////////////////////////////////////////////////////////////// // Other implementation helpers #define BEFORE_START_POSITION ((POSITION)-1L) ///////////////////////////////////////////////////////////////////////////// // explicit initialization for general purpose classes BOOL AFXAPI AfxInitialize(BOOL bDLL = FALSE, DWORD dwVersion = _MFC_VER); #undef AFX_DATA #define AFX_DATA AFX_CORE_DATA ///////////////////////////////////////////////////////////////////////////// // Basic object model struct CRuntimeClass { // Attributes LPCSTR m_lpszClassName; int m_nObjectSize; UINT m_wSchema; // schema number of the loaded class CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class #ifdef _AFXDLL CRuntimeClass* (PASCAL* m_pfnGetBaseClass)(); #else CRuntimeClass* m_pBaseClass; #endif // Operations CObject* CreateObject(); BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const; // Implementation void Store(CArchive& ar) const; static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum); // CRuntimeClass objects linked together in simple list CRuntimeClass* m_pNextClass; // linked list of registered classes }; ///////////////////////////////////////////////////////////////////////////// // Strings #ifndef _OLEAUTO_H_ #ifdef OLE2ANSI typedef LPSTR BSTR; #else typedef LPWSTR BSTR;// must (semantically) match typedef in oleauto.h #endif #endif struct CStringData { long nRefs; // reference count int nDataLength; // length of data (including terminator) int nAllocLength; // length of allocation // TCHAR data[nAllocLength] TCHAR* data() // TCHAR* to managed data { return (TCHAR*)(this+1); } }; class CString { public: // Constructors // constructs empty CString CString(); // copy constructor CString(const CString& stringSrc); // from a single character CString(TCHAR ch, int nRepeat = 1); // from an ANSI string (converts to TCHAR) CString(LPCSTR lpsz); // from a UNICODE string (converts to TCHAR) CString(LPCWSTR lpsz); // subset of characters from an ANSI string (converts to TCHAR) CString(LPCSTR lpch, int nLength); // subset of characters from a UNICODE string (converts to TCHAR) CString(LPCWSTR lpch, int nLength); // from unsigned characters CString(const unsigned char* psz); // Attributes & Operations // get data length int GetLength() const; // TRUE if zero length BOOL IsEmpty() const; // clear contents to empty void Empty(); // return single character at zero-based index TCHAR GetAt(int nIndex) const; // return single character at zero-based index TCHAR operator[](int nIndex) const; // set a single character at zero-based index void SetAt(int nIndex, TCHAR ch); // return pointer to const string operator LPCTSTR() const; // overloaded assignment // ref-counted copy from another CString const CString& operator=(const CString& stringSrc); // set string content to single character const CString& operator=(TCHAR ch); #ifdef _UNICODE const CString& operator=(char ch); #endif // copy string content from ANSI string (converts to TCHAR) const CString& operator=(LPCSTR lpsz); // copy string content from UNICODE string (converts to TCHAR) const CString& operator=(LPCWSTR lpsz); // copy string content from unsigned chars const CString& operator=(const unsigned char* psz); // string concatenation // concatenate from another CString const CString& operator+=(const CString& string); // concatenate a single character const CString& operator+=(TCHAR ch); #ifdef _UNICODE // concatenate an ANSI character after converting it to TCHAR const CString& operator+=(char ch); #endif // concatenate a UNICODE character after converting it to TCHAR const CString& operator+=(LPCTSTR lpsz); friend CString AFXAPI operator+(const CString& string1, const CString& string2); friend CString AFXAPI operator+(const CString& string, TCHAR ch); friend CString AFXAPI operator+(TCHAR ch, const CString& string); #ifdef _UNICODE friend CString AFXAPI operator+(const CString& string, char ch); friend CString AFXAPI operator+(char ch, const CString& string); #endif friend CString AFXAPI operator+(const CString& string, LPCTSTR lpsz); friend CString AFXAPI operator+(LPCTSTR lpsz, const CString& string); // string comparison // straight character comparison int Compare(LPCTSTR lpsz) const; // compare ignoring case int CompareNoCase(LPCTSTR lpsz) const; // NLS aware comparison, case sensitive int Collate(LPCTSTR lpsz) const; // NLS aware comparison, case insensitive int CollateNoCase(LPCTSTR lpsz) const; // simple sub-string extraction // return nCount characters starting at zero-based nFirst CString Mid(int nFirst, int nCount) const; // return all characters starting at zero-based nFirst CString Mid(int nFirst) const; // return first nCount characters in string CString Left(int nCount) const; // return nCount characters from end of string CString Right(int nCount) const; // characters from beginning that are also in passed string CString SpanIncluding(LPCTSTR lpszCharSet) const; // characters from beginning that are not also in passed string CString SpanExcluding(LPCTSTR lpszCharSet) const; // upper/lower/reverse conversion // NLS aware conversion to uppercase void MakeUpper(); // NLS aware conversion to lowercase void MakeLower(); // reverse string right-to-left void MakeReverse(); // trimming whitespace (either side) // remove whitespace starting from right edge void TrimRight(); // remove whitespace starting from left side void TrimLeft(); // trimming anything (either side) // remove continuous occurrences of chTarget starting from right void TrimRight(TCHAR chTarget); // remove continuous occcurrences of characters in passed string, // starting from right void TrimRight(LPCTSTR lpszTargets); // remove continuous occurrences of chTarget starting from left void TrimLeft(TCHAR chTarget); // remove continuous occcurrences of characters in // passed string, starting from left void TrimLeft(LPCTSTR lpszTargets); // advanced manipulation // replace occurrences of chOld with chNew int Replace(TCHAR chOld, TCHAR chNew); // replace occurrences of substring lpszOld with lpszNew; // empty lpszNew removes instances of lpszOld int Replace(LPCTSTR lpszOld, LPCTSTR lpszNew); // remove occurrences of chRemove int Remove(TCHAR chRemove); // insert character at zero-based index; concatenates // if index is past end of string int Insert(int nIndex, TCHAR ch); // insert substring at zero-based index; concatenates // if index is past end of string int Insert(int nIndex, LPCTSTR pstr); // delete nCount characters starting at zero-based index int Delete(int nIndex, int nCount = 1); // searching // find character starting at left, -1 if not found int Find(TCHAR ch) const; // find character starting at right int ReverseFind(TCHAR ch) const; // find character starting at zero-based index and going right int Find(TCHAR ch, int nStart) const; // find first instance of any character in passed string int FindOneOf(LPCTSTR lpszCharSet) const; // find first instance of substring int Find(LPCTSTR lpszSub) const; // find first instance of substring starting at zero-based index int Find(LPCTSTR lpszSub, int nStart) const; // simple formatting // printf-like formatting using passed string void AFX_CDECL Format(LPCTSTR lpszFormat, ...); // printf-like formatting using referenced string resource void AFX_CDECL Format(UINT nFormatID, ...); // printf-like formatting using variable arguments parameter void FormatV(LPCTSTR lpszFormat, va_list argList); // formatting for localization (uses FormatMessage API) // format using FormatMessage API on passed string void AFX_CDECL FormatMessage(LPCTSTR lpszFormat, ...); // format using FormatMessage API on referenced string resource void AFX_CDECL FormatMessage(UINT nFormatID, ...); // input and output #ifdef _DEBUG friend CDumpContext& AFXAPI operator<<(CDumpContext& dc, const CString& string); #endif friend CArchive& AFXAPI operator<<(CArchive& ar, const CString& string); friend CArchive& AFXAPI operator>>(CArchive& ar, CString& string); // load from string resource BOOL LoadString(UINT nID); #ifndef _UNICODE // ANSI <-> OEM support (convert string in place) // convert string from ANSI to OEM in-place void AnsiToOem(); // convert string from OEM to ANSI in-place void OemToAnsi(); #endif #ifndef _AFX_NO_BSTR_SUPPORT // OLE BSTR support (use for OLE automation) // return a BSTR initialized with this CString's data BSTR AllocSysString() const; // reallocates the passed BSTR, copies content of this CString to it BSTR SetSysString(BSTR* pbstr) const; #endif // Access to string implementation buffer as "C" character array // get pointer to modifiable buffer at least as long as nMinBufLength LPTSTR GetBuffer(int nMinBufLength); // release buffer, setting length to nNewLength (or to first nul if -1) void ReleaseBuffer(int nNewLength = -1); // get pointer to modifiable buffer exactly as long as nNewLength LPTSTR GetBufferSetLength(int nNewLength); // release memory allocated to but unused by string void FreeExtra(); // Use LockBuffer/UnlockBuffer to turn refcounting off // turn refcounting back on LPTSTR LockBuffer(); // turn refcounting off void UnlockBuffer(); // Implementation public: ~CString(); int GetAllocLength() const; protected: LPTSTR m_pchData; // pointer to ref counted string data // implementation helpers CStringData* GetData() const; void Init(); void AllocCopy(CString& dest, int nCopyLen, int nCopyIndex, int nExtraLen) const; void AllocBuffer(int nLen); void AssignCopy(int nSrcLen, LPCTSTR lpszSrcData); void ConcatCopy(int nSrc1Len, LPCTSTR lpszSrc1Data, int nSrc2Len, LPCTSTR lpszSrc2Data); void ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData); void CopyBeforeWrite(); void AllocBeforeWrite(int nLen); void Release(); static void PASCAL Release(CStringData* pData); static int PASCAL SafeStrlen(LPCTSTR lpsz); static void FASTCALL FreeData(CStringData* pData); }; // Compare helpers bool AFXAPI operator==(const CString& s1, const CString& s2); bool AFXAPI operator==(const CString& s1, LPCTSTR s2); bool AFXAPI operator==(LPCTSTR s1, const CString& s2); bool AFXAPI operator!=(const CString& s1, const CString& s2); bool AFXAPI operator!=(const CString& s1, LPCTSTR s2); bool AFXAPI operator!=(LPCTSTR s1, const CString& s2); bool AFXAPI operator<(const CString& s1, const CString& s2); bool AFXAPI operator<(const CString& s1, LPCTSTR s2); bool AFXAPI operator<(LPCTSTR s1, const CString& s2); bool AFXAPI operator>(const CString& s1, const CString& s2); bool AFXAPI operator>(const CString& s1, LPCTSTR s2); bool AFXAPI operator>(LPCTSTR s1, const CString& s2); bool AFXAPI operator<=(const CString& s1, const CString& s2); bool AFXAPI operator<=(const CString& s1, LPCTSTR s2); bool AFXAPI operator<=(LPCTSTR s1, const CString& s2); bool AFXAPI operator>=(const CString& s1, const CString& s2); bool AFXAPI operator>=(const CString& s1, LPCTSTR s2); bool AFXAPI operator>=(LPCTSTR s1, const CString& s2); // conversion helpers int AFX_CDECL _wcstombsz(char* mbstr, const wchar_t* wcstr, size_t count); int AFX_CDECL _mbstowcsz(wchar_t* wcstr, const char* mbstr, size_t count); // Globals extern AFX_DATA TCHAR afxChNil; #ifdef _AFXDLL const CString& AFXAPI AfxGetEmptyString(); #define afxEmptyString AfxGetEmptyString() #else extern LPCTSTR _afxPchNil; #define afxEmptyString ((CString&)*(CString*)&_afxPchNil) #endif ///////////////////////////////////////////////////////////////////////////// // class CObject is the root of all compliant objects #ifdef _AFXDLL class CObject #else class AFX_NOVTABLE CObject #endif { public: // Object model (types, destruction, allocation) virtual CRuntimeClass* GetRuntimeClass() const; virtual ~CObject(); // virtual destructors are necessary // Diagnostic allocations void* PASCAL operator new(size_t nSize); void* PASCAL operator new(size_t, void* p); void PASCAL operator delete(void* p); #if _MSC_VER >= 1200 void PASCAL operator delete(void* p, void* pPlace); #endif #if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT) // for file name/line number tracking using DEBUG_NEW void* PASCAL operator new(size_t nSize, LPCSTR lpszFileName, int nLine); #if _MSC_VER >= 1200 void PASCAL operator delete(void *p, LPCSTR lpszFileName, int nLine); #endif #endif // Disable the copy constructor and assignment by default so you will get // compiler errors instead of unexpected behaviour if you pass objects // by value or assign objects. protected: CObject(); private: CObject(const CObject& objectSrc); // no implementation void operator=(const CObject& objectSrc); // no implementation // Attributes public: BOOL IsSerializable() const; BOOL IsKindOf(const CRuntimeClass* pClass) const; // Overridables virtual void Serialize(CArchive& ar); #if defined(_DEBUG) || defined(_AFXDLL) // Diagnostic Support virtual void AssertValid() const; virtual void Dump(CDumpContext& dc) const; #endif // Implementation public: static const AFX_DATA CRuntimeClass classCObject; #ifdef _AFXDLL static CRuntimeClass* PASCAL _GetBaseClass(); #endif }; // Helper macros #define RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name)) #define ASSERT_KINDOF(class_name, object) \ ASSERT((object)->IsKindOf(RUNTIME_CLASS(class_name))) // RTTI helper macros/functions const CObject* AFX_CDECL AfxDynamicDownCast(CRuntimeClass* pClass, const CObject* pObject); CObject* AFX_CDECL AfxDynamicDownCast(CRuntimeClass* pClass, CObject* pObject); #define DYNAMIC_DOWNCAST(class_name, object) \ (class_name*)AfxDynamicDownCast(RUNTIME_CLASS(class_name), object) #ifdef _DEBUG const CObject* AFX_CDECL AfxStaticDownCast(CRuntimeClass* pClass, const CObject* pObject); CObject* AFX_CDECL AfxStaticDownCast(CRuntimeClass* pClass, CObject* pObject); #define STATIC_DOWNCAST(class_name, object) \ ((class_name*)AfxStaticDownCast(RUNTIME_CLASS(class_name), object)) #else #define STATIC_DOWNCAST(class_name, object) ((class_name*)object) #endif ////////////////////////////////////////////////////////////////////////////// // Helper macros for declaring CRuntimeClass compatible classes #ifdef _AFXDLL #define DECLARE_DYNAMIC(class_name) \ protected: \ static CRuntimeClass* PASCAL _GetBaseClass(); \ public: \ static const AFX_DATA CRuntimeClass class##class_name; \ virtual CRuntimeClass* GetRuntimeClass() const; \ #define _DECLARE_DYNAMIC(class_name) \ protected: \ static CRuntimeClass* PASCAL _GetBaseClass(); \ public: \ static AFX_DATA CRuntimeClass class##class_name; \ virtual CRuntimeClass* GetRuntimeClass() const; \ #else #define DECLARE_DYNAMIC(class_name) \ public: \ static const AFX_DATA CRuntimeClass class##class_name; \ virtual CRuntimeClass* GetRuntimeClass() const; \ #define _DECLARE_DYNAMIC(class_name) \ public: \ static AFX_DATA CRuntimeClass class##class_name; \ virtual CRuntimeClass* GetRuntimeClass() const; \ #endif // not serializable, but dynamically constructable #define DECLARE_DYNCREATE(class_name) \ DECLARE_DYNAMIC(class_name) \ static CObject* PASCAL CreateObject(); #define _DECLARE_DYNCREATE(class_name) \ _DECLARE_DYNAMIC(class_name) \ static CObject* PASCAL CreateObject(); #define DECLARE_SERIAL(class_name) \ _DECLARE_DYNCREATE(class_name) \ AFX_API friend CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb); // generate static object constructor for class registration void AFXAPI AfxClassInit(CRuntimeClass* pNewClass); struct AFX_CLASSINIT { AFX_CLASSINIT(CRuntimeClass* pNewClass) { AfxClassInit(pNewClass); } }; struct AFX_CLASSINIT_COMPAT { AFX_CLASSINIT_COMPAT(CRuntimeClass* pNewClass); }; #ifdef _AFXDLL #define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ CRuntimeClass* PASCAL class_name::_GetBaseClass() \ { return RUNTIME_CLASS(base_class_name); } \ AFX_COMDAT const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ #class_name, sizeof(class class_name), wSchema, pfnNew, \ &class_name::_GetBaseClass, NULL }; \ CRuntimeClass* class_name::GetRuntimeClass() const \ { return RUNTIME_CLASS(class_name); } \ #define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ CRuntimeClass* PASCAL class_name::_GetBaseClass() \ { return RUNTIME_CLASS(base_class_name); } \ AFX_COMDAT AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ #class_name, sizeof(class class_name), wSchema, pfnNew, \ &class_name::_GetBaseClass, NULL }; \ CRuntimeClass* class_name::GetRuntimeClass() const \ { return RUNTIME_CLASS(class_name); } \ #else #define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ AFX_COMDAT const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ #class_name, sizeof(class class_name), wSchema, pfnNew, \ RUNTIME_CLASS(base_class_name), NULL }; \ CRuntimeClass* class_name::GetRuntimeClass() const \ { return RUNTIME_CLASS(class_name); } \ #define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ #class_name, sizeof(class class_name), wSchema, pfnNew, \ RUNTIME_CLASS(base_class_name), NULL }; \ CRuntimeClass* class_name::GetRuntimeClass() const \ { return RUNTIME_CLASS(class_name); } \ #endif #define IMPLEMENT_DYNAMIC(class_name, base_class_name) \ IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL) #define IMPLEMENT_DYNCREATE(class_name, base_class_name) \ CObject* PASCAL class_name::CreateObject() \ { return new class_name; } \ IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \ class_name::CreateObject) #define IMPLEMENT_SERIAL(class_name, base_class_name, wSchema) \ CObject* PASCAL class_name::CreateObject() \ { return new class_name; } \ _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, \ class_name::CreateObject) \ AFX_CLASSINIT _init_##class_name(RUNTIME_CLASS(class_name)); \ CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb) \ { pOb = (class_name*) ar.ReadObject(RUNTIME_CLASS(class_name)); \ return ar; } \ // optional bit for schema number that enables object versioning #define VERSIONABLE_SCHEMA (0x80000000) ///////////////////////////////////////////////////////////////////////////// // other helpers // zero fill everything after the vtbl pointer #define AFX_ZERO_INIT_OBJECT(base_class) \ memset(((base_class*)this)+1, 0, sizeof(*this) - sizeof(class base_class)); ///////////////////////////////////////////////////////////////////////////// // Exceptions #ifdef _AFXDLL class CException : public CObject #else class AFX_NOVTABLE CException : public CObject #endif { // abstract class for dynamic type checking DECLARE_DYNAMIC(CException) public: // Constructors CException(); // sets m_bAutoDelete = TRUE CException(BOOL bAutoDelete); // sets m_bAutoDelete = bAutoDelete // Operations void Delete(); // use to delete exception in 'catch' block virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext = NULL); virtual int ReportError(UINT nType = MB_OK, UINT nMessageID = 0); // Implementation (setting m_bAutoDelete to FALSE is advanced) public: virtual ~CException(); BOOL m_bAutoDelete; #ifdef _DEBUG void PASCAL operator delete(void* pbData); #if _MSC_VER >= 1200 void PASCAL operator delete(void* pbData, LPCSTR lpszFileName, int nLine); #endif protected: BOOL m_bReadyForDelete; #endif }; #ifdef _AFXDLL class CSimpleException : public CException #else class AFX_NOVTABLE CSimpleException : public CException #endif { // base class for resource-critical MFC exceptions // handles ownership and initialization of an error message public: // Constructors CSimpleException(); CSimpleException(BOOL bAutoDelete); // Operations virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext = NULL); // Implementation (setting m_bAutoDelete to FALSE is advanced) public: virtual ~CSimpleException(); BOOL m_bAutoDelete; void InitString(); // used during MFC initialization protected: BOOL m_bInitialized; BOOL m_bLoaded; TCHAR m_szMessage[128]; UINT m_nResourceID; #ifdef _DEBUG BOOL m_bReadyForDelete; #endif }; // helper routines for non-C++ EH implementations #ifdef _AFX_OLD_EXCEPTIONS BOOL AFXAPI AfxCatchProc(CRuntimeClass* pClass); void AFXAPI AfxThrow(CException* pException); #else // for THROW_LAST auto-delete backward compatiblity void AFXAPI AfxThrowLastCleanup(); #endif // other out-of-line helper functions void AFXAPI AfxTryCleanup(); #ifndef _AFX_JUMPBUF // Use portable 'jmp_buf' defined by ANSI by default. #define _AFX_JUMPBUF jmp_buf #endif // Placed on frame for EXCEPTION linkage, or CException cleanup struct AFX_EXCEPTION_LINK { #ifdef _AFX_OLD_EXCEPTIONS union { _AFX_JUMPBUF m_jumpBuf; struct { void (PASCAL* pfnCleanup)(AFX_EXCEPTION_LINK* pLink); void* pvData; // extra data follows } m_callback; // callback for cleanup (nType != 0) }; UINT m_nType; // 0 for setjmp, !=0 for user extension #endif //!_AFX_OLD_EXCEPTIONS AFX_EXCEPTION_LINK* m_pLinkPrev; // previous top, next in handler chain CException* m_pException; // current exception (NULL in TRY block) AFX_EXCEPTION_LINK(); // for initialization and linking ~AFX_EXCEPTION_LINK() // for cleanup and unlinking { AfxTryCleanup(); }; }; // Exception global state - never access directly struct AFX_EXCEPTION_CONTEXT { AFX_EXCEPTION_LINK* m_pLinkTop; // Note: most of the exception context is now in the AFX_EXCEPTION_LINK }; #ifndef _PNH_DEFINED typedef int (__cdecl * _PNH)( size_t ); #define _PNH_DEFINED #endif _PNH AFXAPI AfxGetNewHandler(); _PNH AFXAPI AfxSetNewHandler(_PNH pfnNewHandler); int AFX_CDECL AfxNewHandler(size_t nSize); void AFXAPI AfxAbort(); #ifdef _AFX_OLD_EXCEPTIONS // Obsolete and non-portable: setting terminate handler // use CWinApp::ProcessWndProcException for Windows apps instead // can also use set_terminate which is part of C++ standard library // (these are provided for backward compatibility) void AFXAPI AfxTerminate(); typedef void (AFXAPI* AFX_TERM_PROC)(); AFX_TERM_PROC AFXAPI AfxSetTerminate(AFX_TERM_PROC); #endif ///////////////////////////////////////////////////////////////////////////// // Exception macros using try, catch and throw // (for backward compatibility to previous versions of MFC) #ifndef _AFX_OLD_EXCEPTIONS #define TRY { AFX_EXCEPTION_LINK _afxExceptionLink; try { #define CATCH(class, e) } catch (class* e) \ { ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \ _afxExceptionLink.m_pException = e; #define AND_CATCH(class, e) } catch (class* e) \ { ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \ _afxExceptionLink.m_pException = e; #define END_CATCH } } #define THROW(e) throw e #define THROW_LAST() (AfxThrowLastCleanup(), throw) // Advanced macros for smaller code #define CATCH_ALL(e) } catch (CException* e) \ { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \ _afxExceptionLink.m_pException = e; #define AND_CATCH_ALL(e) } catch (CException* e) \ { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \ _afxExceptionLink.m_pException = e; #define END_CATCH_ALL } } } #define END_TRY } catch (CException* e) \ { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \ _afxExceptionLink.m_pException = e; } } #else //_AFX_OLD_EXCEPTIONS ///////////////////////////////////////////////////////////////////////////// // Exception macros using setjmp and longjmp // (for portability to compilers with no support for C++ exception handling) #define TRY \ { AFX_EXCEPTION_LINK _afxExceptionLink; \ if (::setjmp(_afxExceptionLink.m_jumpBuf) == 0) #define CATCH(class, e) \ else if (::AfxCatchProc(RUNTIME_CLASS(class))) \ { class* e = (class*)_afxExceptionLink.m_pException; #define AND_CATCH(class, e) \ } else if (::AfxCatchProc(RUNTIME_CLASS(class))) \ { class* e = (class*)_afxExceptionLink.m_pException; #define END_CATCH \ } else { ::AfxThrow(NULL); } } #define THROW(e) AfxThrow(e) #define THROW_LAST() AfxThrow(NULL) // Advanced macros for smaller code #define CATCH_ALL(e) \ else { CException* e = _afxExceptionLink.m_pException; #define AND_CATCH_ALL(e) \ } else { CException* e = _afxExceptionLink.m_pException; #define END_CATCH_ALL } } #define END_TRY } #endif //_AFX_OLD_EXCEPTIONS ///////////////////////////////////////////////////////////////////////////// // Standard Exception classes class CMemoryException : public CSimpleException { DECLARE_DYNAMIC(CMemoryException) public: CMemoryException(); // Implementation public: CMemoryException(BOOL bAutoDelete); CMemoryException(BOOL bAutoDelete, UINT nResourceID); virtual ~CMemoryException(); }; class CNotSupportedException : public CSimpleException { DECLARE_DYNAMIC(CNotSupportedException) public: CNotSupportedException(); // Implementation public: CNotSupportedException(BOOL bAutoDelete); CNotSupportedException(BOOL bAutoDelete, UINT nResourceID); virtual ~CNotSupportedException(); }; class CArchiveException : public CException { DECLARE_DYNAMIC(CArchiveException) public: enum { none, generic, readOnly, endOfFile, writeOnly, badIndex, badClass, badSchema }; // Constructor CArchiveException(int cause = CArchiveException::none, LPCTSTR lpszArchiveName = NULL); // Attributes int m_cause; CString m_strFileName; // Implementation public: virtual ~CArchiveException(); #ifdef _DEBUG virtual void Dump(CDumpContext& dc) const; #endif virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext = NULL); }; class CFileException : public CException { DECLARE_DYNAMIC(CFileException) public: enum { none, generic, fileNotFound, badPath, tooManyOpenFiles, accessDenied, invalidFile, removeCurrentDir, directoryFull, badSeek, hardIO, sharingViolation, lockViolation, diskFull, endOfFile }; // Constructor CFileException(int cause = CFileException::none, LONG lOsError = -1, LPCTSTR lpszArchiveName = NULL); // Attributes int m_cause; LONG m_lOsError; CString m_strFileName; // Operations // convert a OS dependent error code to a Cause static int PASCAL OsErrorToException(LONG lOsError); static int PASCAL ErrnoToException(int nErrno); // helper functions to throw exception after converting to a Cause static void PASCAL ThrowOsError(LONG lOsError, LPCTSTR lpszFileName = NULL); static void PASCAL ThrowErrno(int nErrno, LPCTSTR lpszFileName = NULL); // Implementation public: virtual ~CFileException(); #ifdef _DEBUG virtual void Dump(CDumpContext&) const; #endif virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext = NULL); }; ///////////////////////////////////////////////////////////////////////////// // Standard exception throws void AFXAPI AfxThrowMemoryException(); void AFXAPI AfxThrowNotSupportedException(); void AFXAPI AfxThrowArchiveException(int cause, LPCTSTR lpszArchiveName = NULL); void AFXAPI AfxThrowFileException(int cause, LONG lOsError = -1, LPCTSTR lpszFileName = NULL); ///////////////////////////////////////////////////////////////////////////// // File - raw unbuffered disk file I/O class CFile : public CObject { DECLARE_DYNAMIC(CFile) public: // Flag values enum OpenFlags { modeRead = 0x0000, modeWrite = 0x0001, modeReadWrite = 0x0002, shareCompat = 0x0000, shareExclusive = 0x0010, shareDenyWrite = 0x0020, shareDenyRead = 0x0030, shareDenyNone = 0x0040, modeNoInherit = 0x0080, modeCreate = 0x1000, modeNoTruncate = 0x2000, typeText = 0x4000, // typeText and typeBinary are used in typeBinary = (int)0x8000 // derived classes only }; enum Attribute { normal = 0x00, readOnly = 0x01, hidden = 0x02, system = 0x04, volume = 0x08, directory = 0x10, archive = 0x20 }; enum SeekPosition { begin = 0x0, current = 0x1, end = 0x2 }; enum { hFileNull = -1 }; // Constructors CFile(); CFile(int hFile); CFile(LPCTSTR lpszFileName, UINT nOpenFlags); // Attributes UINT m_hFile; operator HFILE() const; virtual DWORD GetPosition() const; BOOL GetStatus(CFileStatus& rStatus) const; virtual CString GetFileName() const; virtual CString GetFileTitle() const; virtual CString GetFilePath() const; virtual void SetFilePath(LPCTSTR lpszNewName); // Operations virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL); static void PASCAL Rename(LPCTSTR lpszOldName, LPCTSTR lpszNewName); static void PASCAL Remove(LPCTSTR lpszFileName); static BOOL PASCAL GetStatus(LPCTSTR lpszFileName, CFileStatus& rStatus); static void PASCAL SetStatus(LPCTSTR lpszFileName, const CFileStatus& status); DWORD SeekToEnd(); void SeekToBegin(); // backward compatible ReadHuge and WriteHuge DWORD ReadHuge(void* lpBuffer, DWORD dwCount); void WriteHuge(const void* lpBuffer, DWORD dwCount); // Overridables virtual CFile* Duplicate() const; virtual LONG Seek(LONG lOff, UINT nFrom); virtual void SetLength(DWORD dwNewLen); virtual DWORD GetLength() const; virtual UINT Read(void* lpBuf, UINT nCount); virtual void Write(const void* lpBuf, UINT nCount); virtual void LockRange(DWORD dwPos, DWORD dwCount); virtual void UnlockRange(DWORD dwPos, DWORD dwCount); virtual void Abort(); virtual void Flush(); virtual void Close(); // Implementation public: virtual ~CFile(); #ifdef _DEBUG virtual void AssertValid() const; virtual void Dump(CDumpContext& dc) const; #endif enum BufferCommand { bufferRead, bufferWrite, bufferCommit, bufferCheck }; virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0, void** ppBufStart = NULL, void** ppBufMax = NULL); protected: BOOL m_bCloseOnDelete; CString m_strFileName; }; ///////////////////////////////////////////////////////////////////////////// // STDIO file implementation class CStdioFile : public CFile { DECLARE_DYNAMIC(CStdioFile) public: // Constructors CStdioFile(); CStdioFile(FILE* pOpenStream); CStdioFile(LPCTSTR lpszFileName, UINT nOpenFlags); // Attributes FILE* m_pStream; // stdio FILE // m_hFile from base class is _fileno(m_pStream) // Operations // reading and writing strings virtual void WriteString(LPCTSTR lpsz); virtual LPTSTR ReadString(LPTSTR lpsz, UINT nMax); virtual BOOL ReadString(CString& rString); // Implementation public: virtual ~CStdioFile(); #ifdef _DEBUG void Dump(CDumpContext& dc) const; #endif virtual DWORD GetPosition() const; virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL); virtual UINT Read(void* lpBuf, UINT nCount); virtual void Write(const void* lpBuf, UINT nCount); virtual LONG Seek(LONG lOff, UINT nFrom); virtual void Abort(); virtual void Flush(); virtual void Close(); // Unsupported APIs virtual CFile* Duplicate() const; virtual void LockRange(DWORD dwPos, DWORD dwCount); virtual void UnlockRange(DWORD dwPos, DWORD dwCount); }; //////////////////////////////////////////////////////////////////////////// // Memory based file implementation class CMemFile : public CFile { DECLARE_DYNAMIC(CMemFile) public: // Constructors CMemFile(UINT nGrowBytes = 1024); CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0); // Operations void Attach(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0); BYTE* Detach(); // Advanced Overridables protected: virtual BYTE* Alloc(DWORD nBytes); virtual BYTE* Realloc(BYTE* lpMem, DWORD nBytes); virtual BYTE* Memcpy(BYTE* lpMemTarget, const BYTE* lpMemSource, UINT nBytes); virtual void Free(BYTE* lpMem); virtual void GrowFile(DWORD dwNewLen); // Implementation protected: UINT m_nGrowBytes; DWORD m_nPosition; DWORD m_nBufferSize; DWORD m_nFileSize; BYTE* m_lpBuffer; BOOL m_bAutoDelete; public: virtual ~CMemFile(); #ifdef _DEBUG virtual void Dump(CDumpContext& dc) const; virtual void AssertValid() const; #endif virtual DWORD GetPosition() const; BOOL GetStatus(CFileStatus& rStatus) const; virtual LONG Seek(LONG lOff, UINT nFrom); virtual void SetLength(DWORD dwNewLen); virtual UINT Read(void* lpBuf, UINT nCount); virtual void Write(const void* lpBuf, UINT nCount); virtual void Abort(); virtual void Flush(); virtual void Close(); virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0, void** ppBufStart = NULL, void** ppBufMax = NULL); // Unsupported APIs virtual CFile* Duplicate() const; virtual void LockRange(DWORD dwPos, DWORD dwCount); virtual void UnlockRange(DWORD dwPos, DWORD dwCount); }; //////////////////////////////////////////////////////////////////////////// // Local file searches class CFileFind : public CObject { public: CFileFind(); virtual ~CFileFind(); // Attributes public: DWORD GetLength() const; #if defined(_X86_) || defined(_ALPHA_) __int64 GetLength64() const; #endif virtual CString GetFileName() const; virtual CString GetFilePath() const; virtual CString GetFileTitle() const; virtual CString GetFileURL() const; virtual CString GetRoot() const; virtual BOOL GetLastWriteTime(FILETIME* pTimeStamp) const; virtual BOOL GetLastAccessTime(FILETIME* pTimeStamp) const; virtual BOOL GetCreationTime(FILETIME* pTimeStamp) const; virtual BOOL GetLastWriteTime(CTime& refTime) const; virtual BOOL GetLastAccessTime(CTime& refTime) const; virtual BOOL GetCreationTime(CTime& refTime) const; virtual BOOL MatchesMask(DWORD dwMask) const; virtual BOOL IsDots() const; // these aren't virtual because they all use MatchesMask(), which is BOOL IsReadOnly() const; BOOL IsDirectory() const; BOOL IsCompressed() const; BOOL IsSystem() const; BOOL IsHidden() const; BOOL IsTemporary() const; BOOL IsNormal() const; BOOL IsArchived() const; // Operations void Close(); virtual BOOL FindFile(LPCTSTR pstrName = NULL, DWORD dwUnused = 0); virtual BOOL FindNextFile(); protected: virtual void CloseContext(); // Implementation protected: void* m_pFoundInfo; void* m_pNextInfo; HANDLE m_hContext; BOOL m_bGotLast; CString m_strRoot; TCHAR m_chDirSeparator; // not '\\' for Internet classes #ifdef _DEBUG void Dump(CDumpContext& dc) const; void AssertValid() const; #endif DECLARE_DYNAMIC(CFileFind) }; ///////////////////////////////////////////////////////////////////////////// // CTimeSpan and CTime class CTimeSpan { public: // Constructors CTimeSpan(); CTimeSpan(time_t time); CTimeSpan(LONG lDays, int nHours, int nMins, int nSecs); CTimeSpan(const CTimeSpan& timeSpanSrc); const CTimeSpan& operator=(const CTimeSpan& timeSpanSrc); // Attributes // extract parts LONG GetDays() const; // total # of days LONG GetTotalHours() const; int GetHours() const; LONG GetTotalMinutes() const; int GetMinutes() const; LONG GetTotalSeconds() const; int GetSeconds() const; // Operations // time math CTimeSpan operator-(CTimeSpan timeSpan) const; CTimeSpan operator+(CTimeSpan timeSpan) const; const CTimeSpan& operator+=(CTimeSpan timeSpan); const CTimeSpan& operator-=(CTimeSpan timeSpan); BOOL operator==(CTimeSpan timeSpan) const; BOOL operator!=(CTimeSpan timeSpan) const; BOOL operator<(CTimeSpan timeSpan) const; BOOL operator>(CTimeSpan timeSpan) const; BOOL operator<=(CTimeSpan timeSpan) const; BOOL operator>=(CTimeSpan timeSpan) const; #ifdef _UNICODE // for compatibility with MFC 3.x CString Format(LPCSTR pFormat) const; #endif CString Format(LPCTSTR pFormat) const; CString Format(UINT nID) const; // serialization #ifdef _DEBUG friend CDumpContext& AFXAPI operator<<(CDumpContext& dc,CTimeSpan timeSpan); #endif friend CArchive& AFXAPI operator<<(CArchive& ar, CTimeSpan timeSpan); friend CArchive& AFXAPI operator>>(CArchive& ar, CTimeSpan& rtimeSpan); private: time_t m_timeSpan; friend class CTime; }; class CTime { public: // Constructors static CTime PASCAL GetCurrentTime(); CTime(); CTime(time_t time); CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, int nDST = -1); CTime(WORD wDosDate, WORD wDosTime, int nDST = -1); CTime(const CTime& timeSrc); CTime(const SYSTEMTIME& sysTime, int nDST = -1); CTime(const FILETIME& fileTime, int nDST = -1); const CTime& operator=(const CTime& timeSrc); const CTime& operator=(time_t t); // Attributes struct tm* GetGmtTm(struct tm* ptm = NULL) const; struct tm* GetLocalTm(struct tm* ptm = NULL) const; BOOL GetAsSystemTime(SYSTEMTIME& timeDest) const; time_t GetTime() const; int GetYear() const; int GetMonth() const; // month of year (1 = Jan) int GetDay() const; // day of month int GetHour() const; int GetMinute() const; int GetSecond() const; int GetDayOfWeek() const; // 1=Sun, 2=Mon, ..., 7=Sat // Operations // time math CTimeSpan operator-(CTime time) const; CTime operator-(CTimeSpan timeSpan) const; CTime operator+(CTimeSpan timeSpan) const; const CTime& operator+=(CTimeSpan timeSpan); const CTime& operator-=(CTimeSpan timeSpan); BOOL operator==(CTime time) const; BOOL operator!=(CTime time) const; BOOL operator<(CTime time) const; BOOL operator>(CTime time) const; BOOL operator<=(CTime time) const; BOOL operator>=(CTime time) const; // formatting using "C" strftime CString Format(LPCTSTR pFormat) const; CString FormatGmt(LPCTSTR pFormat) const; CString Format(UINT nFormatID) const; CString FormatGmt(UINT nFormatID) const; #ifdef _UNICODE // for compatibility with MFC 3.x CString Format(LPCSTR pFormat) const; CString FormatGmt(LPCSTR pFormat) const; #endif // serialization #ifdef _DEBUG friend CDumpContext& AFXAPI operator<<(CDumpContext& dc, CTime time); #endif friend CArchive& AFXAPI operator<<(CArchive& ar, CTime time); friend CArchive& AFXAPI operator>>(CArchive& ar, CTime& rtime); private: time_t m_time; }; ///////////////////////////////////////////////////////////////////////////// // File status struct CFileStatus { CTime m_ctime; // creation date/time of file CTime m_mtime; // last modification date/time of file CTime m_atime; // last access date/time of file LONG m_size; // logical size of file in bytes BYTE m_attribute; // logical OR of CFile::Attribute enum values BYTE _m_padding; // pad the structure to a WORD TCHAR m_szFullName[_MAX_PATH]; // absolute path name #ifdef _DEBUG void Dump(CDumpContext& dc) const; #endif }; ///////////////////////////////////////////////////////////////////////////// // Diagnostic memory management routines // Low level sanity checks for memory blocks BOOL AFXAPI AfxIsValidAddress(const void* lp, UINT nBytes, BOOL bReadWrite = TRUE); BOOL AFXAPI AfxIsValidString(LPCWSTR lpsz, int nLength = -1); BOOL AFXAPI AfxIsValidString(LPCSTR lpsz, int nLength = -1); #if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT) // Memory tracking allocation void* AFX_CDECL operator new(size_t nSize, LPCSTR lpszFileName, int nLine); #define DEBUG_NEW new(THIS_FILE, __LINE__) #if _MSC_VER >= 1200 void AFX_CDECL operator delete(void* p, LPCSTR lpszFileName, int nLine); #endif void* AFXAPI AfxAllocMemoryDebug(size_t nSize, BOOL bIsObject, LPCSTR lpszFileName, int nLine); void AFXAPI AfxFreeMemoryDebug(void* pbData, BOOL bIsObject); // Dump any memory leaks since program started BOOL AFXAPI AfxDumpMemoryLeaks(); // Return TRUE if valid memory block of nBytes BOOL AFXAPI AfxIsMemoryBlock(const void* p, UINT nBytes, LONG* plRequestNumber = NULL); // Return TRUE if memory is sane or print out what is wrong BOOL AFXAPI AfxCheckMemory(); #define afxMemDF _crtDbgFlag enum AfxMemDF // memory debug/diagnostic flags { allocMemDF = 0x01, // turn on debugging allocator delayFreeMemDF = 0x02, // delay freeing memory checkAlwaysMemDF = 0x04 // AfxCheckMemory on every alloc/free }; #ifdef _UNICODE #define AfxOutputDebugString(lpsz) \ do \ { \ USES_CONVERSION; \ _RPT0(_CRT_WARN, W2CA(lpsz)); \ } while (0) #else #define AfxOutputDebugString(lpsz) _RPT0(_CRT_WARN, lpsz) #endif // turn on/off tracking for a short while BOOL AFXAPI AfxEnableMemoryTracking(BOOL bTrack); // Advanced initialization: for overriding default diagnostics BOOL AFXAPI AfxDiagnosticInit(void); // A failure hook returns whether to permit allocation typedef BOOL (AFXAPI* AFX_ALLOC_HOOK)(size_t nSize, BOOL bObject, LONG lRequestNumber); // Set new hook, return old (never NULL) AFX_ALLOC_HOOK AFXAPI AfxSetAllocHook(AFX_ALLOC_HOOK pfnAllocHook); // Debugger hook on specified allocation request - Obsolete void AFXAPI AfxSetAllocStop(LONG lRequestNumber); // Memory state for snapshots/leak detection struct CMemoryState { // Attributes enum blockUsage { freeBlock, // memory not used objectBlock, // contains a CObject derived class object bitBlock, // contains ::operator new data crtBlock, ignoredBlock, nBlockUseMax // total number of usages }; _CrtMemState m_memState; LONG m_lCounts[nBlockUseMax]; LONG m_lSizes[nBlockUseMax]; LONG m_lHighWaterCount; LONG m_lTotalCount; CMemoryState(); // Operations void Checkpoint(); // fill with current state BOOL Difference(const CMemoryState& oldState, const CMemoryState& newState); // fill with difference void UpdateData(); // Output to afxDump void DumpStatistics() const; void DumpAllObjectsSince() const; }; // Enumerate allocated objects or runtime classes void AFXAPI AfxDoForAllObjects(void (AFX_CDECL *pfn)(CObject* pObject, void* pContext), void* pContext); void AFXAPI AfxDoForAllClasses(void (AFX_CDECL *pfn)(const CRuntimeClass* pClass, void* pContext), void* pContext); #else // non-_DEBUG_ALLOC version that assume everything is OK #define DEBUG_NEW new #define AfxCheckMemory() TRUE #define AfxIsMemoryBlock(p, nBytes) TRUE #define AfxEnableMemoryTracking(bTrack) FALSE #define AfxOutputDebugString(lpsz) ::OutputDebugString(lpsz) // diagnostic initialization #ifndef _DEBUG #define AfxDiagnosticInit() TRUE #else BOOL AFXAPI AfxDiagnosticInit(void); #endif #endif // _DEBUG ///////////////////////////////////////////////////////////////////////////// // Archives for serializing CObject data // needed for implementation class CPtrArray; class CMapPtrToPtr; class CDocument; class CArchive { public: // Flag values enum Mode { store = 0, load = 1, bNoFlushOnDelete = 2, bNoByteSwap = 4 }; CArchive(CFile* pFile, UINT nMode, int nBufSize = 4096, void* lpBuf = NULL); ~CArchive(); // Attributes BOOL IsLoading() const; BOOL IsStoring() const; BOOL IsByteSwapping() const; BOOL IsBufferEmpty() const; CFile* GetFile() const; UINT GetObjectSchema(); // only valid when reading a CObject* void SetObjectSchema(UINT nSchema); // pointer to document being serialized -- must set to serialize // COleClientItems in a document! CDocument* m_pDocument; // Operations UINT Read(void* lpBuf, UINT nMax); void Write(const void* lpBuf, UINT nMax); void Flush(); void Close(); void Abort(); // close and shutdown without exceptions // reading and writing strings void WriteString(LPCTSTR lpsz); LPTSTR ReadString(LPTSTR lpsz, UINT nMax); BOOL ReadString(CString& rString); public: // Object I/O is pointer based to avoid added construction overhead. // Use the Serialize member function directly for embedded objects. friend CArchive& AFXAPI operator<<(CArchive& ar, const CObject* pOb); friend CArchive& AFXAPI operator>>(CArchive& ar, CObject*& pOb); friend CArchive& AFXAPI operator>>(CArchive& ar, const CObject*& pOb); // insertion operations CArchive& operator<<(BYTE by); CArchive& operator<<(WORD w); CArchive& operator<<(LONG l); CArchive& operator<<(DWORD dw); CArchive& operator<<(float f); CArchive& operator<<(double d); CArchive& operator<<(int i); CArchive& operator<<(short w); CArchive& operator<<(char ch); CArchive& operator<<(unsigned u); // extraction operations CArchive& operator>>(BYTE& by); CArchive& operator>>(WORD& w); CArchive& operator>>(DWORD& dw); CArchive& operator>>(LONG& l); CArchive& operator>>(float& f); CArchive& operator>>(double& d); CArchive& operator>>(int& i); CArchive& operator>>(short& w); CArchive& operator>>(char& ch); CArchive& operator>>(unsigned& u); // object read/write CObject* ReadObject(const CRuntimeClass* pClass); void WriteObject(const CObject* pOb); // advanced object mapping (used for forced references) void MapObject(const CObject* pOb); // advanced versioning support void WriteClass(const CRuntimeClass* pClassRef); CRuntimeClass* ReadClass(const CRuntimeClass* pClassRefRequested = NULL, UINT* pSchema = NULL, DWORD* pObTag = NULL); void SerializeClass(const CRuntimeClass* pClassRef); // advanced operations (used when storing/loading many objects) void SetStoreParams(UINT nHashSize = 2053, UINT nBlockSize = 128); void SetLoadParams(UINT nGrowBy = 1024); // Implementation public: BOOL m_bForceFlat; // for COleClientItem implementation (default TRUE) BOOL m_bDirectBuffer; // TRUE if m_pFile supports direct buffering void FillBuffer(UINT nBytesNeeded); void CheckCount(); // throw exception if m_nMapCount is too large // special functions for reading and writing (16-bit compatible) counts DWORD ReadCount(); void WriteCount(DWORD dwCount); // public for advanced use UINT m_nObjectSchema; CString m_strFileName; protected: // archive objects cannot be copied or assigned CArchive(const CArchive& arSrc); void operator=(const CArchive& arSrc); BOOL m_nMode; BOOL m_bUserBuf; int m_nBufSize; CFile* m_pFile; BYTE* m_lpBufCur; BYTE* m_lpBufMax; BYTE* m_lpBufStart; // array/map for CObject* and CRuntimeClass* load/store UINT m_nMapCount; union { CPtrArray* m_pLoadArray; CMapPtrToPtr* m_pStoreMap; }; // map to keep track of mismatched schemas CMapPtrToPtr* m_pSchemaMap; // advanced parameters (controls performance with large archives) UINT m_nGrowSize; UINT m_nHashSize; }; ///////////////////////////////////////////////////////////////////////////// // Diagnostic dumping // Note: AfxDumpStack is available in release builds, although it is always // statically linked so as to not negatively affect the size of MFC42.DLL. #define AFX_STACK_DUMP_TARGET_TRACE 0x0001 #define AFX_STACK_DUMP_TARGET_CLIPBOARD 0x0002 #define AFX_STACK_DUMP_TARGET_BOTH 0x0003 #define AFX_STACK_DUMP_TARGET_ODS 0x0004 #ifdef _DEBUG #define AFX_STACK_DUMP_TARGET_DEFAULT AFX_STACK_DUMP_TARGET_TRACE #else #define AFX_STACK_DUMP_TARGET_DEFAULT AFX_STACK_DUMP_TARGET_CLIPBOARD #endif void AFXAPI AfxDumpStack(DWORD dwFlags = AFX_STACK_DUMP_TARGET_DEFAULT); class CDumpContext { public: CDumpContext(CFile* pFile = NULL); // Attributes int GetDepth() const; // 0 => this object, 1 => children objects void SetDepth(int nNewDepth); // Operations CDumpContext& operator<<(LPCTSTR lpsz); #ifdef _UNICODE CDumpContext& operator<<(LPCSTR lpsz); // automatically widened #else CDumpContext& operator<<(LPCWSTR lpsz); // automatically thinned #endif CDumpContext& operator<<(const void* lp); CDumpContext& operator<<(const CObject* pOb); CDumpContext& operator<<(const CObject& ob); CDumpContext& operator<<(BYTE by); CDumpContext& operator<<(WORD w); CDumpContext& operator<<(UINT u); CDumpContext& operator<<(LONG l); CDumpContext& operator<<(DWORD dw); CDumpContext& operator<<(float f); CDumpContext& operator<<(double d); CDumpContext& operator<<(int n); void HexDump(LPCTSTR lpszLine, BYTE* pby, int nBytes, int nWidth); void Flush(); // Implementation protected: // dump context objects cannot be copied or assigned CDumpContext(const CDumpContext& dcSrc); void operator=(const CDumpContext& dcSrc); void OutputString(LPCTSTR lpsz); int m_nDepth; public: CFile* m_pFile; }; #ifdef _DEBUG extern AFX_DATA CDumpContext afxDump; extern AFX_DATA BOOL afxTraceEnabled; #endif ///////////////////////////////////////////////////////////////////////////// // Special include for Win32s compatibility #ifdef _AFX_PACKING #pragma pack(pop) #endif #ifndef __AFXCOLL_H__ #include <afxcoll.h> #ifndef __AFXSTATE_H__ #include <afxstat_.h> // for _AFX_APP_STATE and _AFX_THREAD_STATE #endif #endif ///////////////////////////////////////////////////////////////////////////// // Inline function declarations #ifdef _AFX_ENABLE_INLINES #define _AFX_INLINE AFX_INLINE #if !defined(_AFX_CORE_IMPL) || !defined(_AFXDLL) || defined(_DEBUG) #define _AFX_PUBLIC_INLINE AFX_INLINE #else #define _AFX_PUBLIC_INLINE #endif #include <afx.inl> #endif #undef AFX_DATA #define AFX_DATA #ifdef _AFX_MINREBUILD #pragma component(minrebuild, on) #endif #ifndef _AFX_FULLTYPEINFO #pragma component(mintypeinfo, off) #endif #endif // __AFX_H__ /////////////////////////////////////////////////////////////////////////////