add cthread, cdatetime, cstring

Author: xueqing

.gitignore

@@ -0,0 +1,3 @@
+build/
+*~
+*.user

CPPUtility/CPPUtility.pro

@@ -0,0 +1,23 @@
+TARGET = CPPUtility
+TEMPLATE = lib
+CONFIG -= qt
+CONFIG += c++11
+
+unix
+{
+    CONFIG(debug, debug|release) {
+        DESTDIR = $$PWD/../build/debug
+    } else {
+        DESTDIR = $$PWD/../build/release
+    }
+}
+
+HEADERS += \
+    cthread.h \
+    cdatetime.h \
+    cstring.h
+
+SOURCES += \
+    cthread.cpp \
+    cdatetime.cpp \
+    cstring.cpp

CPPUtility/cdatetime.cpp

@@ -0,0 +1,51 @@
+#include "cdatetime.h"
+
+#include <string.h>
+#include <time.h>
+#include <chrono>
+
+bool CDateTime::GetCurrentDateTime(std::string &strtime, std::string strformat)
+{
+    long timestamp = std::time(nullptr);
+    return GetTimeAsString(strtime, strformat, timestamp);
+}
+
+bool CDateTime::GetTimeAsString(std::string &strtime, std::string strformat, long timestamp)
+{
+    char buffer[30];
+    memset(buffer, 0, sizeof(buffer));
+
+    std::chrono::seconds cseconds(timestamp);
+    std::chrono::system_clock::time_point sctimepoint(cseconds);
+    std::time_t ttime = std::chrono::system_clock::to_time_t(sctimepoint);
+    std::tm tmres;
+    localtime_r(&ttime, &tmres);
+    std::strftime(buffer, 30, strformat.data(), &tmres);
+
+    strtime = std::string(buffer);
+    return true;
+}
+
+bool CDateTime::GetTimeFromString(std::string strtime, long &timestamp)
+{
+    int nyear, nmon, nday, nhou, nmin, nsec;
+
+    sscanf(strtime.data(), "%d-%d-%dT%d:%d:%d", &nyear, &nmon, &nday, &nhou, &nmin, &nsec);
+    std::tm stimeinfo;
+    stimeinfo.tm_year = nyear-1900;
+    stimeinfo.tm_mon = nmon-1;
+    stimeinfo.tm_mday = nday;
+    stimeinfo.tm_hour = nhou;
+    stimeinfo.tm_min = nmin;
+    stimeinfo.tm_sec = nsec;
+
+    timestamp = std::mktime(&stimeinfo);
+    return true;
+}
+
+int CDateTime::GetDiffDay(long starttime, long endtime)
+{
+    double diffsec = std::difftime(endtime, starttime);
+    int diffday = diffsec / (24 * 3600);
+    return diffday;
+}

CPPUtility/cdatetime.h

@@ -0,0 +1,42 @@
+#ifndef CDATETIME_H
+#define CDATETIME_H
+
+#include <string>
+
+namespace CDateTime {
+    /**
+     * @brief GetCurrentDateTime    transform current timestamp into strtime according to strformat
+     * @param strtime               formatted string
+     * @param strformat             format, referring to format of 'std::strftime()'
+     * @return
+     */
+    bool GetCurrentDateTime(std::string &strtime, std::string strformat);
+
+    /**
+     * @brief GetTimeAsString   transform timestamp into strtime according to strformat
+     * @param strtime           formatted string
+     * @param strformat         format, referring to format of 'std::strftime()'
+     * @param timestamp         given time
+     * @return
+     */
+    bool GetTimeAsString(std::string &strtime, std::string strformat, long timestamp);
+
+    /**
+     * @brief GetTimeFromString transform strtime into timestamp according to strformat
+     * @param strtime           given string of time, "yyyy-mm-ddThh:mm:ss"
+     * @param timestamp         requested time
+     * @return
+     */
+    bool GetTimeFromString(std::string strtime, long &timestamp);
+
+    /**
+     * @brief GetDiffDay        calculate different day from starttime to endtime
+     * @param starttime         start timestamp
+     * @param endtime           end timestamp
+     * @return
+     */
+    int GetDiffDay(long starttime, long endtime);
+
+} //namespace CDateTime
+
+#endif // CDATETIME_H

CPPUtility/cstring.cpp

@@ -0,0 +1,29 @@
+#include "cstring.h"
+
+#ifdef __linux__
+#include <strings.h>
+#endif
+
+#include <stdio.h>
+
+int CString::StrCmpCaseInsensitive(const char *str1, const char *str2)
+{
+    int ret = 0;
+#ifdef __linux__
+    ret = strcasecmp(str1, str2);
+#else
+    ret = stricmp(str1, str2);
+#endif
+    return ret;
+}
+
+int CString::NumberToString(char *str, int num, const char * format)
+{
+    str = new char[20]();
+    return sprintf(str, format, num);
+}
+
+int CString::StringToNumber(const char *str, int num, const char *format)
+{
+    return sscanf(str, format, num);
+}

CPPUtility/cstring.h

@@ -0,0 +1,15 @@
+#ifndef CSTRING_H
+#define CSTRING_H
+
+#include <stdio.h>
+
+#define MYLOG(fmt, ...) printf("File %s line %d: " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
+
+namespace CString
+{
+    int StrCmpCaseInsensitive(const char *str1, const char *str2);
+    int NumberToString(char *str, int num, const char *format = "%d");
+    int StringToNumber(const char *str, int num, const char *format = "%d");
+} //namespace CString
+
+#endif // CSTRING_H

CPPUtility/cthread.cpp

@@ -0,0 +1,71 @@
+#include "cthread.h"
+
+
+#include <iostream>
+
+CThread::CThread()
+    : m_isRunning(false)
+{
+
+}
+
+CThread::~CThread()
+{
+    if(m_thread.joinable())
+    {
+        m_thread.join();
+    }
+}
+
+void CThread::start()
+{
+
+#ifndef _POSIX_MONOTONIC_CLOCK
+std::cout << "error" << std::endl;
+#endif
+
+    m_startmutex.lock();
+    m_thread = std::thread(&CThread::thread, this);
+    m_thread.detach();
+}
+
+bool CThread::isRunning()
+{
+    return m_isRunning;
+}
+
+bool CThread::isFinished()
+{
+    return !m_isRunning;
+}
+
+bool CThread::wait(unsigned long time)
+{
+    std::unique_lock<std::mutex> locker(m_startmutex);
+    std::chrono::seconds cseconds(time);
+    std::chrono::system_clock::time_point sctimepoint(cseconds);
+    bool bWait = m_mutex.try_lock_until(sctimepoint);
+    if(bWait)
+        m_mutex.unlock();
+    return bWait;
+}
+
+void CThread::sleep(unsigned long sec)
+{
+    std::this_thread::sleep_for(std::chrono::seconds(sec));
+}
+
+void CThread::finished()
+{
+}
+
+void CThread::thread()
+{
+    m_startmutex.unlock();
+    std::unique_lock<std::timed_mutex> locker(m_mutex);
+    m_isRunning = true;
+    run();
+    // finish
+    finished();
+    m_isRunning = false;
+}

CPPUtility/cthread.h

@@ -0,0 +1,42 @@
+#ifndef CTHREAD_H
+#define CTHREAD_H
+
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+
+class CThread
+{
+public:
+    CThread();
+    ~CThread();
+
+    // 开启线程
+    void start();
+
+    // 线程是否运行
+    bool isRunning();
+    bool isFinished();
+
+    bool wait(unsigned long time = -1);
+    static void sleep(unsigned long sec);
+
+protected:
+    /**
+     * @brief run a pure function to be executed in thread body
+     */
+    virtual void run() = 0;
+    virtual void finished();
+
+private:
+    void thread();
+
+private:
+    bool m_isRunning;
+
+    std::thread m_thread;
+    std::mutex m_startmutex;
+    std::timed_mutex m_mutex;
+};
+
+#endif // CTHREAD_H

UtilityTest/UtilityTest.pro

@@ -0,0 +1,26 @@
+TARGET = UtilityTest
+TEMPLATE = lib
+CONFIG -= qt
+CONFIG += c++11
+
+INCLUDEPATH += \
+    $$PWD/../CPPUtility
+
+unix
+{
+    CONFIG(debug, debug|release) {
+        DESTDIR = $$PWD/../build/debug
+    } else {
+        DESTDIR = $$PWD/../build/release
+    }
+}
+
+HEADERS += \
+    cthreadtest.h \
+    cstringtest.h \
+    cdatetimetest.h
+
+SOURCES += \
+    cthreadtest.cpp \
+    cstringtest.cpp \
+    cdatetimetest.cpp

UtilityTest/cdatetimetest.cpp

@@ -0,0 +1,44 @@
+#include "cdatetimetest.h"
+
+#include <chrono>
+#include <iostream>
+
+#include "cdatetime.h"
+
+void CDateTimeTest::Test()
+{
+    // get current time
+    std::string curtime;
+    CDateTime::GetCurrentDateTime(curtime, "%FT%T");
+    std::cout << "CDateTimeTest::Test--curtime=[" << curtime << "]" << std::endl;
+
+    // get request parameters
+    std::string starttime = "2010-11-11T19:46:17";
+    std::string endtime = "2010-11-12T19:46:17";
+
+    // get seconds_since_epoch for starttime and endtime
+    long scount=-1, ecount=-1;
+    CDateTime::GetTimeFromString(starttime, scount);
+    CDateTime::GetTimeFromString(endtime, ecount);
+    std::cout << "CDateTimeTest::Test--scount=" << scount << ";ecount=" << ecount << std::endl;
+
+    std::string tableName;
+    std::chrono::system_clock::time_point stimepoint = std::chrono::system_clock::from_time_t(scount);
+
+    int diffday = CDateTime::GetDiffDay(scount, ecount);
+    for(int i=-1; i<=diffday && diffday>=0; i++)
+    {
+        tableName.clear();
+        std::chrono::hours oneday(i*24);
+        std::chrono::system_clock::time_point itimepoint = stimepoint + oneday;
+        time_t itime = std::chrono::system_clock::to_time_t(itimepoint);
+        CDateTime::GetTimeAsString(tableName, "S%G%m%d", itime);
+
+        std::cout << "CDateTimeTest::Test--table name: " << tableName << std::endl;
+    }
+
+    long timestamp = 1499258297;
+    std::string stimetamsp;
+    CDateTime::GetTimeAsString(stimetamsp, "%FT%T", timestamp);
+    std::cout << "CDateTimeTest::Test--stimestamp=" << stimetamsp << std::endl;
+}

UtilityTest/cdatetimetest.h

@@ -0,0 +1,14 @@
+#ifndef CDATETIMETEST_H
+#define CDATETIMETEST_H
+
+class CDateTimeTest
+{
+public:
+    CDateTimeTest(){Test();}
+    ~CDateTimeTest(){}
+
+private:
+    void Test();
+};
+
+#endif // CDATETIMETEST_H

UtilityTest/cstringtest.cpp

@@ -0,0 +1,13 @@
+#include "cstringtest.h"
+
+#include <iostream>
+
+#include "cstring.h"
+
+void CStringTest::Test()
+{
+    std::cout << "CStringTimeTest::Test--   " << CString::StrCmpCaseInsensitive("dec", "DEC") << std::endl;
+    std::cout << "CStringTimeTest::Test--   " << CString::StrCmpCaseInsensitive("dec", "eEC") << std::endl;
+    std::cout << "CStringTimeTest::Test--   " << CString::StrCmpCaseInsensitive("eec", "DEC") << std::endl;
+    MYLOG("%s", "CStringTest::Hello!");
+}

UtilityTest/cstringtest.h

@@ -0,0 +1,14 @@
+#ifndef CSTRINGTEST_H
+#define CSTRINGTEST_H
+
+class CStringTest
+{
+public:
+    CStringTest(){Test();}
+    ~CStringTest(){}
+
+private:
+    void Test();
+};
+
+#endif // CSTRINGTEST_H