IOUtilities.hpp

Go to the documentation of this file.

// _LICENSE_HEADER_
//
// Copyright (C) 2019 - 2025.
// Terms register on the GPL-3.0 license.
//
// This file can be redistributed and/or modified under the license terms.
//
// See top level LICENSE file for more details.
//
// This file can be used citing references in CITATION.cff file.
 
#ifndef __GEDIM_IOUtilities_H
#define __GEDIM_IOUtilities_H
 
#include "Gedim_Macro.hpp"
#include <unordered_set>
 
#if USE_MPI == 1
#include <mpi.h>
#endif
 
#include <cstdarg>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <unordered_map>
#include <vector>
 
namespace Gedim
{
class Output;
class Profiler;
class LogFile;
 
class Output
{
  public:
    enum FileFilter
    {
        FilesAndDirectories = 0,
        Files = 1,
        Directories = 2
    };
 
    static std::string BlueColor;
    static std::string RedColor;
    static std::string GreenColor;
    static std::string YellowColor;
    static std::string MagentaColor;
    static std::string EndColor;
 
    static int MaxElementToPrint;    
    static int StartingIndexToPrint; 
 
    static void CreateFolder(const std::string &nameFolder);
    static std::vector<std::string> StringSplit(const std::string &stringToSplit, const char character);
    static bool FileExists(const std::string &nameFile);
    static void GetFilePath(const std::string &nameFilePath, std::string &filePath, std::string &fileName, std::string &fileExtension);
    static void GetFileList(const std::string &mainDirectory,
                            std::vector<std::string> &out,
                            const FileFilter &filter = Output::FilesAndDirectories,
                            const bool &hiddenElements = false);
    static void FindPaths(const std::string &mainDirectory,
                          const std::string &objectNameToFind,
                          std::vector<std::string> &paths,
                          const FileFilter &filter = Output::FilesAndDirectories,
                          const bool &hiddenElements = false);
 
    static void GetBinaryFileSize(const std::string &nameFile,
                                  unsigned int &fileSize,
                                  const unsigned int &sizeOfSingleDataToWrite,
                                  const unsigned int &startingPosition = 0);
    static void ReadBinaryFile(const std::string &nameFile,
                               void *dataToRead,
                               const unsigned int &sizeOfSingleDataToWrite,
                               const unsigned int &dataSizeToRead,
                               const unsigned int &startingPosition = 0);
    static bool ReadBinaryFile(const std::string &nameFile,
                               std::vector<double> &dataToRead,
                               const unsigned int &dataSizeToRead = 0,
                               const unsigned int &startingPosition = 0);
    static void WriteBinaryFile(const std::string &nameFile,
                                const void *dataToWrite,
                                const unsigned int &sizeOfSingleDataToWrite,
                                const unsigned int &dataSizeToWrite,
                                const bool &append = false);
    static bool WriteBinaryFile(const std::string &nameFile,
                                const std::vector<double> &dataToWrite,
                                const unsigned int &dataSizeToWrite = 0,
                                const unsigned int &dataStartingPositionToWrite = 0,
                                const bool &append = false);
 
    static void PrintLine(char character = ' ', bool onlyMaster = true);
 
    static std::ostream &PrintStars(std::ostream &out);
    static std::ostream &PrintLines(std::ostream &out);
 
    static void PrintStatusProgram(const std::string &programStep, ...);
    static void PrintGenericMessageOnLine(const std::string &message, ...);
    static void PrintGenericMessage(const std::string &message, const bool &onlyMaster, ...);
    static void PrintErrorMessage(const std::string &message, const bool &onlyMaster, ...);
    static void PrintWarningMessage(const std::string &message, const bool &onlyMaster, ...);
    static void PrintDebugMessage(const std::string &message, const bool &onlyMaster, ...);
    static void PrintSuccessMessage(const std::string &message, const bool &onlyMaster, ...);
 
    inline static void Assert(const bool &logicResult)
    {
        if (!logicResult)
            abort();
    }
 
    static void Assert(const bool &logicResult, const std::string &message, ...);
};
 
class LogFile
{
  private:
    static std::string GetDateTime();
    static void PrintMessage(const std::string &type, const std::string &message, va_list args);
 
  public:
    static int LogMaxFileSize;      
    static int LogMaxNumFiles;      
    static std::string LogFolder;   
    static std::string LogNameFile; 
 
    static void PrintLine(const char &symbol = ' ');
    static void PrintWarningMessage(const std::string &message, va_list args);
    static void PrintErrorMessage(const std::string &message, va_list args);
    static void PrintInfoMessage(const std::string &message, va_list args);
    static void PrintDebugMessage(const std::string &message, va_list args);
 
    static void CheckFileSize(const std::string &nameFile);
    static double GetFileSize(const std::string &nameFile);
};
 
class Profiler
{
  private:
    static std::map<std::string, double> times;      
    static std::map<std::string, double> localTimes; 
    static unsigned long totalAvailStartingMemory;   
    static int ParseLine(char *line);                
 
  public:
    static bool ActivateProfiler;  
    static std::string TimeFile;   
    static std::string MemoryFile; 
 
    static double GetTime(const std::string &nameTime, const bool &localTime = false);
    static double GetTime();
    static double ComputeTime(const double &startTime, const double &stopTime)
    {
#if USE_MPI == 1
        return stopTime - startTime;
#elif USE_MPI == 0
        return (stopTime - startTime) / (double)CLOCKS_PER_SEC;
#endif // USE_MPI
    }
 
    static void GetTotalMemory(std::vector<unsigned long> &totalMemory);
 
    static void GetProcessMemory(std::vector<unsigned long> &memoryUsed);
 
    static void CheckMemory(const std::string &nameMemory, const bool &checkProcessesMemory = false);
 
    static void Sleep(const unsigned int &milliseconds);
 
    static void StartTime(const std::string &nameTime);
    static void InsertTime(const std::string &nameTime, const double &globalTime, const double &localTime);
    static void SplitTime(const std::string &nameTime, double &globalTime, double &localTime);
    static double StopTime(const std::string &nameTime, const bool &printTime = true);
 
    static void WriteTime(const std::string &nameTime, const double &globalTime, const double &localTime);
};
 
} // namespace Gedim
 
#endif