app-mengyu/threeQuads.hh

Go to the documentation of this file.

/* square made out of one or two hexahedron
 */

#ifndef threequads_hh
#define threequads_hh

#include "basics/typedefs.hh"
#include "geometry/mesh.hh"
#include "geometry/topology.hh"
#include "geometry/cell2D.hh"
#include "toolbox.hh"

namespace concepts {

  // ***************************************************************** Square3 **

  class ThreeQuads : public Mesh2 {
    //    static const uint ncell_ = 3;
  public:
    ThreeQuads();
    ThreeQuads(Array<uint> attrib);
    virtual ~ThreeQuads();

    inline uint ncell() const { return cell_.size(); }
    //    inline Scan2* scan() { return new S(cell_); }
    inline Scan2* scan() { 
      return new PStlVectorScan<Cell2>(cell_.begin(), cell_.end());
    }
// return new S(cell_.begin(), cell_.end()); }

    virtual std::ostream& info(std::ostream& os) const;
  private:
//     class S : public Scan<Cell2> {
//       // index
//       uint idx_;
//       // stored C-array
//      Quad2d *(&cell_)[ncell_];
//     public:
//       inline S(Quad2d *(&cell)[ncell_]) : idx_(0), cell_(cell) {}
//       inline S(const S &scan) : idx_(scan.idx_), cell_(scan.cell_) {}

//       inline bool eos() const { return idx_ == ncell_; }

//       // increment operator over the C-array
// //       inline Cell2& operator++(int) { 
// //         return *cell_[idx_++]; }

//       // increment operator over the C-array
//       inline Cell2& operator++(int) { 
//         return *cell_[idx_++]; }

//       inline Scan2* clone() const { 
//         return new S(*this); }
//     };

    // Class for a scanner over a STL vector


//     class S : public Scan<Cell2> {
//       // iterator 
//       Sequence<Quad2d*>::iterator i_;
//       // iterator after the last element
//       Sequence<Quad2d*>::iterator end_;      
//     public:
//       inline S(Sequence<Quad2d*>::iterator i,
//                Sequence<Quad2d*>::iterator end) : i_(i), end_(end) {}
//       // copy constructor
//       inline S(const S &scan) : i_(scan.i_), end_(scan.end_) {}

//       inline bool eos() const { return i_ == end_; }

//       // increment operator over the C-array
//       inline Cell2& operator++(int) { 
//         return **(i_++);
//       }

//       inline Scan2* clone() const { return new S(*this); }
//     };

    void construct_(const Array<uint>& attrib);


    Sequence<Vertex*> vtx_;
    Sequence<Edge*> edg_;
    Sequence<Quad*> quad_;
    //Vertex* vtx_[7];
    //Edge* edg_[9];
    //Quad* quad_[ncell_];

    //    Quad2d* cell_[ncell_];
    Sequence<Cell2*> cell_;
  };

} // namespace concepts

#endif // square_hh