ShapeList.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef BOARD_SHAPELIST_H
#define BOARD_SHAPELIST_H
 
#include <board/Exception.h>
#include <board/Shape.h>
#include <board/Tools.h>
#include <queue>
#include <stack>
#include <typeinfo>
#include <vector>
 
namespace LibBoard
{
 
struct Group;
 
struct ShapeList : public Shape {
 
  typedef std::vector<Shape *>::size_type size_type;
 
  inline ShapeList();
 
  ShapeList(const ShapeList & other);
 
  ShapeList & operator=(const ShapeList & other);
 
  ShapeList(ShapeList && other);
 
  ShapeList & operator=(ShapeList && other);
 
  ShapeList(const Shape & shape, unsigned int times, double dx, double dy, double scale);
 
  ShapeList(const Shape & shape, unsigned int times, double dx, double dy, double scaleX, double scaleY, double angle);
 
  template <typename S> ShapeList(const std::vector<S> & shapes);
 
  ~ShapeList() override;
 
  const std::string & name() const override;
 
  ShapeList & clear();
 
  ShapeList & rotate(double angle, const Point & center) override;
 
  ShapeList rotated(double angle, const Point & center);
 
  ShapeList & rotate(double angle) override;
 
  ShapeList rotated(double angle);
 
  ShapeList & translate(double dx, double dy) override;
 
  ShapeList translated(double dx, double dy);
 
  ShapeList & scale(double sx, double sy) override;
 
  ShapeList & scale(double s) override;
 
  ShapeList scaled(double sx, double sy) const;
 
  ShapeList scaled(double s) const;
 
  void scaleAll(double s) override;
 
  void flushPostscript(std::ostream & stream, const TransformEPS & transform) const override;
 
  void flushFIG(std::ostream & stream, const TransformFIG & transform, std::map<Color, int> & colormap) const override;
 
  void flushSVG(std::ostream & stream, const TransformSVG & transform) const override;
 
  void flushTikZ(std::ostream & stream, const TransformTikZ & transform) const override;
 
  Rect boundingBox(LineWidthFlag) const override;
 
  ShapeList * clone() const override;
 
  ShapeList & push_back(Shape * shape);
 
  ShapeList & operator<<(const Shape & shape);
 
  template <typename S> //
  ShapeList & operator<<(const std::vector<S> & shapes);
 
  ShapeList & operator+=(const Shape & shape);
 
  ShapeList & append(const Shape & shape, Direction direction = Direction::Right, Alignment alignment = Alignment::Center, double margin = 0.0, LineWidthFlag lineWidthFlag = UseLineWidth);
 
  void addRepeated(const Shape & shape, unsigned int times, double dx, double dy, double scaleX = 1.0, double scaleY = 1.0, double angle = 0.0);
 
  ShapeList & duplicateLast(std::size_t copies = 1);
 
  template <typename T> T & last(const std::size_t position = 0);
 
  Shape & last(const std::size_t position = 0);
 
  template <typename T> T & topLevelFindLast(std::size_t position = 0);
 
  Shape & top();
 
  void accept(ShapeVisitor & visitor) override;
 
  void accept(const ShapeVisitor & visitor) override;
 
  void accept(ConstShapeVisitor & visitor) const override;
 
  void accept(const ConstShapeVisitor & visitor) const override;
 
  Shape * accept(CompositeShapeTransform & transform) const override;
 
  Shape * accept(const CompositeShapeTransform & transform) const override;
 
  struct TopLevelIterator {
    inline TopLevelIterator(std::vector<Shape *>::iterator it);
    inline Shape & operator*();
    inline Shape * operator->();
    inline Shape * pointer();
    inline TopLevelIterator & operator++();
    inline TopLevelIterator operator++(int);
    inline bool operator==(const TopLevelIterator & other);
    inline bool operator!=(const TopLevelIterator & other);
 
  private:
    std::vector<Shape *>::iterator _it;
  };
 
  struct TopLevelConstIterator {
    inline TopLevelConstIterator(std::vector<Shape *>::const_iterator it);
    inline const Shape & operator*();
    inline const Shape * operator->();
    inline const Shape * pointer();
    inline TopLevelConstIterator & operator++();
    inline TopLevelConstIterator operator++(int);
    inline bool operator==(const TopLevelConstIterator & other);
    inline bool operator!=(const TopLevelConstIterator & other);
 
  private:
    std::vector<Shape *>::const_iterator _it;
  };
 
  struct DepthFirstIterator {
    inline DepthFirstIterator();
    inline DepthFirstIterator(ShapeList * list);
    inline Shape & operator*();
    inline Shape * operator->();
    inline Shape * pointer();
    inline bool operator==(const DepthFirstIterator & other);
    inline bool operator!=(const DepthFirstIterator & other);
    inline DepthFirstIterator & operator++();
    inline DepthFirstIterator operator++(int);
 
  private:
    void moveToFirstActuelShape();
    void moveToNextActualShape();
    std::stack<ShapeList *> _shapeListsStack;
    std::stack<TopLevelIterator> _iteratorsStack;
  };
 
  struct BreadthFirstIterator {
    inline BreadthFirstIterator();
    inline BreadthFirstIterator(ShapeList * list);
    inline Shape & operator*();
    inline Shape * operator->();
    inline Shape * pointer();
    inline bool operator==(const BreadthFirstIterator & other);
    inline bool operator!=(const BreadthFirstIterator & other);
    inline BreadthFirstIterator & operator++();
    inline BreadthFirstIterator operator++(int);
 
  private:
    void moveToFirstActuelShape();
    void moveToNextActualShape();
    std::queue<ShapeList *> _shapeListsQueue;
    std::queue<TopLevelIterator> _iteratorsQueue;
  };
 
  inline TopLevelIterator begin();
 
  inline TopLevelIterator end();
 
  inline TopLevelConstIterator begin() const;
 
  inline TopLevelConstIterator cbegin() const;
 
  inline TopLevelConstIterator end() const;
 
  inline TopLevelConstIterator cend() const;
 
  inline DepthFirstIterator depthFirstBegin();
 
  inline DepthFirstIterator depthFirstEnd();
 
  inline BreadthFirstIterator breadthFirstBegin();
 
  inline BreadthFirstIterator breadthFirstEnd();
 
  std::size_t deepSize() const;
 
  inline std::size_t size() const;
 
private:
  static const std::string _name; 
protected:
  void addShape(const Shape & shape, double scaleFactor);
 
  std::vector<Shape *> _shapes; 
  void deleteShapes();
};
 
// Inline methods and functions
 
#if defined(max)
#undef max
#define HAS_MSVC_MAX true
#endif
 
ShapeList::ShapeList() {}
 
template <typename T> T & ShapeList::last(const std::size_t position)
{
  if (position < _shapes.size()) {
    std::vector<Shape *>::reverse_iterator it = _shapes.rbegin() + static_cast<std::vector<Shape *>::difference_type>(position);
    Shape * pshape = *it;
    T * result = dynamic_cast<T *>(pshape);
    if (!result) {
      std::cerr << "Error: ShapeList::last<> called with invalid result type\n";
      exit(-1);
    }
    return dynamic_cast<T &>(*result);
  } else {
    Tools::error << "Trying to access an element that does not exist (" << position << "/" << _shapes.size() << ").\n";
    throw -1;
  }
}
 
template <typename T> T & ShapeList::topLevelFindLast(std::size_t position)
{
  std::vector<Shape *>::reverse_iterator it = _shapes.rbegin();
  while (it != _shapes.rend()) {
    T * shape = dynamic_cast<T *>(*it);
    if (shape) {
      if (!position) {
        return *shape;
      } else {
        --position;
      }
    }
    ++it;
  }
  throw Exception("topLevelFindLast<T>(): no such shape type found (" + std::string(typeid(T).name()) + ")");
}
 
ShapeList::TopLevelIterator::TopLevelIterator(std::vector<Shape *>::iterator it) : _it(it) {}
 
Shape & ShapeList::TopLevelIterator::operator*()
{
  return **_it;
}
 
Shape * ShapeList::TopLevelIterator::operator->()
{
  return *_it;
}
 
Shape * ShapeList::TopLevelIterator::pointer()
{
  return *_it;
}
 
ShapeList::TopLevelIterator & ShapeList::TopLevelIterator::operator++()
{
  ++_it;
  return *this;
}
 
ShapeList::TopLevelIterator ShapeList::TopLevelIterator::operator++(int)
{
  TopLevelIterator previous(*this);
  ++_it;
  return previous;
}
 
bool ShapeList::TopLevelIterator::operator==(const TopLevelIterator & other)
{
  return _it == other._it;
}
 
bool ShapeList::TopLevelIterator::operator!=(const TopLevelIterator & other)
{
  return _it != other._it;
}
 
ShapeList::TopLevelConstIterator::TopLevelConstIterator(std::vector<Shape *>::const_iterator it) : _it(it) {}
 
const Shape & ShapeList::TopLevelConstIterator::operator*()
{
  return **_it;
}
 
const Shape * ShapeList::TopLevelConstIterator::operator->()
{
  return *_it;
}
 
const Shape * ShapeList::TopLevelConstIterator::pointer()
{
  return *_it;
}
 
ShapeList::TopLevelConstIterator & ShapeList::TopLevelConstIterator::operator++()
{
  ++_it;
  return *this;
}
 
ShapeList::TopLevelConstIterator ShapeList::TopLevelConstIterator::operator++(int)
{
  TopLevelConstIterator previous(*this);
  ++_it;
  return previous;
}
 
bool ShapeList::TopLevelConstIterator::operator==(const TopLevelConstIterator & other)
{
  return _it == other._it;
}
 
bool ShapeList::TopLevelConstIterator::operator!=(const TopLevelConstIterator & other)
{
  return _it != other._it;
}
 
ShapeList::TopLevelIterator ShapeList::begin()
{
  return TopLevelIterator(_shapes.begin());
}
 
ShapeList::TopLevelIterator ShapeList::end()
{
  return TopLevelIterator(_shapes.end());
}
 
ShapeList::TopLevelConstIterator ShapeList::begin() const
{
  return TopLevelConstIterator(_shapes.begin());
}
 
ShapeList::TopLevelConstIterator ShapeList::cbegin() const
{
  return TopLevelConstIterator(_shapes.begin());
}
 
ShapeList::TopLevelConstIterator ShapeList::end() const
{
  return TopLevelConstIterator(_shapes.end());
}
 
ShapeList::TopLevelConstIterator ShapeList::cend() const
{
  return TopLevelConstIterator(_shapes.end());
}
 
ShapeList::DepthFirstIterator ShapeList::depthFirstBegin()
{
  return DepthFirstIterator(this);
}
 
ShapeList::DepthFirstIterator ShapeList::depthFirstEnd()
{
  return DepthFirstIterator();
}
 
ShapeList::BreadthFirstIterator ShapeList::breadthFirstBegin()
{
  return BreadthFirstIterator(this);
}
 
ShapeList::BreadthFirstIterator ShapeList::breadthFirstEnd()
{
  return BreadthFirstIterator();
}
 
std::size_t ShapeList::size() const
{
  return _shapes.size();
}
 
ShapeList::DepthFirstIterator::DepthFirstIterator() {}
 
ShapeList::DepthFirstIterator::DepthFirstIterator(ShapeList * list)
{
  _shapeListsStack.push(list);
  _iteratorsStack.push(list->begin());
  moveToFirstActuelShape();
}
 
Shape & ShapeList::DepthFirstIterator::operator*()
{
  return *(_iteratorsStack.top());
}
 
Shape * ShapeList::DepthFirstIterator::operator->()
{
  return pointer();
}
 
Shape * ShapeList::DepthFirstIterator::pointer()
{
  return _iteratorsStack.top().pointer();
}
 
bool ShapeList::DepthFirstIterator::operator==(const DepthFirstIterator & other)
{
  return (_shapeListsStack.empty() && other._shapeListsStack.empty()) ||
         ((!_shapeListsStack.empty() && !other._shapeListsStack.empty()) && (_shapeListsStack.top() == other._shapeListsStack.top()) && (_iteratorsStack.top() == other._iteratorsStack.top()));
}
 
bool ShapeList::DepthFirstIterator::operator!=(const DepthFirstIterator & other)
{
  return !(*this == other);
}
 
ShapeList::DepthFirstIterator & ShapeList::DepthFirstIterator::operator++()
{
  moveToNextActualShape();
  return *this;
}
 
ShapeList::DepthFirstIterator ShapeList::DepthFirstIterator::operator++(int)
{
  DepthFirstIterator currentValue(*this);
  moveToNextActualShape();
  return currentValue;
}
 
ShapeList::BreadthFirstIterator::BreadthFirstIterator() {}
 
ShapeList::BreadthFirstIterator::BreadthFirstIterator(ShapeList * list)
{
  _shapeListsQueue.push(list);
  _iteratorsQueue.push(list->begin());
  moveToFirstActuelShape();
}
 
Shape & ShapeList::BreadthFirstIterator::operator*()
{
  return *(_iteratorsQueue.front());
}
 
Shape * ShapeList::BreadthFirstIterator::operator->()
{
  return pointer();
}
 
Shape * ShapeList::BreadthFirstIterator::pointer()
{
  return _iteratorsQueue.front().pointer();
}
 
bool ShapeList::BreadthFirstIterator::operator==(const BreadthFirstIterator & other)
{
  return (_shapeListsQueue.empty() && other._shapeListsQueue.empty()) ||
         ((!_shapeListsQueue.empty() && !other._shapeListsQueue.empty()) && (_shapeListsQueue.front() == other._shapeListsQueue.front()) && (_iteratorsQueue.front() == other._iteratorsQueue.front()));
}
 
bool ShapeList::BreadthFirstIterator::operator!=(const BreadthFirstIterator & other)
{
  return !(*this == other);
}
 
ShapeList::BreadthFirstIterator & ShapeList::BreadthFirstIterator::operator++()
{
  moveToNextActualShape();
  return *this;
}
 
ShapeList::BreadthFirstIterator ShapeList::BreadthFirstIterator::operator++(int)
{
  BreadthFirstIterator currentValue(*this);
  moveToNextActualShape();
  return currentValue;
}
 
template <typename S>                               //
ShapeList::ShapeList(const std::vector<S> & shapes) //
    : ShapeList()
{
  (*this) << shapes;
}
 
template <typename S>                                            //
ShapeList & ShapeList::operator<<(const std::vector<S> & shapes) //
{
  for (const S & shape : shapes) {
    (*this) << shape;
  }
  return *this;
}
 
#if defined(HAS_MSVC_MAX)
#define max(A, B) ((A) > (B) ? (A) : (B))
#endif
 
} // namespace LibBoard
 
#endif /* BOARD_SHAPELIST_H */