namespaceEdit.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_SDF_NAMESPACE_EDIT_H
#define PXR_USD_SDF_NAMESPACE_EDIT_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/api.h"
#include "pxr/usd/sdf/path.h"
 
#include <functional>
#include <iosfwd>
#include <string>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct SdfNamespaceEdit {
public:
    typedef SdfNamespaceEdit This;
    typedef SdfPath Path;
    typedef int Index;
 
    static const Index AtEnd = -1;
 
    static const Index Same  = -2;
 
    SdfNamespaceEdit() : index(AtEnd) { }
 
    SdfNamespaceEdit(const Path& currentPath_, const Path& newPath_,
                     Index index_ = AtEnd) :
        currentPath(currentPath_), newPath(newPath_), index(index_) { }
 
    static This Remove(const Path& currentPath)
    {
        return This(currentPath, Path::EmptyPath());
    }
 
    static This Rename(const Path& currentPath, const TfToken& name)
    {
        return This(currentPath, currentPath.ReplaceName(name), Same);
    }
 
    static This Reorder(const Path& currentPath, Index index)
    {
        return This(currentPath, currentPath, index);
    }
 
    static This Reparent(const Path& currentPath,
                         const Path& newParentPath,
                         Index index)
    {
        return This(currentPath,
                    currentPath.ReplacePrefix(currentPath.GetParentPath(),
                                              newParentPath),
                    index);
    }
 
    static This ReparentAndRename(const Path& currentPath,
                                  const Path& newParentPath,
                                  const TfToken& name,
                                  Index index)
    {
        return This(currentPath,
                    currentPath.ReplacePrefix(currentPath.GetParentPath(),
                                              newParentPath).
                                ReplaceName(name),
                    index);
    }
 
    SDF_API bool operator==(const This& rhs) const;
    SDF_API bool operator!=(const This& rhs) const;
 
public:
    Path currentPath;   
    Path newPath;       
    Index index;        
};
 
typedef std::vector<SdfNamespaceEdit> SdfNamespaceEditVector;
 
SDF_API std::ostream& operator<<(std::ostream&, const SdfNamespaceEdit&);
SDF_API std::ostream& operator<<(std::ostream&, const SdfNamespaceEditVector&);
 
struct SdfNamespaceEditDetail {
public:
    enum Result {
        Error,          
        Unbatched,      
        Okay,           
    };
 
    SDF_API SdfNamespaceEditDetail();
    SDF_API SdfNamespaceEditDetail(Result, const SdfNamespaceEdit& edit,
                           const std::string& reason);
 
    SDF_API bool operator==(const SdfNamespaceEditDetail& rhs) const;
    SDF_API bool operator!=(const SdfNamespaceEditDetail& rhs) const;
 
public:
    Result result;          
    SdfNamespaceEdit edit;  
    std::string reason;     
};
 
typedef std::vector<SdfNamespaceEditDetail> SdfNamespaceEditDetailVector;
 
SDF_API std::ostream& operator<<(std::ostream&, const SdfNamespaceEditDetail&);
SDF_API std::ostream& operator<<(std::ostream&, const SdfNamespaceEditDetailVector&);
 
inline
SdfNamespaceEditDetail::Result
CombineResult(
    SdfNamespaceEditDetail::Result lhs,
    SdfNamespaceEditDetail::Result rhs)
{
    return lhs < rhs ? lhs : rhs;
}
 
inline
SdfNamespaceEditDetail::Result
CombineError(SdfNamespaceEditDetail::Result)
{
    return SdfNamespaceEditDetail::Error;
}
 
inline
SdfNamespaceEditDetail::Result
CombineUnbatched(SdfNamespaceEditDetail::Result other)
{
    return CombineResult(other, SdfNamespaceEditDetail::Unbatched);
}
 
class SdfBatchNamespaceEdit {
public:
    SDF_API SdfBatchNamespaceEdit();
    SDF_API SdfBatchNamespaceEdit(const SdfBatchNamespaceEdit&);
    SDF_API SdfBatchNamespaceEdit(const SdfNamespaceEditVector&);
    SDF_API ~SdfBatchNamespaceEdit();
 
    SDF_API SdfBatchNamespaceEdit& operator=(const SdfBatchNamespaceEdit&);
 
    void Add(const SdfNamespaceEdit& edit)
    {
        _edits.push_back(edit);
    }
 
    void Add(const SdfNamespaceEdit::Path& currentPath,
             const SdfNamespaceEdit::Path& newPath,
             SdfNamespaceEdit::Index index = SdfNamespaceEdit::AtEnd)
    {
        Add(SdfNamespaceEdit(currentPath, newPath, index));
    }
 
    const SdfNamespaceEditVector& GetEdits() const
    {
        return _edits;
    }
 
    typedef std::function<bool(const SdfPath&)> HasObjectAtPath;
 
    typedef std::function<bool(const SdfNamespaceEdit&,std::string*)> CanEdit;
 
    SDF_API
    bool Process(SdfNamespaceEditVector* processedEdits,
                 const HasObjectAtPath& hasObjectAtPath,
                 const CanEdit& canEdit,
                 SdfNamespaceEditDetailVector* details = NULL,
                 bool fixBackpointers = true) const;
 
private:
    SdfNamespaceEditVector _edits;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDF_NAMESPACE_EDIT_H