boundary.h

Go to the documentation of this file.

#ifndef BOUNDARY_H
#define BOUNDARY_H

#include <interval.h>
#include <linkedlist.h>

namespace frechet { namespace reach {

enum Type : uint8_t {
    NON_ACCESSIBLE,
    REACHABLE,
    SEE_THROUGH
};

enum Orientation : uint8_t {
    HORIZONTAL=0, VERTICAL=1
};

inline Orientation opposite(Orientation ori) {
    return (Orientation)(1-ori);
}
inline Orientation& operator++ (Orientation& ori) {
    ori = (Orientation)(ori+1);
    return ori;
}

class BoundarySegment;

typedef BoundarySegment* Pointer;


enum Direction : uint8_t {
    // Two Segments
    FIRST=0,      
    SECOND=1,     

    //  Rectangle sections
    BOTTOM_LEFT = FIRST, 
    RIGHT_TOP = SECOND,  

    //  l,h pointer direction
    FORWARD = RIGHT_TOP,      
    BACKWARD = BOTTOM_LEFT,   

    //  interval orientation
    COUNTER_CLOCKWISE = RIGHT_TOP,
    CLOCKWISE = BOTTOM_LEFT
};

inline Direction opposite(Direction dir) {
    return (Direction)(1-dir);
}
inline Direction& operator++ (Direction& dir) {
    dir = (Direction)(dir+1);
    return dir;
}

struct PointerInterval {    
  Pointer l;    
  Pointer h;    

  PointerInterval();
  PointerInterval(Pointer a, Pointer b);

  operator bool () const;
  bool operator! () const;

  PointerInterval& operator= (const Pointer& p);
  PointerInterval& swap(bool doit=true);
  PointerInterval swapped() const;

  bool contains(Pointer p) const;

  PointerInterval normalized() const;
  PointerInterval operator+ (const PointerInterval& that) const;

  bool operator== (const PointerInterval& that) const {
      return (this->l==that.l) && (this->h==that.h);
  }
  void clear();
};

Pointer min(const Pointer a, const Pointer b);
Pointer min(const PointerInterval& ival);
Pointer min(const PointerInterval& a, const PointerInterval& b);

Pointer max(const Pointer a, const Pointer b);
Pointer max(const PointerInterval& ival);
Pointer max(const PointerInterval& a, const PointerInterval& b);


class BoundarySegment :
        public data::LinkedListElement<BoundarySegment>,
        public data::Interval,        //  bounds
        public PointerInterval  //  l,h
{
private:
    friend class Structure;   
    mutable struct {
        union { 
            Pointer clone;
            Pointer _twin;
        };
#ifdef QT_DEBUG
        void* owner;
#endif
    } temp;    
    Pointer twin(int hops) {
        Pointer result=this;
        while(hops--) result = result->temp._twin;
        return result;
    }

public:
    Type type;
    const Orientation ori;    
    const Direction dir;      

public:
    Pointer createClone() const {
        Pointer clone = new BoundarySegment(*this);
        temp.clone = clone;
        clone->temp.clone = (Pointer)this;  //  non-const, but mostly harmless
        return clone;
    }
    Pointer clone() const               { return temp.clone; }
    void clearClone() const             { temp.clone=nullptr; }

#ifdef QT_DEBUG
    void* owner() const                 { return temp.owner; }
    void  setOwner(void* own) const     { temp.owner=own; }
#endif

public:
    BoundarySegment(const Interval& ival, Orientation ori, Direction dir, Type t, void* owner=nullptr);

    void clear() {
        type = NON_ACCESSIBLE;
        PointerInterval::clear();
        //  NEVER Interval::clear()
    }
    bool contains(double x) const {
        return Interval::contains(x);
    }
    bool contains(Pointer p) const {
        return PointerInterval::contains(p);
    }
    BoundarySegment& operator= (const PointerInterval& lh) {
        PointerInterval::operator= (lh);
        return *this;
    }
    bool operator== (const BoundarySegment& that) const {
        return (this->type==that.type)
                && (this->ori==that.ori)
                && (this->dir==that.dir)
                && PointerInterval::operator== (that);
    }
#ifdef BOUNDARY_VDESTRUCTOR

    virtual ~BoundarySegment() {
#ifdef QT_DEBUG
        temp.owner=nullptr;
#endif
    }
#endif
};

int compare_interval(Pointer a, Pointer b);
int compare_interval(const PointerInterval& ival);
bool empty_interval(Pointer a, Pointer b);
bool empty_interval(const PointerInterval& ival);
bool empty_see_through_interval(Pointer p);

int compare_pointers(Pointer a, Pointer b);

typedef data::LinkedList<BoundarySegment> BoundaryList;

std::ostream& operator<< (std::ostream& out, const BoundaryList& list);

} } //  namespace frechet::reach

#endif // BOUNDARY_H