zynq_7010/filetools.h

#pragma once
#include <vector>
#include <iostream>
#include <fstream>
#include <time.h>
#include <sstream>
#include <chrono>
#include <sys/timeb.h>
#include <chrono>
#include <iostream>
#include <ctime>

class FileTools
{
private:
	std::string mPath;

public:
	FileTools(std::string path)
	{
		mPath = path;
	}
	void createLog(std::string log)
	{
		time_t now = time(0);
		tm *ltm = localtime(&now);
		char loc_date[30];
		sprintf(loc_date, "%d%02d%02d  %d:%d:%d", 1900 + ltm->tm_year, 1 + ltm->tm_mon, ltm->tm_mday, ltm->tm_hour, ltm->tm_min, ltm->tm_sec);
		std::ofstream ofs(mPath);
		ofs << loc_date << ":	" << log << std::endl;
		ofs.close();
	}
	void append_log(std::string log, bool printTime = true)
	{
		std::ofstream ofs(mPath, std::ios::app);
		if (printTime)
		{
			// time_t now = time(0);

			// struct  timeb   stTimeb;

			// ftime(&stTimeb);
			// tm *ltm = localtime(&now);
			// char loc_date[30];
			// sprintf(loc_date, "%d%02d%02d  %d:%d:%d", 1900 + ltm->tm_year, 1 + ltm->tm_mon, ltm->tm_mday, ltm->tm_hour, ltm->tm_min, ltm->tm_sec);
			struct tm *ptm;
			struct timeb stTimeb;
			static char loc_date[30];

			ftime(&stTimeb);
			ptm = localtime(&stTimeb.time);
			sprintf(loc_date, "%02d-%02d %02d:%02d:%02d.%03d",
					ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec, stTimeb.millitm);
			ofs << loc_date << ":	" << log << std::endl;
		}
		else
		{
			ofs << "	" << log << std::endl;
		}
		ofs.close();
	}

	void clear()
	{
		try
		{
			std::fstream fout(mPath, std::ios::out | std::ios::trunc);
			fout.close();
		}
		catch (std::exception &e)
		{
			//LOG("error happened: %s \n", e.what());
		}
	}
};


static std::string GetCurrentTimeStamp(int time_stamp_type )
{
	std::chrono::system_clock::time_point now = std::chrono::system_clock::now();

	std::time_t now_time_t = std::chrono::system_clock::to_time_t(now);
	std::tm* now_tm = std::localtime(&now_time_t);

	char buffer[128];
	strftime(buffer, sizeof(buffer), "%F %T", now_tm);

	std::ostringstream ss;
	ss.fill('0');

	std::chrono::milliseconds ms;
	std::chrono::microseconds cs;
	std::chrono::nanoseconds ns;
	
	switch (time_stamp_type)
	{
	case 0:
		ss << buffer;
		break;
	case 1:
		ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
		ss << buffer << ":" << ms.count();
		break;
	case 2:
		ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
		cs = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()) % 1000000;
		ss << buffer << ":" << ms.count() << ":" << cs.count() % 1000;
		break;
	case 3:
		ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
		cs = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()) % 1000000;
		ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()) % 1000000000;
		ss << buffer << ":" << ms.count() << ":" << cs.count() % 1000 << ":" << ns.count() % 1000;
		break;
	default:
		ss << buffer;
		break;
	}

	return ss.str();
}

class StopWatch
{
public:
	StopWatch()
	{
		_start = std::chrono::steady_clock::now();
	}

	void reset()
	{
		_start = std::chrono::steady_clock::now();
	}

	double elapsed_s()
	{
		return std::chrono::duration<double>(std::chrono::steady_clock::now() - _start).count();
	}

	double elapsed_ms()
	{
		return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - _start).count();
	}

	double elapsed_us()
	{
		return std::chrono::duration<double, std::micro>(std::chrono::steady_clock::now() - _start).count();
	}

	double elapsed_ns()
	{
		return std::chrono::duration<double, std::nano>(std::chrono::steady_clock::now() - _start).count();
	}

private:
	std::chrono::steady_clock::time_point _start;
};