mdal_utils.hpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2018 Peter Petrik (zilolv at gmail dot com)
*/
 
#ifndef MDAL_UTILS_HPP
#define MDAL_UTILS_HPP
 
#include <string>
#include <vector>
#include <stddef.h>
#include <limits>
#include <sstream>
#include <fstream>
#include <cmath>
#include <functional>
 
#if defined (WIN32)
#include <windows.h>
#undef min
#undef max
#else
#include <dlfcn.h>
#include <dirent.h>
#endif
 
#include <algorithm>
 
#include "mdal_data_model.hpp"
#include "mdal_memory_data_model.hpp"
#include "mdal_datetime.hpp"
 
// avoid unused variable warnings
#define MDAL_UNUSED(x) (void)x;
#define MDAL_NAN std::numeric_limits<double>::quiet_NaN()
 
#ifndef M_PI
#define M_PI 3.14159265358979323846264338327
#endif
 
namespace MDAL
{
 
  std::string getEnvVar( const std::string &varname, const std::string &defaultVal = std::string() );
 
  // endianness
  bool isNativeLittleEndian();
 
  // numbers
  inline bool equals( double val1, double val2, double eps = std::numeric_limits<double>::epsilon() )
  {
    return fabs( val1 - val2 ) < eps;
  }
 
  double safeValue( double val, double nodata, double eps = std::numeric_limits<double>::epsilon() );
 
  bool openInputFile( std::ifstream &inputFileStream, const std::string &fileName, std::ifstream::openmode mode = std::ifstream::binary );
  std::ifstream openInputFile( const std::string &fileName, std::ios_base::openmode mode = std::ifstream::in );
 
  std::ofstream openOutputFile( const std::string &fileName, std::ios_base::openmode mode = std::ios_base::in );
 
  bool fileExists( const std::string &filename );
  std::string baseName( const std::string &filename, bool keepExtension = false );
  std::string fileExtension( const std::string &path );
  std::string dirName( const std::string &filename );
  std::string pathJoin( const std::string &path1, const std::string &path2 );
  std::string readFileToString( const std::string &filename );
 
  // strings
  enum ContainsBehaviour
  {
    CaseSensitive,
    CaseInsensitive
  };
 
  bool startsWith( const std::string &str, const std::string &substr, ContainsBehaviour behaviour = CaseSensitive );
  bool endsWith( const std::string &str, const std::string &substr, ContainsBehaviour behaviour = CaseSensitive );
  bool contains( const std::string &str, const std::string &substr, ContainsBehaviour behaviour = CaseSensitive );
  bool contains( const std::vector<std::string> &list, const std::string &str );
  std::string replace( const std::string &str, const std::string &substr, const std::string &replacestr, ContainsBehaviour behaviour = CaseSensitive );
  std::string removeFrom( const std::string &str, const std::string &substr );
 
  std::string leftJustified( const std::string &str, size_t width, char fill = ' ' );
 
  std::string toLower( const std::string &std );
 
  bool getHeaderLine( std::ifstream &stream, std::string &line );
 
  size_t toSizeT( const std::string &str );
  size_t toSizeT( const char &str );
  size_t toSizeT( const double value );
  int toInt( const std::string &str );
  int toInt( const size_t value );
  double toDouble( const std::string &str );
  double toDouble( const size_t value );
  bool toBool( const std::string &str );
 
  std::string coordinateToString( double coordinate, int precision = 2 );
 
  std::string doubleToString( double value, int precision = 6 );
 
  std::vector<std::string> split( const std::string &str, const char delimiter );
 
  std::vector<std::string> split( const std::string &str, const std::string &delimiter );
 
  std::string join( const std::vector<std::string> parts, const std::string &delimiter );
 
  std::string rtrim(
    const std::string &s,
    const std::string &delimiters = " \f\n\r\t\v" );
 
  std::string ltrim(
    const std::string &s,
    const std::string &delimiters = " \f\n\r\t\v" );
 
  std::string trim(
    const std::string &s,
    const std::string &delimiters = " \f\n\r\t\v" );
 
  // extent
  BBox computeExtent( const Vertices &vertices );
 
  // time
  double parseTimeUnits( const std::string &units );
  std::string getCurrentTimeStamp();
 
  // statistics
  void combineStatistics( Statistics &main, const Statistics &other );
 
  Statistics calculateStatistics( std::shared_ptr<DatasetGroup> grp );
  Statistics calculateStatistics( DatasetGroup *grp );
 
  Statistics calculateStatistics( std::shared_ptr<Dataset> dataset );
 
  // mesh & datasets
  void addBedElevationDatasetGroup( MDAL::Mesh *mesh, const Vertices &vertices );
  void addFaceScalarDatasetGroup( MDAL::Mesh *mesh, const std::vector<double> &values, const std::string &name );
  void addVertexScalarDatasetGroup( MDAL::Mesh *mesh, const std::vector<double> &values, const std::string &name );
  void addEdgeScalarDatasetGroup( MDAL::Mesh *mesh, const std::vector<double> &values, const std::string &name );
 
  template<typename T>
  bool readValue( T &value, std::ifstream &in, bool changeEndianness = false )
  {
    char *const p = reinterpret_cast<char *>( &value );
 
    if ( !in.read( p, sizeof( T ) ) )
      return false;
 
    if ( changeEndianness )
      std::reverse( p, p + sizeof( T ) );
 
    return true;
  }
 
  template<typename T>
  void writeValue( T &value, std::ofstream &out, bool changeEndianness = false )
  {
    T v = value;
    char *const p = reinterpret_cast<char *>( &v );
 
    if ( changeEndianness )
      std::reverse( p, p + sizeof( T ) );
 
    out.write( p, sizeof( T ) );
  }
 
  std::string prependZero( const std::string &str, size_t length );
 
  RelativeTimestamp::Unit parseDurationTimeUnit( const std::string &timeUnit );
 
  RelativeTimestamp::Unit parseCFTimeUnit( std::string timeInformation );
 
  MDAL::DateTime parseCFReferenceTime( const std::string &timeInformation, const std::string &calendarString );
 
  void parseDriverAndMeshFromUri( const std::string &uri, std::string &driver, std::string &meshFile, std::string &meshName );
 
  void parseDriverFromUri( const std::string &uri, std::string &driver );
 
  void parseMeshFileFromUri( const std::string &uri, std::string &meshFile );
 
  std::string buildMeshUri( const std::string &meshFile, const std::string &meshName, const std::string &driver );
 
  std::string buildAndMergeMeshUris( const std::string &meshfile, const std::vector<std::string> &meshNames, const std::string &driver = "" );
 
  struct Error
  {
    Error( MDAL_Status status, std::string message, std::string driverName = "" );
    void setDriver( std::string d );
    MDAL_Status status;
    std::string mssg;
    std::string driver;
  };
 
  class Library
  {
    public:
      Library( std::string libraryFile );
      ~Library();
      Library( const Library &other );
      Library &operator=( const Library &other );
 
      bool isValid();
 
      static std::vector<std::string> libraryFilesInDir( const std::string &dirPath );
 
      template<typename T, typename ... Ts>
      std::function<T( Ts ... args )> getSymbol( const std::string &symbolName )
      {
        if ( !isValid() )
          return std::function<T( Ts ... args )>();
#ifdef WIN32
        FARPROC proc = GetProcAddress( d->mLibrary, symbolName.c_str() );
 
        if ( !proc )
          return std::function<T( Ts ... args )>();
 
        std::function<T( Ts ... args )> symbol = reinterpret_cast<T( * )( Ts ... args )>( proc );
#else
        std::function<T( Ts ... args )> symbol =
          reinterpret_cast<T( * )( Ts ... args )>( dlsym( d->mLibrary, symbolName.c_str() ) );
 
#if (defined(__APPLE__) && defined(__MACH__))
        /* On mach-o systems, C symbols have a leading underscore and depending
         * on how dlcompat is configured it may or may not add the leading
         * underscore.  If dlsym() fails, add an underscore and try again.
         */
        if ( symbol == nullptr )
        {
          char withUnder[256] = {};
          snprintf( withUnder, sizeof( withUnder ), "_%s", symbolName.c_str() );
          std::function<T( Ts ... args )> symbol = reinterpret_cast<T( * )( Ts ... args )>( dlsym( d->mLibrary, withUnder ) );
        }
#endif
#endif
        return symbol;
      }
 
 
    private:
      struct Data
      {
#ifdef  WIN32
        HINSTANCE  mLibrary = nullptr;
#else
        void *mLibrary = nullptr;
#endif
        mutable int mRef = 0;
        std::string mLibraryFile;
      };
 
      Data *d;
 
      bool loadLibrary();
  };
} // namespace MDAL
#endif //MDAL_UTILS_HPP