00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00030 #ifndef _UCOMMON_PROTOCOLS_H_
00031 #define _UCOMMON_PROTOCOLS_H_
00032
00033 #ifndef _UCOMMON_CPR_H_
00034 #include <ucommon/cpr.h>
00035 #endif
00036
00037 NAMESPACE_UCOMMON
00038
00039 class String;
00040 class StringPager;
00041
00042 class __EXPORT MemoryProtocol
00043 {
00044 protected:
00045 friend class MemoryRedirect;
00046
00054 virtual void *_alloc(size_t size) = 0;
00055
00059 virtual void fault(void) const;
00060
00061 public:
00062 virtual ~MemoryProtocol();
00063
00069 inline void *alloc(size_t size)
00070 {return _alloc(size);};
00071
00079 void *zalloc(size_t size);
00080
00087 char *dup(const char *string);
00088
00095 void *dup(void *memory, size_t size);
00096 };
00097
00103 class __EXPORT MemoryRedirect : public MemoryProtocol
00104 {
00105 private:
00106 MemoryProtocol *target;
00107
00108 public:
00109 MemoryRedirect(MemoryProtocol *protocol);
00110
00111 virtual void *_alloc(size_t size);
00112 };
00113
00121 class __EXPORT LockingProtocol
00122 {
00123 protected:
00124 virtual void _lock(void);
00125 virtual void _unlock(void);
00126
00127 public:
00128 virtual ~LockingProtocol();
00129 };
00130
00137 class __EXPORT PrintProtocol
00138 {
00139 public:
00140 virtual ~PrintProtocol();
00141
00145 virtual const char *_print(void) const = 0;
00146 };
00147
00156 class __EXPORT InputProtocol
00157 {
00158 public:
00159 virtual ~InputProtocol();
00160
00166 virtual int _input(int code) = 0;
00167 };
00168
00174 class __EXPORT CharacterProtocol
00175 {
00176 protected:
00177 const char *eol;
00178 int back;
00179
00180 CharacterProtocol();
00181
00186 virtual int _getch(void) = 0;
00187
00193 virtual int _putch(int code) = 0;
00194
00199 inline void putback(int code)
00200 {back = code;}
00201
00209 inline void seteol(const char *string)
00210 {eol = string;};
00211
00212 public:
00213 virtual ~CharacterProtocol();
00214
00219 inline int getchar(void)
00220 {return _getch();};
00221
00227 inline int putchar(int code)
00228 {return _putch(code);};
00229
00230 size_t print(const PrintProtocol& format);
00231
00232 size_t input(InputProtocol& format);
00233
00244 size_t getline(char *string, size_t size);
00245
00255 size_t getline(String& buffer);
00256
00263 size_t putline(const char *string);
00264
00265 size_t putchars(const char *string, size_t count = 0);
00266
00273 size_t load(StringPager *list);
00274
00280 size_t save(const StringPager *list);
00281 };
00282
00291 class __EXPORT BufferProtocol : public CharacterProtocol
00292 {
00293 public:
00294 typedef enum {RDONLY, WRONLY, RDWR} mode_t;
00295
00296 private:
00297 char *buffer;
00298 char *input, *output;
00299 size_t bufsize, bufpos, insize, outsize;
00300 bool end;
00301
00302 protected:
00303 const char *format;
00304
00308 BufferProtocol();
00309
00315 BufferProtocol(size_t size, mode_t access = RDWR);
00316
00320 virtual ~BufferProtocol();
00321
00325 virtual void fault(void) const;
00326
00333 void allocate(size_t size, mode_t access = RDWR);
00334
00338 void release(void);
00339
00347 char *request(size_t size);
00348
00355 char *gather(size_t size);
00356
00364 virtual size_t _push(const char *address, size_t size) = 0;
00365
00373 virtual size_t _pull(char *address, size_t size) = 0;
00374
00379 virtual int _err(void) const = 0;
00380
00384 virtual void _clear(void) = 0;
00385
00389 virtual bool _blocking(void);
00390
00394 virtual bool _pending(void);
00395
00399 virtual bool _flush(void);
00400
00401 virtual int _getch(void);
00402
00403 virtual int _putch(int ch);
00404
00410 inline size_t input_pending(void)
00411 {return bufpos;};
00412
00417 inline size_t output_waiting(void)
00418 {return outsize;};
00419
00420 public:
00421 const char *endl(void)
00422 {return eol;}
00423
00431 size_t put(const void *address, size_t count);
00432
00439 size_t get(void *address, size_t count);
00440
00447 size_t printf(const char *format, ...) __PRINTF(2, 3);
00448
00453 inline bool flush(void)
00454 {return _flush();}
00455
00459 void purge(void);
00460
00464 void reset(void);
00465
00470 bool eof(void);
00471
00476 inline operator bool()
00477 {return buffer != NULL;}
00478
00483 inline bool operator!()
00484 {return buffer == NULL;}
00485
00490 inline bool is_open(void)
00491 {return buffer != NULL;}
00492
00497 inline bool is_input(void)
00498 {return input != NULL;}
00499
00504 inline bool is_output(void)
00505 {return output != NULL;}
00506
00511 inline bool is_pending(void)
00512 {return _pending();}
00513
00517 inline void seteof(void)
00518 {end = true;}
00519
00520 inline int err(void)
00521 {return _err();}
00522
00523 template<typename T> inline size_t write(const T& data)
00524 {return put(&data, sizeof(T));}
00525
00526 template<typename T> inline size_t read(T& data)
00527 {return get(&data, sizeof(T));}
00528
00529 template<typename T> inline size_t write(const T* data, unsigned count)
00530 {return put(data, sizeof(T) * count) / sizeof(T);}
00531
00532 template<typename T> inline size_t read(T* data, unsigned count)
00533 {return get(data, sizeof(T) * count) / sizeof(T);}
00534
00535 };
00536
00544 class __EXPORT ObjectProtocol
00545 {
00546 public:
00550 virtual void retain(void) = 0;
00551
00555 virtual void release(void) = 0;
00556
00560 virtual ~ObjectProtocol();
00561
00565 ObjectProtocol *copy(void);
00566
00570 inline void operator++(void)
00571 {retain();};
00572
00576 inline void operator--(void)
00577 {release();};
00578 };
00579
00584 class __EXPORT _character_operators
00585 {
00586 private:
00587 inline _character_operators() {};
00588
00589 public:
00590 static CharacterProtocol& print(CharacterProtocol& p, const char *s);
00591
00592 static CharacterProtocol& print(CharacterProtocol& p, const char& ch);
00593
00594 static CharacterProtocol& input(CharacterProtocol& p, char& ch);
00595
00596 static CharacterProtocol& input(CharacterProtocol& p, String& str);
00597
00598 static CharacterProtocol& print(CharacterProtocol& p, const long& value);
00599
00600 static CharacterProtocol& input(CharacterProtocol& p, long& value);
00601
00602 static CharacterProtocol& print(CharacterProtocol& p, const double& value);
00603
00604 static CharacterProtocol& input(CharacterProtocol& p, double& value);
00605 };
00606
00607 inline CharacterProtocol& operator<< (CharacterProtocol& p, const char *s)
00608 {return _character_operators::print(p, s);}
00609
00610 inline CharacterProtocol& operator<< (CharacterProtocol& p, const char& ch)
00611 {return _character_operators::print(p, ch);}
00612
00613 inline CharacterProtocol& operator>> (CharacterProtocol& p, char& ch)
00614 {return _character_operators::input(p, ch);}
00615
00616 inline CharacterProtocol& operator>> (CharacterProtocol& p, String& str)
00617 {return _character_operators::input(p, str);}
00618
00619 inline CharacterProtocol& operator<< (CharacterProtocol& p, const PrintProtocol& format)
00620 {p.print(format); return p;}
00621
00622 inline CharacterProtocol& operator>> (CharacterProtocol& p, InputProtocol& format)
00623 {p.input(format); return p;}
00624
00625 inline CharacterProtocol& operator<< (CharacterProtocol& p, const StringPager& list)
00626 {p.save(&list); return p;}
00627
00628 inline CharacterProtocol& operator>> (CharacterProtocol& p, StringPager& list)
00629 {p.load(&list); return p;}
00630
00631 inline CharacterProtocol& operator<< (CharacterProtocol& p, const long& value)
00632 {return _character_operators::print(p, value);}
00633
00634 inline CharacterProtocol& operator>> (CharacterProtocol& p, long& value)
00635 {return _character_operators::input(p, value);}
00636
00637 inline CharacterProtocol& operator<< (CharacterProtocol& p, const double& value)
00638 {return _character_operators::print(p, value);}
00639
00640 inline CharacterProtocol& operator>> (CharacterProtocol& p, double& value)
00641 {return _character_operators::input(p, value);}
00642
00643 END_NAMESPACE
00644
00645 #endif