31 #ifndef _UCOMMON_PROTOCOLS_H_
32 #define _UCOMMON_PROTOCOLS_H_
34 #ifndef _UCOMMON_CPR_H_
43 class __EXPORT MemoryProtocol
46 friend class MemoryRedirect;
55 virtual void *_alloc(
size_t size) = 0;
60 virtual void fault(
void)
const;
63 virtual ~MemoryProtocol();
70 inline void *alloc(
size_t size)
71 {
return _alloc(size);}
80 void *zalloc(
size_t size);
88 char *
dup(
const char *
string);
96 void *
dup(
void *memory,
size_t size);
107 MemoryProtocol *target;
112 virtual void *_alloc(
size_t size);
125 virtual void _lock(
void);
126 virtual void _unlock(
void);
146 virtual const char *_print(
void)
const = 0;
167 virtual int _input(
int code) = 0;
187 virtual int _getch(
void) = 0;
194 virtual int _putch(
int code) = 0;
229 {
return _putch(code);}
245 size_t getline(
char *
string,
size_t size);
256 size_t getline(
String& buffer);
264 size_t putline(
const char *
string);
266 size_t putchars(
const char *
string,
size_t count = 0);
295 typedef enum {RDONLY, WRONLY, RDWR} mode_t;
299 char *input, *output;
300 size_t bufsize, bufpos, insize, outsize;
326 virtual void fault(
void)
const;
334 void allocate(
size_t size, mode_t
access = RDWR);
348 char *request(
size_t size);
356 char *gather(
size_t size);
365 virtual size_t _push(
const char *address,
size_t size) = 0;
374 virtual size_t _pull(
char *address,
size_t size) = 0;
380 virtual int _err(
void)
const = 0;
385 virtual void _clear(
void) = 0;
390 virtual bool _blocking(
void);
395 virtual bool _pending(
void);
400 virtual bool _flush(
void);
402 virtual int _getch(
void);
404 virtual int _putch(
int ch);
422 const char *endl(
void)
const
432 size_t put(
const void *address,
size_t count);
440 size_t get(
void *address,
size_t count);
448 size_t printf(
const char *format, ...) __PRINTF(2, 3);
454 inline
bool flush(
void)
477 inline operator bool()
const
478 {
return buffer != NULL;}
485 {
return buffer == NULL;}
492 {
return buffer != NULL;}
499 {
return input != NULL;}
506 {
return output != NULL;}
521 inline int err(
void)
const
524 template<
typename T>
inline size_t write(
const T& data)
525 {
return put(&data,
sizeof(T));}
527 template<
typename T>
inline size_t read(T& data)
528 {
return get(&data,
sizeof(T));}
530 template<
typename T>
inline size_t write(
const T* data,
unsigned count)
531 {
return put(data,
sizeof(T) * count) /
sizeof(T);}
533 template<
typename T>
inline size_t read(T* data,
unsigned count)
534 {
return get(data,
sizeof(T) * count) /
sizeof(T);}
551 virtual void retain(
void) = 0;
556 virtual void release(
void) = 0;
587 virtual int keytype(
void)
const = 0;
592 virtual size_t keysize(
void)
const = 0;
597 virtual const void *
keydata(
void)
const = 0;
599 virtual bool equal(
const KeyProtocol& compare)
const;
601 inline bool operator!=(
const KeyProtocol& compare)
const {
602 return !equal(compare);
636 {
return _character_operators::print(p, s);}
638 inline CharacterProtocol& operator<< (CharacterProtocol& p,
const char& ch)
639 {
return _character_operators::print(p, ch);}
641 inline CharacterProtocol& operator>> (CharacterProtocol& p,
char& ch)
642 {
return _character_operators::input(p, ch);}
644 inline CharacterProtocol& operator>> (CharacterProtocol& p, String& str)
645 {
return _character_operators::input(p, str);}
647 inline CharacterProtocol& operator<< (CharacterProtocol& p,
const PrintProtocol& format)
648 {p.print(format);
return p;}
650 inline CharacterProtocol& operator>> (CharacterProtocol& p, InputProtocol& format)
651 {p.input(format);
return p;}
653 inline CharacterProtocol& operator<< (CharacterProtocol& p,
const StringPager& list)
654 {p.save(&list);
return p;}
656 inline CharacterProtocol& operator>> (CharacterProtocol& p, StringPager& list)
657 {p.load(&list);
return p;}
659 inline CharacterProtocol& operator<< (CharacterProtocol& p,
const long& value)
660 {
return _character_operators::print(p, value);}
662 inline CharacterProtocol& operator>> (CharacterProtocol& p,
long& value)
663 {
return _character_operators::input(p, value);}
665 inline CharacterProtocol& operator<< (CharacterProtocol& p,
const double& value)
666 {
return _character_operators::print(p, value);}
668 inline CharacterProtocol& operator>> (CharacterProtocol& p,
double& value)
669 {
return _character_operators::input(p, value);}
void access(SharedAccess &object)
Convenience function to access (lock) shared object through it's protocol.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
size_t input_pending(void) const
Get current input position.
void putback(int code)
Write to back buffer.
void operator++(void)
Increase retention operator.
At least with gcc, linking of stream operators was broken.
bool is_pending(void)
See if pending input.
void operator--(void)
Decrease retention operator.
bool is_input(void) const
See if input active.
void seteof(void)
Set eof flag.
ObjectProtocol * copy(ObjectProtocol *object)
Convenience function to access object copy.
A copy-on-write string class that operates by reference count.
Used for forming stream output.
T * dup(const T &object)
Convenience function to duplicate object pointer to heap.
A redirection base class for the memory protocol.
A common base class for all managed objects.
bool operator!() const
See if buffer closed.
int putchar(int code)
Put the next character.
Common buffer protocol class.
int getchar(void)
Get the next character.
Common namespace for all ucommon objects.
Key data protocol used for things like maps and ordered lists.
void retain(ObjectProtocol *object)
Convenience function to access object retention.
size_t output_waiting(void) const
Get current output position.
bool is_open(void) const
See if buffer open.
String pager for storing lists of NULL terminated strings.
Used for processing input.
void seteol(const char *string)
Set end of line marker.
bool is_output(void) const
See if output active.
Data keys parsed from a keyfile.
Common character processing protocol.