diagnosticTrap.h

Go to the documentation of this file.

//
// Copyright 2026 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_BASE_TF_DIAGNOSTIC_TRAP_H
#define PXR_BASE_TF_DIAGNOSTIC_TRAP_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/tf/api.h"
#include "pxr/base/tf/diagnosticContainer.h"
#include "pxr/base/tf/diagnosticTransport.h"
#include "pxr/base/tf/tryInvoke.h"
 
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TfDiagnosticTrap {
public:
    TfDiagnosticTrap(const TfDiagnosticTrap&) = delete;
    TfDiagnosticTrap& operator=(const TfDiagnosticTrap&) = delete;
 
    TF_API TfDiagnosticTrap();
 
    TF_API ~TfDiagnosticTrap();
 
    TF_API void Dismiss();
 
    TF_API void Clear();
 
    TF_API void ClearErrors();
 
    TF_API void ClearWarnings();
 
    TF_API void ClearStatuses();
    
    template <class Predicate>
    size_t EraseMatching(Predicate &&pred) {
        Tf_DiagnosticContainer result;
        size_t erased = 0;
        auto it = _container.GetIterator();
        while (it.Next([&](auto const &d) {
            if (auto r = TfTryInvoke<bool>(std::forward<Predicate>(pred), d)) {
                if (*r) {
                    ++erased;
                    return; // erase
                }
            }
            result.Append(d); // keep
        }));
        if (erased) {
            _container = std::move(result);
            _OnContentsChanged();
        }
        return erased;
    }
    
    TF_API bool IsClean() const;
 
    TF_API bool HasErrors() const;
 
    TF_API bool HasWarnings() const;
 
    TF_API bool HasStatuses() const;
 
    template <class Predicate>
    bool HasAnyMatching(Predicate &&pred) const {
        auto it = _container.GetIterator();
        while (auto r = it.Next(std::forward<Predicate>(pred))) {
            if (*r) {
                return true;
            }
        }
        return false;
    }
 
    template <class Predicate>
    bool HasAllMatching(Predicate &&pred) const {
        auto it = _container.GetIterator();
        while (auto r = it.Next(std::forward<Predicate>(pred))) {
            if (!*r) {
                return false;
            }
        }
        return true;
    }
    
    template <class Predicate>
    size_t CountMatching(Predicate &&pred) const {
        size_t count = 0;
        auto it = _container.GetIterator();
        while (auto r = it.Next(std::forward<Predicate>(pred))) {
            if (*r) {
                ++count;
            }
        }
        return count;
    }
    
    TF_API std::vector<TfError> const& GetErrors() const;
 
    TF_API std::vector<TfWarning> const& GetWarnings() const;
 
    TF_API std::vector<TfStatus> const& GetStatuses() const;
 
    template <class Fn>
    void ForEach(Fn &&fn) const {
        Tf_DiagnosticContainer copy(_container);
        auto it = copy.GetIterator();
        while (it.Next(std::forward<Fn>(fn))) {}
    }
    
    TF_API TfDiagnosticTransport Transport();
 
private:
    friend class TfDiagnosticMgr;
 
    TF_API void _OnContentsChanged() const;
 
    Tf_DiagnosticContainer _container;
    bool _active = false;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_TF_DIAGNOSTIC_TRAP_H