Return to iomanip.h CVS log

Up to [WindowsNT SDKs] / mstools / h

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

1.1     ! root        1: /***
        !             2: *iomanip.h - definitions/declarations for iostream's parameterized manipulators
        !             3: *
        !             4: *      Copyright (c) 1991-1992, 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: ****/
        !            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; } \
        !            47:        friend istream& operator>>(istream& s, SMANIP(T) & sm) { (*(sm._fp))(s,sm._tp); return s; } \
        !            48:        friend ostream& operator<<(ostream& s, SMANIP(T) & sm) { (*(sm._fp))(s,sm._tp); return s; } \
        !            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.