PlaceholderExpression.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Enumerator.hxx"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Commons/Environment.hpp"
#include <sstream>
 
namespace Arp { namespace System { namespace Commons { namespace Configuration
{
 
class PlaceholderExpression
{
public: // nested types
    class Enumerator : public Arp::Enumerator<const String&>
    {
    public: // construcion
        Enumerator(const String& input);
 
    public: // Enumerator<String> operations
        bool    MoveNext(void)override;
        bool    IsCurrentBuiltIn(void); // placeholder starts with '!'
 
    private:
        size_t  currentStart = 0;
        size_t  currentEnd = 0;
        String  input;
    };
 
public: // construction/destruction
    PlaceholderExpression(void) = default;
    PlaceholderExpression(const PlaceholderExpression& arg) = default;
    PlaceholderExpression& operator=(const PlaceholderExpression& arg) = default;
    ~PlaceholderExpression(void) = default;
 
public: // operators
 
public: // static operations
    static bool         HasPlaceholder(const String& input, const String& placeholder);
    static bool         HasPlaceholder(const String& input);
    static bool         HasLogicalExpression(const String& input);
    static String       GetPlaceholderName(const String& placeholderToken);
    static Enumerator   GetEnumerator(const String& input);
 
public: // setter/getter operations
 
public: // operations
    String  Resolve(const String& input);
    bool    TryResolve(const String& input, String& result);
    bool    ResolveCondition(const String& input);
    String  ResolveLogicalExpression(const String& input);
 
    template<class T>
    T       ResolveTo(const String& input);
 
protected: // operations
 
private: // static methods
 
private: // methods
    static bool TryResolveLogicalExpression(const String& input, bool& result);
    static bool TryResolveLogicalExpression(const String& input, String& result);
    static bool HasLogicalExpression(const std::string& input);
 
private: // fields
 
private: // static fields
    static const String envVarSeperator;
};
 
// inline methods of class PlaceholderExpression
 
inline bool PlaceholderExpression::HasLogicalExpression(const String& input)
{
    return PlaceholderExpression::HasLogicalExpression(input.GetBaseString());
}
 
template<class T>
inline T PlaceholderExpression::ResolveTo(const String& input)
{
    if (input.IsEmpty())
    {
        throw ArgumentException("Input is empty.");
    }
    // else
    std::istringstream iss(this->Resolve(input));
    T result;
    iss >> std::boolalpha >> result;
    if (iss.fail())
    {
        throw ArgumentException("Input is not of required type.");
    }
    // else
    return result;
}
 
inline PlaceholderExpression::Enumerator PlaceholderExpression::GetEnumerator(const String& input)
{
    return Enumerator(input);
}
 
// inline methods of class PlaceholderExpression::Eumerator
inline PlaceholderExpression::Enumerator::Enumerator(const String& input)
    : input(input)
{
}
 
}}}} // end of namespace Arp::System::Commons::Configuration