AF2Binding.hpp

Go to the documentation of this file.

/*
 * AF2Binding.hpp
 *
 * An AF2Binding is an object that manages binding the edges and vertices
 * that a rule has specified must exist (i.e., AF2RuleExistingEdge and
 * AF2RuleExistingVertex) to edges and vertices (i.e., AF2Edge2D
 * and AF2Point2D) that actually do exist in some AF2Neighborhood.
 *
 * The AF2Binding provides methods to bind an edge or a vertex and to check
 * whether binding an edge or vertex is consistent with what has already
 * been bound.  Binding an edge implies binding the endpoint vertices
 * of that edge.  Attempting to bind an edge or vertex that is not
 * consistent with what is already bound will result in an exception.
 * Attempting to bind an edge or vertex that is already bound will succeed
 * if the binding is consistent.
 *
 * AF2Binding also provides methods to release edges or vertices that are
 * bound.  Attempting to release an edge or vertex that is not bound
 * will result in an exception.  The model for binding a vertex tracks
 * both whether the vertex has been explicitly bound with a call to the
 * method that binds vertices and whether it is implicitly bound because it
 * is an endpoint of an edge that is bound.  Attempting to release a vertex
 * that has been bound in both ways will release the explicit bound, but not
 * the implicit bound.  Attempting to release a vertex that is implicitly
 * bound but not explicitly bound will result in an exception.
 */

#ifndef AF2BINDING_HPP
#define AF2BINDING_HPP

// C++
#include <map>
#include <set>

// MeshKit
#include "meshkit/AF2Edge2D.hpp"
#include "meshkit/AF2Point2D.hpp"
#include "meshkit/AF2RuleExistEdge.hpp"
#include "meshkit/AF2RuleExistVertex.hpp"

class AF2Binding
{
  private:

    struct VtxBindRec
    {
      const AF2Point2D* pointPtr;
      unsigned int numBoundEdges;
      bool xplctBound;

      VtxBindRec();
    };

    std::map<const AF2RuleExistVertex*, VtxBindRec> vertexBindMap;
    std::set<const AF2Point2D*> verticesInUse;
    std::map<const AF2RuleExistEdge*, const AF2Edge2D*> edgeBindMap;
    std::set<const AF2Edge2D*> edgesInUse;

    void bind(const AF2RuleExistVertex* ruleVertexPtr,
        const AF2Point2D* ngbhdVertexPtr, bool isExplicit);

    void release(const AF2RuleExistVertex* ruleVertexPtr, bool isExplicit);

  public:

    void bind(const AF2RuleExistEdge* ruleEdgePtr,
        const AF2Edge2D* ngbhdEdgePtr);

    void bind(const AF2RuleExistVertex* ruleVertexPtr,
        const AF2Point2D* ngbhdVertexPtr);


    const AF2Point2D* getBoundValue(
        const AF2RuleExistVertex* ruleVertexPtr) const;

    bool isConsistent(const AF2RuleExistEdge* ruleEdgePtr,
        const AF2Edge2D* ngbhdEdgePtr) const;

    bool isConsistent(const AF2RuleExistVertex* ruleVertexPtr,
        const AF2Point2D* ngbhdVertexPtr) const;

    void release(const AF2RuleExistEdge* ruleEdgePtr);

    void release(const AF2RuleExistVertex* ruleVertexPtr);
};

#endif