mirror of
https://github.com/NGSolve/netgen.git
synced 2024-12-25 05:20:34 +05:00
move flags to ngcore
This commit is contained in:
Christopher Lackner
parent
318a6092e3
commit
dc8d96aefa
@ -3,6 +3,7 @@ add_library(ngcore SHARED
|
||||
archive.cpp
|
||||
localheap.cpp
|
||||
logging.cpp
|
||||
flags.cpp
|
||||
paje_trace.cpp
|
||||
profiler.cpp
|
||||
taskmanager.cpp
|
||||
@ -43,7 +44,8 @@ target_link_libraries(ngcore PUBLIC netgen_mpi PRIVATE ${CMAKE_THREAD_LIBS_INIT}
|
||||
|
||||
install(FILES ngcore.hpp archive.hpp type_traits.hpp version.hpp ngcore_api.hpp logging.hpp
|
||||
exception.hpp symboltable.hpp paje_trace.hpp utils.hpp profiler.hpp mpi_wrapper.hpp
|
||||
array.hpp taskmanager.hpp concurrentqueue.h localheap.hpp python_ngcore.hpp
|
||||
array.hpp taskmanager.hpp concurrentqueue.h localheap.hpp python_ngcore.hpp flags.hpp
|
||||
xbool.hpp
|
||||
DESTINATION ${NG_INSTALL_DIR_INCLUDE}/core COMPONENT netgen_devel)
|
||||
|
||||
if(ENABLE_CPP_CORE_GUIDELINES_CHECK)
|
||||
|
||||
620
libsrc/core/flags.cpp
Normal file
620
libsrc/core/flags.cpp
Normal file
@ -0,0 +1,620 @@
|
||||
/**************************************************************************/
|
||||
/* File: flags.cpp */
|
||||
/* Author: Joachim Schoeberl */
|
||||
/* Date: 10. Oct. 96 */
|
||||
/**************************************************************************/
|
||||
|
||||
#include "flags.hpp"
|
||||
|
||||
#ifdef WIN32
|
||||
#include <float.h>
|
||||
#endif
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace ngcore
|
||||
{
|
||||
using std::string;
|
||||
using std::endl;
|
||||
Flags :: Flags () { ; }
|
||||
|
||||
Flags :: Flags (const Flags & flags)
|
||||
{
|
||||
string name;
|
||||
for (int i = 0; i < flags.GetNStringFlags(); i++)
|
||||
{
|
||||
string str = flags.GetStringFlag (i, name);
|
||||
SetFlag (name, str);
|
||||
}
|
||||
for (int i = 0; i < flags.GetNNumFlags(); i++)
|
||||
{
|
||||
double val = flags.GetNumFlag (i, name);
|
||||
SetFlag (name, val);
|
||||
}
|
||||
for (int i = 0; i < flags.GetNDefineFlags(); i++)
|
||||
{
|
||||
bool val = flags.GetDefineFlag (i, name);
|
||||
SetFlag (name, val);
|
||||
}
|
||||
for (int i = 0; i < flags.GetNNumListFlags(); i++)
|
||||
{
|
||||
auto numa = flags.GetNumListFlag (i, name);
|
||||
SetFlag (name, *numa);
|
||||
}
|
||||
for (int i = 0; i < flags.GetNStringListFlags(); i++)
|
||||
{
|
||||
auto stra = flags.GetStringListFlag (i, name);
|
||||
SetFlag (name, *stra);
|
||||
}
|
||||
for (int i = 0; i < flags.GetNFlagsFlags(); i++)
|
||||
{
|
||||
auto lflags = flags.GetFlagsFlag (i, name);
|
||||
SetFlag (name, lflags);
|
||||
}
|
||||
}
|
||||
|
||||
Flags :: Flags (Flags && flags)
|
||||
: strflags(flags.strflags), numflags(flags.numflags),
|
||||
defflags(flags.defflags), strlistflags(flags.strlistflags),
|
||||
numlistflags(flags.numlistflags) { ; }
|
||||
|
||||
Flags :: Flags (std::initializer_list<string> list)
|
||||
{
|
||||
for (auto i = list.begin(); i < list.end(); i++)
|
||||
SetCommandLineFlag ((string("-")+*i).c_str());
|
||||
}
|
||||
|
||||
|
||||
Flags :: Flags (string f1, string f2, string f3, string f4, string f5)
|
||||
{
|
||||
SetCommandLineFlag ((string("-")+f1).c_str());
|
||||
if (f2.length()) SetCommandLineFlag ( (string("-")+f2).c_str() );
|
||||
if (f3.length()) SetCommandLineFlag ( (string("-")+f3).c_str() );
|
||||
if (f4.length()) SetCommandLineFlag ( (string("-")+f4).c_str() );
|
||||
if (f5.length()) SetCommandLineFlag ( (string("-")+f5).c_str() );
|
||||
}
|
||||
|
||||
Flags :: ~Flags ()
|
||||
{
|
||||
DeleteFlags ();
|
||||
}
|
||||
|
||||
void Flags :: DeleteFlags ()
|
||||
{
|
||||
strflags.DeleteAll();
|
||||
numflags.DeleteAll();
|
||||
defflags.DeleteAll();
|
||||
strlistflags.DeleteAll();
|
||||
numlistflags.DeleteAll();
|
||||
}
|
||||
|
||||
|
||||
Flags Flags :: SetFlag (const char * name, bool b) &&
|
||||
{
|
||||
this -> SetFlag (name, b);
|
||||
return std::move(*this);
|
||||
}
|
||||
|
||||
Flags Flags :: SetFlag (const char * name, double val) &&
|
||||
{
|
||||
this -> SetFlag (name, val);
|
||||
return std::move(*this);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Flags & Flags :: SetFlag (const char * name, const string & val)
|
||||
{
|
||||
strflags.Set (name, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const char * name, double val) &
|
||||
{
|
||||
numflags.Set (name, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const char * name, bool b) &
|
||||
{
|
||||
defflags.Set (name, b);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const char * name, Flags & val) &
|
||||
{
|
||||
flaglistflags.Set (name, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Flags & Flags :: SetFlag (const string & name, const string & val)
|
||||
{
|
||||
// char * hval = new char[strlen (val) + 1];
|
||||
// strcpy (hval, val);
|
||||
strflags.Set (name, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const string & name, double val)
|
||||
{
|
||||
numflags.Set (name, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const string & name, bool b)
|
||||
{
|
||||
defflags.Set (name, b);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const string & name, Flags & val)
|
||||
{
|
||||
flaglistflags.Set (name, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const string & name, const Array<string> & val)
|
||||
{
|
||||
auto strarray = std::make_shared<Array<string>>(val);
|
||||
/*
|
||||
for (int i = 0; i < val.Size(); i++)
|
||||
{
|
||||
strarray->Append (new char[strlen(val[i])+1]);
|
||||
strcpy (strarray->Last(), val[i]);
|
||||
}
|
||||
*/
|
||||
strlistflags.Set (name, strarray);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Flags & Flags :: SetFlag (const string & name, const Array<double> & val)
|
||||
{
|
||||
// Array<double> * numarray = new Array<double>(val);
|
||||
auto numarray = std::make_shared<Array<double>> (val);
|
||||
|
||||
numlistflags.Set (name, numarray);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
string Flags :: GetStringFlag (const string & name, const char * def) const
|
||||
{
|
||||
if (strflags.Used (name))
|
||||
return strflags[name];
|
||||
else
|
||||
{
|
||||
if (!def) return string("");
|
||||
return def;
|
||||
}
|
||||
}
|
||||
|
||||
string Flags :: GetStringFlag (const string & name, string def) const
|
||||
{
|
||||
if (strflags.Used (name))
|
||||
return strflags[name];
|
||||
else
|
||||
return def;
|
||||
}
|
||||
|
||||
|
||||
double Flags :: GetNumFlag (const string & name, double def) const
|
||||
{
|
||||
if (numflags.Used (name))
|
||||
return numflags[name];
|
||||
else
|
||||
return def;
|
||||
}
|
||||
|
||||
const double * Flags :: GetNumFlagPtr (const string & name) const
|
||||
{
|
||||
if (numflags.Used (name))
|
||||
return & ((SymbolTable<double>&)numflags)[name];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
double * Flags :: GetNumFlagPtr (const string & name)
|
||||
{
|
||||
if (numflags.Used (name))
|
||||
return & ((SymbolTable<double>&)numflags)[name];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
int Flags :: GetDefineFlag (const char * name) const
|
||||
{
|
||||
return defflags.Used (name);
|
||||
}
|
||||
*/
|
||||
bool Flags :: GetDefineFlag (const string & name) const throw()
|
||||
{
|
||||
if (!defflags.Used (name)) return false;
|
||||
return defflags[name];
|
||||
}
|
||||
|
||||
xbool Flags :: GetDefineFlagX (const string & name) const throw()
|
||||
{
|
||||
if (!defflags.Used (name)) return maybe;
|
||||
return bool(defflags[name]);
|
||||
}
|
||||
|
||||
|
||||
const Array<string> &
|
||||
Flags :: GetStringListFlag (const string & name) const
|
||||
{
|
||||
if (strlistflags.Used (name))
|
||||
return *strlistflags[name];
|
||||
else
|
||||
{
|
||||
static Array<string> hstra(0);
|
||||
return hstra;
|
||||
}
|
||||
}
|
||||
|
||||
const Array<double> &
|
||||
Flags ::GetNumListFlag (const string & name) const
|
||||
{
|
||||
if (numlistflags.Used (name))
|
||||
return *numlistflags[name];
|
||||
else
|
||||
{
|
||||
static Array<double> hnuma(0);
|
||||
return hnuma;
|
||||
}
|
||||
}
|
||||
|
||||
const Flags &
|
||||
Flags ::GetFlagsFlag (const string & name) const
|
||||
{
|
||||
if (flaglistflags.Used (name))
|
||||
return flaglistflags[name];
|
||||
else
|
||||
{
|
||||
static Flags empty;
|
||||
return empty;
|
||||
}
|
||||
}
|
||||
|
||||
bool Flags :: StringFlagDefined (const string & name) const
|
||||
{
|
||||
return strflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: NumFlagDefined (const string &name) const
|
||||
{
|
||||
return numflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: FlagsFlagDefined (const string &name) const
|
||||
{
|
||||
return flaglistflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: StringListFlagDefined (const string & name) const
|
||||
{
|
||||
return strlistflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: NumListFlagDefined (const string & name) const
|
||||
{
|
||||
return numlistflags.Used (name);
|
||||
}
|
||||
|
||||
void Flags :: SaveFlags (ostream & str) const
|
||||
{
|
||||
for (int i = 0; i < strflags.Size(); i++)
|
||||
str << strflags.GetName(i) << " = " << strflags[i] << endl;
|
||||
for (int i = 0; i < numflags.Size(); i++)
|
||||
str << numflags.GetName(i) << " = " << numflags[i] << endl;
|
||||
for (int i = 0; i < defflags.Size(); i++)
|
||||
str << defflags.GetName(i) << " = " << (defflags[i] ? "_TRUE" : "_FALSE") << endl;
|
||||
for (int i = 0; i < flaglistflags.Size(); i++)
|
||||
str << flaglistflags.GetName(i) << " =*" << flaglistflags[i] << endl;
|
||||
for (int i = 0; i < numlistflags.Size(); i++)
|
||||
{
|
||||
str << numlistflags.GetName(i) << " = [";
|
||||
int j = 0;
|
||||
for (j = 0; j + 1 < numlistflags[i]->Size(); ++j)
|
||||
str << (*numlistflags[i])[j] << ", ";
|
||||
if (numlistflags[i]->Size())
|
||||
str << (*numlistflags[i])[j];
|
||||
str << "]" << endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Flags :: SaveFlags (const char * filename) const
|
||||
{
|
||||
std::ofstream outfile (filename);
|
||||
SaveFlags(outfile);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Flags :: PrintFlags (ostream & ost) const
|
||||
{
|
||||
for (int i = 0; i < strflags.Size(); i++)
|
||||
ost << strflags.GetName(i) << " = " << strflags[i] << endl;
|
||||
for (int i = 0; i < numflags.Size(); i++)
|
||||
ost << numflags.GetName(i) << " = " << numflags[i] << endl;
|
||||
for (int i = 0; i < defflags.Size(); i++)
|
||||
ost << defflags.GetName(i) << endl;
|
||||
for (int i = 0; i < strlistflags.Size(); i++)
|
||||
ost << strlistflags.GetName(i) << " = " << strlistflags[i] << endl;
|
||||
for (int i = 0; i < numlistflags.Size(); i++)
|
||||
ost << numlistflags.GetName(i) << " = " << numlistflags[i] << endl;
|
||||
for (int i = 0; i < flaglistflags.Size(); i++)
|
||||
ost << flaglistflags.GetName(i) << " = " << flaglistflags[i] << endl;
|
||||
}
|
||||
|
||||
void Flags :: LoadFlags (const char * filename, SymbolTable<Flags> * sf)
|
||||
{
|
||||
std::ifstream str(filename);
|
||||
LoadFlags(str,sf);
|
||||
}
|
||||
|
||||
void Flags :: LoadFlags (std::istream & istr, SymbolTable<Flags> * sf )
|
||||
{
|
||||
char str[100];
|
||||
char ch;
|
||||
// double val;
|
||||
|
||||
while (istr.good())
|
||||
{
|
||||
string name;
|
||||
string content;
|
||||
string line;
|
||||
getline(istr, line);
|
||||
std::istringstream line_stream(line);
|
||||
|
||||
getline(line_stream, name, '=');
|
||||
name.erase(std::remove(name.begin(), name.end(), ' '), name.end());
|
||||
|
||||
getline(line_stream, content);
|
||||
content.erase(std::remove(content.begin(), content.end(), ' '), content.end());
|
||||
|
||||
// if (name[0] == '/' && name[1] == '/')
|
||||
// {
|
||||
// ch = 0;
|
||||
// while (ch != '\n' && istr.good())
|
||||
// {
|
||||
// ch = istr.get();
|
||||
// }
|
||||
// continue;
|
||||
// }
|
||||
|
||||
if (strlen(content.c_str())==0)
|
||||
{
|
||||
SetFlag (name);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::istringstream content_stream(content);
|
||||
|
||||
content_stream >> ch;
|
||||
if (ch != '*')
|
||||
{
|
||||
if (ch == '[')
|
||||
{
|
||||
// content_stream.putback (ch);
|
||||
// content_stream >> ch;
|
||||
string inner_string;
|
||||
getline(content_stream, inner_string, ']');
|
||||
std::istringstream inner_string_stream(inner_string);
|
||||
|
||||
Array<double> values;
|
||||
Array<string> strings;
|
||||
|
||||
string cur;
|
||||
while (getline(inner_string_stream, cur, ','))
|
||||
{
|
||||
char* endptr;
|
||||
double vald = strtod (cur.c_str(), &endptr);
|
||||
|
||||
if (endptr != cur.c_str() && strings.Size() == 0)
|
||||
values.Append(vald);
|
||||
else
|
||||
strings.Append(cur);
|
||||
}
|
||||
if (strings.Size() > 0)
|
||||
SetFlag(name, strings);
|
||||
else
|
||||
SetFlag(name, values);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(content == "_TRUE" || content == "_FALSE")
|
||||
{
|
||||
SetFlag(name, (content =="_TRUE") ? true : false);
|
||||
continue;
|
||||
}
|
||||
char* endptr;
|
||||
double vald = strtod (content.c_str(), &endptr);
|
||||
if (endptr != content.c_str())
|
||||
SetFlag (name, vald);
|
||||
else
|
||||
SetFlag (name, content);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
content_stream.clear();
|
||||
content_stream >> str;
|
||||
if (sf)
|
||||
SetFlag (name, (*sf)[str]);
|
||||
else
|
||||
throw Exception (" no symboltable of flags ");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Flags :: DoArchive(Archive & archive)
|
||||
{
|
||||
archive & strflags & numflags & defflags & numlistflags & strlistflags & flaglistflags;
|
||||
}
|
||||
|
||||
void Flags :: Update(const Flags& other)
|
||||
{
|
||||
strflags.Update(other.strflags);
|
||||
numflags.Update(other.numflags);
|
||||
defflags.Update(other.defflags);
|
||||
numlistflags.Update(other.numlistflags);
|
||||
strlistflags.Update(other.strlistflags);
|
||||
flaglistflags.Update(other.flaglistflags);
|
||||
}
|
||||
|
||||
void Flags :: SetCommandLineFlag (const char * st, SymbolTable<Flags> * sf )
|
||||
{
|
||||
//cout << "SetCommandLineFlag: flag = " << st << endl;
|
||||
std::istringstream inst( (char *)st);
|
||||
|
||||
char name[100];
|
||||
double val;
|
||||
|
||||
|
||||
if (st[0] != '-')
|
||||
{
|
||||
std::cerr << "flag must start with '-'" << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
// flag with double --
|
||||
if (st[1] == '-') st++;
|
||||
|
||||
const char * pos = strchr (st, '=');
|
||||
const char * posstar = strchr (st, '*');
|
||||
const char * posbrack = strchr (st, '[');
|
||||
|
||||
if (!pos)
|
||||
{
|
||||
// (cout) << "Add def flag: " << st+1 << endl;
|
||||
SetFlag (st+1);
|
||||
}
|
||||
else
|
||||
{
|
||||
//cout << "pos = " << pos << endl;
|
||||
|
||||
strncpy (name, st+1, (pos-st)-1);
|
||||
name[pos-st-1] = 0;
|
||||
|
||||
//cout << "name = " << name << endl;
|
||||
|
||||
pos++;
|
||||
char * endptr = NULL;
|
||||
val = strtod (pos, &endptr);
|
||||
|
||||
/*
|
||||
cout << "val = " << val << endl;
|
||||
cout << "isfinite = " << std::isfinite (val) << endl;
|
||||
cout << "isinf = " << std::isinf (val) << endl;
|
||||
cout << "pos = " << pos << ", endpos = " << endptr << endl;
|
||||
*/
|
||||
if (endptr != pos && !std::isfinite (val))
|
||||
endptr = const_cast<char *>(pos);
|
||||
|
||||
/*
|
||||
#ifdef WIN32
|
||||
if(endptr != pos && !_finite(val))
|
||||
endptr = const_cast<char *>(pos);
|
||||
#else
|
||||
#ifdef MACOS
|
||||
if(endptr != pos && (__isnand(val) || __isinfd(val)))
|
||||
endptr = const_cast<char *>(pos);
|
||||
#else
|
||||
#ifdef SUN
|
||||
#else
|
||||
if(endptr != pos && (std::isnan(val) || std::isinf(val)))
|
||||
endptr = const_cast<char *>(pos);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
*/
|
||||
|
||||
//cout << "val = " << val << endl;
|
||||
|
||||
if (!posbrack)
|
||||
{
|
||||
if (posstar)
|
||||
{
|
||||
pos++;
|
||||
if (sf)
|
||||
SetFlag (name, (*sf)[pos]);
|
||||
else
|
||||
throw Exception (" no symboltable of flags ");
|
||||
}
|
||||
else if (endptr == pos)
|
||||
{
|
||||
// string-flag
|
||||
//(cout) << "Add String Flag: " << name << " = " << pos << endl;
|
||||
SetFlag (name, pos);
|
||||
}
|
||||
else
|
||||
{
|
||||
// num-flag
|
||||
//(cout) << "Add Num Flag: " << name << " = " << val << endl;
|
||||
SetFlag (name, val);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// list-flag
|
||||
char hc;
|
||||
double val;
|
||||
|
||||
val = strtod (posbrack+1, &endptr);
|
||||
if (endptr != posbrack+1)
|
||||
{
|
||||
Array<double> values;
|
||||
|
||||
std::istringstream ist(posbrack);
|
||||
ist >> hc; // '['
|
||||
ist >> val;
|
||||
while (ist.good())
|
||||
{
|
||||
values.Append (val);
|
||||
ist >> hc; // ','
|
||||
ist >> val;
|
||||
}
|
||||
SetFlag (name, values);
|
||||
}
|
||||
else
|
||||
{
|
||||
// to be cleand up ...
|
||||
Array<char *> strs;
|
||||
|
||||
posbrack++;
|
||||
char * hstr = new char[strlen(posbrack)+1];
|
||||
strcpy (hstr, posbrack);
|
||||
|
||||
char * chp = hstr;
|
||||
|
||||
bool start = 1;
|
||||
while (*chp && *chp != ']')
|
||||
{
|
||||
if (start)
|
||||
strs.Append (chp);
|
||||
start = 0;
|
||||
if (*chp == ',')
|
||||
{
|
||||
*chp = 0;
|
||||
start = 1;
|
||||
}
|
||||
chp++;
|
||||
}
|
||||
*chp = 0;
|
||||
|
||||
Array<string> strings;
|
||||
for (int i = 0; i < strs.Size(); i++)
|
||||
strings.Append (string (strs[i]));
|
||||
SetFlag (name, strings);
|
||||
delete [] hstr;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} // namespace ngcore
|
||||
189
libsrc/core/flags.hpp
Normal file
189
libsrc/core/flags.hpp
Normal file
@ -0,0 +1,189 @@
|
||||
#ifndef NETGEN_CORE_FLAGS_HPP
|
||||
#define NETGEN_CORE_FLAGS_HPP
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* File: flags.hpp */
|
||||
/* Author: Joachim Schoeberl */
|
||||
/* Date: 10. Oct. 96 */
|
||||
/**************************************************************************/
|
||||
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "array.hpp"
|
||||
#include "symboltable.hpp"
|
||||
#include "xbool.hpp"
|
||||
|
||||
namespace ngcore
|
||||
{
|
||||
|
||||
/**
|
||||
A storage for command-line flags.
|
||||
The flag structure maintains string flags, numerical flags,
|
||||
define flags, string list flags, num list flags.
|
||||
*/
|
||||
class NGCORE_API Flags
|
||||
{
|
||||
/// string flags
|
||||
SymbolTable<std::string> strflags;
|
||||
/// numerical flags
|
||||
SymbolTable<double> numflags;
|
||||
/// define flags
|
||||
SymbolTable<bool> defflags;
|
||||
/// string list flags
|
||||
SymbolTable<std::shared_ptr<Array<std::string>>> strlistflags;
|
||||
/// numerical list flags
|
||||
SymbolTable<std::shared_ptr<Array<double>>> numlistflags;
|
||||
/// flags list flags
|
||||
SymbolTable<Flags> flaglistflags;
|
||||
public:
|
||||
/// no flags
|
||||
Flags ();
|
||||
/// copy flags
|
||||
Flags (const Flags & flags);
|
||||
/// steal flags
|
||||
Flags (Flags && flags);
|
||||
///
|
||||
Flags (std::initializer_list<std::string> list);
|
||||
///
|
||||
Flags (std::string f1, std::string f2 = "", std::string f3 = "", std::string f4 = "", std::string f5 = "");
|
||||
/// delete mem
|
||||
~Flags ();
|
||||
|
||||
Flags & operator= (const Flags & f2) = default;
|
||||
Flags & operator= (Flags && f2) = default;
|
||||
|
||||
void DoArchive(Archive& ar);
|
||||
|
||||
void Update(const Flags& other);
|
||||
|
||||
/// Deletes all flags
|
||||
void DeleteFlags ();
|
||||
|
||||
/// Sets string flag, overwrite if exists
|
||||
Flags & SetFlag (const char * name, const std::string & val);
|
||||
/// Sets string flag, overwrite if exists
|
||||
Flags & SetFlag (const char * name, const char * str)
|
||||
{ return SetFlag (name, std::string(str)); }
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
Flags & SetFlag (const char * name, double val) &;
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
Flags & SetFlag (const char * name, int val)
|
||||
{ return SetFlag (name, double(val)); }
|
||||
/// Sets boolean flag
|
||||
Flags & SetFlag (const char * name, bool b = true) &;
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
Flags & SetFlag (const char * name, Flags & val) &;
|
||||
|
||||
/// Sets string flag, overwrite if exists
|
||||
Flags & SetFlag (const std::string & name, const std::string & val);
|
||||
Flags & SetFlag (const std::string & name, const char * str)
|
||||
{ return SetFlag (name, std::string(str)); }
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
Flags & SetFlag (const std::string & name, double val);
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
Flags & SetFlag (const std::string & name, int val)
|
||||
{ return SetFlag (name, double(val)); }
|
||||
/// Sets boolean flag
|
||||
Flags & SetFlag (const std::string & name, bool b = true);
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
Flags & SetFlag (const std::string & name, Flags & val);
|
||||
/// Sets string array flag
|
||||
Flags & SetFlag (const std::string & name, const Array<std::string> & val);
|
||||
/// Sets double array flag
|
||||
Flags & SetFlag (const std::string & name, const Array<double> & val);
|
||||
|
||||
|
||||
Flags SetFlag (const char * name, bool b = true) &&;
|
||||
Flags SetFlag (const char * name, double val) &&;
|
||||
|
||||
|
||||
|
||||
/// Save flags to file
|
||||
void SaveFlags (const char * filename) const;
|
||||
void SaveFlags (ostream & str) const;
|
||||
/// write flags to stream
|
||||
void PrintFlags (ostream & ost) const;
|
||||
/// Load flags from file
|
||||
void LoadFlags (const char * filename, SymbolTable<Flags> * sf = nullptr);
|
||||
void LoadFlags (std::istream & str, SymbolTable<Flags> * sf = nullptr);
|
||||
/**
|
||||
Set command line flag.
|
||||
Flag must be in form: -name=hello -val=0.5 -defflag
|
||||
-names=[Joe,Jim] -values=[1,3,4] -solverflags=*abc
|
||||
*/
|
||||
void SetCommandLineFlag (const char * st, SymbolTable<Flags> * sf = nullptr);
|
||||
/// Returns string flag, default value if not exists
|
||||
std::string GetStringFlag (const std::string & name, const char * def) const;
|
||||
/// Returns std::string flag, default value if not exists
|
||||
std::string GetStringFlag (const std::string & name, std::string def = "") const;
|
||||
/// Returns numerical flag, default value if not exists
|
||||
double GetNumFlag (const std::string & name, double def) const;
|
||||
/// Returns address of numerical flag, null if not exists
|
||||
const double * GetNumFlagPtr (const std::string & name) const;
|
||||
/// Returns address of numerical flag, null if not exists
|
||||
double * GetNumFlagPtr (const std::string & name);
|
||||
/// Returns boolean flag
|
||||
// int GetDefineFlag (const char * name) const;
|
||||
bool GetDefineFlag (const std::string & name) const throw();
|
||||
xbool GetDefineFlagX (const std::string & name) const throw();
|
||||
/// Returns string list flag, empty array if not exist
|
||||
const Array<std::string> & GetStringListFlag (const std::string & name) const;
|
||||
/// Returns num list flag, empty array if not exist
|
||||
const Array<double> & GetNumListFlag (const std::string & name) const;
|
||||
/// Returns flag list flag, empty flag if not exist
|
||||
const Flags & GetFlagsFlag (const std::string & name) const;
|
||||
|
||||
|
||||
/// Test, if string flag is defined
|
||||
bool StringFlagDefined (const std::string & name) const;
|
||||
/// Test, if num flag is defined
|
||||
bool NumFlagDefined (const std::string & name) const;
|
||||
/// Test, if num flag is defined
|
||||
bool FlagsFlagDefined (const std::string & name) const;
|
||||
/// Test, if string list flag is defined
|
||||
bool StringListFlagDefined (const std::string & name) const;
|
||||
/// Test, if num list flag is defined
|
||||
bool NumListFlagDefined (const std::string & name) const;
|
||||
|
||||
/// number of string flags
|
||||
int GetNStringFlags () const { return strflags.Size(); }
|
||||
/// number of num flags
|
||||
int GetNNumFlags () const { return numflags.Size(); }
|
||||
/// number of num flags
|
||||
int GetNFlagsFlags () const { return flaglistflags.Size(); }
|
||||
/// number of define flags
|
||||
int GetNDefineFlags () const { return defflags.Size(); }
|
||||
/// number of string-list flags
|
||||
int GetNStringListFlags () const { return strlistflags.Size(); }
|
||||
/// number of num-list flags
|
||||
int GetNNumListFlags () const { return numlistflags.Size(); }
|
||||
|
||||
///
|
||||
const std::string & GetStringFlag (int i, std::string & name) const
|
||||
{ name = strflags.GetName(i); return strflags[i]; }
|
||||
double GetNumFlag (int i, std::string & name) const
|
||||
{ name = numflags.GetName(i); return numflags[i]; }
|
||||
bool GetDefineFlag (int i, std::string & name) const
|
||||
{ name = defflags.GetName(i); return defflags[i]; }
|
||||
const std::shared_ptr<Array<double>> GetNumListFlag (int i, std::string & name) const
|
||||
{ name = numlistflags.GetName(i).c_str(); return numlistflags[i]; }
|
||||
const std::shared_ptr<Array<std::string>> GetStringListFlag (int i, std::string & name) const
|
||||
{ name = strlistflags.GetName(i); return strlistflags[i]; }
|
||||
const Flags & GetFlagsFlag (int i, std::string & name) const
|
||||
{ name = flaglistflags.GetName(i); return flaglistflags[i]; }
|
||||
};
|
||||
|
||||
/// Print flags
|
||||
inline std::ostream & operator<< (std::ostream & s, const Flags & flags)
|
||||
{
|
||||
flags.PrintFlags (s);
|
||||
return s;
|
||||
}
|
||||
} // namespace ngcore
|
||||
|
||||
|
||||
#endif // NETGEN_CORE_FLAGS_HPP
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
#include "archive.hpp"
|
||||
#include "array.hpp"
|
||||
#include "exception.hpp"
|
||||
#include "flags.hpp"
|
||||
#include "localheap.hpp"
|
||||
#include "logging.hpp"
|
||||
#include "mpi_wrapper.hpp"
|
||||
@ -11,5 +12,6 @@
|
||||
#include "symboltable.hpp"
|
||||
#include "taskmanager.hpp"
|
||||
#include "version.hpp"
|
||||
#include "xbool.hpp"
|
||||
|
||||
#endif // NETGEN_CORE_NGCORE_HPP
|
||||
|
||||
37
libsrc/core/xbool.hpp
Normal file
37
libsrc/core/xbool.hpp
Normal file
@ -0,0 +1,37 @@
|
||||
#ifndef NETGEN_CORE_XBOOL_HPP
|
||||
#define NETGEN_CORE_XBOOL_HPP
|
||||
|
||||
/**************************************************************************/
|
||||
/* File: xbool.hpp */
|
||||
/* Author: Joachim Schoeberl */
|
||||
/* Date: 14. Nov. 07 */
|
||||
/**************************************************************************/
|
||||
|
||||
|
||||
namespace ngcore
|
||||
{
|
||||
// an extended bool with values false/maybe/true
|
||||
|
||||
enum TMAYBE { maybe };
|
||||
|
||||
class xbool
|
||||
{
|
||||
uint8_t state;
|
||||
|
||||
public:
|
||||
xbool (bool b) : state(b ? 2 : 0) { ; }
|
||||
xbool (TMAYBE x) : state(1) { ; }
|
||||
xbool () = default;
|
||||
xbool (const xbool &) = default;
|
||||
|
||||
xbool & operator= (bool b) { state = b ? 2 : 0; return *this; }
|
||||
xbool & operator= (TMAYBE x) { state = 1; return *this; }
|
||||
|
||||
bool IsTrue () const { return state == 2; }
|
||||
bool IsMaybe () const { return state == 1; }
|
||||
bool IsFalse () const { return state == 0; }
|
||||
};
|
||||
|
||||
} // namespace ngcore
|
||||
|
||||
#endif // NETGEN_CORE_XBOOL_HPP
|
||||
@ -752,7 +752,7 @@ namespace netgen
|
||||
|
||||
if (flags.StringListFlagDefined ("bcname"))
|
||||
{
|
||||
const NgArray<char*> & bcname = flags.GetStringListFlag("bcname");
|
||||
auto& bcname = flags.GetStringListFlag("bcname");
|
||||
|
||||
Polyhedra * polyh;
|
||||
if(solid->S1())
|
||||
@ -806,7 +806,7 @@ namespace netgen
|
||||
|
||||
if (flags.NumListFlagDefined ("bc"))
|
||||
{
|
||||
const NgArray<double> & bcnum = flags.GetNumListFlag("bc");
|
||||
const auto& bcnum = flags.GetNumListFlag("bc");
|
||||
|
||||
Polyhedra * polyh;
|
||||
if(solid->S1())
|
||||
|
||||
@ -786,7 +786,7 @@ namespace netgen
|
||||
|
||||
if(scan.GetToken() == '-' || scan.GetToken() == TOK_NUM)
|
||||
{
|
||||
NgArray<double> vals;
|
||||
Array<double> vals;
|
||||
vals.Append (ParseNumber(scan));
|
||||
while (scan.GetToken() == ',')
|
||||
{
|
||||
@ -794,28 +794,22 @@ namespace netgen
|
||||
vals.Append (ParseNumber(scan));
|
||||
}
|
||||
ParseChar (scan, ']');
|
||||
flags.SetFlag (name.c_str(), vals);
|
||||
flags.SetFlag (name, vals);
|
||||
}
|
||||
else
|
||||
{ // string list
|
||||
NgArray<char*> vals;
|
||||
string val = scan.GetStringValue();
|
||||
vals.Append(new char[val.size()+1]);
|
||||
strcpy(vals.Last(),val.c_str());
|
||||
Array<string> vals;
|
||||
vals.Append(scan.GetStringValue());
|
||||
scan.ReadNext();
|
||||
|
||||
while (scan.GetToken() == ',')
|
||||
{
|
||||
scan.ReadNext();
|
||||
val = scan.GetStringValue();
|
||||
vals.Append(new char[val.size()+1]);
|
||||
strcpy(vals.Last(),val.c_str());
|
||||
vals.Append(scan.GetStringValue());
|
||||
scan.ReadNext();
|
||||
}
|
||||
ParseChar (scan, ']');
|
||||
flags.SetFlag (name.c_str(), vals);
|
||||
for(int i=0; i<vals.Size(); i++)
|
||||
delete [] vals[i];
|
||||
flags.SetFlag (name, vals);
|
||||
}
|
||||
}
|
||||
else if (scan.GetToken() == TOK_NUM)
|
||||
@ -908,7 +902,7 @@ namespace netgen
|
||||
|
||||
if (flags.NumListFlagDefined ("col"))
|
||||
{
|
||||
const NgArray<double> & col =
|
||||
const Array<double> & col =
|
||||
flags.GetNumListFlag ("col");
|
||||
tlo->SetRGB (col[0], col[1], col[2]);
|
||||
}
|
||||
@ -942,8 +936,8 @@ namespace netgen
|
||||
TopLevelObject * tlo = geom->GetTopLevelObject (tlonr);
|
||||
if (flags.NumListFlagDefined ("col"))
|
||||
{
|
||||
const NgArray<double> & col = flags.GetNumListFlag ("col");
|
||||
tlo->SetRGB (col.Get(1), col.Get(2), col.Get(3));
|
||||
const auto& col = flags.GetNumListFlag ("col");
|
||||
tlo->SetRGB (col[0], col[1], col[2]);
|
||||
}
|
||||
if (flags.GetDefineFlag ("transparent"))
|
||||
tlo->SetTransparent (1);
|
||||
|
||||
@ -123,7 +123,7 @@ namespace netgen
|
||||
int ref_levels_s2;
|
||||
///
|
||||
double eps_n;
|
||||
NgArray<double> slices;
|
||||
Array<double> slices;
|
||||
/// used only for domain-local identification:
|
||||
NgArray<int> domain_surfaces;
|
||||
///
|
||||
@ -154,7 +154,7 @@ namespace netgen
|
||||
virtual int IdentifyableCandidate (const SpecialPoint & sp1) const;
|
||||
virtual int ShortEdge (const SpecialPoint & sp1, const SpecialPoint & sp2) const;
|
||||
virtual int GetIdentifiedPoint (class Mesh & mesh, int pi1);
|
||||
const NgArray<double> & GetSlices () const { return slices; }
|
||||
const Array<double> & GetSlices () const { return slices; }
|
||||
virtual void IdentifyPoints (class Mesh & mesh);
|
||||
virtual void IdentifyFaces (class Mesh & mesh);
|
||||
virtual void BuildSurfaceElements (NgArray<class Segment> & segs,
|
||||
|
||||
@ -509,7 +509,7 @@ However, when r = 0, the top part becomes a point(tip) and meshing fails!
|
||||
try
|
||||
{
|
||||
int n = py::len(aslices);
|
||||
NgArray<double> slices(n);
|
||||
Array<double> slices(n);
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
slices[i]= py::extract<double>(aslices[i])();
|
||||
|
||||
@ -389,12 +389,12 @@ namespace netgen
|
||||
edge.Sort();
|
||||
if (!refedges.Used(edge))
|
||||
{
|
||||
const NgArray<double> & slices = csid->GetSlices();
|
||||
const auto& slices = csid->GetSlices();
|
||||
//(*testout) << "idnr " << idnr << " i " << i << endl;
|
||||
//(*testout) << "slices " << slices << endl;
|
||||
double slicefac = slices.Get(slicenr);
|
||||
double slicefac = slices[slicenr-1];
|
||||
double slicefaclast =
|
||||
(slicenr == slices.Size()) ? 1 : slices.Get(slicenr+1);
|
||||
(slicenr == slices.Size()) ? 1 : slices[slicenr];
|
||||
|
||||
Point3d np = p1 + (slicefac / slicefaclast) * (p2-p1);
|
||||
//(*testout) << "slicenr " << slicenr << " slicefac " << slicefac << " quot " << (slicefac / slicefaclast) << " np " << np << endl;
|
||||
|
||||
@ -2,7 +2,7 @@ add_definitions(-DNGINTERFACE_EXPORTS)
|
||||
add_library(gen INTERFACE)
|
||||
set(sdir ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
target_sources(gen INTERFACE
|
||||
${sdir}/ngarray.cpp ${sdir}/bitarray.cpp ${sdir}/dynamicmem.cpp ${sdir}/flags.cpp
|
||||
${sdir}/ngarray.cpp ${sdir}/bitarray.cpp ${sdir}/dynamicmem.cpp
|
||||
${sdir}/hashtabl.cpp ${sdir}/mystring.cpp ${sdir}/optmem.cpp ${sdir}/parthreads.cpp
|
||||
${sdir}/seti.cpp ${sdir}/sort.cpp ${sdir}/spbita2d.cpp ${sdir}/table.cpp
|
||||
${sdir}/mpi_interface.cpp ${sdir}/gzstream.cpp
|
||||
@ -10,7 +10,7 @@ target_sources(gen INTERFACE
|
||||
|
||||
install(FILES
|
||||
ngarray.hpp autodiff.hpp autoptr.hpp bitarray.hpp
|
||||
dynamicmem.hpp flags.hpp hashtabl.hpp mpi_interface.hpp myadt.hpp
|
||||
dynamicmem.hpp hashtabl.hpp mpi_interface.hpp myadt.hpp
|
||||
ngsimd.hpp mystring.hpp netgenout.hpp ngpython.hpp
|
||||
optmem.hpp parthreads.hpp seti.hpp sort.hpp
|
||||
spbita2d.hpp stack.hpp table.hpp template.hpp
|
||||
|
||||
@ -1,330 +0,0 @@
|
||||
/**************************************************************************/
|
||||
/* File: flags.cc */
|
||||
/* Author: Joachim Schoeberl */
|
||||
/* Date: 10. Oct. 96 */
|
||||
/**************************************************************************/
|
||||
|
||||
/*
|
||||
Datatype Flags
|
||||
*/
|
||||
|
||||
#include <mystdlib.h>
|
||||
#include <myadt.hpp>
|
||||
|
||||
namespace netgen
|
||||
{
|
||||
//using namespace netgen;
|
||||
|
||||
Flags :: Flags ()
|
||||
{
|
||||
;
|
||||
}
|
||||
|
||||
Flags :: ~Flags ()
|
||||
{
|
||||
DeleteFlags ();
|
||||
}
|
||||
|
||||
void Flags :: DeleteFlags ()
|
||||
{
|
||||
for (int i = 0; i < strflags.Size(); i++)
|
||||
delete [] strflags[i];
|
||||
for (int i = 0; i < numlistflags.Size(); i++)
|
||||
delete numlistflags[i];
|
||||
strflags.DeleteAll();
|
||||
numflags.DeleteAll();
|
||||
defflags.DeleteAll();
|
||||
strlistflags.DeleteAll();
|
||||
numlistflags.DeleteAll();
|
||||
}
|
||||
|
||||
void Flags :: SetFlag (const char * name, const char * val)
|
||||
{
|
||||
char * hval = new char[strlen (val) + 1];
|
||||
strcpy (hval, val);
|
||||
strflags.Set (name, hval);
|
||||
}
|
||||
|
||||
void Flags :: SetFlag (const char * name, double val)
|
||||
{
|
||||
numflags.Set (name, val);
|
||||
}
|
||||
|
||||
void Flags :: SetFlag (const char * name)
|
||||
{
|
||||
defflags.Set (name, 1);
|
||||
}
|
||||
|
||||
|
||||
void Flags :: SetFlag (const char * name, const NgArray<char*> & val)
|
||||
{
|
||||
NgArray<char*> * strarray = new NgArray<char*>;
|
||||
for (int i = 1; i <= val.Size(); i++)
|
||||
{
|
||||
strarray->Append (new char[strlen(val.Get(i))+1]);
|
||||
strcpy (strarray->Last(), val.Get(i));
|
||||
}
|
||||
strlistflags.Set (name, strarray);
|
||||
}
|
||||
|
||||
void Flags :: SetFlag (const char * name, const NgArray<double> & val)
|
||||
{
|
||||
NgArray<double> * numarray = new NgArray<double>;
|
||||
for (int i = 1; i <= val.Size(); i++)
|
||||
numarray->Append (val.Get(i));
|
||||
numlistflags.Set (name, numarray);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
const char *
|
||||
Flags :: GetStringFlag (const char * name, const char * def) const
|
||||
{
|
||||
if (strflags.Used (name))
|
||||
return strflags[name];
|
||||
else
|
||||
return def;
|
||||
}
|
||||
|
||||
double Flags :: GetNumFlag (const char * name, double def) const
|
||||
{
|
||||
if (numflags.Used (name))
|
||||
return numflags[name];
|
||||
else
|
||||
return def;
|
||||
}
|
||||
|
||||
const double * Flags :: GetNumFlagPtr (const char * name) const
|
||||
{
|
||||
if (numflags.Used (name))
|
||||
return & ((SymbolTable<double>&)numflags)[name];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
double * Flags :: GetNumFlagPtr (const char * name)
|
||||
{
|
||||
if (numflags.Used (name))
|
||||
return & ((SymbolTable<double>&)numflags)[name];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool Flags :: GetDefineFlag (const char * name) const
|
||||
{
|
||||
return defflags.Used (name);
|
||||
}
|
||||
|
||||
|
||||
const NgArray<char*> &
|
||||
Flags :: GetStringListFlag (const char * name) const
|
||||
{
|
||||
if (strlistflags.Used (name))
|
||||
return *strlistflags[name];
|
||||
else
|
||||
{
|
||||
static NgArray<char*> dummy_array(0);
|
||||
return dummy_array;
|
||||
}
|
||||
}
|
||||
|
||||
const NgArray<double> &
|
||||
Flags ::GetNumListFlag (const char * name) const
|
||||
{
|
||||
if (numlistflags.Used (name))
|
||||
return *numlistflags[name];
|
||||
else
|
||||
{
|
||||
static NgArray<double> dummy_array(0);
|
||||
return dummy_array;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool Flags :: StringFlagDefined (const char * name) const
|
||||
{
|
||||
return strflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: NumFlagDefined (const char * name) const
|
||||
{
|
||||
return numflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: StringListFlagDefined (const char * name) const
|
||||
{
|
||||
return strlistflags.Used (name);
|
||||
}
|
||||
|
||||
bool Flags :: NumListFlagDefined (const char * name) const
|
||||
{
|
||||
return numlistflags.Used (name);
|
||||
}
|
||||
|
||||
|
||||
void Flags :: SaveFlags (const char * filename) const
|
||||
{
|
||||
int i;
|
||||
ofstream outfile (filename);
|
||||
|
||||
for (i = 1; i <= strflags.Size(); i++)
|
||||
outfile << strflags.GetName(i) << " = " << strflags[i] << endl;
|
||||
for (i = 1; i <= numflags.Size(); i++)
|
||||
outfile << numflags.GetName(i) << " = " << numflags[i] << endl;
|
||||
for (i = 1; i <= defflags.Size(); i++)
|
||||
outfile << defflags.GetName(i) << endl;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Flags :: PrintFlags (ostream & ost) const
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 1; i <= strflags.Size(); i++)
|
||||
ost << strflags.GetName(i) << " = " << strflags[i] << endl;
|
||||
for (i = 1; i <= numflags.Size(); i++)
|
||||
ost << numflags.GetName(i) << " = " << numflags[i] << endl;
|
||||
for (i = 1; i <= defflags.Size(); i++)
|
||||
ost << defflags.GetName(i) << endl;
|
||||
}
|
||||
|
||||
|
||||
void Flags :: LoadFlags (const char * filename)
|
||||
{
|
||||
char name[100], str[100];
|
||||
char ch;
|
||||
double val;
|
||||
ifstream infile(filename);
|
||||
|
||||
// (*logout) << "Load flags from " << filename << endl << endl;
|
||||
while (infile.good())
|
||||
{
|
||||
infile >> name;
|
||||
if (strlen (name) == 0) break;
|
||||
|
||||
if (name[0] == '/' && name[1] == '/')
|
||||
{
|
||||
// (*logout) << "comment: ";
|
||||
ch = 0;
|
||||
while (ch != '\n' && infile.good())
|
||||
{
|
||||
ch = infile.get();
|
||||
// (*logout) << ch;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// (*logout) << name;
|
||||
ch = 0;
|
||||
infile >> ch;
|
||||
if (ch != '=')
|
||||
{
|
||||
// (*logout) << endl;
|
||||
infile.putback (ch);
|
||||
SetFlag (name);
|
||||
}
|
||||
else
|
||||
{
|
||||
infile >> val;
|
||||
if (!infile.good())
|
||||
{
|
||||
infile.clear();
|
||||
infile >> str;
|
||||
SetFlag (name, str);
|
||||
// (*logout) << " = " << str << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetFlag (name, val);
|
||||
// (*logout) << " = " << val << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
// (*logout) << endl;
|
||||
}
|
||||
|
||||
|
||||
void Flags :: SetCommandLineFlag (const char * st)
|
||||
{
|
||||
// cout << "clflag = " << st << endl;
|
||||
istringstream inst( (char *)st);
|
||||
// istrstream defined with char * (not const char * ?????)
|
||||
|
||||
char name[100];
|
||||
double val;
|
||||
|
||||
|
||||
if (st[0] != '-')
|
||||
{
|
||||
cerr << "flag must start with '-'" << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
const char * pos = strchr (st, '=');
|
||||
|
||||
if (!pos)
|
||||
{
|
||||
// (cout) << "Add def flag: " << st+1 << endl;
|
||||
SetFlag (st+1);
|
||||
}
|
||||
else
|
||||
{
|
||||
// cout << "pos = " << pos << endl;
|
||||
|
||||
strncpy (name, st+1, (pos-st)-1);
|
||||
name[pos-st-1] = 0;
|
||||
|
||||
// cout << "name = " << name << endl;
|
||||
|
||||
pos++;
|
||||
char * endptr = NULL;
|
||||
|
||||
val = strtod (pos, &endptr);
|
||||
|
||||
// cout << "val = " << val << endl;
|
||||
|
||||
if (endptr == pos)
|
||||
{
|
||||
// (cout) << "Add String Flag: " << name << " = " << pos << endl;
|
||||
SetFlag (name, pos);
|
||||
}
|
||||
else
|
||||
{
|
||||
// (cout) << "Add Num Flag: " << name << " = " << val << endl;
|
||||
SetFlag (name, val);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
inst >> name;
|
||||
(*mycout) << "name = " << name << endl;
|
||||
|
||||
ch = 0;
|
||||
inst >> ch;
|
||||
if (ch != '=')
|
||||
{
|
||||
SetFlag (name);
|
||||
}
|
||||
else
|
||||
{
|
||||
inst >> val;
|
||||
if (!inst.good())
|
||||
{
|
||||
inst.clear();
|
||||
inst >> str;
|
||||
SetFlag (name, str);
|
||||
(*mycout) << "str = " << str << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetFlag (name, val);
|
||||
(*mycout) << "val = " << val << endl;
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
}
|
||||
@ -1,88 +0,0 @@
|
||||
#ifndef FILE_FLAGS
|
||||
#define FILE_FLAGS
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* File: flags.hh */
|
||||
/* Author: Joachim Schoeberl */
|
||||
/* Date: 10. Oct. 96 */
|
||||
/**************************************************************************/
|
||||
|
||||
namespace netgen
|
||||
{
|
||||
|
||||
/**
|
||||
Flag - Table.
|
||||
A flag table maintains string variables, numerical
|
||||
variables and boolean flags.
|
||||
*/
|
||||
class Flags
|
||||
{
|
||||
///
|
||||
SymbolTable<char *> strflags;
|
||||
///
|
||||
SymbolTable<double> numflags;
|
||||
///
|
||||
SymbolTable<int> defflags;
|
||||
///
|
||||
SymbolTable<NgArray<char*>*> strlistflags;
|
||||
///
|
||||
SymbolTable<NgArray<double>*> numlistflags;
|
||||
public:
|
||||
///
|
||||
DLL_HEADER Flags ();
|
||||
///
|
||||
DLL_HEADER ~Flags ();
|
||||
|
||||
/// Deletes all flags
|
||||
DLL_HEADER void DeleteFlags ();
|
||||
/// Sets string flag, overwrite if exists
|
||||
DLL_HEADER void SetFlag (const char * name, const char * val);
|
||||
/// Sets numerical flag, overwrite if exists
|
||||
DLL_HEADER void SetFlag (const char * name, double val);
|
||||
/// Sets boolean flag
|
||||
DLL_HEADER void SetFlag (const char * name);
|
||||
/// Sets string arary flag
|
||||
DLL_HEADER void SetFlag (const char * name, const NgArray<char*> & val);
|
||||
/// Sets double array flag
|
||||
DLL_HEADER void SetFlag (const char * name, const NgArray<double> & val);
|
||||
|
||||
/// Save flags to file
|
||||
DLL_HEADER void SaveFlags (const char * filename) const;
|
||||
/// write flags to stream
|
||||
DLL_HEADER void PrintFlags (ostream & ost) const;
|
||||
/// Load flags from file
|
||||
DLL_HEADER void LoadFlags (const char * filename);
|
||||
/// set flag of form -name=hello -val=0.5 -defined
|
||||
DLL_HEADER void SetCommandLineFlag (const char * st);
|
||||
|
||||
/// Returns string flag, default value if not exists
|
||||
DLL_HEADER const char * GetStringFlag (const char * name, const char * def) const;
|
||||
/// Returns numerical flag, default value if not exists
|
||||
DLL_HEADER double GetNumFlag (const char * name, double def) const;
|
||||
/// Returns address of numerical flag, null if not exists
|
||||
DLL_HEADER const double * GetNumFlagPtr (const char * name) const;
|
||||
/// Returns address of numerical flag, null if not exists
|
||||
DLL_HEADER double * GetNumFlagPtr (const char * name);
|
||||
/// Returns boolean flag
|
||||
DLL_HEADER bool GetDefineFlag (const char * name) const;
|
||||
/// Returns string list flag, empty array if not exist
|
||||
DLL_HEADER const NgArray<char*> & GetStringListFlag (const char * name) const;
|
||||
/// Returns num list flag, empty array if not exist
|
||||
DLL_HEADER const NgArray<double> & GetNumListFlag (const char * name) const;
|
||||
|
||||
|
||||
/// Test, if string flag is defined
|
||||
DLL_HEADER bool StringFlagDefined (const char * name) const;
|
||||
/// Test, if num flag is defined
|
||||
DLL_HEADER bool NumFlagDefined (const char * name) const;
|
||||
/// Test, if string list flag is defined
|
||||
DLL_HEADER bool StringListFlagDefined (const char * name) const;
|
||||
/// Test, if num list flag is defined
|
||||
DLL_HEADER bool NumListFlagDefined (const char * name) const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -34,7 +34,6 @@ namespace netgen
|
||||
|
||||
|
||||
#include "bitarray.hpp"
|
||||
#include "flags.hpp"
|
||||
#include "spbita2d.hpp"
|
||||
|
||||
#include "seti.hpp"
|
||||
|
||||
@ -24,7 +24,7 @@ DLL_HEADER void ImportSolution2 (const char * filename)
|
||||
char buf[100], name[1000];
|
||||
int i, size, comps, order;
|
||||
bool iscomplex;
|
||||
const char * type;
|
||||
std::string type;
|
||||
Flags flags;
|
||||
|
||||
while (1)
|
||||
@ -83,19 +83,19 @@ DLL_HEADER void ImportSolution2 (const char * filename)
|
||||
soldata.soltype = NG_SOLUTION_NODAL;
|
||||
soldata.draw_surface = 1;
|
||||
soldata.draw_volume = 1;
|
||||
if (strcmp (type, "element") == 0)
|
||||
if (type == "element")
|
||||
{
|
||||
soldata.soltype = NG_SOLUTION_ELEMENT;
|
||||
soldata.draw_surface = 0;
|
||||
}
|
||||
if (strcmp (type, "surfaceelement") == 0)
|
||||
if (type == "surfaceelement")
|
||||
{
|
||||
soldata.soltype = NG_SOLUTION_SURFACE_ELEMENT;
|
||||
soldata.draw_volume = 0;
|
||||
}
|
||||
if (strcmp (type, "noncontinuous") == 0)
|
||||
if (type == "noncontinuous")
|
||||
soldata.soltype = NG_SOLUTION_NONCONTINUOUS;
|
||||
if (strcmp (type, "surfacenoncontinuous") == 0)
|
||||
if (type == "surfacenoncontinuous")
|
||||
soldata.soltype = NG_SOLUTION_SURFACE_NONCONTINUOUS;
|
||||
|
||||
Ng_SetSolutionData (&soldata);
|
||||
|
||||
@ -1302,7 +1302,7 @@ namespace netgen
|
||||
|
||||
if (parameters.StringFlagDefined (argv[1]))
|
||||
Tcl_SetResult (interp,
|
||||
(char*)parameters.GetStringFlag (argv[1], NULL), TCL_STATIC);
|
||||
(char*)parameters.GetStringFlag (argv[1], NULL).c_str(), TCL_STATIC);
|
||||
else if (parameters.NumFlagDefined (argv[1]))
|
||||
{
|
||||
sprintf (buf, "%lf", parameters.GetNumFlag (argv[1], 0));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user