home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / iomanip.h < prev    next >
C/C++ Source or Header  |  1998-06-16  |  5KB  |  154 lines
  1. /***
  2. *iomanip.h - definitions/declarations for iostream's parameterized manipulators
  3. *
  4. *       Copyright (c) 1991-1997, Microsoft Corporation.  All rights reserved.
  5. *
  6. *Purpose:
  7. *       This file defines the classes, values, macros, and functions
  8. *       used by the iostream classes' paramterized manipulators.
  9. *       [AT&T C++]
  10. *
  11. *       [Public]
  12. *
  13. ****/
  14.  
  15. #if     _MSC_VER > 1000
  16. #pragma once
  17. #endif
  18.  
  19. #ifdef  __cplusplus
  20.  
  21. #ifndef _INC_IOMANIP
  22. #define _INC_IOMANIP
  23.  
  24. #if     !defined(_WIN32) && !defined(_MAC)
  25. #error ERROR: Only Mac or Win32 targets supported!
  26. #endif
  27.  
  28.  
  29. #ifdef  _MSC_VER
  30. // Currently, all MS C compilers for Win32 platforms default to 8 byte
  31. // alignment.
  32. #pragma pack(push,8)
  33.  
  34. #include <useoldio.h>
  35.  
  36. #endif  // _MSC_VER
  37.  
  38. #include <iostream.h>
  39.  
  40. #ifdef  _MSC_VER
  41. #pragma warning(disable:4514)           // disable unwanted /W4 warning
  42. // #pragma warning(default:4514)        // use this to reenable, if necessary
  43. #endif  // _MSC_VER
  44.  
  45. // #define __MKMANIP(X) \#define X##(T) __##X##_ \#\# T
  46. // __MKMANIP(SMANIP);
  47. // __MKMANIP(SAPP);
  48. // __MKMANIP(IMANIP);
  49. // __MKMANIP(IAPP);
  50. // __MKMANIP(OMANIP);
  51. // __MKMANIP(OAPP);
  52. // __MKMANIP(IOMANIP);
  53. // __MKMANIP(IOAPP);
  54.  
  55. #define SMANIP(T) __SMANIP_##T
  56. #define SAPP(T) __SAPP_##T
  57. #define IMANIP(T) __IMANIP_##T
  58. #define IAPP(T) __IAPP_##T
  59. #define OMANIP(T) __OMANIP_##T
  60. #define OAPP(T) __OAPP_##T
  61. #define IOMANIP(T) __IOMANIP_##T
  62. #define IOAPP(T) __IOAPP_##T
  63.  
  64. #define IOMANIPdeclare(T)  \
  65. class SMANIP(T) { \
  66. public: \
  67.         SMANIP(T)(ios& (*f)(ios&,T), T t) : _fp(f), _tp(t) {} \
  68.         friend istream& operator>>(istream& s, const SMANIP(T) & sm) { (*(sm._fp))(s,sm._tp); return s; } \
  69.         friend ostream& operator<<(ostream& s, const SMANIP(T) & sm) { (*(sm._fp))(s,sm._tp); return s; } \
  70. private:        \
  71.         ios& (* _fp)(ios&,T); \
  72.         T _tp; \
  73. };      \
  74. class SAPP(T) { \
  75. public: \
  76.         SAPP(T)( ios& (*f)(ios&,T)) : _fp(f) {} \
  77.         SMANIP(T) operator()(T t) { return SMANIP(T)(_fp,t); }  \
  78. private:        \
  79.         ios& (* _fp)(ios&,T); \
  80. };      \
  81. class IMANIP(T) { \
  82. public: \
  83.         IMANIP(T)(istream& (*f)(istream&,T), T t) : _fp(f), _tp(t) {} \
  84.         friend istream& operator>>(istream& s, IMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
  85. private:        \
  86.         istream& (* _fp)(istream&,T); \
  87.         T _tp;  \
  88. };      \
  89. class IAPP(T) { \
  90. public: \
  91.         IAPP(T)( istream& (*f)(istream&,T)) : _fp(f) {} \
  92.         IMANIP(T) operator()(T t) { return IMANIP(T)(_fp,t); }  \
  93. private:        \
  94.         istream& (* _fp)(istream&,T); \
  95. };      \
  96. class OMANIP(T) { \
  97. public: \
  98.         OMANIP(T)(ostream& (*f)(ostream&,T), T t) : _fp(f), _tp(t) {} \
  99.         friend ostream& operator<<(ostream& s, OMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
  100. private:        \
  101.         ostream& (* _fp)(ostream&,T); \
  102.         T _tp; \
  103. };      \
  104. class OAPP(T) { \
  105. public: \
  106.         OAPP(T)(ostream& (*f)(ostream&,T)) : _fp(f) {}  \
  107.         OMANIP(T) operator()(T t) { return OMANIP(T)(_fp,t); } \
  108. private:        \
  109.         ostream& (* _fp)(ostream&,T); \
  110. };      \
  111. \
  112. class IOMANIP(T) { \
  113. public: \
  114.         IOMANIP(T)(iostream& (*f)(iostream&,T), T t) : _fp(f), _tp(t) {} \
  115.         friend istream& operator>>(iostream& s, IOMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
  116.         friend ostream& operator<<(iostream& s, IOMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
  117. private:        \
  118.         iostream& (* _fp)(iostream&,T); \
  119.         T _tp; \
  120. };      \
  121. class IOAPP(T) {        \
  122. public: \
  123.         IOAPP(T)( iostream& (*f)(iostream&,T)) : _fp(f) {}      \
  124.         IOMANIP(T) operator()(T t) { return IOMANIP(T)(_fp,t); }        \
  125. private:        \
  126.         iostream& (* _fp)(iostream&,T); \
  127. }; \
  128.  
  129.         
  130. IOMANIPdeclare(int)
  131.  
  132. IOMANIPdeclare(long)
  133.  
  134. inline ios& __resetiosflags(ios& s, long _flg) { s.setf(0,_flg); return s; }
  135. inline ios& __setfill(ios& s, int _fc) { s.fill((char)_fc); return s; }
  136. inline ios& __setiosflags(ios& s, long _flg) { s.setf(_flg); return s; }
  137. inline ios& __setprecision(ios& s, int _pre) { s.precision(_pre); return s; }
  138. inline ios& __setw(ios& s, int _wid) { s.width(_wid); return s; }
  139.  
  140. inline SMANIP(long)     resetiosflags(long _l) { return SMANIP(long)(__resetiosflags, _l); }
  141. inline SMANIP(int)      setfill(int _m) {return SMANIP(int)(__setfill, _m); }
  142. inline SMANIP(long)     setiosflags(long _l) {return SMANIP(long)(__setiosflags, _l); }
  143. inline SMANIP(int)      setprecision(int _p) {return SMANIP(int)(__setprecision, _p); }
  144. inline SMANIP(int)      setw(int _w) { return SMANIP(int)(__setw, _w); }
  145.  
  146. // Restore previous packing
  147. #ifdef  _MSC_VER
  148. #pragma pack(pop)
  149. #endif  // _MSC_VER
  150.  
  151. #endif  // _INC_IOMANIP
  152.  
  153. #endif  /* __cplusplus */
  154.