rmqt_result.h

// Copyright 2020-2023 Bloomberg Finance L.P.
// SPDX-License-Identifier: Apache-2.0
//
// 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.
 
// rmqt_result.h
#ifndef INCLUDED_RMQT_RESULT
#define INCLUDED_RMQT_RESULT
 
#include <bsl_functional.h>
#include <bsl_memory.h>
#include <bsl_ostream.h>
#include <bsl_string.h>
 
namespace BloombergLP {
namespace rmqt {
 
typedef enum { TIMEOUT = 408 } ReturnCodes;
 
 
template <typename T = void>
class Result {
  private:
    typedef void (Result::*BoolType)() const;
    void thisTypeDoesNotSupportComparisons() const {}
 
  public:
    // CREATORS
    explicit Result(const bsl::string& error, int resultCode = -1)
    : d_value()
    , d_error(error)
    , d_resultCode(resultCode)
    {
    }
 
    explicit Result(const bsl::shared_ptr<T>& value,
                    const bsl::string& error = bsl::string(),
                    int resultCode           = 0)
    : d_value(value)
    , d_error(error)
    , d_resultCode(resultCode)
    {
    }
 
    const bsl::shared_ptr<T>& value() const { return d_value; }
 
    const bsl::string& error() const { return d_error; }
 
    int returnCode() const { return d_resultCode; }
 
    operator BoolType() const
    {
        return d_resultCode == 0 ? &Result::thisTypeDoesNotSupportComparisons
                                 : 0;
    }
 
    bsl::ostream& operator<<(bsl::ostream& os)
    {
        os << "VALUE: " << (d_value ? d_value : "null") << "\n";
        if (!*this) {
            os << "ERROR: " << error();
        }
        return os;
    }
 
  private:
    bsl::shared_ptr<T> d_value;
    bsl::string d_error;
 
    int d_resultCode;
 
}; // class Result
 
template <>
class Result<void> {
  private:
    typedef void (Result::*BoolType)() const;
    void thisTypeDoesNotSupportComparisons() const {}
 
  public:
    Result()
    : d_error()
    , d_resultCode(0)
    {
    }
 
    explicit Result(const bsl::string& error, int resultCode = -1)
    : d_error(error)
    , d_resultCode(resultCode)
    {
    }
 
    const bsl::string& error() const { return d_error; }
    int returnCode() const { return d_resultCode; }
 
    operator BoolType() const
    {
        return d_resultCode == 0 ? &Result::thisTypeDoesNotSupportComparisons
                                 : 0;
    }
 
    bsl::ostream& operator<<(bsl::ostream& os) const
    {
        if (!*this) {
            os << "ERROR: " << error();
        }
        return os;
    }
 
  private:
    bsl::string d_error;
    int d_resultCode;
};
 
template <typename T, typename U>
bool operator!=(const Result<T>& lhs, const U&)
{
    lhs.thisTypeDoesNotSupportComparisons();
    return false;
}
 
template <typename T, typename U>
bool operator==(const Result<T>& lhs, const U&)
{
    lhs.typeTypeDoesNotSupportComparisons();
    return false;
}
 
typedef bsl::function<void(const bsl::string& errorText, int errorCode)>
    ErrorCallback;
 
} // namespace rmqt
} // namespace BloombergLP
 
#endif // ! INCLUDED_RMQT_RESULT