service.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2025 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
 
#ifndef SERVICE_H_
#define SERVICE_H_
 
#include <string>
#include <vector>
 
extern const double pos_pow10[];
extern const int max_pow10;
extern const double neg_pow10[];
extern const int min_pow10;
 
// remove whitespace from the end of a string
void trimTrailingWhiteSpace( std::string &str );
// remove whitespace form the end of a char array
void trimTrailingWhiteSpace( char *str );
// remove whitespace from the beginning and end of a string
void trimWhiteSpace( string &str );
 
// helper routine for DataParser -- efficiently read double
void FPRead(istringstream& iss, const string& s, double& value);
 
// helper routine for DataParser -- efficiently read sys_float
inline void FPRead(istringstream& iss, const string& s, sys_float& value)
{
        double x;
        FPRead(iss, s, x);
        value = sys_float(x);
}
 
// helper routine for DataParser -- efficiently read signed 64-bit integer
void IntRead(istringstream& iss, const string& s, long long& value);
 
// helper routine for DataParser -- efficiently read long
inline void IntRead(istringstream& iss, const string& s, long& value)
{
        long long x;
        IntRead(iss, s, x);
        value = long(x);
}
 
// helper routine for DataParser -- efficiently read int
inline void IntRead(istringstream& iss, const string& s, int& value)
{
        long long x;
        IntRead(iss, s, x);
        value = int(x);
}
 
// helper routine for DataParser -- efficiently read unsigned 64-bit integer
void IntRead(istringstream& iss, const string& s, unsigned long long& value);
 
// helper routine for DataParser -- efficiently read unsigned int
inline void IntRead(istringstream& iss, const string& s, unsigned long& value)
{
        unsigned long long x;
        IntRead(iss, s, x);
        value = (unsigned long)x;
}
 
// helper routine for DataParser -- efficiently read unsigned int
inline void IntRead(istringstream& iss, const string& s, unsigned int& value)
{
        unsigned long long x;
        IntRead(iss, s, x);
        value = (unsigned int)x;
}

typedef enum { SPM_RELAX, SPM_KEEP_EMPTY, SPM_STRICT } split_mode;

void Split(const std::string& str,   // input string
           const std::string& sep,   // separator, may be multiple characters
           std::vector<std::string>& lst, // the separated items will be appended here
           split_mode mode);    // see above
 
inline bool FindAndReplace(std::string& str,
                           const std::string& substr,
                           const std::string& newstr)
{
        std::string::size_type ptr = str.find( substr );
        if( ptr != std::string::npos )
                str.replace( ptr, substr.length(), newstr );
        return ptr != std::string::npos;
}
 
inline bool FindAndErase(std::string& str,
                         const std::string& substr)
{
        return FindAndReplace( str, substr, "" );
}
 
void service(double tau, double a, double beta);

inline void wr_block(const void *ptr,
                                         size_t len,
                                         FILE *fdes,
                                         const string& fnam = string())
{
        if( fwrite(ptr,len,size_t(1),fdes) != 1 ) {
                fprintf( ioQQQ, "wr_block: error writing to file %s\n", fnam.c_str() );
                fclose(fdes);
                cdEXIT(EXIT_FAILURE);
        }
}

inline void wr_block(const void *ptr,
                                         size_t len,
                                         const string& fnam)
{
        FILE *fdes = open_data( fnam, "wb" );
        wr_block( ptr, len, fdes, fnam );
        fclose(fdes);
}

inline void rd_block(void *ptr,
                                         size_t len,
                                         FILE *fdes,
                                         const string& fnam)
{
        if( fread(ptr,len,size_t(1),fdes) != 1 ) {
                fprintf( ioQQQ, "rd_block: error reading from file %s\n", fnam.c_str() );
                fclose(fdes);
                cdEXIT(EXIT_FAILURE);
        }
}

inline void rd_block(void *ptr,
                                         size_t len,
                                         const string& fnam)
{
        FILE *fdes = open_data( fnam, "rb", AS_LOCAL_ONLY );
        rd_block( ptr, len, fdes, fnam );
        fclose(fdes);
}

const uintmax_t FS_UNKNOWN = static_cast<uintmax_t>(-1);

uintmax_t FileSize(const string& fpath);
 
#endif /* SERVICE_ */