1 /* { dg-do compile } */
2 
3 #include<cassert>
4 #include<new>
5 #include<utility>
6 
7 namespace boost {
8 
9 template<class T>
10 class optional;
11 
12 class aligned_storage
13 {
14 	char data[ 1000 ];
15   public:
address()16     void const* address() const { return &data[0]; }
address()17     void      * address()       { return &data[0]; }
18 } ;
19 
20 
21 template<class T>
22 class optional_base
23 {
24   protected :
optional_base()25     optional_base(){}
optional_base(T const & val)26     optional_base ( T const& val )
27     {
28       construct(val);
29     }
30 
31     template<class U>
assign(optional<U> const & rhs)32     void assign ( optional<U> const& rhs )
33     {
34       if (!is_initialized())
35         if ( rhs.is_initialized() )
36           construct(T());
37     }
38 
39   public :
40 
is_initialized()41     bool is_initialized() const { return m_initialized ; }
42 
43   protected :
44 
construct(T const & val)45     void construct ( T const& val )
46      {
47        new (m_storage.address()) T(val) ;
48      }
49 
get_ptr_impl()50     T const* get_ptr_impl() const
51     { return static_cast<T const*>(m_storage.address()); }
52 
53   private :
54 
55     bool m_initialized ;
56     aligned_storage  m_storage ;
57 } ;
58 
59 
60 template<class T>
61 class optional : public optional_base<T>
62 {
63     typedef optional_base<T> base ;
64 
65   public :
66 
optional()67     optional() : base() {}
optional(T const & val)68     optional ( T const& val ) : base(val) {}
69     optional& operator= ( optional const& rhs )
70       {
71         this->assign( rhs ) ;
72         return *this ;
73       }
74 
75     T const& get() const ;
76 
77     T const* operator->() const { assert(this->is_initialized()) ; return this->get_ptr_impl() ; }
78 
79 } ;
80 
81 
82 } // namespace boost
83 
84 
85 namespace std
86 {
87 
88   template<typename _Tp, std::size_t _Nm>
89     struct array
90     {
91       typedef _Tp 	    			      value_type;
92       typedef const value_type*			      const_iterator;
93 
94       value_type _M_instance[_Nm];
95 
96     };
97 }
98 
99 
100 class NT
101 {
102   double _inf, _sup;
103 };
104 
105 
106 template < typename T > inline
107 std::array<T, 1>
make_array(const T & b1)108 make_array(const T& b1)
109 {
110   std::array<T, 1> a = { { b1 } };
111   return a;
112 }
113 
114 class V
115 {
116   typedef std::array<NT, 1>               Base;
117   Base base;
118 
119 public:
V()120   V() {}
V(const NT & x)121   V(const NT &x)
122     : base(make_array(x)) {}
123 
124 };
125 
126 using boost::optional ;
127 
128 optional< std::pair< NT, NT > >
129   linsolve_pointC2() ;
130 
construct_normal_offset_lines_isecC2()131 optional< V > construct_normal_offset_lines_isecC2 ( )
132 {
133   optional< std::pair<NT,NT> > ip;
134 
135   ip = linsolve_pointC2();
136 
137   V a(ip->first) ;
138   return a;
139 }
140 
141 
142 
143