Humble Framework

00001 /****************************************************************************
00002 **
00003 **  $Header: /SkyOS.root/pig/Humble/HMemory.h 4     12/23/04 1:34p Neusel $
00004 **
00005 ****************************************************************************/
00012 #ifndef HMEM_H
00013     #define HMEM_H
00014 
00047 class HMemory : public HObjNoCopy
00048     {
00049     typedef HObjNoCopy  base_class;
00050     static StringPtr    ClassName(void) { return "HMemory"; }
00051 /*  ----------------------------------------------------------------------
00052     VARIABLES
00053     ----------------------------------------------------------------------  */
00054 protected:
00055     uint32              m_uBytes;       
00056     PtrData             m_pData;        
00057 /*  ----------------------------------------------------------------------
00058     CTOR / DTOR
00059     ----------------------------------------------------------------------  */
00060 public:
00061     HMemory(uint32 uSize = 0) throw() : m_uBytes(0), m_pData(NULL)
00062         { 
00063         if (uSize > 0 && create(uSize) != NO_ERROR)
00064             throw HError::GetLastError();
00065         }
00066 
00067     HMemory(PtrConst pData, uint32 uSize) throw() : m_uBytes(0), m_pData(NULL)
00068         { 
00069         if (GOOD_PTR(pData) && uSize > 0 && create(uSize, pData) != NO_ERROR)
00070             throw HError::GetLastError();
00071         }
00072         
00073     virtual             
00074     ~HMemory(void)
00075         { (void) Destroy(); }
00076 /*  ----------------------------------------------------------------------
00077     METHODS
00078     ----------------------------------------------------------------------  */
00079 public:
00085     ErrCode
00086     Destroy(void)
00087         {
00088         ErrCode     ec = HError::NoError();
00089         
00090         if (GOOD_PTR(m_pData))
00091             {
00092 #if __DEBUG__
00093             m_pData -= sizeof(uint32) + sizeof(uint16);
00094                     
00095             ASSERT(*MAKE_PTR(uint16 *, m_pData, 0x0004) == 0xDEAD);
00096             ASSERT(*MAKE_PTR(uint32 *, m_pData, 0x0000) == m_uBytes);
00097             ASSERT(*MAKE_PTR(uint16 *, m_pData, 0x0006 + m_uBytes) == 0xDEAD);
00098 
00099             DEBUG_LOG("HMemory: %8lu -\n", m_uBytes);
00100 #endif
00101             delete [] m_pData;
00102             m_pData = NULL;
00103             }
00104                     
00105         m_uBytes = 0;
00106 
00107         return ec;
00108         }
00113     ErrCode
00114     Zero(void) 
00115         { 
00116         ErrCode     ec = HError::NoError();
00117         
00118         if (IsValid())
00119             MEM_ZERO(m_pData, m_uBytes);
00120         else
00121             ec = HError::Set(ERR_NOT_INITIALIZED, __FILE__, __LINE__);
00122                 
00123         return ec;
00124         }                           
00125 protected:
00139     ErrCode             
00140     create(uint32 uBytes, PtrConst pData = NULL)
00141         {
00142         ErrCode     ec = HError::NoError();
00143         
00144         ASSERT( NULL_PTR(m_pData) );    // don't step on an existing pointer!
00145 
00146         try
00147             {
00148             if (uBytes > 0)
00149                 {
00150 #if __DEBUG__
00151                 m_pData = new uint8[uBytes + 8];
00152                 ASSERT_PTR(m_pData);
00153                 
00154                 *MAKE_PTR(uint32 *, m_pData, 0x0000) = uBytes;
00155                 *MAKE_PTR(uint16 *, m_pData, 0x0004) = 0xDEAD;
00156                 *MAKE_PTR(uint16 *, m_pData, 0x0006 + uBytes) = 0xDEAD;
00157                 m_pData += sizeof(uint32) + sizeof(uint16);
00158 
00159                 DEBUG_LOG("HMemory: %8lu +\n", uBytes);
00160 #else
00161                 m_pData = new uint8[uBytes];
00162 #endif
00163                 m_uBytes = uBytes;
00164                 if (validPtr(pData))
00165                     (void) MEM_COPY(m_pData, pData, m_uBytes);
00166                 else
00167                     (void) MEM_ZERO(m_pData, m_uBytes);
00168                 }
00169             else
00170                 ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00171             }
00172         catch (const std::exception & e)
00173             {
00174             DEBUG_LOG("HMemory::Create() => caught %s\n", e.what());
00175             if ((ec = ErrCode( HError::GetLastError() )) == NO_ERROR)
00176                 ec = HError::Set(ERR_BUY_MORE_RAM, __FILE__, __LINE__);
00177 
00178             m_uBytes    = 0;
00179             m_pData     = NULL;
00180             }
00181             
00182         return ec;
00183         }
00184 /*  ----------------------------------------------------------------------
00185     GETTERS & SETTERS
00186     ----------------------------------------------------------------------  */
00187 public:
00193     uint8               GetAt(uint32 udx) const
00194                             { return validIndex(udx) ? m_pData[udx] : '\0'; }
00200     Ptr                 GetPtr(uint32 udx = 0) const
00201                             { return validIndex(udx) ? &m_pData[udx] : NULL; }
00206     uint32              GetSize(void) const
00207                             { return m_uBytes; }
00218     ErrCode             Set(PtrConst pData, uint32 uBytes) 
00219                             { 
00220                             ErrCode     ec = HError::NoError();
00221                             
00222                             if (validPtr(pData) && uBytes > 0)
00223                                 {
00224                                 if ((ec = Destroy()) == NO_ERROR)
00225                                     ec = create(uBytes, pData);
00226                                 }
00227                             else
00228                                 ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00229                             
00230                             return ec;
00231                             }
00239     ErrCode             SetAt(uint32 udx, uint8 xVal) 
00240                             { 
00241                             ErrCode     ec = HError::NoError();
00242                             
00243                             if (validIndex(udx))
00244                                 m_pData[udx] = xVal; 
00245                             else
00246                                 ec = HError::Set(ERR_OUT_OF_RANGE, __FILE__, __LINE__);
00247                                 
00248                             return ec;
00249                             }
00258     ErrCode             SetAt(uint32 udx, PtrConst pData, uint32 uBytes) 
00259                             { 
00260                             ErrCode     ec = HError::NoError();
00261                             
00262                             if (GOOD_PTR(pData) && uBytes > 0)
00263                                 {
00264                                 if (validIndex(udx))
00265                                     {
00266                                     uint32  uCount = m_uBytes - udx;
00267                                     
00268                                     if (uCount > uBytes)
00269                                         {
00270                                         uCount = uBytes;
00271                                         ec = HError::Set(ERR_BUFFER_OVERFLOW, __FILE__, __LINE__);
00272                                         }
00273                             
00274                                     if (uCount > 0)
00275                                         (void) MEM_COPY(&m_pData[udx], pData, uCount);
00276                                     }
00277                                 else
00278                                     ec = HError::Set(ERR_OUT_OF_RANGE, __FILE__, __LINE__);
00279                                 }
00280                             else
00281                                 ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00282                             
00283                             return ec;
00284                             }
00296     ErrCode             SetSize(uint32 uSize) 
00297                             {
00298                             ErrCode     ec = HError::NoError();
00299                             
00300                             if ((ec = Destroy()) == NO_ERROR && uSize > 0)
00301                                 ec = create(uSize);
00302                                 
00303                             return ec;
00304                             }
00305 /*  ----------------------------------------------------------------------
00306     INLINES
00307     ----------------------------------------------------------------------  */
00308 public:
00315     inline bool         Contains(const void * p, uint32 uBytes = 1) const
00316                             {
00317                             return (GOOD_PTR(m_pData) && GOOD_PTR(p) && uBytes > 0) ? 
00318                                     (p >= m_pData && MAKE_PTR(PtrData, p, uBytes) <= &m_pData[m_uBytes]) : false;
00319                             }
00324     inline bool         IsValid(void) const
00325                             { return (GOOD_PTR(m_pData) && m_uBytes > 0); }
00326 protected:
00332     inline bool         validIndex(uint32 udx) const
00333                             { return (GOOD_PTR(m_pData) && udx <= m_uBytes); }
00344     inline bool         validPtr(PtrConst pData) const
00345                             { return (GOOD_PTR(pData) && pData != m_pData); }
00346 /*  ----------------------------------------------------------------------
00347     OPERATORS
00348     ----------------------------------------------------------------------  */
00349 public:
00350     operator Ptr (void)     
00351         { return m_pData; }
00352         
00353     operator PtrData (void)
00354         { return m_pData; }
00355 
00356     uint8
00357     operator[](uint32 udx) const
00358         { return GetAt(udx); }
00359 
00360     uint8 &             
00361     operator [] (uint32 udx) throw (HError)
00362         {
00363         if (!validIndex(udx))
00364             HError::Throw(ERR_OUT_OF_RANGE, __FILE__, __LINE__);
00365         
00366         return m_pData[udx];
00367         }
00368                             
00369     HMemory &
00370     operator = (HMemory const & rhs) throw ()
00371         { 
00372         if (Destroy() != NO_ERROR)
00373             throw HError::GetLastError();
00374         
00375         if (rhs.IsValid())
00376             {
00377             if (create(rhs.m_uBytes, rhs.m_pData) != NO_ERROR)
00378                 throw HError::GetLastError();
00379             }
00380         else
00381             HError::Throw(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00382 
00383         return *this; 
00384         }
00385     };
00394 template <uint32 BUFFER_SIZE>
00395 class HMem : public HObj
00396     {
00397     typedef HObj        base_class;
00398     static StringPtr    ClassName(void) { return "HMem"; }
00399 /*  ----------------------------------------------------------------------
00400     VARIABLES
00401     ----------------------------------------------------------------------  */
00402 protected:
00403     uint8               m_buffer[BUFFER_SIZE];  
00404 /*  ----------------------------------------------------------------------
00405     CTOR / DETOR
00406     ----------------------------------------------------------------------  */
00407 public:
00408     HMem() 
00409         { (void) Zero(); }
00410         
00411     HMem(PtrConst pData, uint32 uSize) throw()
00412         { 
00413         if (assign(pData, uSize) != NO_ERROR)
00414             throw HError::GetLastError();
00415         }
00416 
00417     virtual
00418     ~HMem() 
00419         { /* STUB DTOR */ };
00420 /*  ----------------------------------------------------------------------
00421     METHODS
00422     ----------------------------------------------------------------------  */
00423 public:
00428     ErrCode
00429     Zero(void) 
00430         { 
00431         if (BUFFER_SIZE > 0)
00432             MEM_ZERO(m_buffer, BUFFER_SIZE); 
00433         return HError::NoError();
00434         }
00435 
00436 protected:
00444     ErrCode
00445     assign(PtrData pData, uint32 uBytes)
00446         {
00447         ErrCode     ec = HError::NoError();
00448         
00449         if (validPtr(pData) && uBytes > 0)
00450             {
00451             if (uBytes > BUFFER_SIZE)
00452                 {
00453                 uBytes = BUFFER_SIZE;
00454                 ec = HError::Set(ERR_BUFFER_OVERFLOW, __FILE__, __LINE__);
00455                 }
00456 
00457             (void) MEM_COPY(m_buffer, pData, uBytes);
00458             }
00459         else
00460             ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00461         
00462         return ec;
00463         }
00464 /*  ----------------------------------------------------------------------
00465     GETTERS / SETTERS
00466     ----------------------------------------------------------------------  */
00467 public:
00473     inline uint8        GetAt(uint32 udx) const
00474                             { return validIndex(udx) ? m_buffer[udx] : '\0'; }
00479     inline static uint32 GetSize(void)
00480                             { return BUFFER_SIZE; }
00488     ErrCode             SetAt(uint32 udx, uint8 xVal) 
00489                             { 
00490                             ErrCode     ec = HError::NoError();
00491                             
00492                             if (validIndex(udx))
00493                                 m_buffer[udx] = xVal; 
00494                             else
00495                                 ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00496 
00497                             return ec;
00498                             }
00507     ErrCode             SetAt(uint32 udx, PtrConst pData, uint32 uBytes) 
00508                             { 
00509                             ErrCode     ec = HError::NoError();
00510                             
00511                             if (GOOD_PTR(pData) && uBytes > 0)
00512                                 {
00513                                 if (validIndex(udx))
00514                                     {
00515                                     uint32  uCount = BUFFER_SIZE - udx;
00516                                     
00517                                     if (uCount > uBytes)
00518                                         {
00519                                         uCount = uBytes;
00520                                         ec = HError::Set(ERR_BUFFER_OVERFLOW, __FILE__, __LINE__);
00521                                         }
00522                             
00523                                     if (uCount > 0)
00524                                         (void) MEM_COPY(&m_buffer[udx], pData, uCount);
00525                                     }
00526                                 else
00527                                     ec = HError::Set(ERR_OUT_OF_RANGE, __FILE__, __LINE__);
00528                                 }
00529                             else
00530                                 ec = HError::Set(ERR_BAD_PARAMETER, __FILE__, __LINE__);
00531                             
00532                             return ec;
00533                             }
00534 /*  ----------------------------------------------------------------------
00535     INLINES
00536     ----------------------------------------------------------------------  */
00537 protected:
00543     inline bool         validIndex(const uint32 udx) const
00544                             { return (udx >= 0 && udx < BUFFER_SIZE); }
00555     inline bool         validPtr(PtrConst pData) const
00556                             { return (GOOD_PTR(pData) && pData != m_buffer); }
00557 /*  ----------------------------------------------------------------------
00558     OPERATORS
00559     ----------------------------------------------------------------------  */
00560 public:
00561     operator PtrDataConst() const   
00562         { return m_buffer; }
00563 
00564     uint8 &             
00565     operator [] (uint32 udx) throw (HError)
00566         {
00567         if (!validIndex(udx))
00568             HError::Throw(ERR_OUT_OF_RANGE, __FILE__, __LINE__);
00569             
00570         return m_buffer[udx];
00571         }
00572 
00573     uint8
00574     operator [] (uint32 udx) const throw (HError)
00575         { return GetAt(udx); }
00576 
00577     HMem &          
00578     operator = (HMem const & rhs) throw()
00579         {
00580         if (assign(rhs.m_buffer, rhs.GetSize()) != NO_ERROR)
00581             throw HError::GetLastError();
00582 
00583         return *this; 
00584         }
00585     };
00586 #endif  // HMEM_H
00587 /****************************************************************************
00588 **
00589 **  $History: HMemory.h $
00590  * 
00591  * *****************  Version 4  *****************
00592  * User: Neusel       Date: 12/23/04   Time: 1:34p
00593  * Updated in $/SkyOS.root/pig/Humble
00594  * Posted as HFramework-debug 20041223
00595  * 
00596  * *****************  Version 3  *****************
00597  * User: Neusel       Date: 12/08/04   Time: 5:06p
00598  * Updated in $/SkyOS.root/pig/Humble
00599  * 20041208
00600  * 
00601  * *****************  Version 2  *****************
00602  * User: Neusel       Date: 11/30/04   Time: 1:01p
00603  * Updated in $/SkyOS.root/pig/Humble
00604  * Released as HUMBLE_VER 20041130.
00605  * 
00606  * *****************  Version 1  *****************
00607  * User: Neusel       Date: 11/23/04   Time: 8:24a
00608  * Created in $/SkyOS.root/pig/Humble
00609 **
00610 **  -------------------------------------------------------------------------
00611 **
00612 **  End of HMem.h
00613 **
00614 ****************************************************************************/
00615
Humble Framework for SkyOS

HMemory.h
