text_eval_wrapper.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <kicommon.h>
#include <wx/string.h>
#include <unordered_map>
#include <string>
#include <memory>
#include <variant>
#include <vector>
#include <functional>
 
// Include EDA units support
#include <eda_units.h>
 
// Include the parser types
#include <text_eval/text_eval_types.h>
 
// Forward declaration for NUMERIC_EVALUATOR compatibility
class NUMERIC_EVALUATOR_COMPAT;

 */
class KICOMMON_API EXPRESSION_EVALUATOR
{
public:
    // Callback function type for dynamic variable resolution
    using VAR_CALLBACK = std::function<calc_parser::RESULT<calc_parser::VALUE>(const std::string& aVariableName)>;
 
public:
    explicit EXPRESSION_EVALUATOR( bool aClearVariablesOnEvaluate = false );

    explicit EXPRESSION_EVALUATOR( EDA_UNITS aUnits, bool aClearVariablesOnEvaluate = false );

    explicit EXPRESSION_EVALUATOR( VAR_CALLBACK aVariableCallback, bool aClearVariablesOnEvaluate = false );

    explicit EXPRESSION_EVALUATOR( EDA_UNITS aUnits, VAR_CALLBACK aVariableCallback,
                                   bool aClearVariablesOnEvaluate = false );

    ~EXPRESSION_EVALUATOR();
 
    // Copy and move operations
    EXPRESSION_EVALUATOR( const EXPRESSION_EVALUATOR& aOther );
    EXPRESSION_EVALUATOR& operator=( const EXPRESSION_EVALUATOR& aOther );
    EXPRESSION_EVALUATOR( EXPRESSION_EVALUATOR&& aOther ) noexcept;
    EXPRESSION_EVALUATOR& operator=( EXPRESSION_EVALUATOR&& aOther ) noexcept;

    void SetVariableCallback( VAR_CALLBACK aCallback );

    void ClearVariableCallback();

    bool HasVariableCallback() const;

    void SetDefaultUnits( EDA_UNITS aUnits );

    EDA_UNITS GetDefaultUnits() const;

    void SetVariable( const wxString& aName, double aValue );

    void SetVariable( const wxString& aName, const wxString& aValue );

    void SetVariable( const std::string& aName, const std::string& aValue );

    bool RemoveVariable( const wxString& aName );

    void ClearVariables();

    bool HasVariable( const wxString& aName ) const;

    wxString GetVariable( const wxString& aName ) const;

    std::vector<wxString> GetVariableNames() const;

    void SetVariables( const std::unordered_map<wxString, double>& aVariables );

    void SetVariables( const std::unordered_map<wxString, wxString>& aVariables );

    wxString Evaluate( const wxString& aInput );

    wxString Evaluate( const wxString& aInput, const std::unordered_map<wxString, double>& aTempVariables );

    wxString Evaluate( const wxString& aInput, const std::unordered_map<wxString, double>& aTempNumericVars,
                       const std::unordered_map<wxString, wxString>& aTempStringVars );

    bool HasErrors() const;

    size_t GetErrorCount() const;

    wxString GetErrorSummary() const;

    std::vector<wxString> GetErrors() const;

    void ClearErrors();

    void SetClearVariablesOnEvaluate( bool aEnable );

    bool GetClearVariablesOnEvaluate() const;

    bool TestExpression( const wxString& aExpression );

    size_t CountExpressions( const wxString& aInput ) const;

    std::vector<wxString> ExtractExpressions( const wxString& aInput ) const;
 
private:
    std::string wxStringToStdString( const wxString& aWxStr ) const;

    wxString stdStringToWxString( const std::string& aStdStr ) const;

    VAR_CALLBACK createCombinedCallback( const std::unordered_map<wxString, double>* aTempNumericVars = nullptr,
                                         const std::unordered_map<wxString, wxString>* aTempStringVars = nullptr ) const;

    std::pair<std::string, bool> evaluateWithParser( const std::string& aInput, VAR_CALLBACK aVariableCallback );

    std::pair<std::string, bool> evaluateWithPartialErrorRecovery( const std::string& aInput,
                                                                   VAR_CALLBACK aVariableCallback );

    std::pair<std::string, bool> evaluateWithFullParser( const std::string& aInput, VAR_CALLBACK aVariableCallback );

    wxString expandVariablesOutsideExpressions( const wxString& aInput,
                                                const std::unordered_map<wxString, double>& aTempNumericVars,
                                                const std::unordered_map<wxString, wxString>& aTempStringVars ) const;
 
private:
    std::unordered_map<std::string, calc_parser::VALUE>   m_variables;
    mutable std::unique_ptr<calc_parser::ERROR_COLLECTOR> m_lastErrors;
    bool                                                  m_clearVariablesOnEvaluate;
    VAR_CALLBACK                                          m_customCallback;
    bool                                                  m_useCustomCallback;
    EDA_UNITS                                             m_defaultUnits;  // Default units for calculations
};

 */
class KICOMMON_API NUMERIC_EVALUATOR_COMPAT
{
public:
    explicit NUMERIC_EVALUATOR_COMPAT( EDA_UNITS aUnits );

    ~NUMERIC_EVALUATOR_COMPAT();

    void Clear();

    void SetDefaultUnits( EDA_UNITS aUnits );

    void LocaleChanged();

    bool IsValid() const;

    wxString Result() const;

    bool Process( const wxString& aString );

    wxString OriginalText() const;

    void SetVar( const wxString& aString, double aValue );

    double GetVar( const wxString& aString );

    void RemoveVar( const wxString& aString );

    void ClearVar();
 
private:
    EXPRESSION_EVALUATOR m_evaluator;
    wxString             m_lastInput;
    wxString             m_lastResult;
    bool                 m_lastValid;
};