Return to iomanip.h CVS log

Up to [WindowsNT SDKs] / mstools / h

Annotation of mstools/h/iomanip.h, revision 1.1.1.2

1.1       root        1: /***
                      2: *iomanip.h - definitions/declarations for iostream's parameterized manipulators
                      3: *
1.1.1.2 ! root        4: *      Copyright (c) 1991-1993, Microsoft Corporation.  All rights reserved.
1.1       root        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: ****/
                     12: 
                     13: #ifndef _INC_IOMANIP
                     14: #define _INC_IOMANIP
                     15: #include <iostream.h>
                     16: 
                     17: // Force word packing to avoid possible -Zp override
                     18: #pragma pack(4)
                     19: 
                     20: #pragma warning(disable:4505)          // disable unwanted /W4 warning
                     21: // #pragma warning(default:4505)       // use this to reenable, if necessary
                     22: 
                     23: // CONSIDER: use macro to define these
                     24: // #define __MKMANIP(X) \#define X##(T) __##X##_ \#\# T
                     25: // __MKMANIP(SMANIP);
                     26: // __MKMANIP(SAPP);
                     27: // __MKMANIP(IMANIP);
                     28: // __MKMANIP(IAPP);
                     29: // __MKMANIP(OMANIP);
                     30: // __MKMANIP(OAPP);
                     31: // __MKMANIP(IOMANIP);
                     32: // __MKMANIP(IOAPP);
                     33: 
                     34: #define SMANIP(T) __SMANIP_##T
                     35: #define SAPP(T) __SAPP_##T
                     36: #define IMANIP(T) __IMANIP_##T
                     37: #define IAPP(T) __IAPP_##T
                     38: #define OMANIP(T) __OMANIP_##T
                     39: #define OAPP(T) __OAPP_##T
                     40: #define IOMANIP(T) __IOMANIP_##T
                     41: #define IOAPP(T) __IOAPP_##T
                     42: 
                     43: #define IOMANIPdeclare(T)  \
                     44: class SMANIP(T) { \
                     45: public:        \
                     46:        SMANIP(T)(ios& (*f)(ios&,T), T t) { _fp = f; _tp = t; } \
1.1.1.2 ! root       47:        friend istream& operator>>(istream& s, const SMANIP(T) & sm) { (*(sm._fp))(s,sm._tp); return s; } \
        !            48:        friend ostream& operator<<(ostream& s, const SMANIP(T) & sm) { (*(sm._fp))(s,sm._tp); return s; } \
1.1       root       49: private:       \
                     50:        ios& (* _fp)(ios&,T); \
                     51:        T _tp; \
                     52: };     \
                     53: class SAPP(T) {        \
                     54: public:        \
                     55:        SAPP(T)( ios& (*f)(ios&,T)) { _fp = f; }        \
                     56:        SMANIP(T) operator()(T t) { return SMANIP(T)(_fp,t); }  \
                     57: private:       \
                     58:        ios& (* _fp)(ios&,T); \
                     59: };     \
                     60: class IMANIP(T) { \
                     61: public:        \
                     62:        IMANIP(T)(istream& (*f)(istream&,T), T t) { _fp = f; _tp = t; } \
                     63:        friend istream& operator>>(istream& s, IMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
                     64: private:       \
                     65:        istream& (* _fp)(istream&,T); \
                     66:        T _tp;  \
                     67: };     \
                     68: class IAPP(T) {        \
                     69: public:        \
                     70:        IAPP(T)( istream& (*f)(istream&,T)) { _fp = f; }        \
                     71:        IMANIP(T) operator()(T t) { return IMANIP(T)(_fp,t); }  \
                     72: private:       \
                     73:        istream& (* _fp)(istream&,T); \
                     74: };     \
                     75: class OMANIP(T) { \
                     76: public:        \
                     77:        OMANIP(T)(ostream& (*f)(ostream&,T), T t) { _fp = f; _tp = t; } \
                     78:        friend ostream& operator<<(ostream& s, OMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
                     79: private:       \
                     80:        ostream& (* _fp)(ostream&,T); \
                     81:        T _tp; \
                     82: };     \
                     83: class OAPP(T) {        \
                     84: public:        \
                     85:        OAPP(T)(ostream& (*f)(ostream&,T)) { _fp = f; } \
                     86:        OMANIP(T) operator()(T t) { return OMANIP(T)(_fp,t); } \
                     87: private:       \
                     88:        ostream& (* _fp)(ostream&,T); \
                     89: };     \
                     90: \
                     91: class IOMANIP(T) { \
                     92: public:        \
                     93:        IOMANIP(T)(iostream& (*f)(iostream&,T), T t) { _fp = f; _tp = t; } \
                     94:        friend istream& operator>>(iostream& s, IOMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
                     95:        friend ostream& operator<<(iostream& s, IOMANIP(T) & sm) { (*sm._fp)(s,sm._tp); return s; } \
                     96: private:       \
                     97:        iostream& (* _fp)(iostream&,T); \
                     98:        T _tp; \
                     99: };     \
                    100: class IOAPP(T) {       \
                    101: public:        \
                    102:        IOAPP(T)( iostream& (*f)(iostream&,T)) { _fp = f; }     \
                    103:        IOMANIP(T) operator()(T t) { return IOMANIP(T)(_fp,t); }        \
                    104: private:       \
                    105:        iostream& (* _fp)(iostream&,T); \
                    106: }; \
                    107: 
                    108:        
                    109: IOMANIPdeclare(int)
                    110: 
                    111: IOMANIPdeclare(long)
                    112: 
                    113: inline ios& __resetiosflags(ios& s, long _flg) { s.setf(0,_flg); return s; }
                    114: inline ios& __setfill(ios& s, int _fc) { s.fill((char)_fc); return s; }
                    115: inline ios& __setiosflags(ios& s, long _flg) { s.setf(_flg); return s; }
                    116: inline ios& __setprecision(ios& s, int _pre) { s.precision(_pre); return s; }
                    117: inline ios& __setw(ios& s, int _wid) { s.width(_wid); return s; }
                    118: 
                    119: inline SMANIP(long)    resetiosflags(long _l) { return SMANIP(long)(__resetiosflags, _l); }
                    120: inline SMANIP(int)     setfill(int _m) {return SMANIP(int)(__setfill, _m); }
                    121: inline SMANIP(long)    setiosflags(long _l) {return SMANIP(long)(__setiosflags, _l); }
                    122: inline SMANIP(int)     setprecision(int _p) {return SMANIP(int)(__setprecision, _p); }
                    123: inline SMANIP(int)     setw(int _w) { return SMANIP(int)(__setw, _w); }
                    124: 
                    125: // Restore default packing
                    126: #pragma pack()
                    127: 
                    128: #endif         // !_INC_IOMANIP

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