2011-09-02 18:51:20 +02:00
|
|
|
#ifndef buffer_hh_INCLUDED
|
|
|
|
#define buffer_hh_INCLUDED
|
|
|
|
|
|
|
|
#include <vector>
|
2011-09-08 02:13:19 +02:00
|
|
|
#include <list>
|
|
|
|
#include <memory>
|
2013-01-31 18:58:25 +01:00
|
|
|
#include <unordered_set>
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2011-09-17 16:13:33 +02:00
|
|
|
#include "line_and_column.hh"
|
2012-04-03 15:39:20 +02:00
|
|
|
#include "option_manager.hh"
|
2012-06-07 15:29:44 +02:00
|
|
|
#include "hook_manager.hh"
|
2012-04-14 03:17:09 +02:00
|
|
|
#include "string.hh"
|
2012-08-22 23:33:52 +02:00
|
|
|
#include "units.hh"
|
2011-09-05 21:06:31 +02:00
|
|
|
|
2011-09-02 18:51:20 +02:00
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
|
|
|
class Buffer;
|
2011-09-08 02:13:19 +02:00
|
|
|
|
2012-10-11 00:41:48 +02:00
|
|
|
struct BufferCoord : LineAndColumn<BufferCoord, LineCount, ByteCount>
|
2011-09-02 18:51:20 +02:00
|
|
|
{
|
2012-10-11 00:41:48 +02:00
|
|
|
constexpr BufferCoord(LineCount line = 0, ByteCount column = 0)
|
2011-09-05 21:06:31 +02:00
|
|
|
: LineAndColumn(line, column) {}
|
2011-09-02 18:51:20 +02:00
|
|
|
};
|
|
|
|
|
2012-01-11 15:21:58 +01:00
|
|
|
// A BufferIterator permits to iterate over the characters of a buffer
|
2011-09-02 18:51:20 +02:00
|
|
|
class BufferIterator
|
|
|
|
{
|
|
|
|
public:
|
2012-10-01 20:20:08 +02:00
|
|
|
typedef char value_type;
|
2012-08-23 23:56:35 +02:00
|
|
|
typedef size_t difference_type;
|
2011-09-02 18:51:20 +02:00
|
|
|
typedef const value_type* pointer;
|
|
|
|
typedef const value_type& reference;
|
|
|
|
typedef std::bidirectional_iterator_tag iterator_category;
|
|
|
|
|
2012-04-04 15:56:19 +02:00
|
|
|
BufferIterator() : m_buffer(nullptr) {}
|
2012-03-30 13:37:18 +02:00
|
|
|
BufferIterator(const Buffer& buffer, BufferCoord coord);
|
2011-09-02 18:51:20 +02:00
|
|
|
|
|
|
|
bool operator== (const BufferIterator& iterator) const;
|
|
|
|
bool operator!= (const BufferIterator& iterator) const;
|
|
|
|
bool operator< (const BufferIterator& iterator) const;
|
|
|
|
bool operator<= (const BufferIterator& iterator) const;
|
2011-09-28 22:53:29 +02:00
|
|
|
bool operator> (const BufferIterator& iterator) const;
|
|
|
|
bool operator>= (const BufferIterator& iterator) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-10-01 20:20:08 +02:00
|
|
|
char operator* () const;
|
2012-08-23 23:56:35 +02:00
|
|
|
size_t operator- (const BufferIterator& iterator) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-10-11 00:41:48 +02:00
|
|
|
BufferIterator operator+ (ByteCount size) const;
|
|
|
|
BufferIterator operator- (ByteCount size) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-10-11 00:41:48 +02:00
|
|
|
BufferIterator& operator+= (ByteCount size);
|
|
|
|
BufferIterator& operator-= (ByteCount size);
|
2011-09-02 18:51:20 +02:00
|
|
|
|
|
|
|
BufferIterator& operator++ ();
|
|
|
|
BufferIterator& operator-- ();
|
|
|
|
|
2012-10-02 14:09:06 +02:00
|
|
|
BufferIterator operator++ (int);
|
|
|
|
BufferIterator operator-- (int);
|
|
|
|
|
2013-03-15 14:22:42 +01:00
|
|
|
BufferIterator& operator=(const BufferCoord& coord);
|
|
|
|
|
2012-08-15 18:18:12 +02:00
|
|
|
void clamp(bool avoid_eol);
|
|
|
|
|
2011-09-02 18:51:20 +02:00
|
|
|
bool is_begin() const;
|
|
|
|
bool is_end() const;
|
2011-10-24 16:26:21 +02:00
|
|
|
bool is_valid() const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2011-09-02 20:35:22 +02:00
|
|
|
const Buffer& buffer() const;
|
2012-07-16 21:51:37 +02:00
|
|
|
const BufferCoord& coord() const { return m_coord; }
|
2013-01-23 13:47:45 +01:00
|
|
|
LineCount line() const { return m_coord.line; }
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount column() const { return m_coord.column; }
|
|
|
|
ByteCount offset() const;
|
2012-03-30 13:37:18 +02:00
|
|
|
|
2012-11-22 18:54:37 +01:00
|
|
|
private:
|
2012-11-12 20:07:33 +01:00
|
|
|
safe_ptr<const Buffer> m_buffer;
|
2012-03-30 13:37:18 +02:00
|
|
|
BufferCoord m_coord;
|
2011-09-02 18:51:20 +02:00
|
|
|
};
|
|
|
|
|
2012-07-16 21:51:37 +02:00
|
|
|
class BufferChangeListener
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
virtual void on_insert(const BufferIterator& begin, const BufferIterator& end) = 0;
|
|
|
|
virtual void on_erase(const BufferIterator& begin, const BufferIterator& end) = 0;
|
|
|
|
};
|
|
|
|
|
2012-01-11 15:21:58 +01:00
|
|
|
// A Buffer is a in-memory representation of a file
|
|
|
|
//
|
|
|
|
// The Buffer class permits to read and mutate this file
|
|
|
|
// representation. It also manage modifications undo/redo and
|
|
|
|
// provides tools to deal with the line/column nature of text.
|
2012-06-28 13:45:42 +02:00
|
|
|
class Buffer : public SafeCountable
|
2011-09-02 18:51:20 +02:00
|
|
|
{
|
|
|
|
public:
|
2012-11-20 19:47:56 +01:00
|
|
|
enum class Flags
|
2011-10-07 16:15:55 +02:00
|
|
|
{
|
2012-11-20 19:47:56 +01:00
|
|
|
None = 0,
|
|
|
|
File = 1,
|
|
|
|
New = 2,
|
2012-11-21 13:43:10 +01:00
|
|
|
Fifo = 4,
|
|
|
|
NoUndo = 8,
|
2011-10-07 16:15:55 +02:00
|
|
|
};
|
|
|
|
|
2012-11-23 18:42:07 +01:00
|
|
|
Buffer(String name, Flags flags, std::vector<String> lines = { "\n" });
|
2011-10-24 16:23:13 +02:00
|
|
|
Buffer(const Buffer&) = delete;
|
|
|
|
Buffer& operator= (const Buffer&) = delete;
|
|
|
|
~Buffer();
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-11-20 19:47:56 +01:00
|
|
|
Flags flags() const { return m_flags; }
|
|
|
|
Flags& flags() { return m_flags; }
|
2011-09-06 20:49:32 +02:00
|
|
|
|
2012-09-10 19:26:17 +02:00
|
|
|
void insert(BufferIterator pos, String content);
|
2012-08-14 14:13:10 +02:00
|
|
|
void erase(BufferIterator begin, BufferIterator end);
|
2011-12-07 15:26:40 +01:00
|
|
|
|
2012-08-15 17:07:53 +02:00
|
|
|
size_t timestamp() const { return m_timestamp; }
|
|
|
|
|
2013-02-20 14:20:16 +01:00
|
|
|
void commit_undo_group();
|
2011-09-06 20:49:32 +02:00
|
|
|
bool undo();
|
|
|
|
bool redo();
|
|
|
|
|
2012-03-08 22:23:29 +01:00
|
|
|
String string(const BufferIterator& begin,
|
2011-09-02 18:51:20 +02:00
|
|
|
const BufferIterator& end) const;
|
|
|
|
|
|
|
|
BufferIterator begin() const;
|
|
|
|
BufferIterator end() const;
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount character_count() const;
|
2012-08-22 23:33:52 +02:00
|
|
|
LineCount line_count() const;
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount line_length(LineCount line) const;
|
2012-11-22 18:54:37 +01:00
|
|
|
const String& line_content(LineCount line) const
|
|
|
|
{ return m_lines[line].content; }
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-08-15 18:06:59 +02:00
|
|
|
// returns an iterator at given coordinates. line_and_column is
|
|
|
|
// clamped according to avoid_eol.
|
|
|
|
BufferIterator iterator_at(const BufferCoord& line_and_column,
|
|
|
|
bool avoid_eol = false) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2011-12-05 20:21:11 +01:00
|
|
|
// returns nearest valid coordinates from given ones
|
2012-08-15 18:06:59 +02:00
|
|
|
// if avoid_eol, clamp to character before eol if line is not empty
|
|
|
|
BufferCoord clamp(const BufferCoord& line_and_column,
|
|
|
|
bool avoid_eol = false) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2011-11-28 20:31:29 +01:00
|
|
|
// returns an iterator pointing to the first character of the line
|
|
|
|
// iterator is on
|
|
|
|
BufferIterator iterator_at_line_begin(const BufferIterator& iterator) const;
|
2012-08-21 20:52:49 +02:00
|
|
|
// the same but taking a line number instead of an iterator
|
2012-08-22 23:33:52 +02:00
|
|
|
BufferIterator iterator_at_line_begin(LineCount line) const;
|
2011-11-28 20:31:29 +01:00
|
|
|
|
|
|
|
// returns an iterator pointing to the character after the last of the
|
|
|
|
// line iterator is on (which is the first of the next line if iterator is
|
|
|
|
// not on the last one)
|
|
|
|
BufferIterator iterator_at_line_end(const BufferIterator& iterator) const;
|
2012-08-21 20:52:49 +02:00
|
|
|
// the same but taking a line number instead of an iterator
|
2012-08-22 23:33:52 +02:00
|
|
|
BufferIterator iterator_at_line_end(LineCount line) const;
|
2011-11-28 20:31:29 +01:00
|
|
|
|
2012-11-22 18:54:37 +01:00
|
|
|
const String& name() const { return m_name; }
|
|
|
|
|
|
|
|
// returns true if the buffer is in a different state than
|
|
|
|
// the last time it was saved
|
|
|
|
bool is_modified() const;
|
|
|
|
|
|
|
|
// notify the buffer that it was saved in the current state
|
|
|
|
void notify_saved();
|
2012-03-30 13:37:18 +02:00
|
|
|
|
2012-11-22 13:50:29 +01:00
|
|
|
OptionManager& options() { return m_options; }
|
|
|
|
const OptionManager& options() const { return m_options; }
|
|
|
|
HookManager& hooks() { return m_hooks; }
|
|
|
|
const HookManager& hooks() const { return m_hooks; }
|
2012-04-03 15:39:20 +02:00
|
|
|
|
2013-01-31 18:58:25 +01:00
|
|
|
std::unordered_set<BufferChangeListener*>& change_listeners() const { return m_change_listeners; }
|
2011-09-02 18:51:20 +02:00
|
|
|
private:
|
|
|
|
friend class BufferIterator;
|
|
|
|
|
2012-03-30 13:37:18 +02:00
|
|
|
void check_invariant() const;
|
|
|
|
|
|
|
|
struct Line
|
|
|
|
{
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount start;
|
2012-03-30 13:37:18 +02:00
|
|
|
String content;
|
2012-03-30 14:00:40 +02:00
|
|
|
|
2012-10-11 00:41:48 +02:00
|
|
|
ByteCount length() const { return content.length(); }
|
2012-03-30 13:37:18 +02:00
|
|
|
};
|
2012-08-22 23:33:52 +02:00
|
|
|
struct LineList : std::vector<Line>
|
|
|
|
{
|
|
|
|
Line& operator[](LineCount line)
|
|
|
|
{ return std::vector<Line>::operator[]((int)line); }
|
|
|
|
|
|
|
|
const Line& operator[](LineCount line) const
|
|
|
|
{ return std::vector<Line>::operator[]((int)line); }
|
|
|
|
};
|
|
|
|
LineList m_lines;
|
2012-03-30 13:37:18 +02:00
|
|
|
|
2012-08-10 19:12:43 +02:00
|
|
|
void do_insert(const BufferIterator& pos, const String& content);
|
2012-10-08 19:25:17 +02:00
|
|
|
void do_erase(const BufferIterator& begin, const BufferIterator& end);
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-04-14 03:17:09 +02:00
|
|
|
String m_name;
|
2012-11-20 19:47:56 +01:00
|
|
|
Flags m_flags;
|
2011-09-06 20:49:32 +02:00
|
|
|
|
2012-08-10 19:12:43 +02:00
|
|
|
struct Modification;
|
2011-12-06 19:58:43 +01:00
|
|
|
typedef std::vector<Modification> UndoGroup;
|
2011-09-06 20:49:32 +02:00
|
|
|
|
|
|
|
std::vector<UndoGroup> m_history;
|
|
|
|
std::vector<UndoGroup>::iterator m_history_cursor;
|
2011-10-05 16:21:24 +02:00
|
|
|
UndoGroup m_current_undo_group;
|
2011-09-06 20:49:32 +02:00
|
|
|
|
2011-12-06 19:58:43 +01:00
|
|
|
void apply_modification(const Modification& modification);
|
|
|
|
void revert_modification(const Modification& modification);
|
2011-09-06 20:49:32 +02:00
|
|
|
|
2011-11-03 14:44:02 +01:00
|
|
|
size_t m_last_save_undo_index;
|
2012-08-15 17:07:53 +02:00
|
|
|
size_t m_timestamp;
|
2011-10-18 00:05:06 +02:00
|
|
|
|
2012-11-22 14:08:55 +01:00
|
|
|
// this is mutable as adding or removing listeners is not muting the
|
|
|
|
// buffer observable state.
|
2013-01-31 18:58:25 +01:00
|
|
|
mutable std::unordered_set<BufferChangeListener*> m_change_listeners;
|
2012-04-03 15:39:20 +02:00
|
|
|
|
2012-11-22 13:50:29 +01:00
|
|
|
OptionManager m_options;
|
|
|
|
HookManager m_hooks;
|
2011-09-02 18:51:20 +02:00
|
|
|
};
|
|
|
|
|
2012-11-20 19:47:56 +01:00
|
|
|
constexpr Buffer::Flags operator|(Buffer::Flags lhs, Buffer::Flags rhs)
|
|
|
|
{
|
|
|
|
return (Buffer::Flags)((int) lhs | (int) rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Buffer::Flags& operator|=(Buffer::Flags& lhs, Buffer::Flags rhs)
|
|
|
|
{
|
|
|
|
(int&) lhs |= (int) rhs;
|
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr bool operator&(Buffer::Flags lhs, Buffer::Flags rhs)
|
|
|
|
{
|
|
|
|
return ((int) lhs & (int) rhs) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Buffer::Flags& operator&=(Buffer::Flags& lhs, Buffer::Flags rhs)
|
|
|
|
{
|
|
|
|
(int&) lhs &= (int) rhs;
|
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr Buffer::Flags operator~(Buffer::Flags lhs)
|
|
|
|
{
|
|
|
|
return (Buffer::Flags)(~(int)lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-02 18:51:20 +02:00
|
|
|
}
|
|
|
|
|
2011-10-27 16:13:39 +02:00
|
|
|
#include "buffer_iterator.inl.hh"
|
2011-10-18 00:05:06 +02:00
|
|
|
|
2011-09-02 18:51:20 +02:00
|
|
|
#endif // buffer_hh_INCLUDED
|