protocol.hpp

/*
Author: Nels Frazier
Copyright (C) 2025 Lynker
------------------------------------------------------------------------
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
------------------------------------------------------------------------
Version 0.3
Remove "supported" member variable and added is_supported() method to protocol interface
 
Version 0.2
Enumerate protocol error types and add ProtocolError exception class
Implement error handling via expected<T, ProtocolError> and error_or_warning
Removed model member and required model reference in run(), check_support(), and initialize()
Minor refactoring and style changes
 
Version 0.1
Virtual interface for BMI protocols
*/
 
#pragma once
 
#include "Bmi_Adapter.hpp"
#include "JSONProperty.hpp"
#include <nonstd/expected.hpp>
 
namespace models {
namespace bmi {
namespace protocols {
using nonstd::expected;
using nonstd::make_unexpected;
 
enum class Error {
    UNITIALIZED_MODEL,
    UNSUPPORTED_PROTOCOL,
    INTEGRATION_ERROR,
    PROTOCOL_ERROR,
    PROTOCOL_WARNING
};
 
class ProtocolError : public std::exception {
  public:
    ProtocolError() = delete;
 
    ProtocolError(Error err, const std::string& message = "")
        : err(std::move(err))
        , message(std::move(message)) {
    }
 
    ProtocolError(const ProtocolError& other)                = default;
    ProtocolError(ProtocolError&& other) noexcept            = default;
    ProtocolError& operator=(const ProtocolError& other)     = default;
    ProtocolError& operator=(ProtocolError&& other) noexcept = default;
    ~ProtocolError()                                         = default;
 
    auto to_string() const -> std::string {
        switch (err) {
        case Error::UNITIALIZED_MODEL:
            return "Error(Uninitialized Model)::" + message;
        case Error::UNSUPPORTED_PROTOCOL:
            return "Warning(Unsupported Protocol)::" + message;
        case Error::INTEGRATION_ERROR:
            return "Error(Integration)::" + message;
        case Error::PROTOCOL_ERROR:
            return "Error(Protocol)::" + message;
        case Error::PROTOCOL_WARNING:
            return "Warning(Protocol)::" + message;
        default:
            return "Unknown Error: " + message;
        }
    }
 
    auto error_code() const -> const Error& {
        return err;
    }
 
    auto get_message() const -> const std::string& {
        return message;
    }
 
    const char* what() const noexcept override {
        message = to_string();
        return message.c_str();
    }
 
  private:
    Error err;
    mutable std::string message;
};
 
struct Context {
    const int current_time_step;
    const int total_steps;
    const std::string& timestamp;
    const std::string& id;
};
 
using ModelPtr   = std::shared_ptr<models::bmi::Bmi_Adapter>;
using Properties = geojson::PropertyMap;
 
class NgenBmiProtocol {
  public:
    virtual ~NgenBmiProtocol() = default;
 
  protected:
    static auto error_or_warning(const ProtocolError& err) -> expected<void, ProtocolError> {
        // Log warnings, but throw errors
        switch (err.error_code()) {
        case Error::PROTOCOL_ERROR:
            throw err;
            break;
        case Error::INTEGRATION_ERROR:
        case Error::UNITIALIZED_MODEL:
        case Error::UNSUPPORTED_PROTOCOL:
        case Error::PROTOCOL_WARNING:
            std::cerr << err.to_string() << std::endl;
            return make_unexpected<ProtocolError>(ProtocolError(std::move(err)));
        default:
            throw err;
        }
        assert(false && "Unreachable code reached in error_or_warning");
    }
 
    nsel_NODISCARD virtual auto run(const ModelPtr& model, const Context& ctx) const
        -> expected<void, ProtocolError> = 0;
 
    nsel_NODISCARD virtual expected<void, ProtocolError> check_support(const ModelPtr& model) = 0;
 
    virtual auto initialize(const ModelPtr& model, const Properties& properties)
        -> expected<void, ProtocolError> = 0;
 
    virtual bool is_supported() const = 0;
 
    friend class NgenBmiProtocols;
};
 
} // namespace protocols
} // namespace bmi
} // namespace models