429 lines
10 KiB
C++
429 lines
10 KiB
C++
/***************************************************************************
|
|
misc.cpp
|
|
-------------------
|
|
W. Michael Brown
|
|
|
|
Miscellaneous functions that do not deserve their own class
|
|
|
|
__________________________________________________________________________
|
|
This file is part of the "All" Library
|
|
__________________________________________________________________________
|
|
|
|
begin : May 30 2003
|
|
copyright : (C) 2003 by W. Michael Brown
|
|
email : wmbrown@sandia.gov
|
|
***************************************************************************/
|
|
|
|
#include "misc.h"
|
|
|
|
void a::copyright(ostream &out, unsigned year) {
|
|
out << "Copyright (" << year << ") Sandia Corporation. Under the terms of "
|
|
<< "Contract\nDE-AC04-94AL85000, there is a non-exclusive license for "
|
|
<< "use of this\nwork by or on behalf of the U.S. Government. Export "
|
|
<< "of this program\nmay require a license from the United States "
|
|
<< "Government.\n";
|
|
}
|
|
|
|
// Get the SNL Copyright info as a string
|
|
string a::copyrightstring(unsigned year) {
|
|
return string("Copyright (")+a::itoa(year)+") Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government.";
|
|
}
|
|
|
|
void a::fileopen(ifstream &in, const char *filename, Error &error) {
|
|
in.clear();
|
|
in.open(filename);
|
|
if (!in) {
|
|
error.addwarning(1,15,"Misc",
|
|
"Could not open "+string(filename)+" for input!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileopen(ifstream &in, const string &filename, Error &error) {
|
|
in.clear();
|
|
in.open(filename.c_str());
|
|
if (!in) {
|
|
error.addwarning(1,15,"Misc",
|
|
"Could not open "+string(filename)+" for input!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileopenbinary(ifstream &in, const string &filename, Error &error) {
|
|
in.clear();
|
|
in.open(filename.c_str(), ios::binary);
|
|
if (!in) {
|
|
error.addwarning(1,15,"Misc",
|
|
"Could not open "+string(filename)+" for input!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileopen(ofstream &out, const char *filename, Error &error) {
|
|
out.clear();
|
|
out.open(filename);
|
|
if (!out) {
|
|
error.addwarning(2,15,"Misc",
|
|
"Could not open "+string(filename)+" for output!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileopen(ofstream &out, const string &filename, Error &error) {
|
|
out.clear();
|
|
out.open(filename.c_str());
|
|
if (!out) {
|
|
error.addwarning(2,15,"Misc",
|
|
"Could not open "+string(filename)+" for output!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileopenbinary(ofstream &out, const string &filename, Error &error) {
|
|
out.clear();
|
|
out.open(filename.c_str(),ios::binary);
|
|
if (!out) {
|
|
error.addwarning(2,15,"Misc",
|
|
"Could not open "+string(filename)+" for output!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileopenapp(ofstream &out, const string &filename, Error &error) {
|
|
out.clear();
|
|
out.open(filename.c_str(),ios::app);
|
|
if (!out) {
|
|
error.addwarning(2,15,"Misc",
|
|
"Could not open "+string(filename)+" for output!");
|
|
error.writewarnings();
|
|
}
|
|
}
|
|
|
|
void a::fileclose(ifstream &in, Error &error) {
|
|
in.close();
|
|
}
|
|
|
|
void a::fileclose(ofstream &out, Error &error) {
|
|
if (out.fail()) {
|
|
error.addwarning(10,15,"Misc","Error writing to output file!");
|
|
error.writewarnings();
|
|
}
|
|
out.close();
|
|
}
|
|
|
|
// Put a string back into an istream
|
|
void a::putback(istream &in, const string &s) {
|
|
if (s.size()==0)
|
|
return;
|
|
unsigned i=s.size()-1;
|
|
while (true) {
|
|
in.putback(s[i]);
|
|
if (i==0)
|
|
return;
|
|
i--;
|
|
}
|
|
}
|
|
|
|
string a::date() {
|
|
char datestr[40];
|
|
|
|
time_t t;
|
|
time(&t);
|
|
|
|
strftime(datestr,40,"%B %d, %Y",localtime(&t));
|
|
return string(datestr);
|
|
}
|
|
|
|
// Return the filename without the extension
|
|
string a::namewoext(const string &filename) {
|
|
return (filename.substr(0,filename.find_last_of('.')));
|
|
}
|
|
|
|
// Return the filename without extension or directory
|
|
string a::filenameonly(const string &filename) {
|
|
// Find the start of the filename
|
|
unsigned start=0;
|
|
if (filename.find_last_of('/')<(filename.length()-1))
|
|
start=filename.find_last_of('/')+1;
|
|
|
|
// Find the end of the filename
|
|
unsigned end=filename.find_last_of('.')-start;
|
|
return(filename.substr(start,end));
|
|
}
|
|
|
|
// Return the extension of a filename
|
|
string a::extension(const string &filename) {
|
|
// Find the start of the extension
|
|
unsigned start=filename.find_last_of('.')+1;
|
|
if (start>=filename.length())
|
|
return "";
|
|
|
|
return filename.substr(start,filename.length()-start);
|
|
}
|
|
|
|
// Center a string over the specified length
|
|
string a::strcenter(const string &s, unsigned length) {
|
|
string empty(" ");
|
|
unsigned half=length/2;
|
|
unsigned spacer=half-(s.length()/2)-1;
|
|
return (empty.substr(0,spacer)+s);
|
|
}
|
|
|
|
// True if a character is whitespace
|
|
bool a::whitespace(char c) {
|
|
if (c==' ' || c=='\n' || c=='\t' || c=='\f' || c=='\r' || c=='\v')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// Check if a string is only whitespace
|
|
bool a::whitespace(const string &s) {
|
|
for (unsigned i=0; i<s.length(); i++)
|
|
if (!whitespace(s[i]))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// Remove all whitespace from a string
|
|
string a::remove_whitespace(const string &s) {
|
|
string n;
|
|
for (unsigned i=0; i<s.length(); i++)
|
|
if (!whitespace(s[i]))
|
|
n+=s[i];
|
|
return n;
|
|
}
|
|
|
|
void a::str_replace(const string &source, const string &target, string &s) {
|
|
unsigned slength=source.length();
|
|
unsigned tlength=target.length();
|
|
unsigned loc=0;
|
|
|
|
#ifdef DEBUG
|
|
assert(slength>0 && tlength>0);
|
|
#endif
|
|
|
|
while (true) {
|
|
if (loc>=s.length())
|
|
break;
|
|
loc=s.find(source,loc);
|
|
if (loc>=s.length())
|
|
break;
|
|
s.replace(loc,slength,target,0,tlength);
|
|
loc+=tlength;
|
|
}
|
|
}
|
|
|
|
/// Convert all alpha characters to lower case
|
|
string a::tolower(const string &s) {
|
|
string r="";
|
|
for (unsigned i=0; i<s.length(); i++)
|
|
r+=std::tolower(s[i]);
|
|
return r;
|
|
}
|
|
|
|
// Return a string of num underscores
|
|
string a::underline(unsigned num) {
|
|
return string(num,'_');
|
|
}
|
|
|
|
// The tokens parsed from cstring are \e added to the input vector
|
|
void a::get_tokens(const char *line, vector<string> &tokens) {
|
|
string sline=line;
|
|
get_tokens(sline,tokens);
|
|
}
|
|
|
|
void a::get_tokens(const string &sline, vector<string> &tokens) {
|
|
string token="";
|
|
unsigned i=0;
|
|
while (i<sline.length()) {
|
|
if (whitespace(sline[i])) {
|
|
i++;
|
|
continue;
|
|
}
|
|
while (i<sline.length()) {
|
|
if (whitespace(sline[i])) {
|
|
tokens.push_back(token);
|
|
token="";
|
|
break;
|
|
}
|
|
token+=sline[i];
|
|
i++;
|
|
}
|
|
}
|
|
if (token!="")
|
|
tokens.push_back(token);
|
|
}
|
|
|
|
// Return the first token in a string
|
|
string a::get_first_token(const char *line) {
|
|
string sline=line;
|
|
string token="";
|
|
unsigned i=0;
|
|
while (i<sline.length()) {
|
|
if (whitespace(sline[i])) {
|
|
i++;
|
|
continue;
|
|
}
|
|
while (i<sline.length()) {
|
|
if (whitespace(sline[i]))
|
|
return token;
|
|
token+=sline[i];
|
|
i++;
|
|
}
|
|
}
|
|
return token;
|
|
}
|
|
|
|
void a::get_tokens(char delimiter, const string &sline,vector<string> &tokens) {
|
|
string token="";
|
|
unsigned i=0;
|
|
while (i<sline.length()) {
|
|
if (delimiter==sline[i]) {
|
|
tokens.push_back(token);
|
|
token="";
|
|
} else
|
|
token+=sline[i];
|
|
i++;
|
|
}
|
|
if (token!="")
|
|
tokens.push_back(token);
|
|
}
|
|
|
|
// Format a string to fit within a specified column width
|
|
void a::format_fit(unsigned column_width, const string &input,
|
|
vector<string> &output) {
|
|
vector<string> forced;
|
|
a::get_tokens('\n',input,forced);
|
|
for (unsigned i=0; i<forced.size(); i++) {
|
|
string current_line;
|
|
vector<string> tokens;
|
|
a::get_tokens(forced[i],tokens);
|
|
for (unsigned j=0; j<tokens.size(); j++) {
|
|
if (current_line.length()+tokens[j].length()<column_width) {
|
|
current_line+=tokens[j]+' ';
|
|
} else {
|
|
if (tokens[j].length()+1>column_width) {
|
|
unsigned this_count=column_width-current_line.length();
|
|
current_line+=tokens[j].substr(0,this_count);
|
|
output.push_back(current_line);
|
|
current_line="";
|
|
tokens[j]=tokens[j].substr(this_count,tokens[j].length()-this_count);
|
|
j--;
|
|
} else {
|
|
output.push_back(current_line);
|
|
current_line=tokens[j]+' ';
|
|
}
|
|
}
|
|
}
|
|
output.push_back(current_line);
|
|
}
|
|
return;
|
|
}
|
|
|
|
string a::itoa(unsigned i) {
|
|
ostringstream o;
|
|
o << i;
|
|
return o.str();
|
|
}
|
|
|
|
string a::itoa(int i) {
|
|
ostringstream o;
|
|
o << i;
|
|
return o.str();
|
|
}
|
|
|
|
string a::ftoa(double i) {
|
|
ostringstream o;
|
|
o << i;
|
|
return o.str();
|
|
}
|
|
|
|
// Seed the random number generator
|
|
void a::seedrandom(unsigned seed) {
|
|
srand(seed);
|
|
}
|
|
|
|
// Seed the random number generator with the current time
|
|
void a::seedrandom_time() {
|
|
srand(unsigned(time(0))); //+getpid());
|
|
}
|
|
|
|
// Return an integer between 0 and max
|
|
double a::frandom(double max) {
|
|
return double(rand())/double(RAND_MAX)*max;
|
|
}
|
|
|
|
// Return an integer between 0 and max
|
|
unsigned a::irandom(unsigned max) {
|
|
return unsigned(double(rand())/double(RAND_MAX)*max);
|
|
}
|
|
|
|
// Return an integer between 0 and max
|
|
long a::lrandom(long max) {
|
|
return long(double(rand())/double(RAND_MAX)*max);
|
|
}
|
|
|
|
// Empty constructer with no header, no extension, no lead zeros
|
|
FileIterator::FileIterator() {
|
|
file_num=0;
|
|
digits=0;
|
|
header="";
|
|
extension="";
|
|
}
|
|
|
|
// Specify the filename format with leading zeros
|
|
FileIterator::FileIterator(const string &h,const string &e,unsigned d) {
|
|
file_num=0;
|
|
digits=d;
|
|
header=h;
|
|
extension=e;
|
|
}
|
|
|
|
// Specify the filename format without leading zeros
|
|
FileIterator::FileIterator(const string &h,const string &e) {
|
|
digits=0;
|
|
file_num=0;
|
|
header=h;
|
|
extension=e;
|
|
}
|
|
|
|
// Set the current file number
|
|
void FileIterator::set_file_num(unsigned fnum) {
|
|
file_num=fnum;
|
|
}
|
|
|
|
// Set the file header
|
|
void FileIterator::set_file_header(const string &head) {
|
|
header=head;
|
|
}
|
|
|
|
// Set the file extension
|
|
void FileIterator::set_file_extensions(const string &ext) {
|
|
extension=ext;
|
|
}
|
|
|
|
// Set the number of leading zeros
|
|
void FileIterator::set_lead_zeros(unsigned digs) {
|
|
digits=digs;
|
|
}
|
|
|
|
// Set the current file number, header, extension, leading zeros
|
|
void FileIterator::set(unsigned fnum, const string &head, const string &ext,
|
|
unsigned digs) {
|
|
file_num=fnum;
|
|
header=head;
|
|
extension=ext;
|
|
digits=digs;
|
|
}
|
|
|
|
string FileIterator::nextfilename() {
|
|
// Get an output filename from a string
|
|
string filename;
|
|
filename=a::itoa(file_num);
|
|
while (filename.length()<digits)
|
|
filename='0'+filename;
|
|
file_num++;
|
|
return header+filename+extension;
|
|
}
|
|
|