home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / PowerPlant / Memory Allocator / Templates / Accessors.t next >
Encoding:
Text File  |  1995-10-24  |  3.5 KB  |  117 lines  |  [TEXT/CWIE]
  1. //    ----------------------------------------------------------------------------
  2. //    Accessors.t
  3. //    ----------------------------------------------------------------------------
  4. //    By Jean-François Brouillet, Copyright © 1995
  5. //
  6. //    V0.001        951013    JFB        Tests passed.
  7. //    V0.000        951012    JFB        Creation
  8. //
  9. //    No restriction on use. But please, use with caution as this is not
  10. //    thoroughly tested. 
  11.  
  12.  
  13. #ifndef        __ACCESSORS__
  14. #define        __ACCESSORS__
  15.  
  16. #include    <string.h>
  17.  
  18. //    ----------------------------------------------------------------------------
  19. //    template align32bits
  20. //    ----------------------------------------------------------------------------
  21. template <class T>
  22. inline T align32bits(T inVal)
  23. {
  24.     size_t    vSizer = (size_t) inVal;
  25.     vSizer += 3;
  26.     vSizer &= ~3;
  27.     return (T) vSizer;
  28. }
  29.  
  30. //    ----------------------------------------------------------------------------
  31. //    template peek
  32. //    ----------------------------------------------------------------------------
  33. template <class T, class U>
  34. inline void peek(T & inVal, U * ioAddress, long inOffset)
  35. {
  36.     size_t    vSizer = * (size_t *) ioAddress;
  37.     vSizer += inOffset;
  38.     inVal = * (T *) vSizer;
  39. }
  40.  
  41. //    ----------------------------------------------------------------------------
  42. //    template fetch
  43. //    ----------------------------------------------------------------------------
  44. template <class T, class U>
  45. inline void fetch(T & inVal, U * ioAddress)
  46. {
  47.     size_t    vSizer = * (size_t *) ioAddress;
  48.     vSizer += sizeof(T);
  49.     inVal = * (T *) *ioAddress;
  50.     * ioAddress = (U) vSizer;
  51. }
  52.  
  53. //    ----------------------------------------------------------------------------
  54. //    template prefetch
  55. //    ----------------------------------------------------------------------------
  56. template <class T, class U>
  57. inline void prefetch(T & inVal, U * ioAddress)
  58. {
  59.     size_t    vSizer = * (size_t *) ioAddress;
  60.     vSizer -= sizeof(T);
  61.     inVal = * (T *) vSizer;
  62.     * ioAddress = (U) vSizer;
  63. }
  64.  
  65. //    ----------------------------------------------------------------------------
  66. //    template fetch_array
  67. //    ----------------------------------------------------------------------------
  68. template <class T, class U>
  69. inline void fetch_array(T inVal, U * ioAddress)
  70. {
  71.     size_t    vSizer = * (size_t *) ioAddress;
  72.     unsigned char * p = (unsigned char *) *ioAddress;
  73.     unsigned char length = 1 + *p;
  74.     vSizer += length;
  75.     ::memcpy(inVal, *ioAddress, length);
  76.     * ioAddress = (U) vSizer;
  77. }
  78.  
  79. //    ----------------------------------------------------------------------------
  80. //    template stash
  81. //    ----------------------------------------------------------------------------
  82. template <class T, class U>
  83. inline void stash(T inVal, U * ioAddress)
  84. {
  85.     size_t    vSizer = * (size_t *) ioAddress;
  86.     * (T *) vSizer = inVal;
  87.     vSizer += sizeof(T);
  88.     * ioAddress = (U) vSizer;
  89. }
  90.  
  91. //    ----------------------------------------------------------------------------
  92. //    template prestash
  93. //    ----------------------------------------------------------------------------
  94. template <class T, class U>
  95. inline void prestash(T inVal, U * ioAddress)
  96. {
  97.     size_t    vSizer = * (size_t *) ioAddress;
  98.     vSizer -= sizeof(T);
  99.     * (T *) vSizer = inVal;
  100.     * ioAddress = (U) vSizer;
  101. }
  102.  
  103. //    ----------------------------------------------------------------------------
  104. //    template stash_array
  105. //    ----------------------------------------------------------------------------
  106. template <class T, class U>
  107. inline void stash_array(T inVal, U * ioAddress)
  108. {
  109.     size_t    vSizer = * (size_t *) ioAddress;
  110.     unsigned char * p = (unsigned char *) inVal;
  111.     unsigned char length = 1 + *p;
  112.     vSizer += length;
  113.     ::memcpy(*ioAddress, p, length);
  114.     * ioAddress = (U) vSizer;
  115. }
  116.  
  117. #endif    /*    __ACCESSORS__    */