#include <ParseUtils.h>

Public Member Functions
template<>
bool	GenerateVector (const std::string &str, std::vector< std::string > &out)
	Specialised version of ParseUtils::GenerateVector for std::string. More...

Static Public Member Functions
static bool	GenerateSeqVector (const std::string &str, std::vector< unsigned int > &out)
	Takes a comma-separated compressed string and converts it to entries in a vector. More...

template<typename T >
static bool	GenerateVector (const std::string &str, std::vector< T > &out)
	Takes a comma-separated string and converts it to entries in a vector. More...

template<typename T >
static std::string	GenerateSeqString (const std::vector< T > &v)
	Generate a compressed comma-separated string representation of a vector of unsigned integers. More...

static bool	GenerateVariableSet (const std::string &str, const std::vector< std::string > &variables, std::set< int > &out)
	Generate a set of variable locations. More...

Detailed Description

Definition at line 47 of file ParseUtils.h.

Member Function Documentation

◆ GenerateSeqString()

template<typename T >

static std::string Nektar::ParseUtils::GenerateSeqString ( const std::vector< T > & v )

inlinestatic

Generate a compressed comma-separated string representation of a vector of unsigned integers.

This utility routine takes entries of v and returns a string sequence. For example,

std::vector<unsigned int> vec = {1,2,3,4,6,7,8,5,2,3};
std::string output = ParseUtils::GenerateVector(vec);

will produce an output string containing 1-4,6-8,5,2,3.

Parameters

v	Vector of unsigned integers.

Returns: Compressed comma separated string.

Definition at line 72 of file ParseUtils.h.

     {
         static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value,
                       "Unsigned integer type required.");
  
         if (v.size() == 0)
         {
             return "";
         }
  
         std::ostringstream ss;
         auto first = v[0], last = v[0];
  
         ss << v[0];
  
         for (auto &i : v)
         {
             if (i != last + 1 && i != last)
             {
                 if (last != first)
                 {
                     ss << '-' << last;
                 }
                 ss << ',' << i;
                 first = i;
             }
             last = i;
         }
  
         if (last != first)
         {
             ss << '-' << last;
         }
  
         return ss.str();
     }

Referenced by Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion(), Nektar::LibUtilities::FieldIOXml::v_Write(), and Nektar::LibUtilities::FieldIOXml::WriteMultiFldFileIDs().

◆ GenerateSeqVector()

bool Nektar::ParseUtils::GenerateSeqVector	(	const std::string &	str,
		std::vector< unsigned int > &	out
	)

static

Takes a comma-separated compressed string and converts it to entries in a vector.

This routine is the inverse of ParseUtils::GenerateSeqString. For example,

std::string input = "1-4,6-8,5,2,3";
std::vector<unsigned int> output;
ParseUtils::GenerateSeqString(input, output);

produces an output vector with the entries {1,2,3,4,6,7,8,5,2,3}.

Parameters

str	Input CSV string of unsigned integers.
out	Output vector.

See also: ParseUtils::GenerateSeqString

Definition at line 105 of file ParseUtils.cpp.

 {
     PushBackFunctor<unsigned int> f1(out), f2(out);
  
     auto it      = str.begin();
     bool success = qi::phrase_parse(
         it, str.end(),
         ((qi::uint_ >> '-' >> qi::uint_)[f2] | qi::uint_[f1]) % ',',
         qi::ascii::space);
  
     return success && it == str.end();
 }

Referenced by Nektar::SolverUtils::FilterIntegral::FilterIntegral(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), Nektar::LibUtilities::FieldIOXml::ImportMultiFldFileIDs(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::Collections::CollectionOptimisation::ReadCollOps(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), Nektar::SolverUtils::FilterAeroForces::v_Initialise(), Nektar::FilterMovingBody::v_Initialise(), and Nektar::FieldUtils::ProcessInnerProduct::v_Process().

◆ GenerateVariableSet()

bool Nektar::ParseUtils::GenerateVariableSet	(	const std::string &	str,
		const std::vector< std::string > &	variables,
		std::set< int > &	out
	)

static

Generate a set of variable locations.

This utility routine takes entries of str and returns a integer set that contains locations of parsed variables in variables. For example,

str = "0,1,w,p";
variables = {"u", "v", "w", "p"};

will produce an set out = {0,1,2,3}.

Parameters

str	A string of variables separated by comma.
variables	A vector of variables

Returns: out A set of locations of parsed variables in variables.

Definition at line 166 of file ParseUtils.cpp.

 {
     out.clear();
     std::vector<std::string> vars;
     ASSERTL0(ParseUtils::GenerateVector(str, vars),
              "Failed to interpret variable numbers or names from " + str);
     for (std::string s : vars)
     {
         int v = -1;
         try
         {
             v = boost::lexical_cast<int>(s);
         }
         catch (const boost::bad_lexical_cast &)
         {
             auto index = find(variables.begin(), variables.end(), s);
             v          = index - variables.begin();
         }
         if (v < 0 || v >= variables.size())
         {
             WARNINGL0(false, "Warning: variable " + s + " not found");
         }
         else
         {
             out.insert(v);
         }
     }
     return true;
 }

References ASSERTL0, Nektar::StdRegions::find(), GenerateVector(), and WARNINGL0.

Referenced by Nektar::FieldUtils::ProcessGrad::ParserOptions(), Nektar::FieldUtils::ProcessHalfModeToFourier::v_Process(), Nektar::FieldUtils::ProcessInterpField::v_Process(), and Nektar::FieldUtils::ProcessInterpPoints::v_Process().

◆ GenerateVector() [1/2]

template<>

bool Nektar::ParseUtils::GenerateVector	(	const std::string &	str,
		std::vector< std::string > &	out
	)

Specialised version of ParseUtils::GenerateVector for std::string.

This routine specialises for the std::string data type as this type is not supported by boost::spirit::qi::auto_.

Definition at line 157 of file ParseUtils.cpp.

 {
     auto it      = str.begin();
     bool success = qi::phrase_parse(it, str.end(), +~qi::char_(",") % ',',
                                     qi::ascii::space, out);
     return success && it == str.end();
 }

◆ GenerateVector() [2/2]

template<typename T >

template bool Nektar::ParseUtils::GenerateVector< float >	(	const std::string &	str,
		std::vector< T > &	out
	)

static

Takes a comma-separated string and converts it to entries in a vector.

This routine splits up a comma-separated string and returns a vector with the entries. Template specialisations should be defined in this file (and not in the header file) as the use of boost::spirit::qi makes compilation times quite slow.

Parameters

str	Input CSV string.
out	Output vector.

Definition at line 131 of file ParseUtils.cpp.

 {
     auto it = str.begin();
     bool success =
         qi::phrase_parse(it, str.end(), qi::auto_ % ',', qi::ascii::space, out);
     return success && it == str.end();
 }

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ GenerateSeqString()

◆ GenerateSeqVector()

◆ GenerateVariableSet()

◆ GenerateVector() [1/2]

◆ GenerateVector() [2/2]