declare.h

Go to the documentation of this file.

//
// Copyright 2018 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_SDR_DECLARE_H
#define PXR_USD_SDR_DECLARE_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/sdr/api.h"
#include "pxr/base/tf/token.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class SdrShaderNode;
class SdrShaderProperty;
class SdfValueTypeName;
 
 
typedef TfToken SdrIdentifier;
typedef TfToken::HashFunctor SdrIdentifierHashFunctor;
inline const std::string&
SdrGetIdentifierString(const SdrIdentifier& id) { return id.GetString(); }
typedef std::vector<SdrIdentifier> SdrIdentifierVec;
typedef std::unordered_set<SdrIdentifier,
                           SdrIdentifierHashFunctor> SdrIdentifierSet;
 
// Token
typedef std::vector<TfToken> SdrTokenVec;
typedef std::unordered_map<TfToken, std::string,
                           TfToken::HashFunctor> SdrTokenMap;
 
// ShaderNode
typedef SdrShaderNode* SdrShaderNodePtr;
typedef SdrShaderNode const* SdrShaderNodeConstPtr;
typedef std::unique_ptr<SdrShaderNode> SdrShaderNodeUniquePtr;
typedef std::vector<SdrShaderNodeConstPtr> SdrShaderNodeConstPtrVec;
typedef SdrShaderNodeConstPtrVec SdrShaderNodePtrVec;
typedef std::vector<SdrShaderNodeUniquePtr> SdrShaderNodeUniquePtrVec;
 
// ShaderProperty
typedef SdrShaderProperty* SdrShaderPropertyPtr;
typedef SdrShaderProperty const* SdrShaderPropertyConstPtr;
typedef std::unique_ptr<SdrShaderProperty> SdrShaderPropertyUniquePtr;
typedef std::vector<SdrShaderPropertyUniquePtr> SdrShaderPropertyUniquePtrVec;
typedef std::unordered_map<TfToken, SdrShaderPropertyConstPtr,
                           TfToken::HashFunctor> SdrShaderPropertyMap;
typedef SdrShaderPropertyMap SdrPropertyMap;
 
// Misc
typedef std::vector<std::string> SdrStringVec;
typedef std::pair<TfToken, TfToken> SdrOption;
typedef std::vector<SdrOption> SdrOptionVec;
typedef std::unordered_set<std::string> SdrStringSet;
 
class SdrVersion {
public:
    SDR_API
    SdrVersion() = default;
    SDR_API
    SdrVersion(int major, int minor = 0);
    SDR_API
    SdrVersion(const std::string& x);
 
    SDR_API
    SdrVersion GetAsDefault() const
    {
        return SdrVersion(*this, true);
    }
 
    SDR_API
    int GetMajor() const { return _major; }
    SDR_API
    int GetMinor() const { return _minor; }
    SDR_API
    bool IsDefault() const { return _isDefault; }
 
    SDR_API
    std::string GetString() const;
 
    SDR_API
    std::string GetStringSuffix() const;
 
    SDR_API
    std::size_t GetHash() const
    {
        return (static_cast<std::size_t>(_major) << 32) +
                static_cast<std::size_t>(_minor);
    }
 
    SDR_API
    explicit operator bool() const
    {
        return !!*this;
    }
 
    SDR_API
    bool operator!() const
    {
        return _major == 0 && _minor == 0;
    }
 
    SDR_API
    friend bool operator==(const SdrVersion& lhs, const SdrVersion& rhs)
    {
        return lhs._major == rhs._major && lhs._minor == rhs._minor;
    }
 
    SDR_API
    friend bool operator!=(const SdrVersion& lhs, const SdrVersion& rhs)
    {
        return !(lhs == rhs);
    }
 
    SDR_API
    friend bool operator<(const SdrVersion& lhs, const SdrVersion& rhs)
    {
        return lhs._major < rhs._major ||
               (lhs._major == rhs._major && lhs._minor < rhs._minor);
    }
 
    SDR_API
    friend bool operator<=(const SdrVersion& lhs, const SdrVersion& rhs)
    {
        return lhs._major < rhs._major ||
               (lhs._major == rhs._major && lhs._minor <= rhs._minor);
    }
 
    SDR_API
    friend bool operator>(const SdrVersion& lhs, const SdrVersion& rhs)
    {
        return !(lhs <= rhs);
    }
 
    SDR_API
    friend bool operator>=(const SdrVersion& lhs, const SdrVersion& rhs)
    {
        return !(lhs < rhs);
    }
 
private:
    SdrVersion(const SdrVersion& x, bool)
        : _major(x._major), _minor(x._minor), _isDefault(true) { }
 
private:
    int _major = 0, _minor = 0;
    bool _isDefault = false;
};
 
enum SdrVersionFilter {
    SdrVersionFilterDefaultOnly,
    SdrVersionFilterAllVersions,
    SdrNumVersionFilters
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDR_DECLARE_H