kakoune/src/buffer.hh

277 lines
8.0 KiB
C++
Raw Normal View History

2011-09-02 18:51:20 +02:00
#ifndef buffer_hh_INCLUDED
#define buffer_hh_INCLUDED
#include "line_and_column.hh"
2013-10-25 01:01:17 +02:00
#include "hook_manager.hh"
#include "option_manager.hh"
2013-10-25 01:01:17 +02:00
#include "keymap_manager.hh"
#include "string.hh"
#include "units.hh"
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;
constexpr time_t InvalidTime = 0;
struct BufferCoord : LineAndColumn<BufferCoord, LineCount, ByteCount>
2011-09-02 18:51:20 +02:00
{
constexpr BufferCoord(LineCount line = 0, ByteCount column = 0)
: LineAndColumn(line, column) {}
2011-09-02 18:51:20 +02:00
};
// A BufferIterator permits to iterate over the characters of a buffer
2011-09-02 18:51:20 +02:00
class BufferIterator
{
public:
typedef char value_type;
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::random_access_iterator_tag iterator_category;
2011-09-02 18:51:20 +02:00
BufferIterator() : m_buffer(nullptr) {}
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
char operator* () const;
char operator[](size_t n) const;
size_t operator- (const BufferIterator& iterator) const;
2011-09-02 18:51:20 +02:00
BufferIterator operator+ (ByteCount size) const;
BufferIterator operator- (ByteCount size) const;
2011-09-02 18:51:20 +02:00
BufferIterator& operator+= (ByteCount size);
BufferIterator& operator-= (ByteCount size);
2011-09-02 18:51:20 +02:00
BufferIterator& operator++ ();
BufferIterator& operator-- ();
BufferIterator operator++ (int);
BufferIterator operator-- (int);
const BufferCoord& coord() const { return m_coord; }
private:
safe_ptr<const Buffer> m_buffer;
BufferCoord m_coord;
2011-09-02 18:51:20 +02:00
};
class BufferChangeListener
{
public:
2013-07-26 00:44:00 +02:00
virtual void on_insert(const Buffer& buffer, BufferCoord begin, BufferCoord end) = 0;
virtual void on_erase(const Buffer& buffer, BufferCoord begin, BufferCoord end) = 0;
};
// 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.
class Buffer : public SafeCountable
2011-09-02 18:51:20 +02:00
{
public:
enum class Flags
2011-10-07 16:15:55 +02:00
{
None = 0,
File = 1,
New = 2,
Fifo = 4,
NoUndo = 8,
2011-10-07 16:15:55 +02:00
};
Buffer(String name, Flags flags, std::vector<String> lines = { "\n" },
time_t fs_timestamp = InvalidTime);
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
Flags flags() const { return m_flags; }
Flags& flags() { return m_flags; }
bool set_name(String name);
BufferIterator insert(const BufferIterator& pos, String content);
BufferIterator erase(BufferIterator begin, BufferIterator end);
2012-08-15 17:07:53 +02:00
size_t timestamp() const { return m_timestamp; }
time_t fs_timestamp() const;
void set_fs_timestamp(time_t ts);
2012-08-15 17:07:53 +02:00
void commit_undo_group();
bool undo();
bool redo();
2013-07-26 00:44:00 +02:00
String string(BufferCoord begin, BufferCoord end) const;
2013-07-26 00:44:00 +02:00
char byte_at(BufferCoord c) const;
ByteCount offset(BufferCoord c) const;
ByteCount distance(BufferCoord begin, BufferCoord end) const;
BufferCoord advance(BufferCoord coord, ByteCount count) const;
BufferCoord next(BufferCoord coord) const;
BufferCoord prev(BufferCoord coord) const;
BufferCoord char_next(BufferCoord coord) const;
BufferCoord char_prev(BufferCoord coord) const;
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-07-26 00:44:00 +02:00
bool is_valid(BufferCoord c) const;
bool is_end(BufferCoord c) const;
2011-09-02 18:51:20 +02:00
BufferIterator begin() const;
BufferIterator end() const;
ByteCount byte_count() const;
LineCount line_count() const;
const String& operator[](LineCount line) const
{ return m_lines[line].content; }
2011-09-02 18:51:20 +02:00
// returns an iterator at given coordinates. clamp line_and_column
2013-07-26 00:44:00 +02:00
BufferIterator iterator_at(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
BufferCoord clamp(BufferCoord coord) const;
2011-09-02 18:51:20 +02:00
const String& name() const { return m_name; }
String display_name() const;
// 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();
OptionManager& options() { return m_options; }
const OptionManager& options() const { return m_options; }
HookManager& hooks() { return m_hooks; }
const HookManager& hooks() const { return m_hooks; }
2013-10-25 01:01:17 +02:00
KeymapManager& keymaps() { return m_keymaps; }
const KeymapManager& keymaps() const { return m_keymaps; }
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
void reload(std::vector<String> lines, time_t fs_timestamp = InvalidTime);
void check_invariant() const;
private:
struct Line
{
ByteCount start;
String content;
2012-03-30 14:00:40 +02:00
ByteCount length() const { return content.length(); }
};
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;
2013-07-26 00:44:00 +02:00
BufferCoord do_insert(BufferCoord pos, const String& content);
BufferCoord do_erase(BufferCoord begin, BufferCoord end);
2011-09-02 18:51:20 +02:00
String m_name;
Flags m_flags;
struct Modification;
typedef std::vector<Modification> UndoGroup;
friend class UndoGroupOptimizer;
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;
void apply_modification(const Modification& modification);
void revert_modification(const Modification& modification);
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;
time_t m_fs_timestamp;
// 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;
OptionManager m_options;
HookManager m_hooks;
2013-10-25 01:01:17 +02:00
KeymapManager m_keymaps;
2011-09-02 18:51:20 +02:00
friend constexpr Flags operator|(Flags lhs, Flags rhs)
{
return (Flags)((int) lhs | (int) rhs);
}
friend Flags& operator|=(Flags& lhs, Flags rhs)
{
(int&) lhs |= (int) rhs;
return lhs;
}
friend constexpr bool operator&(Flags lhs, Flags rhs)
{
return ((int) lhs & (int) rhs) != 0;
}
friend Flags& operator&=(Flags& lhs, Flags rhs)
{
(int&) lhs &= (int) rhs;
return lhs;
}
friend constexpr Flags operator~(Flags lhs)
{
return (Flags)(~(int)lhs);
}
};
struct BufferListenerRegisterFuncs
{
static void insert(const Buffer& buffer, BufferChangeListener& listener)
{
buffer.change_listeners().insert(&listener);
}
static void remove(const Buffer& buffer, BufferChangeListener& listener)
{
buffer.change_listeners().erase(&listener);
}
};
class BufferChangeListener_AutoRegister
: public BufferChangeListener,
public AutoRegister<BufferChangeListener_AutoRegister,
BufferListenerRegisterFuncs, const Buffer>
{
public:
BufferChangeListener_AutoRegister(const Buffer& buffer)
: AutoRegister(buffer) {}
const Buffer& buffer() const { return registry(); }
};
2011-09-02 18:51:20 +02:00
}
#include "buffer_iterator.inl.hh"
2011-09-02 18:51:20 +02:00
#endif // buffer_hh_INCLUDED