errorMark.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_TF_ERROR_MARK_H
#define PXR_BASE_TF_ERROR_MARK_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/tf/diagnosticMgr.h"
#include "pxr/base/tf/errorTransport.h"
#include "pxr/base/tf/api.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TfErrorMark
{
    TfErrorMark(const TfErrorMark&) = delete;
    TfErrorMark& operator=(const TfErrorMark&) = delete;
  public:
 
    typedef TfDiagnosticMgr::ErrorIterator Iterator;
    
    TF_API TfErrorMark();
 
    TF_API ~TfErrorMark();
 
    inline void SetMark() {
        _mark = TfDiagnosticMgr::GetInstance()._nextSerial;
    }
 
    inline bool IsClean() const {
        TfDiagnosticMgr &mgr = TfDiagnosticMgr::GetInstance();
        return _mark >= mgr._nextSerial || _IsCleanImpl(mgr);
    }
 
    inline bool Clear() const {
        TfDiagnosticMgr &mgr = TfDiagnosticMgr::GetInstance();
        auto b = GetBegin(), e = mgr.GetErrorEnd();
        if (b != e) {
            mgr.EraseRange(b, e);
            return true;
        }
        return false;
    }
 
    inline TfErrorTransport Transport() const {
        TfDiagnosticMgr &mgr = TfDiagnosticMgr::GetInstance();
        return TfErrorTransport(mgr._errorList.local(),
                                GetBegin(), mgr.GetErrorEnd());
    }
 
    inline void TransportTo(TfErrorTransport &dest) const {
        Transport().swap(dest);
    }
 
    Iterator GetBegin(size_t *nErrors = 0) const {
        return
            TfDiagnosticMgr::GetInstance()._GetErrorMarkBegin(_mark, nErrors);
    }
 
    Iterator GetEnd() const {
        return TfDiagnosticMgr::GetInstance().GetErrorEnd();
    }
 
    Iterator begin() const { return GetBegin(); }
 
    Iterator end() const { return GetEnd(); }
    
  private:
    friend class TfDiagnosticMgr;
 
    // Helper to check if the _mark identifies any errors present on the
    // thread-local error list.
    TF_API bool _IsCleanImpl(TfDiagnosticMgr &mgr) const;
 
    void _ReportErrors(TfDiagnosticMgr &mgr) const;
 
    size_t _mark;
};
 
 
#define TF_HAS_ERRORS(marker, expr) \
        (marker.SetMark(), (expr), !marker.IsClean())
 
TF_API
void TfReportActiveErrorMarks();
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_TF_ERROR_MARK_H