2011-09-02 18:51:20 +02:00
|
|
|
#ifndef buffer_hh_INCLUDED
|
|
|
|
#define buffer_hh_INCLUDED
|
|
|
|
|
2013-04-09 20:05:40 +02:00
|
|
|
#include "hook_manager.hh"
|
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-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
|
|
|
|
2013-04-09 20:05:40 +02:00
|
|
|
#include <vector>
|
|
|
|
#include <list>
|
|
|
|
#include <memory>
|
|
|
|
#include <unordered_set>
|
|
|
|
|
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;
|
2013-05-30 14:05:05 +02:00
|
|
|
typedef std::random_access_iterator_tag iterator_category;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
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;
|
2013-05-30 14:05:05 +02:00
|
|
|
char operator[](size_t n) 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);
|
|
|
|
|
2012-07-16 21:51:37 +02:00
|
|
|
const BufferCoord& coord() const { return m_coord; }
|
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:
|
2013-06-01 00:48:46 +02:00
|
|
|
virtual void on_insert(const Buffer& buffer, const BufferCoord& begin, const BufferCoord& end) = 0;
|
|
|
|
virtual void on_erase(const Buffer& buffer, const BufferCoord& begin, const BufferCoord& end) = 0;
|
2012-07-16 21:51:37 +02:00
|
|
|
};
|
|
|
|
|
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
|
|
|
|
2013-04-22 13:48:18 +02:00
|
|
|
bool set_name(String name);
|
|
|
|
|
2013-05-23 14:17:25 +02:00
|
|
|
void insert(BufferCoord pos, String content);
|
|
|
|
void erase(BufferCoord begin, BufferCoord 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();
|
|
|
|
|
2013-05-30 14:17:19 +02:00
|
|
|
String string(const BufferCoord& begin, const BufferCoord& end) const;
|
2013-06-03 18:56:48 +02:00
|
|
|
|
|
|
|
char byte_at(const BufferCoord& c) const;
|
2013-05-23 19:39:27 +02:00
|
|
|
ByteCount offset(const BufferCoord& c) const;
|
2013-05-30 14:17:19 +02:00
|
|
|
ByteCount distance(const BufferCoord& begin, const BufferCoord& end) const;
|
2013-05-23 19:39:27 +02:00
|
|
|
BufferCoord advance(BufferCoord coord, ByteCount count) const;
|
|
|
|
BufferCoord next(BufferCoord coord) const;
|
|
|
|
BufferCoord prev(BufferCoord coord) const;
|
2013-06-03 18:56:48 +02:00
|
|
|
|
|
|
|
BufferCoord char_next(BufferCoord coord) const;
|
|
|
|
BufferCoord char_prev(BufferCoord coord) const;
|
|
|
|
|
2013-06-04 19:23:11 +02:00
|
|
|
BufferCoord back_coord() const { return { line_count() - 1, m_lines.back().length() - 1 }; }
|
|
|
|
BufferCoord end_coord() const { return { line_count() - 1, m_lines.back().length() }; }
|
|
|
|
|
2013-05-23 19:39:27 +02:00
|
|
|
bool is_valid(const BufferCoord& c) const;
|
|
|
|
bool is_end(const BufferCoord& c) const;
|
2013-04-23 18:46:18 +02:00
|
|
|
|
2011-09-02 18:51:20 +02:00
|
|
|
BufferIterator begin() const;
|
|
|
|
BufferIterator end() const;
|
2013-04-24 13:56:36 +02:00
|
|
|
ByteCount byte_count() const;
|
2012-08-22 23:33:52 +02:00
|
|
|
LineCount line_count() const;
|
2013-06-05 18:41:02 +02:00
|
|
|
|
|
|
|
const String& operator[](LineCount line) const
|
2012-11-22 18:54:37 +01:00
|
|
|
{ return m_lines[line].content; }
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2013-05-30 14:17:19 +02:00
|
|
|
// returns an iterator at given coordinates. clamp line_and_column
|
|
|
|
BufferIterator iterator_at(const BufferCoord& coord) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2011-12-05 20:21:11 +01:00
|
|
|
// returns nearest valid coordinates from given ones
|
2013-05-30 14:17:19 +02:00
|
|
|
BufferCoord clamp(BufferCoord coord) const;
|
2011-09-02 18:51:20 +02:00
|
|
|
|
2012-11-22 18:54:37 +01:00
|
|
|
const String& name() const { return m_name; }
|
2013-03-25 19:58:23 +01:00
|
|
|
String display_name() const;
|
2012-11-22 18:54:37 +01:00
|
|
|
|
|
|
|
// 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
|
|
|
|
2012-03-30 13:37:18 +02:00
|
|
|
void check_invariant() const;
|
2013-04-03 19:22:12 +02:00
|
|
|
private:
|
|
|
|
friend class BufferIterator;
|
2012-03-30 13:37:18 +02:00
|
|
|
|
|
|
|
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
|
|
|
|
2013-05-22 19:21:59 +02:00
|
|
|
void do_insert(const BufferCoord& pos, const String& content);
|
|
|
|
void do_erase(const BufferCoord& begin, const BufferCoord& 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;
|
2013-04-25 14:03:55 +02:00
|
|
|
friend class UndoGroupOptimizer;
|
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);
|
|
|
|
}
|
|
|
|
|
2013-04-02 13:56:30 +02:00
|
|
|
struct BufferListenerRegisterFuncs
|
2013-03-31 13:49:56 +02:00
|
|
|
{
|
2013-04-02 13:56:30 +02:00
|
|
|
static void insert(const Buffer& buffer, BufferChangeListener& listener)
|
2013-03-31 13:49:56 +02:00
|
|
|
{
|
2013-04-02 13:56:30 +02:00
|
|
|
buffer.change_listeners().insert(&listener);
|
2013-03-31 13:49:56 +02:00
|
|
|
}
|
2013-04-02 13:56:30 +02:00
|
|
|
static void remove(const Buffer& buffer, BufferChangeListener& listener)
|
2013-03-31 13:49:56 +02:00
|
|
|
{
|
2013-04-02 13:56:30 +02:00
|
|
|
buffer.change_listeners().erase(&listener);
|
2013-03-31 13:49:56 +02:00
|
|
|
}
|
2013-04-02 13:56:30 +02:00
|
|
|
};
|
2013-03-31 13:49:56 +02:00
|
|
|
|
2013-04-02 13:56:30 +02:00
|
|
|
class BufferChangeListener_AutoRegister
|
|
|
|
: public BufferChangeListener,
|
|
|
|
public AutoRegister<BufferChangeListener_AutoRegister,
|
|
|
|
BufferListenerRegisterFuncs, const Buffer>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
BufferChangeListener_AutoRegister(const Buffer& buffer)
|
|
|
|
: AutoRegister(buffer) {}
|
2013-03-31 13:49:56 +02:00
|
|
|
|
2013-04-02 13:56:30 +02:00
|
|
|
const Buffer& buffer() const { return registry(); }
|
2013-03-31 13:49:56 +02:00
|
|
|
};
|
2012-11-20 19:47:56 +01:00
|
|
|
|
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
|