#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...

static bool	GenerateVariableVector (const std::string &str, const std::vector< std::string > &variables, std::vector< int > &out)

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::SpatialDomains::MeshGraph::GetCompositeString(), Nektar::SpatialDomains::MeshGraphIO::GetCompositeString(), Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion(), Nektar::LibUtilities::FieldIOXml::v_Write(), Nektar::SpatialDomains::MeshGraphIOHDF5::WriteDomain(), Nektar::SpatialDomains::MeshGraphIOXml::WriteDomain(), Nektar::SpatialDomains::Movement::WriteMovement(), Nektar::LibUtilities::FieldIOXml::WriteMultiFldFileIDs(), and Nektar::SpatialDomains::MeshGraphIOXml::WriteXMLGeometry().

◆ 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 104 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();
}

◆ 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 168 of file ParseUtils.cpp.

{
    std::vector<int> tempvect;
    GenerateVariableVector(str, variables, tempvect);
    out.clear();
    for (auto i : tempvect)
    {
        out.insert(i);
    }
    return true;
}

References GenerateVariableVector().

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

◆ GenerateVariableVector()

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

static

Definition at line 185 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.push_back(v);
        }
    }
    return true;
}

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

Referenced by GenerateVariableSet(), and Nektar::FieldUtils::ProcessMRF::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 156 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 130 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()

◆ GenerateVariableVector()

◆ GenerateVector() [1/2]

◆ GenerateVector() [2/2]