dir pattern for Traverser, win32 corrections

diff --git a/base/ReByteBuffer.cpp b/base/ReByteBuffer.cpp
index 4e18366e277543ccb213ba517387a12d46e72bcf..8c72be5f945c60388d6665deb8afd70c880a6b63 100644 (file)
--- a/base/ReByteBuffer.cpp
+++ b/base/ReByteBuffer.cpp
@@ -194,6 +194,7 @@ ReByteBuffer& ReByteBuffer::appendMilliSec(int time, int minLength){
                appendInt(minutes, stdFormat).append(":");
        appendInt(sec, sec > 10 || minimum > 5 ? stdFormat : "%d").append(".");
        appendInt(msec, "%03d");
+    return *this;
 }
 
 /** Converts a subsequence into an integer.
@@ -307,7 +308,7 @@ ReByteBuffer& ReByteBuffer::fill(Byte filler, int start, int end){
        if (end == -1)
                end = m_length;
        if (start >= 0 && start < end){
-               if (end > m_length)
+               if (end > (int) m_length)
                        setLength(end);
                memset(m_buffer + start, filler, end - start);
        }

diff --git a/base/ReSeqArray.cpp b/base/ReSeqArray.cpp
index 5fc6c667837d8d2d254e8857d11d21af9dfcfb2d..66fe1ecfe11fee4a2f8a59eca012b12845dc8d10 100644 (file)
--- a/base/ReSeqArray.cpp
+++ b/base/ReSeqArray.cpp
@@ -60,7 +60,7 @@ enum RELOC_SEQARRAY {
  * @param deltaList            If there is not enough space in the content buffer
  *                                             this amount of bytes is the minimum to reserve.
  */
-ReSeqArray::ReSeqArray(size_t deltaList, int deltaBuffer) :
+ReSeqArray::ReSeqArray(int deltaList, int deltaBuffer) :
        m_content(deltaBuffer),
        m_list(deltaList),
        m_lost(0),

diff --git a/base/ReSeqArray.hpp b/base/ReSeqArray.hpp
index b7a769d7f87f8534d9793f43576b7f5fca539b98..fa460f5cc44485fbe01b3a281ceb3f000c88ccc0 100644 (file)
--- a/base/ReSeqArray.hpp
+++ b/base/ReSeqArray.hpp
@@ -30,7 +30,7 @@ public:
                Tag             m_tag;
        } Sequence;
 public:
-       ReSeqArray(size_t deltaList = -1024*sizeof(size_t), int deltaBuffer = - 1024*1024);
+       ReSeqArray(int deltaList = -1024 * (int) sizeof(size_t), int deltaBuffer = - 1024*1024);
        virtual ~ReSeqArray();
        ReSeqArray(const ReSeqArray& source);
        ReSeqArray& operator = (const ReSeqArray& source);

diff --git a/base/ReTestUnit.cpp b/base/ReTestUnit.cpp
index 7b6a24113577f5a6a7e36308321b711978049562..232a104eafcf631066a0ac59cbf501bd43b2b538 100644 (file)
--- a/base/ReTestUnit.cpp
+++ b/base/ReTestUnit.cpp
@@ -252,6 +252,9 @@ int ReTestUnit::milliSecSince(int64_t start){
 #if defined __linux__
        int64_t diff = clock() - start;
        return diff * 1000 / CLOCKS_PER_SEC;
+#elif defined __WIN32__
+    int64_t diff = clock() - start;
+    return diff * 1000 / CLOCKS_PER_SEC;
 #else
 #      error "timer not defined"
 #endif
@@ -270,6 +273,13 @@ int ReTestUnit::milliSecSince(int64_t start){
 int64_t ReTestUnit::timer(){
 #if defined __linux__
        return clock();
+#elif defined __WIN32__
+    return clock();
+#if 0
+    FILETIME timeBuffer;
+    GetSystemTimeAsFileTime(&timeBuffer);
+    return (int64_t) (((uint64_t) timeBuffer.dwHighDateTime << 32) + timeBuffer.dwLowDateTime);
+#endif
 #else
 #      error "timer not defined"
 #endif

diff --git a/base/ReVarArgs.cpp b/base/ReVarArgs.cpp
index 8f995804999d03b38f44015f9b82a36ce6c6e806..969da46cc49504920b6c7f81f07d6eea853275ad 100644 (file)
--- a/base/ReVarArgs.cpp
+++ b/base/ReVarArgs.cpp
@@ -179,6 +179,33 @@ ReVarArgs& ReVarArgs::arg(int value, const char* format){
        return *this;
 }
 
+/* @brief Defines an 64 bit integer argument.
+ *
+ * @param value                The integer value of the argument.
+ * @param format       The format (used with sprintf()) of the argument, e.g. "%lld".
+ *
+ * @return The instance itself. This is useful for chaining.
+ */
+ReVarArgs& ReVarArgs::arg(int64_t value, const char* format){
+       char number[256];
+       _snprintf(number, sizeof number, format, value);
+       store(number);
+       return *this;
+}
+
+/** @brief Stores an long argument.
+ *
+ * @param value                The argument value.
+ * @param format       The format (used with sprintf()) of the argument, e.g. "%d".
+ *
+ * @return The instance itself. This is useful for chaining.
+ */
+ReVarArgs& ReVarArgs::arg(unsigned int value, const char* format){
+       char number[256];
+       _snprintf(number, sizeof number, format, value);
+       store(number);
+       return *this;
+}
 /** @brief Stores an long argument.
  *
  * @param value                The argument value.
@@ -186,7 +213,7 @@ ReVarArgs& ReVarArgs::arg(int value, const char* format){
  *
  * @return The instance itself. This is useful for chaining.
  */
-ReVarArgs& ReVarArgs::arg(long value, const char* format){
+ReVarArgs& ReVarArgs::arg(uint64_t value, const char* format){
        char number[256];
        _snprintf(number, sizeof number, format, value);
        store(number);

diff --git a/base/ReVarArgs.hpp b/base/ReVarArgs.hpp
index e4258a1fce0d4ace2980e55d4d00f3d7c01d4991..6239c4cb9ce42056fffb32ae5a8afc2b6ea50e2e 100644 (file)
--- a/base/ReVarArgs.hpp
+++ b/base/ReVarArgs.hpp
@@ -41,7 +41,9 @@ private:
 public:
        ReVarArgs& reset(const char* format);
        ReVarArgs& arg(int value, const char* format = "%d");
-       ReVarArgs& arg(long arg, const char* format = "%ld");
+       ReVarArgs& arg(int64_t value, const char* format = "%lld");
+       ReVarArgs& arg(unsigned int arg, const char* format = "%u");
+       ReVarArgs& arg(uint64_t value, const char* format = "%llu");
        ReVarArgs& arg(const char* arg, int minWidth = 0, int maxWidth = 1024, bool alignRight = false);
        ReVarArgs& arg(double arg, const char* format = "%f");
        const char* asCString();

diff --git a/cunit/cuReHashList.cpp b/cunit/cuReHashList.cpp
index 33c7b863d5178584e0dc78ca3e09609cb3d3d5d7..fc21a667ca2c4916f8b936eadd2d5a470a955478 100644 (file)
--- a/cunit/cuReHashList.cpp
+++ b/cunit/cuReHashList.cpp
@@ -13,7 +13,7 @@ private:
                testNext();
        }
        void massTest(){
-               const int maxKeys = 50*1000;
+               const int maxKeys = 20*1000;
                const int minLength = 3;
                const int maxLength = 10;
                const int countGet = maxKeys * 50;

diff --git a/cunit/cuReTest.cpp b/cunit/cuReTest.cpp
index 15bec42b316b671d87c7376ced7206f2486744a7..48688fff9da17094fcae156a8ed66c57b4b5716d 100644 (file)
--- a/cunit/cuReTest.cpp
+++ b/cunit/cuReTest.cpp
@@ -41,7 +41,7 @@ private:
                checkDirExists("/etc/");
                checkFileExists("/etc/passwd");
 #elif defined __WIN32__
-               checkDirExists("c:\\windows")
+               checkDirExists("c:\\windows");
 #endif
                log(false, "8 errors follow:");
                checkT(false);

diff --git a/cunit/cuReTraverser.cpp b/cunit/cuReTraverser.cpp
index f64406f14c4f4e57f803d7fe6f7036097c166c21..3ef63661578ed1e185e80b4c960bde655e43c8f7 100644 (file)
--- a/cunit/cuReTraverser.cpp
+++ b/cunit/cuReTraverser.cpp
@@ -2,7 +2,6 @@
  * cuReTraverser.cpp
  *
  *  Created on: 23.12.2014
- *      Author: hm
  */
 
 #include "base/rebase.hpp"
@@ -48,16 +47,18 @@ private:
         makeDir("dir1/dir1_1");
         makeDir("dir1/dir1_2");
         makeDir("dir1/dir1_2/dir1_2_1");
+               makeDir("dir1/cache");
         makeFile("dir1/dir1_2/dir1_2_1/x1.txt");
         makeFile("dir1/dir1_2/dir1_2_1/x2.txt");
         makeFile("dir2/2.x");
+        makeFile("dir1/cache/cache.txt");
     }
        void run(){
-      initTree();
-      testDirOptions();
-      checkSetFilterFromProgramArgs();
-               testDirStatistic();
+               initTree();
                testBasic();
+               testDirOptions();
+               checkSetFilterFromProgramArgs();
+               testDirStatistic();
         testCopyFile();
         testList();
        }
@@ -67,6 +68,7 @@ private:
         tools.list(2, argv);
     }
     void testCopyFile(){
+#if defined __linux__
         ReByteBuffer src(m_base);
         src.append("dir1/dir1_2/dir1_2_1/x1.txt");
         ReByteBuffer trg(testDir());
@@ -75,6 +77,9 @@ private:
                buffer.ensureSize(5);
         ReDirSync::copyFile(src.str(), 0, -1ll, trg.str(), buffer, ReLogger::globalLogger());
         checkFileEqu(src.str(), trg.str());
+#else
+        log(false, "testCopyFile not implemented");
+#endif
     }
 
     void checkRelDate(time_t absTime, int relTime){
@@ -155,6 +160,13 @@ private:
     }
        void testBasic(){
                ReTraverser traverser(m_base.str());
+               RePatternList patterns;
+               // exclude */cache/*
+               ReByteBuffer buffer(";*;-*");
+               buffer.append(ReTraverser::m_separatorStr).append("cache")
+                       .append(ReTraverser::m_separatorStr);
+               patterns.set(buffer.str());
+               traverser.setDirPattern(&patterns);
                int level = 0;
                ReDirStatus_t* entry;
                ReHashList hash;
@@ -171,6 +183,7 @@ private:
                checkOneFile("dir1_1", "dir1", hash);
                checkOneFile("dir1_2", "dir1", hash);
                checkOneFile("dir1", m_base.str(), hash);
+               checkF(hash.get("cache.txt", buffer));
        }
        void testDirStatistic(){
                ReDirStatistic stat;
@@ -192,7 +205,7 @@ private:
                log(false, list2.join("\n", buffer).str());
         
         buffer.set(list.strOf(0), list.strLengthOf(0));
-        checkT(buffer.startsWith("      0.000054 MB       2       3\t"));
+        checkT(buffer.startsWith("      0.000074 MB       3       4\t"));
         expected.set(m_base.str(), m_base.length()).append("dir1", -1)
              .append(ReTraverser::m_separatorStr);
         checkT(buffer.endsWith(expected.str()));
@@ -204,7 +217,7 @@ private:
         checkT(buffer.endsWith(expected.str()));
 
         buffer.set(list.strOf(2), list.strLengthOf(2));
-        checkT(buffer.startsWith("      0.000067 MB       4       5\t"));
+        checkT(buffer.startsWith("      0.000087 MB       5       6\t"));
         expected.set(m_base.str(), m_base.length());
     }
 };

diff --git a/cunit/testall.cpp b/cunit/testall.cpp
index f914f47fe645c6bcc3f376e4abdb8bbc62f60673..e5fe75dd382c3c0320a118b8081f96b2a7147534 100644 (file)
--- a/cunit/testall.cpp
+++ b/cunit/testall.cpp
@@ -11,11 +11,8 @@
 #endif
 
 void testBase(){
-       extern void testReHashList(void);
-       testReHashList();
-
        extern void testReTestUnit();
-       testReTestUnit();
+       //testReTestUnit();
        extern void testReByteBuffer();
        testReByteBuffer();
        extern void testReSeqArray(void);
@@ -66,8 +63,8 @@ void testMath(){
 void testAll(){
        try
        {
-               testBase();
                testOs();
+               testBase();
                testMath();
                testString();
        } catch (ReException e){

diff --git a/math/ReRandomizer.cpp b/math/ReRandomizer.cpp
index d646d9201f6071c94ebe9a2362dee8205a7fca01..f1d4ab99eb1a381c02ebb8b68c94db8317062fac 100644 (file)
--- a/math/ReRandomizer.cpp
+++ b/math/ReRandomizer.cpp
@@ -56,9 +56,11 @@ ReRandomizer::seed_t ReRandomizer::nearTrueRandom(){
        if (read(fh, buffer, sizeof buffer) > 0)
                rc ^= *(seed_t*) buffer;
        close(fh);
+#elif defined __WIN32__
 #else
 #error "no true random"
 #endif
+    return rc;
 }
 /**
  * @brief Returns the next random integer.
@@ -102,7 +104,7 @@ int ReRandomizer::nextInt(int maxValue, int minValue){
  * @return The next seed.
  */
 int64_t ReRandomizer::nextInt64(int64_t maxValue, int64_t minValue){
-       int rc;
+       seed_t rc;
        if (minValue > maxValue){
                rc = minValue;
                minValue = maxValue;
@@ -112,7 +114,7 @@ int64_t ReRandomizer::nextInt64(int64_t maxValue, int64_t minValue){
        if (minValue == maxValue)
                rc = minValue;
        else if (minValue == 0 && maxValue == LLONG_MAX)
-               rc = abs(seed);
+               rc = abs((int64_t) seed);
        else if (uint64_t(maxValue - minValue) < LLONG_MAX)
                // no signed int64 overflow:
                rc = minValue + seed % (maxValue - minValue + 1);

diff --git a/os/ReTraverser.cpp b/os/ReTraverser.cpp
index a7def560cf096e8331bac4a2615a05daff88ae18..d87066f456dfc289421f2865decf1d1057b6b495 100644 (file)
--- a/os/ReTraverser.cpp
+++ b/os/ReTraverser.cpp
@@ -384,10 +384,15 @@ ReTraverser::ReTraverser(const char* base) :
        m_level(-1),\r
        m_base(base),\r
     // m_dirs\r
-    m_passNoForDirSearch(2)\r
+    m_passNoForDirSearch(2),\r
+    m_dirPatterns(NULL)\r
 {\r
        memset(m_dirs, 0, sizeof m_dirs);\r
        m_dirs[0] = new ReDirStatus_t();\r
+       // remove a preceeding "./". This simplifies the pattern expressions:\r
+       if (m_base.startsWith(ReByteBuffer(".").append(m_separatorStr, 1).str())){\r
+               m_base.remove(0, 2);\r
+       }\r
 }\r
 \r
 /**\r
@@ -444,8 +449,10 @@ ReDirStatus_t* ReTraverser::rawNextFile(int& level)
                                } else {\r
                                        // we are interested only in true subdirectories:\r
                                        again = true;\r
-                    if (current->isDirectory() && ! current->isDotDir() && ! current->isLink()\r
-                        && m_level < m_maxLevel){\r
+                    if (m_level < m_maxLevel && current->isDirectory()\r
+                                                       && ! current->isDotDir() && ! current->isLink()\r
+                                                       && (m_dirPatterns == NULL || isAllowedDir(current->m_path,\r
+                                                               current->node()))){\r
                                                // open a new level\r
                                                alreadyRead = initEntry(current->m_path, current->node() , m_level + 1);\r
                                        }\r

diff --git a/os/ReTraverser.hpp b/os/ReTraverser.hpp
index c751c48e15497296b045f3f39190dbe312c98a6d..24e161b3b964d6c68d41f28005d9fa09a573f872 100644 (file)
--- a/os/ReTraverser.hpp
+++ b/os/ReTraverser.hpp
@@ -104,19 +104,35 @@ public:
 public:
        ReDirStatus_t* rawNextFile(int& level);
        ReDirStatus_t* nextFile(int& level, ReDirEntryFilter_t* filter = NULL);
+    /** Sets directory filter (pattern list).
+     * @param pattern  pattern list for the subdirs to be entered
+    */
+    void setDirPattern(RePatternList* pattern)
+    { m_dirPatterns = pattern; }
     /** Sets the maximal depth.
      * @param value     the value to set
     */
-    void setMinLevel(int value)
-    { m_minLevel = value; }
+    void setMaxLevel(int value)
+    { m_maxLevel = value; }
     /** Sets the minimal depth.
      * @param value     the value to set
     */
-    void setMaxLevel(int value)
-    { m_maxLevel = value; }
+    void setMinLevel(int value)
+    { m_minLevel = value; }
 protected:
        bool initEntry(const ReByteBuffer& parent, const char* node, int level);
        void freeEntry(int level);
+       /**
+       * Tests whether a directory should be processed.
+       * @param path           the path of the subdir
+       * @param node           the base name of the subdir
+       * @return                       <code>true</code>: the subdir will be processed<br>
+       *                                       <code>false</code>: do not enter this subdir
+       */
+       inline bool isAllowedDir(const ReByteBuffer& path, const char* node){
+               bool rc = m_dirPatterns->match(ReByteBuffer(path).append(node).str());
+               return rc;
+       }
 protected:
     int m_minLevel;
     int m_maxLevel;
@@ -126,6 +142,9 @@ protected:
        /// each directory will be passed twice: for all files + for directories only
        /// 1: depth first 2: breadth first
        int m_passNoForDirSearch;
+       /// a subdirectory will be entered only if this pattern list matches
+       /// if NULL any directory will be entered
+       RePatternList* m_dirPatterns;
 public:
        static const char m_separator;
        static const char* const m_separatorStr;