From c689eb12b24282916f88052077f9ccefbed8841d Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Tue, 20 Oct 2015 18:40:27 +0200
Subject: [PATCH 01/11] write overloaded function in fs-descriptor.h, (should
 be) behaving like writev. same for read

---
 .gitignore      | 12 ++++++++++
 fs-descriptor.h | 63 +++++++++++++++++++++++++++++++++++++++++++++++++
 fs.cpp          |  4 ++--
 3 files changed, 77 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index d3a1446..b3b1d39 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,8 @@
+# Visual Studio
+
+# CLion
+.idea/
+
 # Windows image file caches
 Thumbs.db
 ehthumbs.db
@@ -44,3 +49,10 @@ bin/
 Network Trash Folder
 Temporary Items
 .apdisk
+*.suo
+*.opensdf
+VFS.sdf
+*.sln
+VFS.vcxproj
+*.user
+VFS.vcxproj.filters
diff --git a/fs-descriptor.h b/fs-descriptor.h
index a35a93d..807e812 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -73,6 +73,36 @@ struct FileDescriptor {
         _setOffset( _offset + length );
         return length;
     }
+    //TODO nemalo by to vracat length miesto bool?
+    //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & ) od JW
+	//size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
+	virtual bool read(utils::Vector< std::pair< char *, size_t > >buf, size_t &length) {
+        if ( !_inode )
+            throw Error( EBADF );
+        if ( !_flags.has( flags::Open::Read ) )
+            throw Error( EBADF );
+
+        File *file = _inode->data()->as< File >();
+        if ( !file )
+            throw Error( EBADF );
+        if ( _flags.has( flags::Open::NonBlock ) && !file->canRead() )
+            throw Error( EAGAIN );
+
+		length = 0;		//combined length of all members of buf
+		for ( auto dst : buf) {
+			if ( !file->read(dst.first, _offset, dst.second) ) {
+				throw Error(EBADF);
+			}
+			_setOffset(_offset + dst.second);
+			length += dst.second;
+		}
+        /*char *dst = reinterpret_cast< char * >( buf );	//original
+        if ( !file->read( dst, _offset, length ) )
+            throw Error( EBADF );*/
+
+        //_setOffset( _offset + length );
+        return true;
+    }
 
     virtual long long write( const void *buf, size_t length ) {
         if ( !_inode )
@@ -97,6 +127,39 @@ struct FileDescriptor {
         return length;
     }
 
+	//TODO
+	virtual bool write(utils::Vector< std::pair< const char *, size_t > >buf, size_t &length) {
+		if (!_inode)
+			throw Error(EBADF);
+		if (!_flags.has(flags::Open::Write))
+			throw Error(EBADF);
+
+		File *file = _inode->data()->as< File >();
+		if (!file)
+			throw Error(EBADF);
+		if (_flags.has(flags::Open::NonBlock) && !file->canWrite())
+			throw Error(EAGAIN);
+
+		if (_flags.has(flags::Open::Append))
+			_offset = file->size();
+
+		length = 0;
+		for (auto src : buf) {
+			if (!file->write(src.first, _offset, src.second)) {
+				throw Error(EBADF);
+			}
+			_setOffset(_offset + src.second);
+			length += src.second;
+		}
+
+		/*const char *src = reinterpret_cast< const char * >(buf);		//original
+		if (!file->write(src, _offset, length))
+			throw Error(EBADF);*/
+
+		//_setOffset(_offset + length);
+		return true;
+	}
+
     size_t offset() const {
         return _offset;
     }
diff --git a/fs.cpp b/fs.cpp
index fc37259..3c685fc 100644
--- a/fs.cpp
+++ b/fs.cpp
@@ -236,7 +236,7 @@ ssize_t write( int fd, const void *buf, size_t count ) {
         return -1;
     }
 }
-ssize_t pwrite( int fd, const void *buf, size_t count, off_t offset ) {
+ssize_t pwrite( int fd, const void *buf, size_t count, off_t offset ) {		//TODO this
     FS_ENTRYPOINT();
     try {
         auto f = vfs.instance().getFile( fd );
@@ -258,7 +258,7 @@ ssize_t read( int fd, void *buf, size_t count ) {
         return -1;
     }
 }
-ssize_t pread( int fd, void *buf, size_t count, off_t offset ) {
+ssize_t pread( int fd, void *buf, size_t count, off_t offset ) {    //TODO this
     FS_ENTRYPOINT();
     try {
         auto f = vfs.instance().getFile( fd );

From 18e07f8ae6ba0c99b4c3e3843311c63b8f9a396b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vikt=C3=B3ria=20T=C3=B3thov=C3=A1?= <vilikoma@gmail.com>
Date: Tue, 20 Oct 2015 18:59:40 +0200
Subject: [PATCH 02/11] indent size to 4

---
 fs-descriptor.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs-descriptor.h b/fs-descriptor.h
index 807e812..5294cd3 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -76,8 +76,8 @@ struct FileDescriptor {
     //TODO nemalo by to vracat length miesto bool?
     //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & ) od JW
 	//size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
-	virtual bool read(utils::Vector< std::pair< char *, size_t > >buf, size_t &length) {
-        if ( !_inode )
+    virtual bool read(utils::Vector< std::pair< char *, size_t > >buf, size_t &length) {
+       	if ( !_inode )
             throw Error( EBADF );
         if ( !_flags.has( flags::Open::Read ) )
             throw Error( EBADF );

From e6f7ac2e8194a1d68f3bceffd9e86f318f10dd45 Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Tue, 20 Oct 2015 19:13:28 +0200
Subject: [PATCH 03/11] tabs from VS changed to spaces

---
 fs-descriptor.h | 97 +++++++++++++++++++++++++------------------------
 1 file changed, 49 insertions(+), 48 deletions(-)

diff --git a/fs-descriptor.h b/fs-descriptor.h
index 807e812..96cfe91 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -73,32 +73,33 @@ struct FileDescriptor {
         _setOffset( _offset + length );
         return length;
     }
+
     //TODO nemalo by to vracat length miesto bool?
-    //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & ) od JW
-	//size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
-	virtual bool read(utils::Vector< std::pair< char *, size_t > >buf, size_t &length) {
-        if ( !_inode )
+    //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & )
+    //size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
+    virtual bool read( utils::Vector< std::pair< char *, size_t > >buf, size_t &length ) {
+        if (!_inode)
             throw Error( EBADF );
-        if ( !_flags.has( flags::Open::Read ) )
+        if (!_flags.has( flags::Open::Read ))
             throw Error( EBADF );
 
         File *file = _inode->data()->as< File >();
-        if ( !file )
+        if (!file)
             throw Error( EBADF );
-        if ( _flags.has( flags::Open::NonBlock ) && !file->canRead() )
+        if (_flags.has( flags::Open::NonBlock ) && !file->canRead())
             throw Error( EAGAIN );
 
-		length = 0;		//combined length of all members of buf
-		for ( auto dst : buf) {
-			if ( !file->read(dst.first, _offset, dst.second) ) {
-				throw Error(EBADF);
-			}
-			_setOffset(_offset + dst.second);
-			length += dst.second;
-		}
+        length = 0;		//combined length of all members of buf
+        for (auto dst : buf) {
+            if (!file->read( dst.first, _offset, dst.second )) {
+                throw Error( EBADF );
+            }
+            _setOffset( _offset + dst.second );
+            length += dst.second;
+        }
         /*char *dst = reinterpret_cast< char * >( buf );	//original
         if ( !file->read( dst, _offset, length ) )
-            throw Error( EBADF );*/
+        throw Error( EBADF );*/
 
         //_setOffset( _offset + length );
         return true;
@@ -127,38 +128,38 @@ struct FileDescriptor {
         return length;
     }
 
-	//TODO
-	virtual bool write(utils::Vector< std::pair< const char *, size_t > >buf, size_t &length) {
-		if (!_inode)
-			throw Error(EBADF);
-		if (!_flags.has(flags::Open::Write))
-			throw Error(EBADF);
-
-		File *file = _inode->data()->as< File >();
-		if (!file)
-			throw Error(EBADF);
-		if (_flags.has(flags::Open::NonBlock) && !file->canWrite())
-			throw Error(EAGAIN);
-
-		if (_flags.has(flags::Open::Append))
-			_offset = file->size();
-
-		length = 0;
-		for (auto src : buf) {
-			if (!file->write(src.first, _offset, src.second)) {
-				throw Error(EBADF);
-			}
-			_setOffset(_offset + src.second);
-			length += src.second;
-		}
-
-		/*const char *src = reinterpret_cast< const char * >(buf);		//original
-		if (!file->write(src, _offset, length))
-			throw Error(EBADF);*/
-
-		//_setOffset(_offset + length);
-		return true;
-	}
+    //TODO
+    virtual bool write( utils::Vector< std::pair< const char *, size_t > >buf, size_t &length ) {
+        if (!_inode)
+            throw Error( EBADF );
+        if (!_flags.has( flags::Open::Write ))
+            throw Error( EBADF );
+
+        File *file = _inode->data()->as< File >();
+        if (!file)
+            throw Error( EBADF );
+        if (_flags.has( flags::Open::NonBlock ) && !file->canWrite())
+            throw Error( EAGAIN );
+
+        if (_flags.has( flags::Open::Append ))
+            _offset = file->size();
+
+        length = 0;
+        for (auto src : buf) {
+            if (!file->write( src.first, _offset, src.second )) {
+                throw Error( EBADF );
+            }
+            _setOffset( _offset + src.second );
+            length += src.second;
+        }
+
+        /*const char *src = reinterpret_cast< const char * >(buf);		//original
+        if (!file->write(src, _offset, length))
+        throw Error(EBADF);*/
+
+        //_setOffset(_offset + length);
+        return true;
+    }
 
     size_t offset() const {
         return _offset;

From bad26f24fd8e201437a7ffad2af0b672d8374f5c Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Tue, 20 Oct 2015 19:17:54 +0200
Subject: [PATCH 04/11] hopefully spaces fixed

---
 fs-descriptor.h | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/fs-descriptor.h b/fs-descriptor.h
index eaa0150..96cfe91 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -76,7 +76,7 @@ struct FileDescriptor {
 
     //TODO nemalo by to vracat length miesto bool?
     //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & )
-	//size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
+    //size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
     virtual bool read( utils::Vector< std::pair< char *, size_t > >buf, size_t &length ) {
         if (!_inode)
             throw Error( EBADF );
@@ -89,17 +89,17 @@ struct FileDescriptor {
         if (_flags.has( flags::Open::NonBlock ) && !file->canRead())
             throw Error( EAGAIN );
 
-		length = 0;		//combined length of all members of buf
+        length = 0;		//combined length of all members of buf
         for (auto dst : buf) {
             if (!file->read( dst.first, _offset, dst.second )) {
                 throw Error( EBADF );
-			}
+            }
             _setOffset( _offset + dst.second );
-			length += dst.second;
-		}
+            length += dst.second;
+        }
         /*char *dst = reinterpret_cast< char * >( buf );	//original
         if ( !file->read( dst, _offset, length ) )
-            throw Error( EBADF );*/
+        throw Error( EBADF );*/
 
         //_setOffset( _offset + length );
         return true;
@@ -128,38 +128,38 @@ struct FileDescriptor {
         return length;
     }
 
-	//TODO
+    //TODO
     virtual bool write( utils::Vector< std::pair< const char *, size_t > >buf, size_t &length ) {
-		if (!_inode)
+        if (!_inode)
             throw Error( EBADF );
         if (!_flags.has( flags::Open::Write ))
             throw Error( EBADF );
 
-		File *file = _inode->data()->as< File >();
-		if (!file)
+        File *file = _inode->data()->as< File >();
+        if (!file)
             throw Error( EBADF );
         if (_flags.has( flags::Open::NonBlock ) && !file->canWrite())
             throw Error( EAGAIN );
 
         if (_flags.has( flags::Open::Append ))
-			_offset = file->size();
+            _offset = file->size();
 
-		length = 0;
-		for (auto src : buf) {
+        length = 0;
+        for (auto src : buf) {
             if (!file->write( src.first, _offset, src.second )) {
                 throw Error( EBADF );
-			}
+            }
             _setOffset( _offset + src.second );
-			length += src.second;
-		}
+            length += src.second;
+        }
 
-		/*const char *src = reinterpret_cast< const char * >(buf);		//original
-		if (!file->write(src, _offset, length))
-			throw Error(EBADF);*/
+        /*const char *src = reinterpret_cast< const char * >(buf);		//original
+        if (!file->write(src, _offset, length))
+        throw Error(EBADF);*/
 
-		//_setOffset(_offset + length);
-		return true;
-	}
+        //_setOffset(_offset + length);
+        return true;
+    }
 
     size_t offset() const {
         return _offset;

From 9ab5116076a1f40fdcb4253c1de27a059074b5ba Mon Sep 17 00:00:00 2001
From: vilikoma <vilikoma@gmail.com>
Date: Sat, 24 Oct 2015 15:44:57 +0200
Subject: [PATCH 05/11] ignoring build

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index b3b1d39..0324843 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
+# Build
+build/
+
 # Visual Studio
 
 # CLion

From 43bee374bc5f2e5af770e4508fe501f6a424f4e1 Mon Sep 17 00:00:00 2001
From: vilikoma <vilikoma@gmail.com>
Date: Sat, 24 Oct 2015 15:45:26 +0200
Subject: [PATCH 06/11] saving last state

---
 CMakeLists.txt  | 2 +-
 fs-descriptor.h | 8 ++++++--
 fs-file.h       | 9 ++++++---
 3 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 74a3d53..b64390c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 2.8.5)
 project(VFS)
+
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb3 -std=c++11 -DVFS_STANDALONE")
-set(CMAKE_CXX "clang++")
 
 add_executable(fs _glue.cpp fs.cpp fs-dummyEntrypoint.cpp fs-manager.cpp fs-memory.cpp main.cpp)
diff --git a/fs-descriptor.h b/fs-descriptor.h
index 96cfe91..4e2161f 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -77,7 +77,10 @@ struct FileDescriptor {
     //TODO nemalo by to vracat length miesto bool?
     //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & )
     //size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
-    virtual bool read( utils::Vector< std::pair< char *, size_t > >buf, size_t &length ) {
+
+    //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
+    //TODO nech vracia length, size_t &length netreba
+    virtual bool read( utils::Vector< std::pair< char *, size_t > >buf ) {
         if (!_inode)
             throw Error( EBADF );
         if (!_flags.has( flags::Open::Read ))
@@ -128,7 +131,8 @@ struct FileDescriptor {
         return length;
     }
 
-    //TODO
+    //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
+    //TODO nech vracia length, size_t &length netreba
     virtual bool write( utils::Vector< std::pair< const char *, size_t > >buf, size_t &length ) {
         if (!_inode)
             throw Error( EBADF );
diff --git a/fs-file.h b/fs-file.h
index 71568bc..2af7289 100644
--- a/fs-file.h
+++ b/fs-file.h
@@ -35,7 +35,8 @@ struct Link : DataItem {
 };
 
 struct File : DataItem {
-
+    //TODO lower: napisat dokumentaciu pretieto fcie (sem)
+    //TODO dopisat deklaracie pre moje read, write pre vector buf
     virtual bool read( char *, size_t, size_t & ) = 0;
     virtual bool write( const char *, size_t, size_t & ) = 0;
 
@@ -73,20 +74,22 @@ struct RegularFile : File {
         return true;
     }
 
+    //TODO spravit funkciu pre vector buf 
     bool read( char *buffer, size_t offset, size_t &length ) override {
         if ( offset >= _size ) {
             length = 0;
             return true;
         }
-        const char *source = _isSnapshot() ?
+        const char *source = _isSnapshot() ?            //copy on write
                           _roContent + offset :
                           _content.data() + offset;
-        if ( offset + length > _size )
+        if ( offset + length > _size )                  //TODO prepisat tieto 3 riadky :D
             length = _size - offset;
         std::copy( source, source + length, buffer );
         return true;
     }
 
+    //TODO spravit fciu pre vector buf
     bool write( const char *buffer, size_t offset, size_t &length ) override {
         if ( _isSnapshot() )
             _copyOnWrite();

From 6cea511e126a1a3427191a0ec5feca2e805ccedc Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Sun, 25 Oct 2015 14:34:39 +0100
Subject: [PATCH 07/11] in fs-file in struct RegularFile new overloaded read
 write function which work with vector buf in fs_descriptor overloadedread
 write in FileDEscriptor which work with vector buf

---
 fs-descriptor.h | 34 ++++++++++++++++----------
 fs-file.h       | 65 +++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 73 insertions(+), 26 deletions(-)

diff --git a/fs-descriptor.h b/fs-descriptor.h
index 2cc31cb..131cb90 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -80,7 +80,7 @@ struct FileDescriptor {
 
     //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
     //TODO nech vracia length, size_t &length netreba
-    virtual long long read( utils::Vector< std::pair< char *, size_t > >buf ) {
+    virtual long long read( utils::Vector< std::pair< char *, size_t > > &buf ) {
         if (!_inode)
             throw Error( EBADF );
         if (!_flags.has( flags::Open::Read ))
@@ -93,13 +93,17 @@ struct FileDescriptor {
             throw Error( EAGAIN );
 
         long long length = 0;		//combined length of all members of buf
-        for (auto dst : buf) {
-            if (!file->read( dst.first, _offset, dst.second )) {
+        if ( !file->read(buf, _offset, length )) {
                 throw Error( EBADF );
-            }
-            _setOffset( _offset + dst.second );
-            length += dst.second;
         }
+        _setOffset( _offset + length );
+//        for (auto & dst : buf) {
+//            if (!file->read( dst.first, _offset, dst.second )) {
+//                throw Error( EBADF );
+//            }
+//            _setOffset( _offset + dst.second );
+//            length += dst.second;
+//        }
         return length;
     }
 
@@ -128,7 +132,7 @@ struct FileDescriptor {
 
     //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
     //TODO nech vracia length, size_t &length netreba
-    virtual long long write( utils::Vector< std::pair< const char *, size_t > >buf) {
+    virtual long long write( utils::Vector< std::pair< const char *, size_t > > &buf) {
         if (!_inode)
             throw Error( EBADF );
         if (!_flags.has( flags::Open::Write ))
@@ -144,13 +148,17 @@ struct FileDescriptor {
             _offset = file->size();
 
         long long length = 0;
-        for (auto src : buf) {
-            if (!file->write( src.first, _offset, src.second )) {
-                throw Error( EBADF );
-            }
-            _setOffset( _offset + src.second );
-            length += src.second;
+        if ( !file->write( buf, _offset, length )) {
+            throw Error( EBADF );
         }
+        _setOffset( _offset + length );
+//        for (auto src : buf) {
+//            if (!file->write( src.first, _offset, src.second )) {
+//                throw Error( EBADF );
+//            }
+//            _setOffset( _offset + src.second );
+//            length += src.second;
+//        }
 
         return length;
     }
diff --git a/fs-file.h b/fs-file.h
index daeeda0..3b5aa88 100644
--- a/fs-file.h
+++ b/fs-file.h
@@ -92,26 +92,42 @@ struct RegularFile : File {
     }
 
     //TODO spravit funkciu pre vector buf
-    bool read( utils::Vector< std::pair< char *, size_t > >buf, size_t offset, size_t &length ) override {
-
-        if ( offset >= _size ) {
-            length = 0;
-            return true;
-        }
-        const char *source = _isSnapshot() ?            //copy on write
-                             _roContent + offset :
-                             _content.data() + offset;
+    /**
+     * vector predat referenciou (lebo donho zapisujem)
+     */
+    bool read( utils::Vector< std::pair< char *, size_t > > &buf, size_t offset, size_t &length) override {
+
+//        if ( offset >= _size ) {
+//            length = 0;
+//            return true;
+//        }
+//        const char *source = _isSnapshot() ?            //copy on write
+//                             _roContent + offset :
+//                             _content.data() + offset;
+
+        length = 0;
+        for (auto & item : buf) {
+            if ( offset >= _size ) {    // EOF found
+                //length = 0;
+                return true;
+            }
+            const char *source = _isSnapshot() ?            //copy on write
+                                 _roContent + offset :
+                                 _content.data() + offset;
 
+            if (offset + item.second > _size) {
+                item.second = _size - offset;
+            }
 
+            std::copy(source, source + item.second, item.first);
+            length += item.second;
+            offset += item.second;
 
-        if ( offset + length > _size )                  //TODO prepisat tieto 3 riadky :D
-            length = _size - offset;
-        std::copy( source, source + length, buffer );
+        }
 
         return true;
     }
 
-    //TODO spravit fciu pre vector buf
     bool write( const char *buffer, size_t offset, size_t &length ) override {
         if ( _isSnapshot() )
             _copyOnWrite();
@@ -123,6 +139,29 @@ struct RegularFile : File {
         return true;
     }
 
+    //TODO spravit fciu pre vector buf
+    bool write( utils::Vector< std::pair< const char *, size_t > > &buf, size_t offset, size_t &length ) override {
+        if ( _isSnapshot() )
+            _copyOnWrite();
+
+        size_t sumLengthBuf = 0;
+        for (const auto & item : buf ) {            //compute sum of buf lengths
+            sumLengthBuf += item.second;
+        }
+        if ( _content.size() < offset + sumLengthBuf ) {
+            resize(offset + sumLengthBuf);
+        }
+
+        length = 0;
+        for (const auto & item : buf) {
+            std::copy(item.first, item.first + item1.second, _content.begin() + offset);
+            offset += item.second;
+            length += item.second;
+        }
+
+        return true;
+    }
+
     void clear() override {
         if ( !_size )
             return;

From d475737528f364bb41582654f8ed60926eee7500 Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Sun, 25 Oct 2015 14:46:36 +0100
Subject: [PATCH 08/11] added declaration of new functions to struct File

---
 fs-file.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/fs-file.h b/fs-file.h
index 3b5aa88..70f01e4 100644
--- a/fs-file.h
+++ b/fs-file.h
@@ -36,9 +36,11 @@ struct Link : DataItem {
 
 struct File : DataItem {
     //TODO lower: napisat dokumentaciu pretieto fcie (sem)
-    //TODO dopisat deklaracie pre moje read, write pre vector buf
+    //TODO done dopisat deklaracie pre moje read, write pre vector buf
     virtual bool read( char *, size_t, size_t & ) = 0;
+    virtual bool read( utils::Vector< std::pair< char *, size_t > > &buf, size_t offset, size_t &length) = 0;
     virtual bool write( const char *, size_t, size_t & ) = 0;
+    virtual bool write( utils::Vector< std::pair< const char *, size_t > > &buf, size_t offset, size_t &length ) = 0;
 
     virtual void clear() = 0;
     virtual bool canRead() const = 0;

From 776389e1d912dc68fdf18dbc3d2d14671c119fb3 Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Fri, 6 Nov 2015 12:47:32 +0100
Subject: [PATCH 09/11] long long ->size_t length (fs-desc.read/write) typo
 deleted a few comments

---
 fs-descriptor.h | 11 +++--------
 fs-file.h       |  2 +-
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/fs-descriptor.h b/fs-descriptor.h
index 131cb90..c82d273 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -74,12 +74,8 @@ struct FileDescriptor {
         return length;
     }
 
-    //TODO nemalo by to vracat length miesto bool?
     //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & )
-    //size_t & vrací, kolik se toho opravdu přečetlo/zapsalo
-
     //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
-    //TODO nech vracia length, size_t &length netreba
     virtual long long read( utils::Vector< std::pair< char *, size_t > > &buf ) {
         if (!_inode)
             throw Error( EBADF );
@@ -92,9 +88,9 @@ struct FileDescriptor {
         if (_flags.has( flags::Open::NonBlock ) && !file->canRead())
             throw Error( EAGAIN );
 
-        long long length = 0;		//combined length of all members of buf
+        size_t length = 0;		//combined length of all members of buf
         if ( !file->read(buf, _offset, length )) {
-                throw Error( EBADF );
+            throw Error( EBADF );
         }
         _setOffset( _offset + length );
 //        for (auto & dst : buf) {
@@ -131,7 +127,6 @@ struct FileDescriptor {
     }
 
     //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
-    //TODO nech vracia length, size_t &length netreba
     virtual long long write( utils::Vector< std::pair< const char *, size_t > > &buf) {
         if (!_inode)
             throw Error( EBADF );
@@ -147,7 +142,7 @@ struct FileDescriptor {
         if (_flags.has( flags::Open::Append ))
             _offset = file->size();
 
-        long long length = 0;
+        size_t length = 0;
         if ( !file->write( buf, _offset, length )) {
             throw Error( EBADF );
         }
diff --git a/fs-file.h b/fs-file.h
index 70f01e4..56e63af 100644
--- a/fs-file.h
+++ b/fs-file.h
@@ -156,7 +156,7 @@ struct RegularFile : File {
 
         length = 0;
         for (const auto & item : buf) {
-            std::copy(item.first, item.first + item1.second, _content.begin() + offset);
+            std::copy(item.first, item.first + item.second, _content.begin() + offset);
             offset += item.second;
             length += item.second;
         }

From 1cee2caaf1a4e1c078b93641d64bc3d1bd8e3fa5 Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Fri, 6 Nov 2015 15:09:48 +0100
Subject: [PATCH 10/11] vector processed in descriptor (previously in file)

---
 CMakeLists.txt  |  2 +-
 fs-descriptor.h | 39 +++++++++++------------------
 fs-file.h       | 65 +------------------------------------------------
 3 files changed, 16 insertions(+), 90 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d851ba8..9c02ca0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 2.8.5)
 project(VFS)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb3 -std=c++11 -DVFS_STANDALONE")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb3 -std=c++11")
 set(CMAKE_CXX "clang++")
 
 add_executable(fs _glue.cpp fs.cpp fs-dummyEntrypoint.cpp fs-manager.cpp fs-memory.cpp main.cpp)
diff --git a/fs-descriptor.h b/fs-descriptor.h
index c82d273..1886cdc 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -74,8 +74,6 @@ struct FileDescriptor {
         return length;
     }
 
-    //virtual bool read( utils::Vector< std::pair< char *, size_t > >, size_t & )
-    //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
     virtual long long read( utils::Vector< std::pair< char *, size_t > > &buf ) {
         if (!_inode)
             throw Error( EBADF );
@@ -85,21 +83,17 @@ struct FileDescriptor {
         File *file = _inode->data()->as< File >();
         if (!file)
             throw Error( EBADF );
-        if (_flags.has( flags::Open::NonBlock ) && !file->canRead())
+        if (_flags.has( flags::Open::NonBlock ) && !file->canRead())   
             throw Error( EAGAIN );
 
-        size_t length = 0;		//combined length of all members of buf
-        if ( !file->read(buf, _offset, length )) {
-            throw Error( EBADF );
+        long long length = 0;		//combined length of all members of buf
+        for ( auto & dst : buf ) {
+            if ( !file->read( dst.first, _offset, dst.second ))
+                throw Error( EBADF );
+            length += dst.second;
+            _setOffset( _offset + dst.second );
         }
-        _setOffset( _offset + length );
-//        for (auto & dst : buf) {
-//            if (!file->read( dst.first, _offset, dst.second )) {
-//                throw Error( EBADF );
-//            }
-//            _setOffset( _offset + dst.second );
-//            length += dst.second;
-//        }
+        
         return length;
     }
 
@@ -126,7 +120,6 @@ struct FileDescriptor {
         return length;
     }
 
-    //TODO zmenit na volanie mojej metody v fs-file regularfile (proste predam argument buf tej metode )
     virtual long long write( utils::Vector< std::pair< const char *, size_t > > &buf) {
         if (!_inode)
             throw Error( EBADF );
@@ -143,17 +136,13 @@ struct FileDescriptor {
             _offset = file->size();
 
         size_t length = 0;
-        if ( !file->write( buf, _offset, length )) {
-            throw Error( EBADF );
+        for (auto & src : buf) {
+            if (!file->write( src.first, _offset, src.second )) {
+                throw Error( EBADF );
+            }
+            _setOffset( _offset + src.second );
+            length += src.second;
         }
-        _setOffset( _offset + length );
-//        for (auto src : buf) {
-//            if (!file->write( src.first, _offset, src.second )) {
-//                throw Error( EBADF );
-//            }
-//            _setOffset( _offset + src.second );
-//            length += src.second;
-//        }
 
         return length;
     }
diff --git a/fs-file.h b/fs-file.h
index 56e63af..4e9a842 100644
--- a/fs-file.h
+++ b/fs-file.h
@@ -35,12 +35,9 @@ struct Link : DataItem {
 };
 
 struct File : DataItem {
-    //TODO lower: napisat dokumentaciu pretieto fcie (sem)
-    //TODO done dopisat deklaracie pre moje read, write pre vector buf
+    //TODO lower: write documentation
     virtual bool read( char *, size_t, size_t & ) = 0;
-    virtual bool read( utils::Vector< std::pair< char *, size_t > > &buf, size_t offset, size_t &length) = 0;
     virtual bool write( const char *, size_t, size_t & ) = 0;
-    virtual bool write( utils::Vector< std::pair< const char *, size_t > > &buf, size_t offset, size_t &length ) = 0;
 
     virtual void clear() = 0;
     virtual bool canRead() const = 0;
@@ -93,43 +90,6 @@ struct RegularFile : File {
         return true;
     }
 
-    //TODO spravit funkciu pre vector buf
-    /**
-     * vector predat referenciou (lebo donho zapisujem)
-     */
-    bool read( utils::Vector< std::pair< char *, size_t > > &buf, size_t offset, size_t &length) override {
-
-//        if ( offset >= _size ) {
-//            length = 0;
-//            return true;
-//        }
-//        const char *source = _isSnapshot() ?            //copy on write
-//                             _roContent + offset :
-//                             _content.data() + offset;
-
-        length = 0;
-        for (auto & item : buf) {
-            if ( offset >= _size ) {    // EOF found
-                //length = 0;
-                return true;
-            }
-            const char *source = _isSnapshot() ?            //copy on write
-                                 _roContent + offset :
-                                 _content.data() + offset;
-
-            if (offset + item.second > _size) {
-                item.second = _size - offset;
-            }
-
-            std::copy(source, source + item.second, item.first);
-            length += item.second;
-            offset += item.second;
-
-        }
-
-        return true;
-    }
-
     bool write( const char *buffer, size_t offset, size_t &length ) override {
         if ( _isSnapshot() )
             _copyOnWrite();
@@ -141,29 +101,6 @@ struct RegularFile : File {
         return true;
     }
 
-    //TODO spravit fciu pre vector buf
-    bool write( utils::Vector< std::pair< const char *, size_t > > &buf, size_t offset, size_t &length ) override {
-        if ( _isSnapshot() )
-            _copyOnWrite();
-
-        size_t sumLengthBuf = 0;
-        for (const auto & item : buf ) {            //compute sum of buf lengths
-            sumLengthBuf += item.second;
-        }
-        if ( _content.size() < offset + sumLengthBuf ) {
-            resize(offset + sumLengthBuf);
-        }
-
-        length = 0;
-        for (const auto & item : buf) {
-            std::copy(item.first, item.first + item.second, _content.begin() + offset);
-            offset += item.second;
-            length += item.second;
-        }
-
-        return true;
-    }
-
     void clear() override {
         if ( !_size )
             return;

From 0607d4e776bcabd5734ea635542dc666ec8da79d Mon Sep 17 00:00:00 2001
From: solenya <vilikoma@gmail.com>
Date: Fri, 6 Nov 2015 15:37:11 +0100
Subject: [PATCH 11/11] won't attempt to read when EOF encountered during
 reading to buf

---
 fs-descriptor.h | 8 ++++++--
 fs-file.h       | 3 +--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/fs-descriptor.h b/fs-descriptor.h
index 1886cdc..29facd4 100644
--- a/fs-descriptor.h
+++ b/fs-descriptor.h
@@ -88,10 +88,14 @@ struct FileDescriptor {
 
         long long length = 0;		//combined length of all members of buf
         for ( auto & dst : buf ) {
+            size_t originalLengthBuf = dst.second;
             if ( !file->read( dst.first, _offset, dst.second ))
-                throw Error( EBADF );
+                throw Error( EBADF );           
             length += dst.second;
             _setOffset( _offset + dst.second );
+            if (dst.second < originalLengthBuf) {      //nothing left to read
+                break;
+            }
         }
         
         return length;
@@ -135,7 +139,7 @@ struct FileDescriptor {
         if (_flags.has( flags::Open::Append ))
             _offset = file->size();
 
-        size_t length = 0;
+        long long length = 0;
         for (auto & src : buf) {
             if (!file->write( src.first, _offset, src.second )) {
                 throw Error( EBADF );
diff --git a/fs-file.h b/fs-file.h
index 4e9a842..2a1904e 100644
--- a/fs-file.h
+++ b/fs-file.h
@@ -72,8 +72,7 @@ struct RegularFile : File {
     bool canWrite() const override {
         return true;
     }
-
-
+    
     bool read( char *buffer, size_t offset, size_t &length ) override {
         if ( offset >= _size ) {
             length = 0;