cpl_error_internal.h

/**********************************************************************
 *
 * Name:     cpl_error_internal.h
 * Project:  CPL - Common Portability Library
 * Purpose:  CPL Error handling
 * Author:   Even Rouault, <even.rouault at spatialys.com>
 *
 **********************************************************************
 * Copyright (c) 2019, Even Rouault, <even.rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef CPL_ERROR_INTERNAL_H_INCLUDED
#define CPL_ERROR_INTERNAL_H_INCLUDED
 
#if defined(GDAL_COMPILATION) || defined(DOXYGEN_SKIP)
// internal only
 
#include "cpl_error.h"
#include "cpl_string.h"
 
#include <mutex>
#include <vector>
 
/************************************************************************/
/*                   CPLErrorHandlerAccumulatorStruct                   */
/************************************************************************/
 
class CPL_DLL CPLErrorHandlerAccumulatorStruct
{
  public:
    CPLErr type;
 
    CPLErrorNum no;
 
    CPLString msg{};
 
    CPLErrorHandlerAccumulatorStruct() : type(CE_None), no(CPLE_None)
    {
    }
 
    CPLErrorHandlerAccumulatorStruct(CPLErr eErrIn, CPLErrorNum noIn,
                                     const char *msgIn)
        : type(eErrIn), no(noIn), msg(msgIn)
    {
    }
};
 
/************************************************************************/
/*                         CPLErrorAccumulator                          */
/************************************************************************/
 
class CPL_DLL CPLErrorAccumulator
{
  public:
    CPLErrorAccumulator() = default;
 
    struct CPL_DLL Context
    {
        ~Context();
 
        Context(const Context &) = delete;
        Context &operator=(const Context &) = delete;
        Context(Context &&) = delete;
        Context &operator=(Context &&) = delete;
 
      private:
        friend class CPLErrorAccumulator;
        explicit Context(CPLErrorAccumulator &sAccumulator);
    };
 
    Context InstallForCurrentScope() CPL_WARN_UNUSED_RESULT;
 
    const std::vector<CPLErrorHandlerAccumulatorStruct> &GetErrors() const
    {
        return errors;
    }
 
    void ReplayErrors();
 
  private:
    std::mutex mutex{};
    std::vector<CPLErrorHandlerAccumulatorStruct> errors{};
 
    static void CPL_STDCALL Accumulator(CPLErr eErr, CPLErrorNum no,
                                        const char *msg);
};
 
#endif
 
#endif  // CPL_ERROR_INTERNAL_H_INCLUDED