Return to person.h CVS log

Up to [WindowsNT SDKs] / mstools / mfc / samples / tutorial

Annotation of mstools/mfc/samples/tutorial/person.h, revision 1.1

1.1     ! root        1: // person.h : Defines the class interfaces for CPerson, CPersonList.
        !             2: //
        !             3: // This is a part of the Microsoft Foundation Classes C++ library.
        !             4: // Copyright (C) 1992 Microsoft Corporation
        !             5: // All rights reserved.
        !             6: //
        !             7: // This source code is only intended as a supplement to the
        !             8: // Microsoft Foundation Classes Reference and Microsoft
        !             9: // QuickHelp documentation provided with the library.
        !            10: // See these sources for detailed information regarding the
        !            11: // Microsoft Foundation Classes product.
        !            12: 
        !            13: #ifndef __PERSON_H__
        !            14: #define __PERSON_H__
        !            15: #ifdef _DOS
        !            16:        #include <afx.h>
        !            17: #else
        !            18: #ifdef _NTWIN
        !            19:        #include <afx.h>
        !            20: #else
        !            21:        #include <afxwin.h>
        !            22: #endif
        !            23: #endif
        !            24: #include <afxcoll.h>
        !            25: 
        !            26: 
        !            27: /////////////////////////////////////////////////////////////////////////////
        !            28: // class CPerson:
        !            29: // Represents one person in the phone database.  This class is derived from
        !            30: // CObject (mostly to get access to the serialization protocol).
        !            31: 
        !            32: class CPerson : public CObject
        !            33: {
        !            34:        DECLARE_SERIAL( CPerson );
        !            35: 
        !            36: public:
        !            37: //Construction
        !            38:        // For serializable classes, declare a constructor with no arguments.
        !            39:        CPerson()
        !            40:                { m_modTime = CTime::GetCurrentTime(); }
        !            41:                
        !            42:        CPerson( const CPerson& a );
        !            43: 
        !            44:        // For our convenience, also declare a constructor with arguments.
        !            45:        CPerson( const char* pszLastName,
        !            46:                const char* pszFirstName,
        !            47:                const char* pszPhoneNum );
        !            48: 
        !            49: //Attributes
        !            50:        // Member functions to modify the protected member variables.
        !            51:        void SetLastName( const char* pszName )
        !            52:                {   ASSERT_VALID( this );
        !            53:                        ASSERT( pszName != NULL);
        !            54:                        m_LastName = pszName;
        !            55:                        m_modTime = CTime::GetCurrentTime(); }
        !            56:                        
        !            57:        const CString& GetLastName() const
        !            58:                {   ASSERT_VALID( this );
        !            59:                        return m_LastName; }
        !            60: 
        !            61:        void SetFirstName( const char* pszName )
        !            62:                {   ASSERT_VALID( this );
        !            63:                        ASSERT( pszName != NULL );
        !            64:                        m_FirstName = pszName;
        !            65:                        m_modTime = CTime::GetCurrentTime(); }
        !            66:                        
        !            67:        const CString& GetFirstName() const
        !            68:                {   ASSERT_VALID( this );
        !            69:                        return m_FirstName; }
        !            70: 
        !            71:        void SetPhoneNumber( const char* pszNumber )
        !            72:                {   ASSERT_VALID( this );
        !            73:                        ASSERT( pszNumber != NULL );
        !            74:                        m_PhoneNumber = pszNumber;
        !            75:                        m_modTime = CTime::GetCurrentTime(); }
        !            76:                        
        !            77:        const CString& GetPhoneNumber() const
        !            78:                {   ASSERT_VALID( this );
        !            79:                        return m_PhoneNumber; }
        !            80: 
        !            81:        const CTime GetModTime() const
        !            82:                {   ASSERT_VALID( this );
        !            83:                        return m_modTime; }
        !            84: 
        !            85: //Operations
        !            86:        CPerson& operator=( const CPerson& b );
        !            87: 
        !            88: //Implementation
        !            89: protected:
        !            90:        // Member variables that hold data for person
        !            91:        CString        m_LastName;
        !            92:        CString        m_FirstName;
        !            93:        CString        m_PhoneNumber;
        !            94:        CTime          m_modTime;
        !            95: 
        !            96: public:
        !            97:        // Override the Serialize function
        !            98:        virtual void Serialize( CArchive& archive );
        !            99: 
        !           100: #ifdef _DEBUG
        !           101:        // Override Dump for debugging support
        !           102:        virtual void Dump( CDumpContext& dc ) const;
        !           103:        virtual void AssertValid() const;
        !           104: #endif
        !           105: };
        !           106: 
        !           107: /////////////////////////////////////////////////////////////////////////////
        !           108: // class CPersonList:
        !           109: // This represents a list of all persons in a phone database.  This class is
        !           110: // derived from CObList, a list of pointers to CObject-type objects.
        !           111: 
        !           112: class CPersonList : public CObList
        !           113: {
        !           114:        DECLARE_SERIAL( CPersonList )
        !           115:        
        !           116: public:
        !           117: //Construction
        !           118: 
        !           119:        CPersonList()
        !           120:                { m_bIsDirty = FALSE; }
        !           121: 
        !           122:        // Add new functions
        !           123:        CPersonList* FindPerson( const char * szTarget );
        !           124:        
        !           125:        // SetDirty/GetDirty
        !           126:        // Mark the person list as "dirty" (meaning "modified").  This flag can be
        !           127:        // checked later to see if the database needs to be saved.
        !           128:        //
        !           129:        void SetDirty( BOOL bDirty )
        !           130:                {   ASSERT_VALID( this );
        !           131:                        m_bIsDirty = bDirty; }
        !           132:        
        !           133:        BOOL GetDirty()
        !           134:                {   ASSERT_VALID( this );
        !           135:                        return m_bIsDirty; }
        !           136: 
        !           137:        // Delete All will delete the Person objects as well as the pointers.
        !           138:        void DeleteAll();
        !           139:        
        !           140: protected:
        !           141:        BOOL  m_bIsDirty;
        !           142: };
        !           143: 
        !           144: /////////////////////////////////////////////////////////////////////////////
        !           145: 
        !           146: #endif // __PERSON_H__
        !           147: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.