don't copy if a reference is fine

[lyx.git] / src / bufferlist.h

diff --git a/src/bufferlist.h b/src/bufferlist.h
index 3c215a088120e543ee6a12bfdcd46ecd7ccd595d..adb65fde2c4498cc3ed6200e4c6712d33316a9c1 100644 (file)
--- a/src/bufferlist.h
+++ b/src/bufferlist.h
@@ -4,9 +4,9 @@
  * 
  *           LyX, The Document Processor        
  *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-1999 The LyX Team
+ *           Copyright 1995-2001 The LyX Team
  *
- *           This file is Copyright 1996
+ *           This file is Copyright 1996-2001
  *           Lars Gullik Bjønnes
  *
  * ====================================================== */
@@ -18,8 +18,12 @@
 #pragma interface
 #endif
 
-#include "buffer.h"
-#include "debug.h"
+class Buffer;
+class UpdatableInset;
+#include <vector>
+#include <boost/utility.hpp>
+
+#include "LString.h"
 
 /** A class to hold all the buffers in a structure
   The point of this class is to hide from bufferlist what kind
@@ -29,40 +33,45 @@
   This class should ideally be enclosed inside class BufferList, but that
   gave me an "internal gcc error".
   */
-class BufferStorage {
+class BufferStorage : boost::noncopyable {
 public:
        ///
-       typedef vector<Buffer *> Container;
+       typedef std::vector<Buffer *> Container;
        ///
        typedef Container::iterator iterator;
        ///
+       typedef Container::const_iterator const_iterator;
+       ///
+       typedef Container::size_type size_type;
+       ///
        bool empty() const { return container.empty(); }
        ///
        void release(Buffer * buf);
        ///
-       Buffer * newBuffer(string const & s, LyXRC *, bool = false);
+       Buffer * newBuffer(string const & s, bool = false);
        ///
        Container::iterator begin() { return container.begin(); }
        ///
        Container::iterator end() { return container.end(); }
        ///
+       Container::const_iterator begin() const { return container.begin(); }
+       ///
+       Container::const_iterator end() const { return container.end(); }
+       ///
        Buffer * front() { return container.front(); }
        ///
        Buffer * operator[](int c) { return container[c]; }
        ///
-       int size() const { return container.size(); }
+       size_type size() const { return container.size(); }
 private:
        ///
        Container container;
 };
 
 
-/** The class governing all the open buffers
-  This class governs all the currently open buffers. Currently all the buffer
-  are located in a static array, soon this will change and we will have a
-  linked list instead.
+/** The class govern all open buffers.
  */
-class BufferList {
+class BufferList : boost::noncopyable {
 public:
        ///
        BufferList();
@@ -76,7 +85,7 @@ public:
        };
 
        /// returns the state of the bufferlist
-       list_state getState() { return _state; }
+       list_state getState() const { return state_; }
        
        /** loads a LyX file or...
            If the optional argument tolastfiles is false (default is
@@ -87,32 +96,21 @@ public:
                             bool tolastfiles = true);
        
        ///
-       bool empty();
-
-       /// Saves buffer. Returns false if unsuccesful.
-       bool write(Buffer *, bool makeBackup);
+       bool empty() const;
 
        ///
-        bool QwriteAll();
+        bool qwriteAll();
 
        /// Close all open buffers.
        void closeAll();
 
-       ///
-       void resize();
-
        /// Read a file into a buffer readonly or not.
        Buffer * readFile(string const &, bool ro);
 
        /// Make a new file (buffer) using a template
-       Buffer * newFile(string const &, string);
-
-       /** This one must be moved to some other place.
-        */
-       void makePup(int);
-
-       ///
-       void updateInset(Inset *, bool = true);
+       Buffer * newFile(string const &, string, bool isNamed = false);
+       /// returns a vector with all the buffers filenames
+       std::vector<string> const getFileNames() const;
 
        ///
        int unlockInset(UpdatableInset *);
@@ -122,29 +120,38 @@ public:
 
        ///
        void emergencyWriteAll();
-
-       /** closes buffer
-         Returns false if operation was canceled
+       
+       /** Close buffer.
+           @param buf the buffer that should be closed
+           @return #false# if operation was canceled
          */
-       bool close(Buffer *);
+       bool close(Buffer * buf);
 
        ///
        Buffer * first();
        
        /// returns true if the buffer exists already
-       bool exists(string const &);
+       bool exists(string const &) const;
 
+       /// returns true if the buffer is loaded
+       bool isLoaded(Buffer const * b) const;
+       
        /// returns a pointer to the buffer with the given name.
        Buffer * getBuffer(string const &);
        /// returns a pointer to the buffer with the given number.
-       Buffer * getBuffer(int);
+       Buffer * getBuffer(unsigned int);
 
 private:
+       /// ask to save a buffer on quit
+       bool qwriteOne(Buffer * buf, string const & fname, string & unsaved_list); 
+
        ///
        BufferStorage bstore;
        
        ///
-       list_state _state;
+       list_state state_;
+       ///
+       void emergencyWrite(Buffer * buf);
 };
 
 #endif