stageLoadRules.h

Go to the documentation of this file.

//
// Copyright 2019 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_USD_STAGE_LOAD_RULES_H
#define PXR_USD_USD_STAGE_LOAD_RULES_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/usd/api.h"
#include "pxr/usd/usd/common.h"
#include "pxr/usd/sdf/path.h"
 
#include <iosfwd>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdStageLoadRules
{
public:
    enum Rule {
        AllRule,  
        OnlyRule, 
        NoneRule  
    };
 
    UsdStageLoadRules() = default;
 
    static inline UsdStageLoadRules LoadAll() {
        return UsdStageLoadRules();
    }
 
    USD_API
    static UsdStageLoadRules LoadNone();
 
    UsdStageLoadRules(UsdStageLoadRules const &) = default;
    UsdStageLoadRules(UsdStageLoadRules &&) = default;
    UsdStageLoadRules &operator=(UsdStageLoadRules const &) = default;
    UsdStageLoadRules &operator=(UsdStageLoadRules &&) = default;
 
    USD_API
    void LoadWithDescendants(SdfPath const &path);
 
    USD_API
    void LoadWithoutDescendants(SdfPath const &path);
    
    USD_API
    void Unload(SdfPath const &path);
 
    USD_API
    void LoadAndUnload(const SdfPathSet &loadSet,
                       const SdfPathSet &unloadSet, UsdLoadPolicy policy);
 
    USD_API
    void AddRule(SdfPath const &path, Rule rule);
 
    USD_API
    void SetRules(std::vector<std::pair<SdfPath, Rule>> const &rules);
 
    inline void SetRules(std::vector<std::pair<SdfPath, Rule>> &&rules) {
        _rules = std::move(rules);
    }
 
    USD_API
    void Minimize();
 
    USD_API
    bool IsLoaded(SdfPath const &path) const;
 
    USD_API
    bool IsLoadedWithAllDescendants(SdfPath const &path) const;
 
    USD_API
    bool IsLoadedWithNoDescendants(SdfPath const &path) const;
 
    USD_API
    Rule GetEffectiveRuleForPath(SdfPath const &path) const;
 
    inline std::vector<std::pair<SdfPath, Rule>> const &GetRules() const {
        return _rules;
    }
 
    USD_API
    bool operator==(UsdStageLoadRules const &other) const;
 
    inline bool operator!=(UsdStageLoadRules const &other) const {
        return !(*this == other);
    }
 
    inline void swap(UsdStageLoadRules &other) {
        _rules.swap(other._rules);
    }
 
private:
    friend USD_API std::ostream &
    operator<<(std::ostream &, std::pair<SdfPath, Rule> const &);
    
    friend USD_API std::ostream &
    operator<<(std::ostream &, UsdStageLoadRules const &);
 
    friend USD_API
    size_t hash_value(UsdStageLoadRules const &);
 
    USD_API
    std::vector<std::pair<SdfPath, Rule> >::const_iterator
    _LowerBound(SdfPath const &path) const;
 
    USD_API
    std::vector<std::pair<SdfPath, Rule> >::iterator
    _LowerBound(SdfPath const &path);
 
    std::vector<std::pair<SdfPath, Rule>> _rules;
 
};
 
inline void swap(UsdStageLoadRules &l, UsdStageLoadRules &r)
{
    l.swap(r);
}
 
USD_API
std::ostream &operator<<(std::ostream &, UsdStageLoadRules const &);
 
USD_API
std::ostream &operator<<(std::ostream &,
                         std::pair<SdfPath, UsdStageLoadRules::Rule> const &);
 
USD_API
size_t hash_value(UsdStageLoadRules const &);
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_USD_STAGE_LOAD_RULES_H