include/library/messagebuffer.hpp

   1 #ifndef _library__messagebuffer__hpp__included__
   2 #define _library__messagebuffer__hpp__included__
   3
   4 #include <stdexcept>
   5 #include <map>
   6 #include <set>
   7 #include <cstdint>
   8 #include <string>
   9
  10 class messagebuffer
  11 {
  12 public:
  13 /**
  14  * Update handler.
  15  */
  16         class update_handler
  17         {
  18         public:
  19 /**
  20  * Destructor.
  21  */
  22                 virtual ~update_handler() throw();
  23 /**
  24  * Handle update.
  25  */
  26                 virtual void messagebuffer_update() = 0;
  27         };
  28 /**
  29  * Create new message buffer with specified maximum message count.
  30  *
  31  * Parameter maxmessages: The maximum number of messages.
  32  * Parameter windowsize: The initial window size.
  33  * Throws std::bad_alloc: Not enough memory.
  34  * Throws std::logic_error: Windowsize is greater than maxmessages or maxmessages is zero.
  35  */
  36         messagebuffer(size_t maxmessages, size_t windowsize);
  37
  38 /**
  39  * Add a new message to the buffer.
  40  *
  41  * Parameter msg: The new message to add.
  42  * Throws std::bad_alloc: Not enough memory.
  43  * Throws std::runtime_error: Thrown through from update handler.
  44  */
  45         void add_message(const std::string& msg);
  46
  47 /**
  48  * Read a message.
  49  *
  50  * Parameter msgnum: Number of message to read.
  51  * Returns: The read message.
  52  * Throws std::bad_alloc: Not enough memory.
  53  * Throws std::logic_error: Invalid message number.
  54  */
  55         const std::string& get_message(size_t msgnum);
  56
  57 /**
  58  * Get the number of first message present.
  59  *
  60  * Returns: The number of first message present.
  61  */
  62         size_t get_msg_first() throw();
  63
  64 /**
  65  * Get the number of messages present.
  66  *
  67  * Returns: The number of messages present.
  68  */
  69         size_t get_msg_count() throw();
  70
  71 /**
  72  * Get the number of first message visible.
  73  *
  74  * Returns: The number of first message visible.
  75  */
  76         size_t get_visible_first() throw();
  77
  78 /**
  79  * Get the number of messages visible.
  80  *
  81  * Returns: The number of messages visible.
  82  */
  83         size_t get_visible_count() throw();
  84
  85 /**
  86  * Is there more messages after the current window?
  87  *
  88  * Returns: True if there is, false if not.
  89  */
  90         bool is_more_messages() throw();
  91
  92 /**
  93  * Freeze scrolling
  94  */
  95         void freeze_scrolling() throw();
  96
  97 /**
  98  * Unfreeze scrolling
  99  */
 100         void unfreeze_scrolling() throw();
 101
 102 /**
 103  * Freeze updates
 104  */
 105         void freeze_updates() throw();
 106
 107 /**
 108  * Unfreeze updates
 109  *
 110  * Returns: True if update is needed.
 111  */
 112         bool unfreeze_updates() throw();
 113
 114 /**
 115  * Scroll to beginning.
 116  *
 117  * Throws std::bad_alloc: Not enough memory.
 118  * Throws std::runtime_error: Thrown through from update handler.
 119  */
 120         void scroll_beginning();
 121
 122 /**
 123  * Scroll up one page.
 124  *
 125  * Throws std::bad_alloc: Not enough memory.
 126  * Throws std::runtime_error: Thrown through from update handler.
 127  */
 128         void scroll_up_page();
 129
 130 /**
 131  * Scroll up one line.
 132  *
 133  * Throws std::bad_alloc: Not enough memory.
 134  * Throws std::runtime_error: Thrown through from update handler.
 135  */
 136         void scroll_up_line();
 137
 138 /**
 139  * Scroll down one line.
 140  *
 141  * Throws std::bad_alloc: Not enough memory.
 142  * Throws std::runtime_error: Thrown through from update handler.
 143  */
 144         void scroll_down_line();
 145
 146 /**
 147  * Scroll down one page.
 148  *
 149  * Throws std::bad_alloc: Not enough memory.
 150  * Throws std::runtime_error: Thrown through from update handler.
 151  */
 152         void scroll_down_page();
 153
 154 /**
 155  * Scroll to beginning.
 156  *
 157  * Throws std::bad_alloc: Not enough memory.
 158  * Throws std::runtime_error: Thrown through from update handler.
 159  */
 160         void scroll_end();
 161
 162 /**
 163  * Register an update handler.
 164  *
 165  * Parameter handler: The new handler.
 166  * Throws std::bad_alloc: Not enough memory.
 167  */
 168         void register_handler(update_handler& handler);
 169
 170 /**
 171  * Unregister an update handler.
 172  *
 173  * Parameter handler: The handler to remove.
 174  * Throws std::bad_alloc: Not enough memory.
 175  */
 176         void unregister_handler(update_handler& handler) throw();
 177
 178 /**
 179  * Change the window size.
 180  *
 181  * Parameter windowsize: The new window size.
 182  * Throws std::bad_alloc: Not enough memory.
 183  * Throws std::logic_error: Windowsize is greater than maxmessages or maxmessages is zero.
 184  */
 185         void set_max_window_size(size_t windowsize);
 186
 187 /**
 188  * Read the window size.
 189  */
 190         size_t get_max_window_size() throw();
 191 /**
 192  * Read the last message.
 193  */
 194         std::string get_last_message();
 195 private:
 196         void send_notifications();
 197         std::map<uint64_t, std::string> messages_buf;
 198         uint64_t first_present_message;
 199         uint64_t next_message_number;
 200         uint64_t window_start;
 201         size_t max_messages;
 202         size_t window_size;
 203         bool scroll_frozen;
 204         bool updates_frozen;
 205         uint64_t window_start_at_freeze;
 206         uint64_t window_size_at_freeze;
 207         uint64_t next_message_number_at_freeze;
 208         std::set<update_handler*> handlers;
 209 };
 210
 211 #endif