1 //=================================================================================================
2 /*!
3 //  \file blaze/math/typetraits/HasConstDataAccess.h
4 //  \brief Header file for the HasConstDataAccess type trait
5 //
6 //  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
7 //
8 //  This file is part of the Blaze library. You can redistribute it and/or modify it under
9 //  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
10 //  forms, with or without modification, are permitted provided that the following conditions
11 //  are met:
12 //
13 //  1. Redistributions of source code must retain the above copyright notice, this list of
14 //     conditions and the following disclaimer.
15 //  2. Redistributions in binary form must reproduce the above copyright notice, this list
16 //     of conditions and the following disclaimer in the documentation and/or other materials
17 //     provided with the distribution.
18 //  3. Neither the names of the Blaze development group nor the names of its contributors
19 //     may be used to endorse or promote products derived from this software without specific
20 //     prior written permission.
21 //
22 //  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 //  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 //  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 //  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 //  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 //  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 //  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 //  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 //  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 //  DAMAGE.
32 */
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_TYPETRAITS_HASCONSTDATAACCESS_H_
36 #define _BLAZE_MATH_TYPETRAITS_HASCONSTDATAACCESS_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/util/IntegralConstant.h>
44 
45 
46 namespace blaze {
47 
48 //=================================================================================================
49 //
50 //  CLASS DEFINITION
51 //
52 //=================================================================================================
53 
54 //*************************************************************************************************
55 /*!\brief Compile time check for low-level access to constant data.
56 // \ingroup math_type_traits
57 //
58 // This type trait tests whether the given data type provides a low-level access to constant
59 // data via a const 'data' member function. In case the according member function is provided,
60 // the \a value member constant is set to \a true, the nested type definition \a Type is
61 // \a TrueType, and the class derives from \a TrueType. Otherwise \a value is set to \a false,
62 // \a Type is \a FalseType, and the class derives from \a FalseType. Examples:
63 
64    \code
65    blaze::HasConstDataAccess< StaticVector<float,3U> >::value      // Evaluates to 1
66    blaze::HasConstDataAccess< const DynamicVector<double> >::Type  // Results in TrueType
67    blaze::HasConstDataAccess< volatile DynamicMatrix<int> >        // Is derived from TrueType
68    blaze::HasConstDataAccess< int >::value                         // Evaluates to 0
69    blaze::HasConstDataAccess< const CompressedVector<int> >::Type  // Results in FalseType
70    blaze::HasConstDataAccess< volatile CompressedMatrix<int> >     // Is derived from FalseType
71    \endcode
72 */
73 template< typename T >
74 struct HasConstDataAccess
75    : public FalseType
76 {};
77 //*************************************************************************************************
78 
79 
80 //*************************************************************************************************
81 /*! \cond BLAZE_INTERNAL */
82 /*!\brief Specialization of the HasConstDataAccess type trait for const types.
83 // \ingroup math_type_traits
84 */
85 template< typename T >
86 struct HasConstDataAccess< const T >
87    : public HasConstDataAccess<T>
88 {};
89 /*! \endcond */
90 //*************************************************************************************************
91 
92 
93 //*************************************************************************************************
94 /*! \cond BLAZE_INTERNAL */
95 /*!\brief Specialization of the HasConstDataAccess type trait for volatile types.
96 // \ingroup math_type_traits
97 */
98 template< typename T >
99 struct HasConstDataAccess< volatile T >
100    : public HasConstDataAccess<T>
101 {};
102 /*! \endcond */
103 //*************************************************************************************************
104 
105 
106 //*************************************************************************************************
107 /*! \cond BLAZE_INTERNAL */
108 /*!\brief Specialization of the HasConstDataAccess type trait for cv qualified types.
109 // \ingroup math_type_traits
110 */
111 template< typename T >
112 struct HasConstDataAccess< const volatile T >
113    : public HasConstDataAccess<T>
114 {};
115 /*! \endcond */
116 //*************************************************************************************************
117 
118 
119 //*************************************************************************************************
120 /*!\brief Auxiliary variable template for the HasConstDataAccess type trait.
121 // \ingroup math_type_traits
122 //
123 // The HasConstDataAccess_v variable template provides a convenient shortcut to access the nested
124 // \a value of the HasConstDataAccess class template. For instance, given the type \a T the
125 // following two statements are identical:
126 
127    \code
128    constexpr bool value1 = blaze::HasConstDataAccess<T>::value;
129    constexpr bool value2 = blaze::HasConstDataAccess_v<T>;
130    \endcode
131 */
132 template< typename T >
133 constexpr bool HasConstDataAccess_v = HasConstDataAccess<T>::value;
134 //*************************************************************************************************
135 
136 } // namespace blaze
137 
138 #endif
139