StrokeIterators.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "Stroke.h"
 
namespace Freestyle {
 
namespace StrokeInternal {
 
//
// StrokeVertexIterator
//
 
class StrokeVertexIterator : public Interface0DIteratorNested {
 public:
  StrokeVertexIterator() {}
 
  StrokeVertexIterator(const StrokeVertexIterator &vi)
  {
    _it = vi._it;
    _begin = vi._begin;
    _end = vi._end;
  }
 
  StrokeVertexIterator(const Stroke::vertex_container::iterator &it,
                       const Stroke::vertex_container::iterator &begin,
                       const Stroke::vertex_container::iterator &end)
  {
    _it = it;
    _begin = begin;
    _end = end;
  }
 
  virtual ~StrokeVertexIterator() {}
 
  inline Interface0DIterator castToInterface0DIterator() const
  {
    Interface0DIterator ret(new StrokeVertexIterator(*this));
    return ret;
  }
 
  StrokeVertexIterator &operator=(const StrokeVertexIterator &vi)
  {
    _it = vi._it;
    _begin = vi._begin;
    _end = vi._end;
    return *this;
  }
 
  virtual string getExactTypeName() const
  {
    return "StrokeVertexIterator";
  }
 
  virtual StrokeVertex &operator*()
  {
    return **_it;
  }
 
  virtual StrokeVertex *operator->()
  {
    return &(operator*());
  }
 
  virtual StrokeVertexIterator &operator++()
  {
    increment();
    return *this;
  }
 
  virtual StrokeVertexIterator operator++(int)
  {
    StrokeVertexIterator ret(*this);
    increment();
    return ret;
  }
 
  virtual StrokeVertexIterator &operator--()
  {
    decrement();
    return *this;
  }
 
  virtual StrokeVertexIterator operator--(int)
  {
    StrokeVertexIterator ret(*this);
    decrement();
    return ret;
  }
 
  virtual int increment()
  {
    ++_it;
    return 0;
  }
 
  virtual int decrement()
  {
    --_it;
    return 0;
  }
 
  bool isBegin() const
  {
    return _it == _begin;
  }
 
  bool atLast()
  {
    if (_it == _end) {
      return false;
    }
 
    ++_it;
    bool result = (_it == _end);
    --_it;
    return result;
  }
 
  bool isEnd() const
  {
    return _it == _end;
  }
 
  virtual bool operator==(const Interface0DIteratorNested &it) const
  {
    const StrokeVertexIterator *it_exact = dynamic_cast<const StrokeVertexIterator *>(&it);
    if (!it_exact) {
      return false;
    }
    return (_it == it_exact->_it);
  }
 
  virtual float t() const
  {
    return (*_it)->curvilinearAbscissa();
  }
 
  virtual float u() const
  {
    return (*_it)->u();
  }
 
  virtual StrokeVertexIterator *copy() const
  {
    return new StrokeVertexIterator(*this);
  }
 
  //
  // Not exported in Python
  //
  const Stroke::vertex_container::iterator &getIt()
  {
    return _it;
  }
 
 private:
  Stroke::vertex_container::iterator _it;
  Stroke::vertex_container::iterator _begin;
  Stroke::vertex_container::iterator _end;
};
 
}  // end of namespace StrokeInternal
 
} /* namespace Freestyle */