Interface0D.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#pragma once
 
#include <iostream>
#include <string>
 
#include "../geometry/Geom.h"
 
#include "../system/Id.h"
#include "../system/Iterator.h"
#include "../system/Precision.h"
 
#include "../winged_edge/Nature.h"
 
#ifdef WITH_CXX_GUARDEDALLOC
#  include "MEM_guardedalloc.h"
#endif
 
using namespace std;
 
namespace Freestyle {
 
//
// Interface0D
//
 
class FEdge;
class SVertex;
class ViewVertex;
class NonTVertex;
class TVertex;
 
class Interface0D {
 public:
  Interface0D()
  {
  }
 
  virtual ~Interface0D(){};
 
  virtual string getExactTypeName() const
  {
    return "Interface0D";
  }
 
  // Data access methods
 
  virtual real getX() const;
 
  virtual real getY() const;
 
  virtual real getZ() const;
 
  virtual Geometry::Vec3r getPoint3D() const;
 
  virtual real getProjectedX() const;
 
  virtual real getProjectedY() const;
 
  virtual real getProjectedZ() const;
 
  virtual Geometry::Vec2r getPoint2D() const;
 
  virtual FEdge *getFEdge(Interface0D &);
 
  virtual Id getId() const;
 
  virtual Nature::VertexNature getNature() const;
 
  virtual SVertex *castToSVertex();
 
  virtual ViewVertex *castToViewVertex();
 
  virtual NonTVertex *castToNonTVertex();
 
  virtual TVertex *castToTVertex();
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Interface0D")
#endif
};
 
//
// Interface0DIteratorNested
//
 
class Interface0DIteratorNested : public Iterator {
 public:
  virtual ~Interface0DIteratorNested()
  {
  }
 
  virtual string getExactTypeName() const
  {
    return "Interface0DIteratorNested";
  }
 
  virtual Interface0D &operator*() = 0;
 
  virtual Interface0D *operator->()
  {
    return &(operator*());
  }
 
  virtual int increment() = 0;
 
  virtual int decrement() = 0;
 
  virtual bool isBegin() const = 0;
 
  virtual bool isEnd() const = 0;
 
  virtual bool operator==(const Interface0DIteratorNested &it) const = 0;
 
  virtual bool operator!=(const Interface0DIteratorNested &it) const
  {
    return !(*this == it);
  }
 
  virtual float t() const = 0;
 
  virtual float u() const = 0;
 
  virtual Interface0DIteratorNested *copy() const = 0;
};
 
//
// Interface0DIterator
//
 
class Interface0DIterator : public Iterator {
 public:
  Interface0DIterator(Interface0DIteratorNested *it = NULL)
  {
    _iterator = it;
  }
 
  Interface0DIterator(const Interface0DIterator &it)
  {
    _iterator = it._iterator->copy();
  }
 
  virtual ~Interface0DIterator()
  {
    if (_iterator) {
      delete _iterator;
    }
  }
 
  Interface0DIterator &operator=(const Interface0DIterator &it)
  {
    if (_iterator) {
      delete _iterator;
    }
    _iterator = it._iterator->copy();
    return *this;
  }
 
  virtual string getExactTypeName() const
  {
    if (!_iterator) {
      return "Interface0DIterator";
    }
    return _iterator->getExactTypeName() + "Proxy";
  }
 
  // FIXME test it != 0 (exceptions ?)
 
  Interface0D &operator*()
  {
    return _iterator->operator*();
  }
 
  Interface0D *operator->()
  {
    return &(operator*());
  }
 
  Interface0DIterator &operator++()
  {
    _iterator->increment();
    return *this;
  }
 
  Interface0DIterator operator++(int)
  {
    Interface0DIterator ret(*this);
    _iterator->increment();
    return ret;
  }
 
  Interface0DIterator &operator--()
  {
    _iterator->decrement();
    return *this;
  }
 
  Interface0DIterator operator--(int)
  {
    Interface0DIterator ret(*this);
    _iterator->decrement();
    return ret;
  }
 
  virtual int increment()
  {
    return _iterator->increment();
  }
 
  virtual int decrement()
  {
    return _iterator->decrement();
  }
 
  virtual bool isBegin() const
  {
    return _iterator->isBegin();
  }
 
  virtual bool isEnd() const
  {
    return _iterator->isEnd();
  }
 
  virtual bool atLast() const
  {
    if (_iterator->isEnd()) {
      return false;
    }
 
    _iterator->increment();
    bool result = _iterator->isEnd();
    _iterator->decrement();
    return result;
  }
 
  bool operator==(const Interface0DIterator &it) const
  {
    return _iterator->operator==(*(it._iterator));
  }
 
  bool operator!=(const Interface0DIterator &it) const
  {
    return !(*this == it);
  }
 
  inline float t() const
  {
    return _iterator->t();
  }
 
  inline float u() const
  {
    return _iterator->u();
  }
 
 protected:
  Interface0DIteratorNested *_iterator;
};
 
} /* namespace Freestyle */