From a4de474a8c7639c62a51a18fc9b8a19c919cc50a Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Tue, 12 May 2015 19:09:34 +0200
Subject: [PATCH 01/10] Sequence: clean retrieveInfosFromPattern

Less parameters: the function is not const because it updates the
Sequence object.
---
 src/Sequence.cpp   | 30 +++++++++++++-----------------
 src/Sequence.hpp   |  2 +-
 src/filesystem.cpp |  3 +--
 3 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/src/Sequence.cpp b/src/Sequence.cpp
index 620818d..9f03c25 100644
--- a/src/Sequence.cpp
+++ b/src/Sequence.cpp
@@ -318,48 +318,44 @@ EPattern Sequence::checkPattern( const std::string& pattern, const EDetection de
  *        and init internal values.
  * @param[in] pattern
  * @param[in] accept
- * @param[out] prefix
- * @param[out] suffix
- * @param[out] padding
- * @param[out] strictPadding
  */
-bool Sequence::retrieveInfosFromPattern( const std::string& filePattern, const EPattern& accept, std::string& prefix, std::string& suffix, std::size_t& padding, bool& strictPadding ) const
+bool Sequence::retrieveInfosFromPattern( const std::string& filePattern, const EPattern& accept )
 {
 	boost::cmatch matches;
-	//std::cout << filePattern << " / " << prefix << " + " << padding << " + " << suffix << std::endl;
+	//std::cout << filePattern << " / " << _prefix << " + " << _padding << " + " << _suffix << std::endl;
 	if( ( accept & ePatternStandard ) && regex_match( filePattern.c_str(), matches, regexPatternStandard ) )
 	{
 		std::string paddingStr( matches[2].first, matches[2].second );
-		padding = paddingStr.size();
-		strictPadding = ( paddingStr[0] == '#' );
+		_padding = paddingStr.size();
+		_strictPadding = ( paddingStr[0] == '#' );
 	}
 	else if( ( accept & ePatternCStyle ) && regex_match( filePattern.c_str(), matches, regexPatternCStyle ) )
 	{
 		std::string paddingStr( matches[2].first, matches[2].second );
-		padding = paddingStr.size() == 0 ? 0 : boost::lexical_cast<std::size_t > ( paddingStr ); // if no padding value: %d -> padding = 0
-		strictPadding = false;
+		_padding = paddingStr.size() == 0 ? 0 : boost::lexical_cast<std::size_t > ( paddingStr ); // if no _padding value: %d -> _padding = 0
+		_strictPadding = false;
 	}
 	else if( ( accept & ePatternFrame ) && regex_match( filePattern.c_str(), matches, regexPatternFrame ) )
 	{
 		std::string frame( matches[2].first, matches[2].second );
 		// Time t = boost::lexical_cast<Time>( frame );
-		padding = frame.size();
-		strictPadding = false;
+		_padding = frame.size();
+		_strictPadding = false;
 	}
 	else if( ( accept & ePatternFrameNeg ) && regex_match( filePattern.c_str(), matches, regexPatternFrameNeg ) )
 	{
 		std::string frame( matches[2].first, matches[2].second );
 		// Time t = boost::lexical_cast<Time>( frame );
-		padding = frame.size();
-		strictPadding = false;
+		_padding = frame.size();
+		_strictPadding = false;
 	}
 	else
 	{
 		// this is a file, not a sequence
 		return false;
 	}
-	prefix = std::string( matches[1].first, matches[1].second );
-	suffix = std::string( matches[3].first, matches[3].second );
+	_prefix = std::string( matches[1].first, matches[1].second );
+	_suffix = std::string( matches[3].first, matches[3].second );
 	return true;
 }
 
@@ -377,7 +373,7 @@ void Sequence::init( const std::string& prefix, const std::size_t padding, const
 
 bool Sequence::initFromPattern( const std::string& pattern, const std::vector<FrameRange>& frameRanges, const EPattern accept )
 {
-	if( !retrieveInfosFromPattern( pattern, accept, _prefix, _suffix, _padding, _strictPadding ) )
+	if( !retrieveInfosFromPattern( pattern, accept ) )
 		return false; // not regognize as a pattern, maybe a still file
 	_ranges.clear();
 	_ranges = frameRanges;
diff --git a/src/Sequence.hpp b/src/Sequence.hpp
index a2eb7d3..a760e26 100644
--- a/src/Sequence.hpp
+++ b/src/Sequence.hpp
@@ -159,7 +159,7 @@ class Sequence
 	 * @brief Partial initialization, using only pattern informations.
 	 * @warning You don't have all informations like range, directory, etc.
 	 */
-	bool retrieveInfosFromPattern( const std::string& pattern, const EPattern& accept, std::string& prefix, std::string& suffix, std::size_t& padding, bool& strictPadding ) const;
+	bool retrieveInfosFromPattern( const std::string& pattern, const EPattern& accept );
 
 public:
 	std::vector<boost::filesystem::path> getFiles() const;
diff --git a/src/filesystem.cpp b/src/filesystem.cpp
index e4ed132..2e9a36f 100644
--- a/src/filesystem.cpp
+++ b/src/filesystem.cpp
@@ -42,8 +42,7 @@ bool browseSequence( Sequence& outSequence, const std::string& pattern, const EP
 	boost::filesystem::path directory = getDirectoryFromPath( pattern );
 
 	if( !outSequence.retrieveInfosFromPattern(
-			boost::filesystem::path( pattern ).filename().string(), accept,
-			outSequence._prefix, outSequence._suffix, outSequence._padding, outSequence._strictPadding ) )
+			boost::filesystem::path( pattern ).filename().string(), accept ) )
 		return false; // not recognized as a pattern, maybe a still file
 
 	if( !boost::filesystem::exists( directory ) )

From 17bb4c645ed1a8b92bf3894cd3a7a3a8519582ce Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Tue, 12 May 2015 19:10:52 +0200
Subject: [PATCH 02/10] SWIG: FrameRangesSubView is iterable in python

---
 src/FrameRange.i | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/FrameRange.i b/src/FrameRange.i
index 9c71ce3..592c0d2 100644
--- a/src/FrameRange.i
+++ b/src/FrameRange.i
@@ -47,4 +47,15 @@
     }
 }
 
+%extend sequenceParser::FrameRangesSubView
+{
+    %pythoncode
+	{
+        def __iter__(self):
+            return PyFrameRangesConstIterator(self.begin().previous(), self.end())
+        def __str__(self):
+            return self.string()
+    }
+}
+
 #endif

From 6b0ed1c2f8b8dd8231d9251d75992c37d15c7918 Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Wed, 13 May 2015 11:07:35 +0200
Subject: [PATCH 03/10] Sequence: rename retrieveInfosFromPattern to
 initFromPattern

Remove function already named initFromPattern.
---
 src/Sequence.cpp   | 13 +------------
 src/Sequence.hpp   | 13 +++++--------
 src/filesystem.cpp |  3 +--
 3 files changed, 7 insertions(+), 22 deletions(-)

diff --git a/src/Sequence.cpp b/src/Sequence.cpp
index 9f03c25..e4c4777 100644
--- a/src/Sequence.cpp
+++ b/src/Sequence.cpp
@@ -319,7 +319,7 @@ EPattern Sequence::checkPattern( const std::string& pattern, const EDetection de
  * @param[in] pattern
  * @param[in] accept
  */
-bool Sequence::retrieveInfosFromPattern( const std::string& filePattern, const EPattern& accept )
+bool Sequence::initFromPattern( const std::string& filePattern, const EPattern& accept )
 {
 	boost::cmatch matches;
 	//std::cout << filePattern << " / " << _prefix << " + " << _padding << " + " << _suffix << std::endl;
@@ -370,17 +370,6 @@ void Sequence::init( const std::string& prefix, const std::size_t padding, const
 	_strictPadding = strictPadding;
 }
 
-
-bool Sequence::initFromPattern( const std::string& pattern, const std::vector<FrameRange>& frameRanges, const EPattern accept )
-{
-	if( !retrieveInfosFromPattern( pattern, accept ) )
-		return false; // not regognize as a pattern, maybe a still file
-	_ranges.clear();
-	_ranges = frameRanges;
-	return true;
-}
-
-
 std::vector<boost::filesystem::path> Sequence::getFiles() const
 {
 	std::vector<boost::filesystem::path> allPaths;
diff --git a/src/Sequence.hpp b/src/Sequence.hpp
index a760e26..a2b12e7 100644
--- a/src/Sequence.hpp
+++ b/src/Sequence.hpp
@@ -48,7 +48,10 @@ class Sequence
 
 	Sequence( const std::string& pattern, const std::vector<FrameRange>& frameRanges, const EPattern accept = ePatternDefault )
 	{
-		initFromPattern( pattern, frameRanges, accept );
+		if( initFromPattern( pattern, accept ) )
+		{
+			_ranges = frameRanges;
+		}
 	}
 
 	Sequence( const Sequence& v )
@@ -80,12 +83,6 @@ class Sequence
 	 */
 	void init( const std::string& prefix, const std::size_t padding, const std::string& suffix, const Time firstTime, const Time lastTime, const Time step = 1, const bool strictPadding = false );
 
-	/**
-	 * @brief Construct a sequence from a pattern and given informations.
-	 * @warning No check on your filesystem.
-	 */
-	bool initFromPattern( const std::string& pattern, const std::vector<FrameRange>& frameRanges, const EPattern accept = ePatternDefault );
-
 public:
 	std::string getFilenameAt( const Time time ) const;
 
@@ -159,7 +156,7 @@ class Sequence
 	 * @brief Partial initialization, using only pattern informations.
 	 * @warning You don't have all informations like range, directory, etc.
 	 */
-	bool retrieveInfosFromPattern( const std::string& pattern, const EPattern& accept );
+	bool initFromPattern( const std::string& pattern, const EPattern& accept );
 
 public:
 	std::vector<boost::filesystem::path> getFiles() const;
diff --git a/src/filesystem.cpp b/src/filesystem.cpp
index 2e9a36f..c66b82b 100644
--- a/src/filesystem.cpp
+++ b/src/filesystem.cpp
@@ -41,8 +41,7 @@ bool browseSequence( Sequence& outSequence, const std::string& pattern, const EP
 	outSequence.clear();
 	boost::filesystem::path directory = getDirectoryFromPath( pattern );
 
-	if( !outSequence.retrieveInfosFromPattern(
-			boost::filesystem::path( pattern ).filename().string(), accept ) )
+	if( !outSequence.initFromPattern( boost::filesystem::path( pattern ).filename().string(), accept ) )
 		return false; // not recognized as a pattern, maybe a still file
 
 	if( !boost::filesystem::exists( directory ) )

From 0e116e64d61b22ca0fe2e62209d5a84eeb6d5502 Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Wed, 13 May 2015 16:32:54 +0200
Subject: [PATCH 04/10] SWIG: add FrameRangeVector to binding

---
 src/Sequence.i | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/Sequence.i b/src/Sequence.i
index 7b0d5fb..dc9de5a 100644
--- a/src/Sequence.i
+++ b/src/Sequence.i
@@ -5,6 +5,15 @@
 #include "Sequence.hpp"
 %}
 
+namespace std {
+// Allow vector of object with no default constructor
+%ignore vector< sequenceParser::FrameRange >::vector(size_type); 
+%ignore vector< sequenceParser::FrameRange >::resize;
+
+// Create instantiations of a template classes
+%template(FrameRangeVector) vector< sequenceParser::FrameRange >;
+}
+
 %include "Sequence.hpp"
 
 #ifdef SWIGPYTHON

From d027a329eaef0d0608383c0563c4bd793b7967dc Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Mon, 25 May 2015 14:28:48 +0200
Subject: [PATCH 05/10] ItemStat: add getUserName / getGroupName

Fix #25
---
 src/ItemStat.cpp | 26 ++++++++++++++++++++++++++
 src/ItemStat.hpp |  3 +++
 2 files changed, 29 insertions(+)

diff --git a/src/ItemStat.cpp b/src/ItemStat.cpp
index 526a0a4..91e3c18 100644
--- a/src/ItemStat.cpp
+++ b/src/ItemStat.cpp
@@ -5,6 +5,8 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <pwd.h>
+#include <grp.h>
 
 
 namespace bfs = boost::filesystem;
@@ -65,6 +67,30 @@ ItemStat::ItemStat( const Item& item, const bool approximative )
 	}
 }
 
+std::string ItemStat::getUserName() const
+{
+#ifdef __UNIX__
+	passwd* user = getpwuid(userId);
+	if(user == NULL)
+		return std::string("unknown");
+	return std::string(user->pw_name ? user->pw_name : "unknown");
+#else
+	return std::string("not implemented");
+#endif
+}
+
+std::string ItemStat::getGroupName() const
+{
+#ifdef __UNIX__
+	group* group = getgrgid(groupId);
+	if(group == NULL)
+		return std::string("unknown");
+	return std::string(group->gr_name ? group->gr_name : "unknown");
+#else
+	return std::string("not implemented");
+#endif
+}
+
 void ItemStat::statLink( const boost::filesystem::path& path )
 {
 	boost::system::error_code errorCode;
diff --git a/src/ItemStat.hpp b/src/ItemStat.hpp
index 34ab086..4c1bad2 100644
--- a/src/ItemStat.hpp
+++ b/src/ItemStat.hpp
@@ -13,6 +13,9 @@ class ItemStat
 	ItemStat( const Item& item, const bool approximative=true );
 	ItemStat( const EType& type, const boost::filesystem::path& path, const bool approximative=true );
 
+	std::string getUserName() const;
+	std::string getGroupName() const;
+
 private:
 	void statFolder( const boost::filesystem::path& path );
 	void statFile( const boost::filesystem::path& path );

From 5ee2b710a390a4600c16b1912e51a5d20b7fbf49 Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Mon, 25 May 2015 16:44:47 +0200
Subject: [PATCH 06/10] ItemStat: can get permissions

For sequences, we use the most restrictive permissions in the list of
files.
---
 src/ItemStat.cpp | 58 ++++++++++++++++++++++++++++++++++++++++++++----
 src/ItemStat.hpp | 17 ++++++++++++++
 2 files changed, 71 insertions(+), 4 deletions(-)

diff --git a/src/ItemStat.cpp b/src/ItemStat.cpp
index 91e3c18..296389d 100644
--- a/src/ItemStat.cpp
+++ b/src/ItemStat.cpp
@@ -1,9 +1,7 @@
 #include "ItemStat.hpp"
-#include "system.hpp"
 
 #include <boost/filesystem/operations.hpp>
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <pwd.h>
 #include <grp.h>
@@ -91,6 +89,21 @@ std::string ItemStat::getGroupName() const
 #endif
 }
 
+#ifdef __UNIX__
+void ItemStat::setPermissions( const mode_t& protection )
+{
+	ownerCanRead = protection & S_IRUSR;
+	ownerCanWrite = protection & S_IWUSR;
+	ownerCanExecute = protection & S_IXUSR;
+	groupCanRead = protection & S_IRGRP;
+	groupCanWrite = protection & S_IWGRP;
+	groupCanExecute = protection & S_IXGRP;
+	otherCanRead = protection & S_IROTH;
+	otherCanWrite = protection & S_IWOTH;
+	otherCanExecute = protection & S_IXOTH;
+}
+#endif
+
 void ItemStat::statLink( const boost::filesystem::path& path )
 {
 	boost::system::error_code errorCode;
@@ -115,6 +128,7 @@ void ItemStat::statLink( const boost::filesystem::path& path )
 	size = statInfos.st_size;
 	// size on hard-drive (takes hardlinks into account)
 	sizeOnDisk = (statInfos.st_blocks / nbHardLinks) * 512;
+	setPermissions(statInfos.st_mode);
 #else
 	fullNbHardLinks = nbHardLinks = 1;
 	deviceId = 0;
@@ -141,6 +155,15 @@ void ItemStat::setDefaultValues(){
 	realSize = 0;
 	fullNbHardLinks = 0;
 	modificationTime = -1;
+	ownerCanRead = false;
+	ownerCanWrite = false;
+	ownerCanExecute = false;
+	groupCanRead = false;
+	groupCanWrite = false;
+	groupCanExecute = false;
+	otherCanRead = false;
+	otherCanWrite = false;
+	otherCanExecute = false;
 }
 
 void ItemStat::statFolder( const boost::filesystem::path& path )
@@ -169,6 +192,7 @@ void ItemStat::statFolder( const boost::filesystem::path& path )
 	size = statInfos.st_size;
 	// size on hard-drive (takes hardlinks into account)
 	sizeOnDisk = statInfos.st_blocks * 512;
+	setPermissions(statInfos.st_mode);
 #else
 	deviceId = 0;
 	inodeId = 0;
@@ -209,8 +233,8 @@ void ItemStat::statFile( const boost::filesystem::path& path )
 	accessTime = statInfos.st_atime;
 	creationTime = statInfos.st_ctime;
 	// size on hard-drive (takes hardlinks into account)
-	sizeOnDisk = (statInfos.st_blocks / nbHardLinks) * 512; 
-
+	sizeOnDisk = (statInfos.st_blocks / nbHardLinks) * 512;
+	setPermissions(statInfos.st_mode);
 #else
 	deviceId = 0;
 	inodeId = 0;
@@ -245,6 +269,7 @@ void ItemStat::statSequence( const Item& item, const bool approximative )
 	userId = statInfos.st_uid;
 	groupId = statInfos.st_gid;
 	accessTime = statInfos.st_atime;
+	setPermissions(statInfos.st_mode);
 #else
 	deviceId = 0;
 	inodeId = 0;
@@ -276,6 +301,31 @@ void ItemStat::statSequence( const Item& item, const bool approximative )
 
 		ItemStat fileStat(type, filepath);
 		
+		// use the most restrictive permissions in the sequence
+#ifdef __UNIX__
+		// user
+		if( ownerCanRead && ! fileStat.ownerCanRead)
+			ownerCanRead = false;
+		if( ownerCanWrite && ! fileStat.ownerCanWrite)
+			ownerCanWrite = false;
+		if( ownerCanExecute && ! fileStat.ownerCanExecute)
+			ownerCanExecute = false;
+		// group
+		if( groupCanRead && ! fileStat.groupCanRead)
+			groupCanRead = false;
+		if( groupCanWrite && ! fileStat.groupCanWrite)
+			groupCanWrite = false;
+		if( groupCanExecute && ! fileStat.groupCanExecute)
+			groupCanExecute = false;
+		// other
+		if( otherCanRead && ! fileStat.otherCanRead)
+			otherCanRead = false;
+		if( otherCanWrite && ! fileStat.otherCanWrite)
+			otherCanWrite = false;
+		if( otherCanExecute && ! fileStat.otherCanExecute)
+			otherCanExecute = false;
+#endif
+
 		// use the latest modification date in the sequence
 		if( fileStat.modificationTime > modificationTime )
 			modificationTime = fileStat.modificationTime;
diff --git a/src/ItemStat.hpp b/src/ItemStat.hpp
index 4c1bad2..4aa07ea 100644
--- a/src/ItemStat.hpp
+++ b/src/ItemStat.hpp
@@ -3,6 +3,11 @@
 
 #include "Item.hpp"
 #include "common.hpp"
+#include "system.hpp"
+
+#ifdef __UNIX__
+    #include <sys/types.h>
+#endif
 
 
 namespace sequenceParser {
@@ -22,6 +27,9 @@ class ItemStat
 	void statSequence( const Item& item, const bool approximative );
 	void statLink( const boost::filesystem::path& path );
 	void setDefaultValues();
+#ifdef __UNIX__
+	void setPermissions( const mode_t& protection );
+#endif
 
 public:
 	long long deviceId;
@@ -36,6 +44,15 @@ class ItemStat
 	long long accessTime;
 	long long modificationTime;
 	long long creationTime;
+	bool ownerCanRead;
+	bool ownerCanWrite;
+	bool ownerCanExecute;
+	bool groupCanRead;
+	bool groupCanWrite;
+	bool groupCanExecute;
+	bool otherCanRead;
+	bool otherCanWrite;
+	bool otherCanExecute;
 };
 
 }

From 3eae7a92d88e17be8c28d7566383e2b1ea98a49d Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Mon, 25 May 2015 17:44:11 +0200
Subject: [PATCH 07/10] ItemStat: can get minSize/maxSize

* minSize: size of the smallest file in the sequence (otherwise, same
value as size).
* maxSize: size of the biggest file in the sequence (otherwise, same
value as size).
---
 src/ItemStat.cpp | 15 +++++++++++++++
 src/ItemStat.hpp |  2 ++
 2 files changed, 17 insertions(+)

diff --git a/src/ItemStat.cpp b/src/ItemStat.cpp
index 296389d..1c6bb68 100644
--- a/src/ItemStat.cpp
+++ b/src/ItemStat.cpp
@@ -126,6 +126,8 @@ void ItemStat::statLink( const boost::filesystem::path& path )
 	accessTime = statInfos.st_atime;
 	creationTime = statInfos.st_ctime;
 	size = statInfos.st_size;
+	minSize = size;
+	maxSize = size;
 	// size on hard-drive (takes hardlinks into account)
 	sizeOnDisk = (statInfos.st_blocks / nbHardLinks) * 512;
 	setPermissions(statInfos.st_mode);
@@ -152,6 +154,8 @@ void ItemStat::setDefaultValues(){
 	creationTime = 0;
 	sizeOnDisk = 0;
 	size = 0;
+	minSize = 0;
+	maxSize = 0;
 	realSize = 0;
 	fullNbHardLinks = 0;
 	modificationTime = -1;
@@ -190,6 +194,8 @@ void ItemStat::statFolder( const boost::filesystem::path& path )
 	accessTime = statInfos.st_atime;
 	creationTime = statInfos.st_ctime;
 	size = statInfos.st_size;
+	minSize = size;
+	maxSize = size;
 	// size on hard-drive (takes hardlinks into account)
 	sizeOnDisk = statInfos.st_blocks * 512;
 	setPermissions(statInfos.st_mode);
@@ -214,6 +220,8 @@ void ItemStat::statFile( const boost::filesystem::path& path )
 	boost::system::error_code errorCode;
 	fullNbHardLinks = nbHardLinks = bfs::hard_link_count( path, errorCode );
 	size = bfs::file_size( path, errorCode );
+	minSize = size;
+	maxSize = size;
 	modificationTime = bfs::last_write_time( path, errorCode );
 	int stat_status = -1;
 
@@ -281,6 +289,8 @@ void ItemStat::statSequence( const Item& item, const bool approximative )
 	modificationTime = 0;
 	fullNbHardLinks = 0;
 	size = 0;
+	minSize = 0;
+	maxSize = 0;
 	realSize = 0;
 	sizeOnDisk = 0;
 	creationTime = 0;
@@ -332,8 +342,13 @@ void ItemStat::statSequence( const Item& item, const bool approximative )
 		if( creationTime == 0 || creationTime > fileStat.creationTime )
 			creationTime = fileStat.creationTime;
 
+		// compute sizes
 		fullNbHardLinks += fileStat.fullNbHardLinks;
 		size += fileStat.size;
+		if( minSize == 0 || minSize > fileStat.size )
+			minSize = fileStat.size;
+		if( maxSize == 0 || maxSize < fileStat.size )
+			maxSize = fileStat.size;
 		realSize += fileStat.realSize;
 		sizeOnDisk += fileStat.sizeOnDisk;
 	}
diff --git a/src/ItemStat.hpp b/src/ItemStat.hpp
index 4aa07ea..daf1904 100644
--- a/src/ItemStat.hpp
+++ b/src/ItemStat.hpp
@@ -39,6 +39,8 @@ class ItemStat
 	long long userId;
 	long long groupId;
 	long long size;
+	long long minSize; /// size of the smallest file in the sequence (otherwise, same value as size)
+	long long maxSize; /// size of the biggest file in the sequence (otherwise, same value as size)
 	long long realSize; /// size (takes hardlinks into account)
 	long long sizeOnDisk; /// size on hard-drive (takes hardlinks into account)
 	long long accessTime;

From 90019ce9bd55c291437e178574158d9ac28d42c6 Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Fri, 5 Jun 2015 14:27:00 +0200
Subject: [PATCH 08/10] Item: add constructor from a given sequence

This function can be called from python binding (which is not the case
of the same constructor with a boost::filesystem::path).
---
 src/Item.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Item.hpp b/src/Item.hpp
index 5a3e503..17e3d63 100644
--- a/src/Item.hpp
+++ b/src/Item.hpp
@@ -60,6 +60,14 @@ class Item
 		_path /= sequence.getStandardPattern();
 	}
 
+	Item( const Sequence& sequence, const std::string& folder )
+	: _type(eTypeSequence)
+	, _path(folder)
+	, _sequence(sequence)
+	{
+		_path /= sequence.getStandardPattern();
+	}
+
 	EType getType() const { return _type; }
 
 	std::string getAbsoluteFilepath() const { return _path.string(); }

From 72f628bbeb1a72291ec9baa63cbb6e100759b309 Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Mon, 22 Jun 2015 13:49:08 +0200
Subject: [PATCH 09/10] Add eDetectionSequenceWithoutHoles

If this detection method is specify, when add sequences in the output
vector of browse function, split them for each frame ranges.
---
 src/common.hpp     |  2 ++
 src/filesystem.cpp | 27 +++++++++++++++++++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/src/common.hpp b/src/common.hpp
index 863eda8..0b6247f 100644
--- a/src/common.hpp
+++ b/src/common.hpp
@@ -81,6 +81,8 @@ enum EDetection
 	eDetectionIgnoreDotFile = 8,
 	/// detect from an existing filename of the sequence
 	eDetectionSequenceFromFilename = 16,
+	/// detect sequences without holes
+	eDetectionSequenceWithoutHoles = 32,
 	eDetectionDefaultWithDotFile = (eDetectionSequenceNeedAtLeastTwoFiles | eDetectionSequenceFromFilename),
 	eDetectionDefault = (eDetectionSequenceNeedAtLeastTwoFiles | eDetectionIgnoreDotFile | eDetectionSequenceFromFilename)
 };
diff --git a/src/filesystem.cpp b/src/filesystem.cpp
index c66b82b..c90adca 100644
--- a/src/filesystem.cpp
+++ b/src/filesystem.cpp
@@ -85,6 +85,10 @@ bool browseSequence( Sequence& outSequence, const std::string& pattern, const EP
 	return true; // a real file sequence
 }
 
+bool isConsideredAsSingleFile( const Sequence& s, const EDetection detectOptions )
+{
+	return (detectOptions & eDetectionSequenceNeedAtLeastTwoFiles) && (s.getNbFiles() == 1);
+}
 
 std::vector<Item> browse(
 		const boost::filesystem::path& dir,
@@ -160,13 +164,32 @@ std::vector<Item> browse(
 			else
 			{
 				// if it's a sequence of 1 file, it could be considered as a sequence or as a single file
-				if( (detectOptions & eDetectionSequenceNeedAtLeastTwoFiles) && (s.getNbFiles() == 1) )
+				if( isConsideredAsSingleFile( s, detectOptions ) )
 				{
 					output.push_back( Item( getTypeFromPath( directory / s.getFirstFilename() ), directory / s.getFirstFilename() ) );
 				}
 				else
 				{
-					output.push_back( Item( Sequence( directory, s ), directory ) );
+					// if it's a sequence with holes, it could be split in several sequences depending on the detect options
+					if( (detectOptions & eDetectionSequenceWithoutHoles) && (s.getFrameRanges().size() > 1) )
+					{
+						BOOST_FOREACH( FrameRange f, s.getFrameRanges() )
+						{
+							const Sequence sequenceWithoutHoles( s.getPrefix(), s.getPadding(), s.getSuffix(), f.first, f.last, f.step, s.isStrictPadding() );
+							if( isConsideredAsSingleFile( sequenceWithoutHoles, detectOptions ) )
+							{
+								output.push_back( Item( getTypeFromPath( directory / sequenceWithoutHoles.getFirstFilename() ), directory / sequenceWithoutHoles.getFirstFilename() ) );
+							}
+							else
+							{
+								output.push_back( Item( Sequence( directory, sequenceWithoutHoles ), directory ) );
+							}
+						}
+					}
+					else
+					{
+						output.push_back( Item( Sequence( directory, s ), directory ) );
+					}
 				}
 			}
 		}

From 090478d1efe54cae8464a98671ab4d8a7ed36dab Mon Sep 17 00:00:00 2001
From: Clement Champetier <cnt@mikrosimage.eu>
Date: Tue, 23 Jun 2015 15:25:19 +0200
Subject: [PATCH 10/10] Item: add getTypeFromPath from a given string

* Can be used in bindings.
* Hide getTypeFromPath from a given bfs::path, from bindings.
---
 src/Item.cpp | 27 +++++++++++++++++----------
 src/Item.hpp |  3 +++
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/Item.cpp b/src/Item.cpp
index e4f4fae..9030c3b 100644
--- a/src/Item.cpp
+++ b/src/Item.cpp
@@ -42,18 +42,25 @@ std::vector<Item> Item::explode()
 EType getTypeFromPath( const boost::filesystem::path& path )
 {
 	if( bfs::is_symlink( path ) )
-        {
-                return eTypeLink;
-        }
-        if( bfs::is_regular_file( path ) )
 	{
-                return eTypeFile;
-        }
+		return eTypeLink;
+	}
+	if( bfs::is_regular_file( path ) )
+	{
+		return eTypeFile;
+	}
 	if( bfs::is_directory( path ) )
-        {
-                return eTypeFolder;
-        }
-        return eTypeUndefined;
+	{
+		return eTypeFolder;
+	}
+	return eTypeUndefined;
+}
+
+
+EType getTypeFromPath( const std::string& pathStr )
+{
+	const boost::filesystem::path path( pathStr );
+	return getTypeFromPath(path);
 }
 
 
diff --git a/src/Item.hpp b/src/Item.hpp
index 17e3d63..4b478fa 100644
--- a/src/Item.hpp
+++ b/src/Item.hpp
@@ -100,7 +100,10 @@ class Item
 };
 
 
+#ifndef SWIG
 EType getTypeFromPath( const boost::filesystem::path& path );
+#endif
+EType getTypeFromPath( const std::string& pathStr );
 
 
 std::ostream& operator<<( std::ostream& os, const Item& item );