OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [torture/] [pr46383.C] - Blame information for rev 774

Go to most recent revision | Details | Compare with Previous | View Log

(t)(co.triangulation()), c2t3(co), tr(co.triangulation()), surf(s), meshtraits(mesh_traits), criteria(c) C2T3;
Line No. Rev Author Line
1 693 jeremybenn 
// { dg-do compile }
2 
 
3 
namespace std {
4 
templatestruct pair{};
5 
  template struct _Vector_base {
6 
      struct _Vector_impl
7 
      {
8 
        _Tp* _M_start;
9 
        _Tp* _M_finish;
10 
        _Tp* _M_end_of_storage;
11 
      };
12 
      _Vector_impl _M_impl;
13 
    };
14 
  template
15 
    struct vector : _Vector_base<_Tp>
16 
    {
17 
      vector(const vector& __x);
18 
    };
19 
}
20 
namespace boost {
21 
struct G{};
22 
template
23 
struct modable2
24 
: G
25 
{ };
26 
}
27 
namespace CGAL {
28 
struct Rep { };
29 
struct Handle
30 
{
31 
    Handle() ;
32 
    Handle(const Handle& x) ;
33 
    Rep* PTR;
34 
};
35 
template  class Lazy_exact_nt
36 
  : Handle
37 
  , boost::modable2< Lazy_exact_nt, int >
38 
  , boost::modable2< Lazy_exact_nt, double >
39 
{ };
40 
  struct CC_iterator { };
41 
struct Triangulation_data_structure_3 {
42 
  typedef CC_iterator                          Vertex_handle;
43 
  typedef CC_iterator                            Cell_handle;
44 
  typedef std::pair              Facet;
45 
};
46 
template < class GT, class Tds_ > struct Triangulation_3 {
47 
  typedef Tds_                                  Tds;
48 
  typedef typename GT::Point_3                 Point;
49 
  typedef typename Tds::Facet                  Facet;
50 
  typedef typename Tds::Vertex_handle          Vertex_handle;
51 
  enum Locate_type { VERTEX=0, EDGE, FACET, CELL, OUTSIDE_CONVEX_HULL, OUTSIDE_AFFINE_HULL };
52 
  Tds _tds;
53 
  bool is_infinite(const Facet & f) const ;
54 
};
55 
template < class Gt, class Tds_ > struct Delaunay_triangulation_3 : public Triangulation_3 { };
56 
  namespace Surface_mesher { enum Verbose_flag { VERBOSE, NOT_VERBOSE }; }
57 
enum Mesher_level_conflict_status { NO_CONFLICT = 0, CONFLICT_BUT_ELEMENT_CAN_BE_RECONSIDERED, CONFLICT_AND_ELEMENT_SHOULD_BE_DROPPED };
58 
struct Null_mesher_level {
59 
  template  Mesher_level_conflict_status test_point_conflict_from_superior(P, Z) ;
60 
};
61 
template < class Tr, class Derived, class Element, class Previous, class Triangulation_traits > struct Mesher_level {
62 
  typedef Tr Triangulation;
63 
  typedef typename Triangulation::Point Point;
64 
  typedef typename Triangulation::Vertex_handle Vertex_handle;
65 
  typedef typename Triangulation_traits::Zone Zone;
66 
  typedef Previous Previous_level;
67 
  Derived& derived() { return static_cast(*this); }
68 
  Previous& previous_level;
69 
  Mesher_level(Previous_level& previous)
70 
    : previous_level(previous)
71 
  { }
72 
  Vertex_handle insert(Point p, Zone& z) ;
73 
  Zone conflicts_zone(const Point& p, Element e) ;
74 
  Element get_next_element() ;
75 
  template  void before_insertion(Element& e, const Point& p, Zone& zone, Mesh_visitor visitor) {
76 
    visitor.before_insertion(e, p, zone);
77 
  }
78 
  template  void after_insertion(Vertex_handle vh, Mesh_visitor visitor) {
79 
    derived().after_insertion_impl(vh);
80 
  }
81 
  template  void after_no_insertion(const Element& e, const Point& p, Zone& zone, Mesh_visitor visitor) {
82 
    visitor.after_no_insertion(e, p, zone);
83 
  }
84 
  template  void refine(Mesh_visitor visitor)
85 
  {
86 
    Element e = get_next_element();
87 
    const Mesher_level_conflict_status result = try_to_refine_element(e, visitor);
88 
  }
89 
  template  Mesher_level_conflict_status try_to_refine_element(Element e, Mesh_visitor visitor)
90 
  {
91 
    Point p ;
92 
    Zone zone = conflicts_zone(p, e);
93 
    const Mesher_level_conflict_status result = test_point_conflict(p, zone);
94 
      before_insertion(e, p, zone, visitor);
95 
      Vertex_handle v = insert(p, zone);
96 
      after_insertion(v, visitor);
97 
      after_no_insertion(e, p, zone, visitor);
98 
  }
99 
  Mesher_level_conflict_status test_point_conflict(const Point& p, Zone& zone)
100 
  {
101 
    return previous_level.test_point_conflict_from_superior(p, zone);
102 
  }
103 
};
104 
struct Null_mesh_visitor {
105 
  template  void before_insertion(E, P, Z) const {}
106 
  template  void after_no_insertion(E, P, Z) const {}
107 
};
108 
template  struct Triangulation_ref_impl {
109 
  Triangulation_ref_impl(Tr& t);
110 
};
111 
template  struct Triangulation_mesher_level_traits_3
112 
: public Triangulation_ref_impl
113 
{
114 
  typedef typename Tr::Facet Facet;
115 
  Triangulation_mesher_level_traits_3(Tr& t)
116 
    : Triangulation_ref_impl
117 
  { }
118 
  struct Zone {
119 
    typedef std::vector Cells;
120 
    typedef std::vector Facets;
121 
    typedef typename Tr::Locate_type Locate_type;
122 
    Locate_type locate_type;
123 
    Cells cells;
124 
    Facets boundary_facets;
125 
    Facets internal_facets;
126 
  };
127 
};
128 
  namespace Surface_mesher {
129 
    namespace details {
130 
      template  struct Triangulation_generator {
131 
        typedef typename Base::Complex_2_in_triangulation_3 C2T3;
132 
        typedef typename C2T3::Triangulation Triangulation;
133 
        typedef Triangulation Type;
134 
        typedef Type type;
135 
      };
136 
      template  struct Facet_generator {
137 
        typedef typename Triangulation_generator::type Tr;
138 
        typedef typename Tr::Facet Type;
139 
        typedef Type type;
140 
      };
141 
      template  struct Mesher_level_generator {
142 
        typedef typename Base::Complex_2_in_triangulation_3 C2T3;
143 
        typedef typename C2T3::Triangulation Triangulation;
144 
        typedef Triangulation_mesher_level_traits_3 Tr_m_l_traits_3;
145 
        typedef Mesher_level  Type;
146 
      };
147 
    }
148 
  template < class C2T3, class Surface_, class SurfaceMeshTraits, class Criteria_ > struct Surface_mesher_base
149 
    : public Triangulation_mesher_level_traits_3
150 
  {
151 
    typedef C2T3 Complex_2_in_triangulation_3;
152 
    typedef Surface_ Surface;
153 
    typedef SurfaceMeshTraits Surface_mesh_traits;
154 
    typedef Criteria_ Criteria;
155 
    typedef typename C2T3::Triangulation Tr;
156 
    typedef typename Tr::Vertex_handle Vertex_handle;
157 
    typedef typename Tr::Facet Facet;
158 
    Surface_mesher_base (C2T3& co, const Surface& s, const Surface_mesh_traits& mesh_traits, const Criteria& c)
159 
: Triangulation_mesher_level_traits_3
160 
    { }
161 
    C2T3& c2t3;
162 
    Tr& tr;
163 
    const Surface& surf;
164 
    const Surface_mesh_traits& meshtraits;
165 
    const Criteria& criteria;
166 
    void after_insertion_impl(const Vertex_handle& v) {
167 
        after_insertion_handle_opposite_facet (Facet ());
168 
        after_insertion_handle_incident_facet (Facet ());
169 
    }
170 
    void after_insertion_handle_incident_facet (const Facet& f) {
171 
      tr.is_infinite(f) ;
172 
      new_facet(f);
173 
    }
174 
    template  void new_facet (const Facet& f) ;
175 
    void after_insertion_handle_opposite_facet (const Facet& f) {
176 
      after_insertion_handle_incident_facet (f);
177 
    }
178 
  };
179 
  template < typename Base, typename Element = typename details::Facet_generator::type, typename PreviousLevel = Null_mesher_level, Verbose_flag verbose = NOT_VERBOSE > struct Surface_mesher
180 
    : public Base , public details::Mesher_level_generator< Base, Surface_mesher, Element, PreviousLevel >::Type
181 
  {
182 
    typedef typename Base::Complex_2_in_triangulation_3 C2T3;
183 
    typedef typename Base::Surface Surface;
184 
    typedef typename Base::Criteria Criteria;
185 
    typedef typename Base::Surface_mesh_traits Surface_mesh_traits;
186 
    typedef typename details::Mesher_level_generator< Base, Surface_mesher, Element, PreviousLevel >::Type Mesher_lvl;
187 
    using Mesher_lvl::refine;
188 
    Null_mesher_level null_mesher_level;
189 
    Null_mesh_visitor null_visitor;
190 
    bool initialized;
191 
    Surface_mesher(C2T3& c2t3, const Surface& surface, const Surface_mesh_traits& mesh_traits, const Criteria& criteria)
192 
      : Base(c2t3, surface, mesh_traits, criteria), Mesher_lvl(null_mesher_level), initialized(false)
193 
    { }
194 
    void refine_mesh () {
195 
      refine(null_visitor);
196 
    }
197 
  };
198 
  }
199 
template  struct Surface_mesh_traits_generator_3 {
200 
  typedef typename Surface::Surface_mesher_traits_3 Type;
201 
  typedef Type type;
202 
};
203 
template < class Tr, typename Edge_info_ = void > struct Complex_2_in_triangulation_3 {
204 
  typedef Tr Triangulation;
205 
  Triangulation& triangulation();
206 
};
207 
template  struct Surface_mesh_complex_2_in_triangulation_3
208 
: public Complex_2_in_triangulation_3
209 
{ };
210 
  struct Non_manifold_tag {};
211 
  template < typename C2T3, typename SurfaceMeshTraits_3, typename Criteria, typename Tag > struct Make_surface_mesh_helper {
212 
    typedef Surface_mesher::Surface_mesher_base< C2T3, typename SurfaceMeshTraits_3::Surface_3, SurfaceMeshTraits_3, Criteria> Mesher_base;
213 
  };
214 
  template  struct Surface_mesher_generator {
215 
    typedef typename Make_surface_mesh_helper< C2T3, SurfaceMeshTraits_3, Criteria, Tag>::Mesher_base Mesher_base;
216 
    typedef Surface_mesher::Surface_mesher< Mesher_base, typename Surface_mesher::details::Facet_generator::type, Null_mesher_level, verbosity> Mesher;
217 
    typedef Mesher type;
218 
  };
219 
template  void make_surface_mesh(C2T3& c2t3, const typename SurfaceMeshTraits_3::Surface_3& surface, const SurfaceMeshTraits_3& surface_mesh_traits, const Criteria& criteria) {
220 
  typedef typename Surface_mesher_generator< C2T3, SurfaceMeshTraits_3, Criteria, Non_manifold_tag, Surface_mesher::NOT_VERBOSE >::type Mesher;
221 
  Mesher mesher(c2t3, surface, surface_mesh_traits, criteria);
222 
  mesher.refine_mesh();
223 
}
224 
template  struct Surface_mesh_triangulation_generator_3 {
225 
  typedef CGAL::Triangulation_data_structure_3 Tds;
226 
  typedef CGAL::Delaunay_triangulation_3 Type;
227 
};
228 
  namespace Surface_mesher {
229 
  namespace { struct Return_min { }; }
230 
  template < class GT, class Surface, class Unused = Return_min > struct Implicit_surface_oracle_3 {
231 
    typedef Surface Surface_3;
232 
  };
233 
  }
234 
  template< typename GT> struct Implicit_surface_3 {
235 
    typedef GT Geom_traits;
236 
    typedef Implicit_surface_3 Self;
237 
    typedef Surface_mesher::Implicit_surface_oracle_3< Geom_traits, Self> Surface_mesher_traits_3;
238 
  };
239 
}
240 
struct K {
241 
struct Point_3 {
242 
CGAL::Lazy_exact_nt a[3];
243 
};
244 
};
245 
typedef CGAL::Surface_mesh_triangulation_generator_3::Type Tr;
246 
typedef CGAL::Surface_mesh_complex_2_in_triangulation_3
247 
typedef CGAL::Implicit_surface_3 Surface;
248 
typedef CGAL::Surface_mesh_traits_generator_3::type Traits;
249 
void f() {
250 
        C2T3 c2t3 ;
251 
        CGAL::make_surface_mesh(c2t3, Surface(), Traits(), 3);
252 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.