Vc/common/gatherinterface_deprecated.h

0001     /// \name Deprecated Members
0002     ///@{
0003
0004     /**
0005      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0006      *
0007      * \param array   A pointer into memory (without alignment restrictions).
0008      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0009      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0010      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0011      *                (&(array->*member1))[i])
0012      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0013      *                to. The type of indexes can either be an integer vector or a type that supports
0014      *                operator[] access.
0015      */
0016     template <typename S1, typename IT>
0017     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0018                   "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
0019                                                            const EntryType S1::*member1,
0020                                                            IT indexes)
0021     {
0022         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0023                    array, indexes)[member1]
0024                    .gatherArguments());
0025     }
0026
0027     /**
0028      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0029      *
0030      * \param array   A pointer into memory (without alignment restrictions).
0031      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0032      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0033      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0034      *                (&(array->*member1))[i])
0035      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0036      *                to. The type of indexes can either be an integer vector or a type that supports
0037      *                operator[] access.
0038      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0039      */
0040     template <typename S1, typename IT>
0041     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0042                   "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
0043                                                            const EntryType S1::*member1,
0044                                                            IT indexes, MaskArgument mask)
0045     {
0046         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0047                    array, indexes)[member1]
0048                    .gatherArguments(),
0049                mask);
0050     }
0051
0052     /**
0053      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0054      *
0055      * \param array   A pointer into memory (without alignment restrictions).
0056      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0057      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0058      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0059      *                (&(array->*member1))[i])
0060      * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
0061      *                struct (i.e. array[i].*member1.*member2 is read).
0062      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0063      *                to. The type of indexes can either be an integer vector or a type that supports
0064      *                operator[] access.
0065      */
0066     template <typename S1, typename S2, typename IT>
0067     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0068                   "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
0069                                                            const S2 S1::*member1,
0070                                                            const EntryType S2::*member2,
0071                                                            IT indexes)
0072     {
0073         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0074                    array, indexes)[member1][member2]
0075                    .gatherArguments());
0076     }
0077
0078     /**
0079      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0080      *
0081      * \param array   A pointer into memory (without alignment restrictions).
0082      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0083      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0084      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0085      *                (&(array->*member1))[i])
0086      * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
0087      *                struct (i.e. array[i].*member1.*member2 is read).
0088      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0089      *                to. The type of indexes can either be an integer vector or a type that supports
0090      *                operator[] access.
0091      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0092      */
0093     template <typename S1, typename S2, typename IT>
0094     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0095                   "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
0096                                                            const S2 S1::*member1,
0097                                                            const EntryType S2::*member2,
0098                                                            IT indexes, MaskArgument mask)
0099     {
0100         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0101                    array, indexes)[member1][member2]
0102                    .gatherArguments(),
0103                mask);
0104     }
0105
0106     /**
0107      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0108      *
0109      * \param array   A pointer into memory (without alignment restrictions).
0110      * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
0111      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0112      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0113      *                (&(array->*member1))[i])
0114      * \param outerIndexes
0115      * \param innerIndexes
0116      */
0117     template <typename S1, typename IT1, typename IT2>
0118     Vc_DEPRECATED(
0119         "use the subscript operator to Vc::array or Vc::vector "
0120         "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
0121                                                  const EntryType *const S1::*ptrMember1,
0122                                                  IT1 outerIndexes, IT2 innerIndexes)
0123     {
0124         gather(Common::SubscriptOperation<const S1, IT1, std::ratio<1, 1>, true>(
0125                    array, outerIndexes)[ptrMember1][innerIndexes]
0126                    .gatherArguments());
0127     }
0128
0129     /**
0130      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0131      *
0132      * \param array   A pointer into memory (without alignment restrictions).
0133      * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
0134      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0135      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0136      *                (&(array->*member1))[i])
0137      * \param outerIndexes
0138      * \param innerIndexes
0139      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0140      */
0141     template <typename S1, typename IT1, typename IT2>
0142     Vc_DEPRECATED(
0143         "use the subscript operator to Vc::array or Vc::vector "
0144         "instead.") inline Vc_CURRENT_CLASS_NAME(const S1 *array,
0145                                                  const EntryType *const S1::*ptrMember1,
0146                                                  IT1 outerIndexes, IT2 innerIndexes,
0147                                                  MaskArgument mask)
0148     {
0149         gather(Common::SubscriptOperation<const S1, IT1, std::ratio<1, 1>, true>(
0150                    array, outerIndexes)[ptrMember1][innerIndexes]
0151                    .gatherArguments(),
0152                mask);
0153     }
0154
0155     /**
0156      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0157      *
0158      * \param array   A pointer into memory (without alignment restrictions).
0159      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0160      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0161      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0162      *                (&(array->*member1))[i])
0163      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0164      *                to. The type of indexes can either be an integer vector or a type that supports
0165      *                operator[] access.
0166      */
0167     template <typename S1, typename IT>
0168     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0169                   "instead.") inline void gather(const S1 *array,
0170                                                  const EntryType S1::*member1, IT indexes)
0171     {
0172         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0173                    array, indexes)[member1]
0174                    .gatherArguments());
0175     }
0176
0177     /**
0178      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0179      *
0180      * \param array   A pointer into memory (without alignment restrictions).
0181      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0182      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0183      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0184      *                (&(array->*member1))[i])
0185      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0186      *                to. The type of indexes can either be an integer vector or a type that supports
0187      *                operator[] access.
0188      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0189      */
0190     template <typename S1, typename IT>
0191     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0192                   "instead.") inline void gather(const S1 *array,
0193                                                  const EntryType S1::*member1,
0194                                                  IT indexes,
0195                                                  MaskArgument mask)
0196     {
0197         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0198                    array, indexes)[member1]
0199                    .gatherArguments(),
0200                mask);
0201     }
0202
0203     /**
0204      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0205      *
0206      * \param array   A pointer into memory (without alignment restrictions).
0207      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0208      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0209      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0210      *                (&(array->*member1))[i])
0211      * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
0212      *                struct (i.e. array[i].*member1.*member2 is read).
0213      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0214      *                to. The type of indexes can either be an integer vector or a type that supports
0215      *                operator[] access.
0216      */
0217     template <typename S1, typename S2, typename IT>
0218     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0219                   "instead.") inline void gather(const S1 *array, const S2 S1::*member1,
0220                                                  const EntryType S2::*member2, IT indexes)
0221     {
0222         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0223                    array, indexes)[member1][member2]
0224                    .gatherArguments());
0225     }
0226
0227     /**
0228      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0229      *
0230      * \param array   A pointer into memory (without alignment restrictions).
0231      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0232      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0233      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0234      *                (&(array->*member1))[i])
0235      * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
0236      *                struct (i.e. array[i].*member1.*member2 is read).
0237      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0238      *                to. The type of indexes can either be an integer vector or a type that supports
0239      *                operator[] access.
0240      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0241      */
0242     template <typename S1, typename S2, typename IT>
0243     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0244                   "instead.") inline void gather(const S1 *array, const S2 S1::*member1,
0245                                                  const EntryType S2::*member2, IT indexes,
0246                                                  MaskArgument mask)
0247     {
0248         gather(Common::SubscriptOperation<const S1, IT, std::ratio<1, 1>, true>(
0249                    array, indexes)[member1][member2]
0250                    .gatherArguments(),
0251                mask);
0252     }
0253
0254     /**
0255      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0256      *
0257      * \param array   A pointer into memory (without alignment restrictions).
0258      * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
0259      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0260      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0261      *                (&(array->*member1))[i])
0262      * \param outerIndexes
0263      * \param innerIndexes
0264      */
0265     template <typename S1, typename IT1, typename IT2>
0266     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0267                   "instead.") inline void gather(const S1 *array,
0268                                                  const EntryType *const S1::*ptrMember1,
0269                                                  IT1 outerIndexes, IT2 innerIndexes)
0270     {
0271         gather(Common::SubscriptOperation<const S1, IT1, std::ratio<1, 1>, true>(
0272                    array, outerIndexes)[ptrMember1][innerIndexes]
0273                    .gatherArguments());
0274     }
0275
0276     /**
0277      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0278      *
0279      * \param array   A pointer into memory (without alignment restrictions).
0280      * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
0281      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0282      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0283      *                (&(array->*member1))[i])
0284      * \param outerIndexes
0285      * \param innerIndexes
0286      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0287      */
0288     template <typename S1, typename IT1, typename IT2>
0289     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0290                   "instead.") inline void gather(const S1 *array,
0291                                                  const EntryType *const S1::*ptrMember1,
0292                                                  IT1 outerIndexes, IT2 innerIndexes,
0293                                                  MaskArgument mask)
0294     {
0295         gather(Common::SubscriptOperation<const S1, IT1, std::ratio<1, 1>, true>(
0296                    array, outerIndexes)[ptrMember1][innerIndexes]
0297                    .gatherArguments(),
0298                mask);
0299     }
0300     ///@}