The C and C++ Include Header Files

/usr/include/c++/11/bits/valarray_before.h


$ cat -n /usr/include/c++/11/bits/valarray_before.h

     1	// The template and inlines for the -*- C++ -*- internal _Meta class.
     2	
     3	// Copyright (C) 1997-2021 Free Software Foundation, Inc.
     4	//
     5	// This file is part of the GNU ISO C++ Library.  This library is free
     6	// software; you can redistribute it and/or modify it under the
     7	// terms of the GNU General Public License as published by the
     8	// Free Software Foundation; either version 3, or (at your option)
     9	// any later version.
    10	
    11	// This library is distributed in the hope that it will be useful,
    12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
    13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14	// GNU General Public License for more details.
    15	
    16	// Under Section 7 of GPL version 3, you are granted additional
    17	// permissions described in the GCC Runtime Library Exception, version
    18	// 3.1, as published by the Free Software Foundation.
    19	
    20	// You should have received a copy of the GNU General Public License and
    21	// a copy of the GCC Runtime Library Exception along with this program;
    22	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    23	// <http://www.gnu.org/licenses/>.
    24	
    25	/** @file bits/valarray_before.h
    26	 *  This is an internal header file, included by other library headers.
    27	 *  Do not attempt to use it directly. @headername{valarray}
    28	 */
    29	
    30	// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
    31	
    32	#ifndef _VALARRAY_BEFORE_H
    33	#define _VALARRAY_BEFORE_H 1
    34	
    35	#pragma GCC system_header
    36	
    37	#include <bits/slice_array.h>
    38	
    39	namespace std _GLIBCXX_VISIBILITY(default)
    40	{
    41	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    42	
    43	  //
    44	  // Implementing a loosened valarray return value is tricky.
    45	  // First we need to meet 26.3.1/3: we should not add more than
    46	  // two levels of template nesting. Therefore we resort to template
    47	  // template to "flatten" loosened return value types.
    48	  // At some point we use partial specialization to remove one level
    49	  // template nesting due to _Expr<>
    50	  //
    51	
    52	  // This class is NOT defined. It doesn't need to.
    53	  template<typename _Tp1, typename _Tp2> class _Constant;
    54	
    55	  // Implementations of unary functions applied to valarray<>s.
    56	  // I use hard-coded object functions here instead of a generic
    57	  // approach like pointers to function:
    58	  //    1) correctness: some functions take references, others values.
    59	  //       we can't deduce the correct type afterwards.
    60	  //    2) efficiency -- object functions can be easily inlined
    61	  //    3) be Koenig-lookup-friendly
    62	
    63	  struct _Abs
    64	  {
    65	    template<typename _Tp>
    66	      _Tp operator()(const _Tp& __t) const
    67	      { return abs(__t); }
    68	  };
    69	
    70	  struct _Cos
    71	  {
    72	    template<typename _Tp>
    73	      _Tp operator()(const _Tp& __t) const
    74	      { return cos(__t); }
    75	  };
    76	
    77	  struct _Acos
    78	  {
    79	    template<typename _Tp>
    80	      _Tp operator()(const _Tp& __t) const
    81	      { return acos(__t); }
    82	  };
    83	
    84	  struct _Cosh
    85	  {
    86	    template<typename _Tp>
    87	      _Tp operator()(const _Tp& __t) const
    88	      { return cosh(__t); }
    89	  };
    90	
    91	  struct _Sin
    92	  {
    93	    template<typename _Tp>
    94	      _Tp operator()(const _Tp& __t) const
    95	      { return sin(__t); }
    96	  };
    97	
    98	  struct _Asin
    99	  {
   100	    template<typename _Tp>
   101	      _Tp operator()(const _Tp& __t) const
   102	      { return asin(__t); }
   103	  };
   104	
   105	  struct _Sinh
   106	  {
   107	    template<typename _Tp>
   108	      _Tp operator()(const _Tp& __t) const
   109	      { return sinh(__t); }
   110	  };
   111	
   112	  struct _Tan
   113	  {
   114	    template<typename _Tp>
   115	      _Tp operator()(const _Tp& __t) const
   116	      { return tan(__t); }
   117	  };
   118	
   119	  struct _Atan
   120	  {
   121	    template<typename _Tp>
   122	      _Tp operator()(const _Tp& __t) const
   123	      { return atan(__t); }
   124	  };
   125	
   126	  struct _Tanh
   127	  {
   128	    template<typename _Tp>
   129	      _Tp operator()(const _Tp& __t) const
   130	      { return tanh(__t); }
   131	  };
   132	
   133	  struct _Exp
   134	  {
   135	    template<typename _Tp>
   136	      _Tp operator()(const _Tp& __t) const
   137	      { return exp(__t); }
   138	  };
   139	
   140	  struct _Log
   141	  {
   142	    template<typename _Tp>
   143	      _Tp operator()(const _Tp& __t) const
   144	      { return log(__t); }
   145	  };
   146	
   147	  struct _Log10
   148	  {
   149	    template<typename _Tp>
   150	      _Tp operator()(const _Tp& __t) const
   151	      { return log10(__t); }
   152	  };
   153	
   154	  struct _Sqrt
   155	  {
   156	    template<typename _Tp>
   157	      _Tp operator()(const _Tp& __t) const
   158	      { return sqrt(__t); }
   159	  };
   160	
   161	  // In the past, we used to tailor operator applications semantics
   162	  // to the specialization of standard function objects (i.e. plus<>, etc.)
   163	  // That is incorrect.  Therefore we provide our own surrogates.
   164	
   165	  struct __unary_plus
   166	  {
   167	    template<typename _Tp>
   168	      _Tp operator()(const _Tp& __t) const
   169	      { return +__t; }
   170	  };
   171	
   172	  struct __negate
   173	  {
   174	    template<typename _Tp>
   175	      _Tp operator()(const _Tp& __t) const
   176	      { return -__t; }
   177	  };
   178	
   179	  struct __bitwise_not
   180	  {
   181	    template<typename _Tp>
   182	      _Tp operator()(const _Tp& __t) const
   183	      { return ~__t; }
   184	  };
   185	
   186	  struct __plus
   187	  {
   188	    template<typename _Tp>
   189	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   190	      { return __x + __y; }
   191	  };
   192	
   193	  struct __minus
   194	  {
   195	    template<typename _Tp>
   196	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   197	      { return __x - __y; }
   198	  };
   199	
   200	  struct __multiplies
   201	  {
   202	    template<typename _Tp>
   203	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   204	      { return __x * __y; }
   205	  };
   206	
   207	  struct __divides
   208	  {
   209	    template<typename _Tp>
   210	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   211	      { return __x / __y; }
   212	  };
   213	
   214	  struct __modulus
   215	  {
   216	    template<typename _Tp>
   217	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   218	      { return __x % __y; }
   219	  };
   220	
   221	  struct __bitwise_xor
   222	  {
   223	    template<typename _Tp>
   224	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   225	      { return __x ^ __y; }
   226	  };
   227	
   228	  struct __bitwise_and
   229	  {
   230	    template<typename _Tp>
   231	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   232	      { return __x & __y; }
   233	  };
   234	
   235	  struct __bitwise_or
   236	  {
   237	    template<typename _Tp>
   238	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   239	      { return __x | __y; }
   240	  };
   241	
   242	  struct __shift_left
   243	  {
   244	    template<typename _Tp>
   245	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   246	      { return __x << __y; }
   247	  };
   248	
   249	  struct __shift_right
   250	  {
   251	    template<typename _Tp>
   252	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   253	      { return __x >> __y; }
   254	  };
   255	
   256	  struct __logical_and
   257	  {
   258	    template<typename _Tp>
   259	      bool operator()(const _Tp& __x, const _Tp& __y) const
   260	      { return __x && __y; }
   261	  };
   262	
   263	  struct __logical_or
   264	  {
   265	    template<typename _Tp>
   266	      bool operator()(const _Tp& __x, const _Tp& __y) const
   267	      { return __x || __y; }
   268	  };
   269	
   270	  struct __logical_not
   271	  {
   272	    template<typename _Tp>
   273	      bool operator()(const _Tp& __x) const
   274	      { return !__x; }
   275	  };
   276	
   277	  struct __equal_to
   278	  {
   279	    template<typename _Tp>
   280	      bool operator()(const _Tp& __x, const _Tp& __y) const
   281	      { return __x == __y; }
   282	  };
   283	
   284	  struct __not_equal_to
   285	  {
   286	    template<typename _Tp>
   287	      bool operator()(const _Tp& __x, const _Tp& __y) const
   288	      { return __x != __y; }
   289	  };
   290	
   291	  struct __less
   292	  {
   293	    template<typename _Tp>
   294	      bool operator()(const _Tp& __x, const _Tp& __y) const
   295	      { return __x < __y; }
   296	  };
   297	
   298	  struct __greater
   299	  {
   300	    template<typename _Tp>
   301	      bool operator()(const _Tp& __x, const _Tp& __y) const
   302	      { return __x > __y; }
   303	  };
   304	
   305	  struct __less_equal
   306	  {
   307	    template<typename _Tp>
   308	      bool operator()(const _Tp& __x, const _Tp& __y) const
   309	      { return __x <= __y; }
   310	  };
   311	
   312	  struct __greater_equal
   313	  {
   314	    template<typename _Tp>
   315	      bool operator()(const _Tp& __x, const _Tp& __y) const
   316	      { return __x >= __y; }
   317	  };
   318	
   319	  // The few binary functions we miss.
   320	  struct _Atan2
   321	  {
   322	    template<typename _Tp>
   323	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   324	      { return atan2(__x, __y); }
   325	  };
   326	
   327	  struct _Pow
   328	  {
   329	    template<typename _Tp>
   330	      _Tp operator()(const _Tp& __x, const _Tp& __y) const
   331	      { return pow(__x, __y); }
   332	  };
   333	
   334	  template<typename _Tp, bool _IsValidValarrayValue = !__is_abstract(_Tp)>
   335	    struct __fun_with_valarray
   336	    {
   337	      typedef _Tp result_type;
   338	    };
   339	
   340	  template<typename _Tp>
   341	    struct __fun_with_valarray<_Tp, false>
   342	    {
   343	      // No result type defined for invalid value types.
   344	    };
   345	
   346	  // We need these bits in order to recover the return type of
   347	  // some functions/operators now that we're no longer using
   348	  // function templates.
   349	  template<typename, typename _Tp>
   350	    struct __fun : __fun_with_valarray<_Tp>
   351	    {
   352	    };
   353	
   354	  // several specializations for relational operators.
   355	  template<typename _Tp>
   356	    struct __fun<__logical_not, _Tp>
   357	    {
   358	      typedef bool result_type;
   359	    };
   360	
   361	  template<typename _Tp>
   362	    struct __fun<__logical_and, _Tp>
   363	    {
   364	      typedef bool result_type;
   365	    };
   366	
   367	  template<typename _Tp>
   368	    struct __fun<__logical_or, _Tp>
   369	    {
   370	      typedef bool result_type;
   371	    };
   372	
   373	  template<typename _Tp>
   374	    struct __fun<__less, _Tp>
   375	    {
   376	      typedef bool result_type;
   377	    };
   378	
   379	  template<typename _Tp>
   380	    struct __fun<__greater, _Tp>
   381	    {
   382	      typedef bool result_type;
   383	    };
   384	
   385	  template<typename _Tp>
   386	    struct __fun<__less_equal, _Tp>
   387	    {
   388	      typedef bool result_type;
   389	    };
   390	
   391	  template<typename _Tp>
   392	    struct __fun<__greater_equal, _Tp>
   393	    {
   394	      typedef bool result_type;
   395	    };
   396	
   397	  template<typename _Tp>
   398	    struct __fun<__equal_to, _Tp>
   399	    {
   400	      typedef bool result_type;
   401	    };
   402	
   403	  template<typename _Tp>
   404	    struct __fun<__not_equal_to, _Tp>
   405	    {
   406	      typedef bool result_type;
   407	    };
   408	
   409	namespace __detail
   410	{
   411	  // Closure types already have reference semantics and are often short-lived,
   412	  // so store them by value to avoid (some cases of) dangling references to
   413	  // out-of-scope temporaries.
   414	  template<typename _Tp>
   415	    struct _ValArrayRef
   416	    { typedef const _Tp __type; };
   417	
   418	  // Use real references for std::valarray objects.
   419	  template<typename _Tp>
   420	    struct _ValArrayRef< valarray<_Tp> >
   421	    { typedef const valarray<_Tp>& __type; };
   422	
   423	  //
   424	  // Apply function taking a value/const reference closure
   425	  //
   426	
   427	  template<typename _Dom, typename _Arg>
   428	    class _FunBase
   429	    {
   430	    public:
   431	      typedef typename _Dom::value_type value_type;
   432	
   433	      _FunBase(const _Dom& __e, value_type __f(_Arg))
   434	      : _M_expr(__e), _M_func(__f) {}
   435	
   436	      value_type operator[](size_t __i) const
   437	      { return _M_func (_M_expr[__i]); }
   438	
   439	      size_t size() const { return _M_expr.size ();}
   440	
   441	    private:
   442	      typename _ValArrayRef<_Dom>::__type _M_expr;
   443	      value_type (*_M_func)(_Arg);
   444	    };
   445	
   446	  template<class _Dom>
   447	    struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
   448	    {
   449	      typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
   450	      typedef typename _Base::value_type value_type;
   451	      typedef value_type _Tp;
   452	
   453	      _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
   454	    };
   455	
   456	  template<typename _Tp>
   457	    struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
   458	    {
   459	      typedef _FunBase<valarray<_Tp>, _Tp> _Base;
   460	      typedef _Tp value_type;
   461	
   462	      _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
   463	    };
   464	
   465	  template<class _Dom>
   466	    struct _RefFunClos<_Expr, _Dom>
   467	    : _FunBase<_Dom, const typename _Dom::value_type&>
   468	    {
   469	      typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
   470	      typedef typename _Base::value_type value_type;
   471	      typedef value_type _Tp;
   472	
   473	      _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
   474	      : _Base(__e, __f) {}
   475	    };
   476	
   477	  template<typename _Tp>
   478	    struct _RefFunClos<_ValArray, _Tp>
   479	    : _FunBase<valarray<_Tp>, const _Tp&>
   480	    {
   481	      typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
   482	      typedef _Tp value_type;
   483	
   484	      _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
   485	      : _Base(__v, __f) {}
   486	    };
   487	
   488	  //
   489	  // Unary expression closure.
   490	  //
   491	
   492	  template<class _Oper, class _Arg>
   493	    class _UnBase
   494	    {
   495	    public:
   496	      typedef typename _Arg::value_type _Vt;
   497	      typedef typename __fun<_Oper, _Vt>::result_type value_type;
   498	
   499	      _UnBase(const _Arg& __e) : _M_expr(__e) {}
   500	
   501	      value_type operator[](size_t __i) const
   502	      { return _Oper()(_M_expr[__i]); }
   503	
   504	      size_t size() const { return _M_expr.size(); }
   505	      
   506	    private:
   507	      typename _ValArrayRef<_Arg>::__type _M_expr;
   508	    };
   509	
   510	  template<class _Oper, class _Dom>
   511	    struct _UnClos<_Oper, _Expr, _Dom>
   512	    : _UnBase<_Oper, _Dom>
   513	    {
   514	      typedef _Dom _Arg;
   515	      typedef _UnBase<_Oper, _Dom> _Base;
   516	      typedef typename _Base::value_type value_type;
   517	
   518	      _UnClos(const _Arg& __e) : _Base(__e) {}
   519	    };
   520	
   521	  template<class _Oper, typename _Tp>
   522	    struct _UnClos<_Oper, _ValArray, _Tp>
   523	    : _UnBase<_Oper, valarray<_Tp> >
   524	    {
   525	      typedef valarray<_Tp> _Arg;
   526	      typedef _UnBase<_Oper, valarray<_Tp> > _Base;
   527	      typedef typename _Base::value_type value_type;
   528	
   529	      _UnClos(const _Arg& __e) : _Base(__e) {}
   530	    };
   531	
   532	
   533	  //
   534	  // Binary expression closure.
   535	  //
   536	
   537	  template<class _Oper, class _FirstArg, class _SecondArg>
   538	    class _BinBase
   539	    {
   540	    public:
   541	      typedef typename _FirstArg::value_type _Vt;
   542	      typedef typename __fun<_Oper, _Vt>::result_type value_type;
   543	
   544	      _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
   545	      : _M_expr1(__e1), _M_expr2(__e2) {}
   546	
   547	      value_type operator[](size_t __i) const
   548	      { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
   549	
   550	      size_t size() const { return _M_expr1.size(); }
   551	
   552	    private:
   553	      typename _ValArrayRef<_FirstArg>::__type _M_expr1;
   554	      typename _ValArrayRef<_SecondArg>::__type _M_expr2;
   555	    };
   556	
   557	
   558	  template<class _Oper, class _Clos>
   559	    class _BinBase2
   560	    {
   561	    public:
   562	      typedef typename _Clos::value_type _Vt;
   563	      typedef typename __fun<_Oper, _Vt>::result_type value_type;
   564	
   565	      _BinBase2(const _Clos& __e, const _Vt& __t)
   566	      : _M_expr1(__e), _M_expr2(__t) {}
   567	
   568	      value_type operator[](size_t __i) const
   569	      { return _Oper()(_M_expr1[__i], _M_expr2); }
   570	
   571	      size_t size() const { return _M_expr1.size(); }
   572	
   573	    private:
   574	      typename _ValArrayRef<_Clos>::__type _M_expr1;
   575	      _Vt _M_expr2;
   576	    };
   577	
   578	  template<class _Oper, class _Clos>
   579	    class _BinBase1
   580	    {
   581	    public:
   582	      typedef typename _Clos::value_type _Vt;
   583	      typedef typename __fun<_Oper, _Vt>::result_type value_type;
   584	
   585	      _BinBase1(const _Vt& __t, const _Clos& __e)
   586	      : _M_expr1(__t), _M_expr2(__e) {}
   587	
   588	      value_type operator[](size_t __i) const
   589	      { return _Oper()(_M_expr1, _M_expr2[__i]); }
   590	
   591	      size_t size() const { return _M_expr2.size(); }
   592	
   593	    private:
   594	      _Vt _M_expr1;
   595	      typename _ValArrayRef<_Clos>::__type _M_expr2;
   596	    };
   597	
   598	  template<class _Oper, class _Dom1, class _Dom2>
   599	    struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
   600	    : _BinBase<_Oper, _Dom1, _Dom2>
   601	    {
   602	      typedef _BinBase<_Oper, _Dom1, _Dom2> _Base;
   603	      typedef typename _Base::value_type value_type;
   604	
   605	      _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
   606	    };
   607	
   608	  template<class _Oper, typename _Tp>
   609	    struct _BinClos<_Oper, _ValArray, _ValArray, _Tp, _Tp>
   610	    : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> >
   611	    {
   612	      typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base;
   613	      typedef typename _Base::value_type value_type;
   614	
   615	      _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
   616	      : _Base(__v, __w) {}
   617	    };
   618	
   619	  template<class _Oper, class _Dom>
   620	    struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
   621	    : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
   622	    {
   623	      typedef typename _Dom::value_type _Tp;
   624	      typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
   625	      typedef typename _Base::value_type value_type;
   626	
   627	      _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
   628	      : _Base(__e1, __e2) {}
   629	    };
   630	
   631	  template<class _Oper, class _Dom>
   632	    struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
   633	    : _BinBase<_Oper, valarray<typename _Dom::value_type>,_Dom>
   634	    {
   635	      typedef typename _Dom::value_type _Tp;
   636	      typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base;
   637	      typedef typename _Base::value_type value_type;
   638	
   639	      _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
   640	      : _Base(__e1, __e2) {}
   641	    };
   642	
   643	  template<class _Oper, class _Dom>
   644	    struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type>
   645	    : _BinBase2<_Oper, _Dom>
   646	    {
   647	      typedef typename _Dom::value_type _Tp;
   648	      typedef _BinBase2<_Oper,_Dom> _Base;
   649	      typedef typename _Base::value_type value_type;
   650	
   651	      _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
   652	    };
   653	
   654	  template<class _Oper, class _Dom>
   655	    struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom>
   656	    : _BinBase1<_Oper, _Dom>
   657	    {
   658	      typedef typename _Dom::value_type _Tp;
   659	      typedef _BinBase1<_Oper, _Dom> _Base;
   660	      typedef typename _Base::value_type value_type;
   661	
   662	      _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
   663	    };
   664	
   665	  template<class _Oper, typename _Tp>
   666	    struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp>
   667	    : _BinBase2<_Oper, valarray<_Tp> >
   668	    {
   669	      typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
   670	      typedef typename _Base::value_type value_type;
   671	
   672	      _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
   673	    };
   674	
   675	  template<class _Oper, typename _Tp>
   676	    struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp>
   677	    : _BinBase1<_Oper, valarray<_Tp> >
   678	    {
   679	      typedef _BinBase1<_Oper, valarray<_Tp> > _Base;
   680	      typedef typename _Base::value_type value_type;
   681	
   682	      _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
   683	    };
   684	
   685	  //
   686	  // slice_array closure.
   687	  //
   688	  template<typename _Dom>
   689	    class _SBase
   690	    {
   691	    public:
   692	      typedef typename _Dom::value_type value_type;
   693	      
   694	      _SBase (const _Dom& __e, const slice& __s)
   695	      : _M_expr (__e), _M_slice (__s) {}
   696	        
   697	      value_type
   698	      operator[] (size_t __i) const
   699	      { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
   700	        
   701	      size_t
   702	      size() const
   703	      { return _M_slice.size (); }
   704	
   705	    private:
   706	      typename _ValArrayRef<_Dom>::__type _M_expr;
   707	      const slice& _M_slice;
   708	    };
   709	
   710	  template<typename _Tp>
   711	    class _SBase<_Array<_Tp> >
   712	    {
   713	    public:
   714	      typedef _Tp value_type;
   715	      
   716	      _SBase (_Array<_Tp> __a, const slice& __s)
   717	      : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
   718		_M_stride (__s.stride()) {}
   719	        
   720	      value_type
   721	      operator[] (size_t __i) const
   722	      { return _M_array._M_data[__i * _M_stride]; }
   723	      
   724	      size_t
   725	      size() const
   726	      { return _M_size; }
   727	
   728	    private:
   729	      const _Array<_Tp> _M_array;
   730	      const size_t _M_size;
   731	      const size_t _M_stride;
   732	    };
   733	
   734	  template<class _Dom>
   735	    struct _SClos<_Expr, _Dom>
   736	    : _SBase<_Dom>
   737	    {
   738	      typedef _SBase<_Dom> _Base;
   739	      typedef typename _Base::value_type value_type;
   740	      
   741	      _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
   742	    };
   743	
   744	  template<typename _Tp>
   745	    struct _SClos<_ValArray, _Tp>
   746	    : _SBase<_Array<_Tp> >
   747	    {
   748	      typedef  _SBase<_Array<_Tp> > _Base;
   749	      typedef _Tp value_type;
   750	      
   751	      _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
   752	    };
   753	} // namespace __detail
   754	
   755	_GLIBCXX_END_NAMESPACE_VERSION
   756	} // namespace
   757	
   758	#endif /* _CPP_VALARRAY_BEFORE_H */