h o m e

d o c u m e n t a t i o n

c l a s s h i e r a r c h y

---

Interface0D.h

//
//  Filename         : Interface0D.h
//  Author(s)        : Emmanuel Turquin
//  Purpose          : Interface to 0D elts
//  Date of creation : 01/07/2003
//


//
//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
//   with this source distribution. 
//
//  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef  INTERFACE0D_H
# define INTERFACE0D_H

# include <string>
# include <iostream>
# include "../system/Id.h"
# include "../system/Precision.h"
# include "../winged_edge/Nature.h"
# include "../geometry/Geom.h"
using namespace std;

//
// Interface0D
//

class FEdge;
class SVertex;
class ViewVertex;
class NonTVertex;
class TVertex;
class Interface0D
{
public:

  virtual string getExactTypeName() const {
    return "Interface0D";
  }

  // Data access methods

  virtual real getX() const {
    cerr << "Warning: method getX() not implemented" << endl;
    return 0;
  }

  virtual real getY() const {
    cerr << "Warning: method getY() not implemented" << endl;
    return 0;
  }

  virtual real getZ() const {
    cerr << "Warning: method getZ() not implemented" << endl;
    return 0;
  }

  virtual Geometry::Vec3f getPoint3D() const {
    cerr << "Warning: method getPoint3D() not implemented" << endl;
    return 0;
  }

  virtual real getProjectedX() const {
    cerr << "Warning: method getProjectedX() not implemented" << endl;
    return 0;
  }

  virtual real getProjectedY() const {
    cerr << "Warning: method getProjectedY() not implemented" << endl;
    return 0;
  }

  virtual real getProjectedZ() const {
    cerr << "Warning: method getProjectedZ() not implemented" << endl;
    return 0;
  }

  virtual Geometry::Vec2f getPoint2D() const {
    cerr << "Warning: method getPoint2D() not implemented" << endl;
    return 0;
  }

  virtual FEdge* getFEdge(Interface0D&) {
    cerr << "Warning: method getFEdge() not implemented" << endl;
    return 0;
  }

  virtual Id getId() const {
    cerr << "Warning: method getId() not implemented" << endl;
    return Id(0, 0);
  }

  virtual Nature::VertexNature getNature() const {
    cerr << "Warning: method getNature() not implemented" << endl;
    return Nature::POINT;
  }

  virtual SVertex * castToSVertex(){
    cerr << "Warning: can't cast this Interface0D in SVertex" << endl;
    return 0;
  }

  virtual ViewVertex * castToViewVertex(){
    cerr << "Warning: can't cast this Interface0D in ViewVertex" << endl;
    return 0;
  }

  virtual NonTVertex * castToNonTVertex(){
    cerr << "Warning: can't cast this Interface0D in NonTVertex" << endl;
    return 0;
  }

  virtual TVertex * castToTVertex(){
    cerr << "Warning: can't cast this Interface0D in TVertex" << endl;
    return 0;
  }
};


//
// Interface0DIteratorNested
//

class Interface0DIteratorNested
{
public:

  virtual ~Interface0DIteratorNested() {}

  virtual string getExactTypeName() const {
    return "Interface0DIteratorNested";
  }

  virtual Interface0D& operator*() = 0;

  virtual Interface0D* operator->() {
    return &(operator*());
  }

  virtual void increment() = 0;

  virtual void 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:

  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;
  }

  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;
  }

  void increment() {
    _iterator->increment();
  }
  
  void decrement() {
    _iterator->decrement();
  }

  bool isBegin() const {
    return _iterator->isBegin();
  }

  bool isEnd() const {
    return _iterator->isEnd();
  }

  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;
};

#endif // INTERFACE0D_H

---

Last modified 3 Mar 2008

© Stephane Grabli