timeInterval.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_EF_TIME_INTERVAL_H
#define PXR_EXEC_EF_TIME_INTERVAL_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/ef/api.h"
#include "pxr/exec/ef/time.h"
 
#include "pxr/base/gf/interval.h"
#include "pxr/base/gf/multiInterval.h"
 
#include <initializer_list>
#include <iosfwd>
#include <string>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class EfTimeInterval
{
public:
 
    explicit EfTimeInterval(
        const GfMultiInterval &timeMultiInterval = GfMultiInterval(),
        bool defaultTime = false) :
        _timeMultiInterval(timeMultiInterval),
        _defaultTime(defaultTime)
    {}
 
    explicit EfTimeInterval(
        const GfInterval &timeInterval,
        bool defaultTime = false) :
        _timeMultiInterval(timeInterval),
        _defaultTime(defaultTime)
    {}
 
    explicit EfTimeInterval(
        const std::vector<double> &times,
        bool defaultTime = false) :
        _defaultTime(defaultTime)
    {
        for(double t : times)
            _timeMultiInterval.Add(GfInterval(t));
    }
 
    explicit EfTimeInterval(
        const std::initializer_list<double> &times,
        bool defaultTime = false) :
        _defaultTime(defaultTime)
    {
        for(double t : times)
            _timeMultiInterval.Add(GfInterval(t));
    }
 
    void Clear() { 
        _timeMultiInterval.Clear();
        _defaultTime = false;
    }
 
    bool IsEmpty() const {
        return !_defaultTime && _timeMultiInterval.IsEmpty();
    }
    
    const GfMultiInterval &GetTimeMultiInterval() const {
        return _timeMultiInterval;
    }
 
    bool IsDefaultTimeSet() const {
        return _defaultTime;
    }
 
    bool Contains(const EfTime &time) const {
        return time.GetTimeCode().IsDefault()
            ? _defaultTime
            : _ContainsTime(time);
    }
 
    bool Contains(const EfTimeInterval &rhs) const {
        if (!_defaultTime && rhs.IsDefaultTimeSet()) {
            return false;
        }
        return _timeMultiInterval.Contains(rhs.GetTimeMultiInterval());
    }
 
    bool IsFullInterval() const {
        return _defaultTime && 
            _timeMultiInterval == GfMultiInterval::GetFullInterval();
    }
 
    static EfTimeInterval GetFullInterval() {
        return EfTimeInterval(GfMultiInterval::GetFullInterval(), true);
    }
 
    bool operator==(const EfTimeInterval &rhs) const {
        return _timeMultiInterval == rhs._timeMultiInterval &&
            _defaultTime == rhs._defaultTime;
    }
 
    bool operator!=(const EfTimeInterval &rhs) const {
        return !(*this == rhs);
    }
 
    void operator|=(const EfTimeInterval &rhs) {
        _timeMultiInterval.Add(rhs._timeMultiInterval);
        _defaultTime |= rhs._defaultTime;
    }
 
    void operator|=(const GfInterval &interval) {
        _timeMultiInterval.Add(interval);
    }
    
    void operator|=(const EfTime &time)  {
        const UsdTimeCode timeCode = time.GetTimeCode();
        if (timeCode.IsDefault()) {
            _defaultTime = true;
        } else {
            _timeMultiInterval.Add(GfInterval(timeCode.GetValue()));
        }
    }
 
    void operator&=(const EfTimeInterval &rhs) {
        _timeMultiInterval.Intersect(rhs._timeMultiInterval);
        _defaultTime &= rhs._defaultTime;    
    }
 
    bool operator<(const EfTimeInterval &rhs) const {
        if (_timeMultiInterval < rhs._timeMultiInterval) return true;
        if (_timeMultiInterval != rhs._timeMultiInterval) return false;
        if (_defaultTime != rhs._defaultTime) return _defaultTime;
 
        // Equal
        return false;
    }
 
    EfTimeInterval &Extend(double leftFrames, double rightFrames) {
        const GfInterval extension( -leftFrames, +rightFrames, true, true);
            _timeMultiInterval.ArithmeticAdd(extension);
        return *this;
    }
    
    EF_API
    std::string GetAsString() const; 
 
private:
 
    // Returns true if this time is contained in _timeMultiInterval. If frame
    // is "default" this returns false.
    EF_API
    bool _ContainsTime(const EfTime &time) const;
 
    // The time multi interval.
    GfMultiInterval _timeMultiInterval;
 
    // Whether or not the default time is set.
    bool _defaultTime;
};
 
EF_API
std::ostream &operator<<(std::ostream &os, const EfTimeInterval &timeInterval);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif