notice.h

//
// 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_USD_SDF_NOTICE_H
#define PXR_USD_SDF_NOTICE_H

#include "pxr/pxr.h"
#include "pxr/usd/sdf/api.h"
#include "pxr/usd/sdf/changeList.h"
#include "pxr/usd/sdf/declareHandles.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/base/tf/notice.h"

PXR_NAMESPACE_OPEN_SCOPE

SDF_DECLARE_HANDLES(SdfLayer);

class SdfNotice {
public:
    class Base : public TfNotice {
    public:
        SDF_API ~Base();
    };

    class BaseLayersDidChange {
    public:
        BaseLayersDidChange(const SdfLayerChangeListVec &changeVec,
                            size_t serialNumber)
            : _vec(&changeVec)
            , _serialNumber(serialNumber)
            {}

        using const_iterator = SdfLayerChangeListVec::const_iterator;
        using iterator = const_iterator;

        SDF_API
        SdfLayerHandleVector GetLayers() const;

        const SdfLayerChangeListVec &GetChangeListVec() const { return *_vec; }

        const_iterator begin() const { return _vec->begin(); }
        const_iterator cbegin() const { return _vec->cbegin(); }
        const_iterator end() const { return _vec->end(); } 
        const_iterator cend() const { return _vec->cend(); }

        const_iterator find(SdfLayerHandle const &layer) const {
            return std::find_if(
                begin(), end(),
                [&layer](SdfLayerChangeListVec::value_type const &p) {
                    return p.first == layer;
                });
        }
       
        bool count(SdfLayerHandle const &layer) const {
            return find(layer) != end();
        }

        size_t GetSerialNumber() const { return _serialNumber; }

    private:
        const SdfLayerChangeListVec *_vec;
        const size_t _serialNumber;
    };

    class LayersDidChangeSentPerLayer 
        : public Base, public BaseLayersDidChange {
    public:
        LayersDidChangeSentPerLayer(const SdfLayerChangeListVec &changeVec,
                                    size_t serialNumber)
            : BaseLayersDidChange(changeVec, serialNumber) {}
        SDF_API virtual ~LayersDidChangeSentPerLayer();
    };

    class LayersDidChange
        : public Base, public BaseLayersDidChange {
    public:
        LayersDidChange(const SdfLayerChangeListVec &changeVec,
                        size_t serialNumber)
            : BaseLayersDidChange(changeVec, serialNumber) {}
        SDF_API virtual ~LayersDidChange();
    };

    class LayerInfoDidChange : public Base {
    public:
        LayerInfoDidChange( const TfToken &key ) :
            _key(key) {}
        SDF_API ~LayerInfoDidChange();

        const TfToken & key() const { return _key; }
    private:
        TfToken _key;
    };

    class LayerIdentifierDidChange : public Base {
    public:
        SDF_API
        LayerIdentifierDidChange(const std::string& oldIdentifier,
                                 const std::string& newIdentifier);
        SDF_API
        ~LayerIdentifierDidChange();

        const std::string& GetOldIdentifier() const { return _oldId; }

        const std::string& GetNewIdentifier() const { return _newId; }

    private:
        std::string _oldId;
        std::string _newId;
    };
    
    class LayerDidReplaceContent : public Base {
    public:
        SDF_API ~LayerDidReplaceContent();
    };

    class LayerDidReloadContent : public LayerDidReplaceContent {
    public:
        SDF_API virtual ~LayerDidReloadContent();
    };
    
    class LayerDidSaveLayerToFile : public Base {
    public:
        SDF_API ~LayerDidSaveLayerToFile();
    };

    class LayerDirtinessChanged : public Base {
    public:
        SDF_API ~LayerDirtinessChanged();
    };

    class LayerMutenessChanged : public Base {
    public:
        LayerMutenessChanged(const std::string& layerPath, bool wasMuted)
            : _layerPath(layerPath)
            , _wasMuted(wasMuted)
        { }

        SDF_API ~LayerMutenessChanged();

        const std::string& GetLayerPath() const { return _layerPath; }

        bool WasMuted() const { return _wasMuted; }

    private:
        std::string _layerPath;
        bool _wasMuted;
    };
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_SDF_NOTICE_H