ParseContext.hpp

/*
  Copyright 2015 Statoil ASA.

  This file is part of the Open Porous Media project (OPM).

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

  OPM 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 OPM.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef OPM_PARSE_CONTEXT_HPP
#define OPM_PARSE_CONTEXT_HPP

#include <map>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>

namespace Opm {

enum class InputErrorAction;

class ErrorGuard;
class KeywordLocation;

} // namespace Opm

namespace Opm {

    class ParseContext
    {
    public:
        ParseContext();

        explicit ParseContext(InputErrorAction default_action);

        explicit ParseContext(const std::vector<std::pair<std::string, InputErrorAction>>& initial);

        void handleError(const std::string&                    errorKey,
                         const std::string&                    msg,
                         const std::optional<KeywordLocation>& location,
                         ErrorGuard&                           errors)  const;

        void handleUnknownKeyword(const std::string&                    keyword,
                                  const std::optional<KeywordLocation>& location,
                                  ErrorGuard&                           errors) const;

        bool hasKey(const std::string& key) const;

        void updateKey(const std::string& key, InputErrorAction action);

        void update(InputErrorAction action);

        void update(const std::string& keyString, InputErrorAction action);

        void ignoreKeyword(const std::string& keyword);

        InputErrorAction get(const std::string& key) const;

        void addKey(const std::string& key, InputErrorAction default_action);

        void setInputSkipMode(const std::string& skip_mode);

        bool isActiveSkipKeyword(const std::string& deck_name) const;

        const static std::string PARSE_EXTRA_RECORDS;

        const static std::string PARSE_UNKNOWN_KEYWORD;

        const static std::string PARSE_RANDOM_TEXT;

        const static std::string PARSE_RANDOM_SLASH;

        const static std::string PARSE_MISSING_DIMS_KEYWORD;

        const static std::string PARSE_EXTRA_DATA;

        const static std::string PARSE_MISSING_INCLUDE;

        const static std::string PARSE_INVALID_KEYWORD_COMBINATION;

        const static std::string RUNSPEC_NUMWELLS_TOO_LARGE;

        const static std::string RUNSPEC_CONNS_PER_WELL_TOO_LARGE;

        const static std::string RUNSPEC_NUMGROUPS_TOO_LARGE;

        const static std::string RUNSPEC_GROUPSIZE_TOO_LARGE;

        const static std::string RUNSPEC_NUMMSW_TOO_LARGE;

        const static std::string RUNSPEC_NUMSEG_PER_WELL_TOO_LARGE;

        const static std::string RUNSPEC_NUMBRANCH_TOO_LARGE;

        const static std::string PARSE_LONG_KEYWORD;

        const static std::string UNIT_SYSTEM_MISMATCH;

        const static std::string UNSUPPORTED_INITIAL_THPRES;

        const static std::string UNSUPPORTED_TERMINATE_IF_BHP;

        const static std::string UDQ_PARSE_ERROR;

        const static std::string UDQ_TYPE_ERROR;

        const static std::string UDQ_DEFINE_CANNOT_EVAL;

        const static std::string INTERNAL_ERROR_UNINITIALIZED_THPRES;

        const static std::string PARSE_MISSING_SECTIONS;

        const static std::string PARSE_WGNAME_SPACE;

        const static std::string SUMMARY_UNKNOWN_WELL;

        const static std::string SUMMARY_UNKNOWN_GROUP;

        const static std::string SUMMARY_UNKNOWN_NODE;

        const static std::string SUMMARY_UNKNOWN_AQUIFER;

        const static std::string SUMMARY_UNHANDLED_KEYWORD;

        const static std::string SUMMARY_UNDEFINED_UDQ;

        const static std::string SUMMARY_UDQ_MISSING_UNIT;

        const static std::string SUMMARY_INVALID_FIPNUM;

        const static std::string SUMMARY_EMPTY_REGION;

        const static std::string SUMMARY_REGION_TOO_LARGE;

        const static std::string SCHEDULE_INVALID_NAME;

        // Only explicitly supported keywords can be included in an ACTIONX
        // or PYACTION block.  These categories control what should happen
        // when encountering an illegal keyword in such blocks.

        const static std::string ACTIONX_ILLEGAL_KEYWORD;

        const static std::string PYACTION_ILLEGAL_KEYWORD;

        const static std::string ACTIONX_CONDITION_ERROR;

        const static std::string ACTIONX_NO_CONDITION;

        const static std::string RPT_MIXED_STYLE;

        const static std::string RPT_UNKNOWN_MNEMONIC;

        const static std::string SCHEDULE_GROUP_ERROR;

        const static std::string SCHEDULE_IGNORED_GUIDE_RATE;

        const static std::string SCHEDULE_WELL_IN_FIELD_GROUP;

        const static std::string SCHEDULE_COMPSEGS_INVALID;

        const static std::string SCHEDULE_COMPSEGS_NOT_SUPPORTED;

        const static std::string SCHEDULE_COMPDAT_INVALID;

        const static std::string SCHEDULE_COMPDAT_ZERO_PERM;

        const static std::string SCHEDULE_ICD_MISSING_SEGMENT;

        const static std::string SCHEDULE_ICD_INCOMPATIBLE_PDROP_MODEL;

        // The SIMULATOR_KEYWORD_ categories are intended to define the
        // parser behaviour for when the parser itself recognises an input
        // keyword, but the simulator does not support the intended use of
        // that keyword.

        const static std::string SIMULATOR_KEYWORD_NOT_SUPPORTED;

        const static std::string SIMULATOR_KEYWORD_NOT_SUPPORTED_CRITICAL;

        const static std::string SIMULATOR_KEYWORD_ITEM_NOT_SUPPORTED;

        const static std::string SIMULATOR_KEYWORD_ITEM_NOT_SUPPORTED_CRITICAL;

    private:
        std::map<std::string, InputErrorAction> m_errorContexts{};

        std::set<std::string> ignore_keywords{};

        std::string m_input_skip_mode{"100"};

        void initDefault();

        void initEnv();

        void envUpdate(const std::string& envVariable, InputErrorAction action);

        void patternUpdate(const std::string& pattern, InputErrorAction action);
    };

} // namespace Opm

#endif // OPM_PARSE_CONTEXT_HPP