precompare

git-svn-id: https://projectname.googlecode.com/svn/trunk@14 c416075f-80b4-e980-4839-00ea3ed24e77

trunk/src/clusterization.cpp

@@ -0,0 +1,20 @@
+#include "clusterization.h"
+
+void clusterization::next(const T_ptr& t) {
+    std::map<T_ptr, Cont, less>::iterator it = _continuations.find(t);
+    if (it == _continuations.end()) {
+        Cont cont = category::kleisli::sink<T_ptr>::continuation().clone();
+        _continuations.insert(std::make_pair(t, cont));
+        cont->next(t);
+    } else {
+        it->second->next(t);
+    }
+}
+
+void clusterization::stop() {
+    std::map<T_ptr, Cont, less>::iterator it = _continuations.begin();
+    for (; it != _continuations.end(); ++it) {
+        it->second->stop();
+    }
+    _continuations.clear();
+}

trunk/src/clusterization.h

@@ -6,35 +6,27 @@
 #include <map>
 
 #include "kleisli.h"
+#include "file_types/base.h"
 
-template<typename T>
-class clusterization: public category::kleisli::arr<boost::shared_ptr<T>, boost::shared_ptr<T> > {
-    typedef boost::shared_ptr<T> T_ptr;
+class clusterization: public category::kleisli::arr
+  <boost::shared_ptr<file_type::base>, boost::shared_ptr<file_type::base> > {
+    typedef boost::shared_ptr<file_type::base> T_ptr;
+    typedef boost::shared_ptr<category::kleisli::end<T_ptr> > Cont;
     struct less {
         bool operator()(const T_ptr& t1, const T_ptr& t2) {
-            return typeid(*t1).before(typeid(*t2));
+            if (typeid(*t1).before(typeid(*t2))) {
+                return true;
+            }
+            if (typeid(*t2).before(typeid(*t1))) {
+                return false;
+            }
+            return t1->precompare(t2) == file_type::less;
         }
     };
-    typedef boost::shared_ptr<category::kleisli::end<T_ptr> > Cont;
-    typedef std::map<T_ptr, Cont, less> map;
-    map _continuations;
+    std::map<T_ptr, Cont, less> _continuations;
 public:
-    void next(const T_ptr& t) {
-        typename std::map<T_ptr, Cont, less>::iterator it = _continuations.find(t);
-        if (it == _continuations.end()) {
-            Cont cont = category::kleisli::sink<T_ptr>::continuation().clone();
-            _continuations.insert(std::make_pair(t, cont));
-            cont->next(t);
-        } else {
-            it->second->next(t);
-        }
-    }
-    void stop() {
-        for (typename map::iterator it = _continuations.begin(); it != _continuations.end(); ++it) {
-            it->second->stop();
-        }
-        _continuations.clear();
-    }
+    void next(const T_ptr& t);
+    void stop();
 };
 
 #endif

trunk/src/default_main.cpp

@@ -49,7 +49,7 @@ void default_main(const program_options& po) {
     >>= fs::recursive()
     >>= (po.extensions().empty() ? The< arr<fs::path, fs::path> >() : The<elem_filter>(po.extensions()))
     >>= file_typer_match_first()
-    >>= clusterization<file_type::base>()
+    >>= clusterization()
     >>= comparator<file_type::base, file_type::base>()
     >>= accumulator<file_type::base>()
     >>= output;

trunk/src/file_types/base.cpp

@@ -9,16 +9,13 @@
 
 namespace file_type {
 
-base::base(const fs::path& p): _path(p), size(fs::file_size(p)) { }
+base::base(const fs::path& p): _path(p), _size(fs::file_size(p)) { }
 
 boost::shared_ptr<base> base::try_file(const fs::path& file) {
     return boost::make_shared<base>(file);
 }
 
 boost::shared_ptr<base> base::compare(const boost::shared_ptr<base>& a) const {
-    if (fs::file_size(_path) != fs::file_size(a->_path)) {
-        return boost::shared_ptr<base>();
-    }
     const int buf_size = 4096;
     char buf1[buf_size], buf2[buf_size];
     fs::ifstream file1(_path), file2(a->_path);
@@ -34,4 +31,8 @@ boost::shared_ptr<base> base::compare(const boost::shared_ptr<base>& a) const {
     }
 }
 
+inline comparison_result base::precompare(const boost::shared_ptr<base>& a) const {
+    return _size < a->_size ? less : _size == a->_size ? equal : greater;
+}
+
 }

trunk/src/file_types/base.h

@@ -10,14 +10,21 @@
 
 namespace file_type {
 
+enum comparison_result
+  { less
+  , greater
+  , equal
+  };
+
 class base {
     fs::path _path;
-    unsigned int size;
+    unsigned int _size;
 public:
     base(const fs::path& p);
     const fs::path& path() const { return _path; }
     static boost::shared_ptr<base> try_file(const fs::path& file);
     virtual boost::shared_ptr<base> compare(const boost::shared_ptr<base>& a) const;
+    virtual comparison_result precompare(const boost::shared_ptr<base>& a) const;
 };
 
 }

trunk/src/file_types/img.cpp

@@ -31,4 +31,8 @@ boost::shared_ptr<base> img::compare(const boost::shared_ptr<base>& a) const {
     return boost::shared_ptr<img>();
 }
 
+inline comparison_result img::precompare(const boost::shared_ptr<base>& a) const {
+    return equal;
+}
+
 }

trunk/src/file_types/img.h

@@ -12,6 +12,7 @@ struct img: base {
     img(const fs::path& p): base(p) {}
     static boost::shared_ptr<img> try_file(const boost::shared_ptr<base>& file);
     boost::shared_ptr<base> compare(const boost::shared_ptr<base>& a) const;
+    comparison_result precompare(const boost::shared_ptr<base>& a) const;
 };
 
 }

trunk/src/file_types/text.cpp

@@ -77,4 +77,8 @@ boost::shared_ptr<base> text::compare(const boost::shared_ptr<base>& a) const {
     }
 }
 
+inline comparison_result text::precompare(const boost::shared_ptr<base>& a) const {
+    return equal;
+}
+
 }

trunk/src/file_types/text.h

@@ -10,6 +10,7 @@ struct text: base {
     text(const fs::path& p): base(p) {}
     static boost::shared_ptr<text> try_file(const boost::shared_ptr<base>& file);
     boost::shared_ptr<base> compare(const boost::shared_ptr<base>& a) const;
+    comparison_result precompare(const boost::shared_ptr<base>& a) const;
 };
 
 }

trunk/todo.txt

@@ -1 +0,0 @@
-precompare !!!