kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

buffer_manager.cc (4666B)


      1 #include "buffer_manager.hh"
      2 
      3 #include "assert.hh"
      4 #include "buffer.hh"
      5 #include "client_manager.hh"
      6 #include "exception.hh"
      7 #include "format.hh"
      8 #include "buffer_utils.hh"
      9 #include "ranges.hh"
     10 #include "string.hh"
     11 
     12 namespace Kakoune
     13 {
     14 
     15 BufferManager::~BufferManager()
     16 {
     17     // Move buffers to avoid running BufClose with buffers remaining in that list
     18     BufferList buffers = std::move(m_buffers);
     19 
     20     for (auto& buffer : buffers)
     21         buffer->on_unregistered();
     22 
     23     // Make sure not clients exists
     24     if (ClientManager::has_instance())
     25         ClientManager::instance().clear(true);
     26 }
     27 
     28 Buffer* BufferManager::create_buffer(String name, Buffer::Flags flags, BufferLines lines, ByteOrderMark bom, EolFormat eolformat, FinalEol finaleol, FsStatus fs_status)
     29 {
     30     if (get_buffer_ifp(name) != nullptr)
     31         throw runtime_error{"buffer name is already in use"};
     32 
     33     m_buffers.push_back(make_unique_ptr<Buffer>(std::move(name), flags, std::move(lines), bom, eolformat, finaleol, fs_status));
     34     auto* buffer = m_buffers.back().get();
     35     buffer->on_registered();
     36 
     37     if (contains(m_buffer_trash, buffer))
     38         throw runtime_error{"buffer got removed during its creation"};
     39 
     40     return buffer;
     41 }
     42 
     43 void BufferManager::delete_buffer(Buffer& buffer)
     44 {
     45     if (buffer.flags() & Buffer::Flags::Locked)
     46         throw runtime_error{"Trying to delete a locked buffer"};
     47 
     48     auto it = find_if(m_buffers, [&](auto& p) { return p.get() == &buffer; });
     49     if (it == m_buffers.end()) // we might be trying to recursively delete this buffer
     50         return;
     51 
     52     m_buffer_trash.emplace_back(std::move(*it));
     53     m_buffers.erase(it);
     54 
     55     if (ClientManager::has_instance())
     56         ClientManager::instance().ensure_no_client_uses_buffer(buffer);
     57 
     58     buffer.on_unregistered();
     59 }
     60 
     61 Buffer* BufferManager::get_buffer_ifp(StringView name)
     62 {
     63     auto filename = real_path(parse_filename(name));
     64     for (auto& buf : m_buffers)
     65     {
     66         if (buf->name() == name or
     67             (buf->flags() & Buffer::Flags::File and buf->filename() == filename))
     68             return buf.get();
     69     }
     70     return nullptr;
     71 }
     72 
     73 Buffer& BufferManager::get_buffer(StringView name)
     74 {
     75     Buffer* res = get_buffer_ifp(name);
     76     if (not res)
     77         throw runtime_error{format("no such buffer '{}'", name)};
     78     return *res;
     79 }
     80 
     81 Buffer* BufferManager::get_buffer_matching_ifp(const FunctionRef<bool (Buffer&)>& filter)
     82 {
     83     for (auto& buf : m_buffers | reverse())
     84     {
     85         if (filter(*buf))
     86             return buf.get();
     87     }
     88     return nullptr;
     89 }
     90 
     91 Buffer& BufferManager::get_buffer_matching(const FunctionRef<bool (Buffer&)>& filter)
     92 {
     93     Buffer* res = get_buffer_matching_ifp(filter);
     94     if (not res)
     95         throw runtime_error{format("no buffer found")};
     96     return *res;
     97 }
     98 
     99 Buffer& BufferManager::get_first_buffer()
    100 {
    101     if (all_of(m_buffers, [](auto& b) { return (b->flags() & Buffer::Flags::Debug); }))
    102         create_buffer("*scratch*", Buffer::Flags::None, {StringData::create("\n")},
    103                       ByteOrderMark::None, EolFormat::Lf, FinalEol::Present, {InvalidTime, {}, {}});
    104 
    105     return *m_buffers.back();
    106 }
    107 
    108 void BufferManager::backup_modified_buffers()
    109 {
    110     for (auto& buf : m_buffers)
    111     {
    112         if ((buf->flags() & Buffer::Flags::File) and buf->is_modified()
    113             and not (buf->flags() & Buffer::Flags::ReadOnly))
    114             write_buffer_to_backup_file(*buf);
    115     }
    116 }
    117 
    118 void BufferManager::clear_buffer_trash()
    119 {
    120     m_buffer_trash.clear();
    121 }
    122 
    123 void BufferManager::arrange_buffers(ConstArrayView<String> buffers, bool to_back)
    124 {
    125     Vector<size_t> indices;
    126     for (const auto& name : buffers)
    127     {
    128         auto filename = real_path(parse_filename(name));
    129         auto it = find_if(m_buffers, [&](auto& buf) { return buf->display_name() == name or (buf->flags() & Buffer::Flags::File and buf->filename() == filename); });
    130         if (it == m_buffers.end())
    131             throw runtime_error{format("no such buffer '{}'", name)};
    132         size_t index = it - m_buffers.begin();
    133         if (contains(indices, index))
    134             throw runtime_error{format("buffer '{}' appears more than once", name)};
    135         indices.push_back(index);
    136     }
    137 
    138     BufferList res;
    139     for (size_t index : indices)
    140         res.push_back(std::move(m_buffers[index]));
    141     for (auto& buf : m_buffers)
    142     {
    143         if (buf)
    144             res.push_back(std::move(buf));
    145     }
    146     if (to_back)
    147         std::rotate(res.begin(), res.begin() + indices.size(), res.end());
    148 
    149     m_buffers = std::move(res);
    150 }
    151 
    152 void BufferManager::make_latest(Buffer& buffer)
    153 {
    154     auto it = find(m_buffers, &buffer);
    155     kak_assert(it != m_buffers.end());
    156     std::rotate(it, it+1, m_buffers.end());
    157 }
    158 
    159 }