Vc/common/scatterinterface_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 void scatter(S1 *array, EntryType S1::*member1,
0019                                                   IT indexes) const
0020     {
0021         scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
0022                     array, indexes)[member1]
0023                     .scatterArguments());
0024     }
0025
0026     /**
0027      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0028      *
0029      * \param array   A pointer into memory (without alignment restrictions).
0030      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0031      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0032      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0033      *                (&(array->*member1))[i])
0034      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0035      *                to. The type of indexes can either be an integer vector or a type that supports
0036      *                operator[] access.
0037      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0038      */
0039     template <typename S1, typename IT>
0040     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0041                   "instead.") inline void scatter(S1 *array, EntryType S1::*member1,
0042                                                   IT indexes, MaskArgument mask) const
0043     {
0044         scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
0045                     array, indexes)[member1]
0046                     .scatterArguments(),
0047                 mask);
0048     }
0049
0050     /**
0051      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0052      *
0053      * \param array   A pointer into memory (without alignment restrictions).
0054      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0055      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0056      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0057      *                (&(array->*member1))[i])
0058      * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
0059      *                struct (i.e. array[i].*member1.*member2 is read).
0060      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0061      *                to. The type of indexes can either be an integer vector or a type that supports
0062      *                operator[] access.
0063      */
0064     template <typename S1, typename S2, typename IT>
0065     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0066                   "instead.") inline void scatter(S1 *array, S2 S1::*member1,
0067                                                   EntryType S2::*member2,
0068                                                   IT indexes) const
0069     {
0070         scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
0071                     array, indexes)[member1][member2]
0072                     .scatterArguments());
0073     }
0074
0075     /**
0076      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0077      *
0078      * \param array   A pointer into memory (without alignment restrictions).
0079      * \param member1 If \p array points to a struct, \p member1 determines the member in the struct to
0080      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0081      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0082      *                (&(array->*member1))[i])
0083      * \param member2 If \p member1 is a struct then \p member2 selects the member to be read from that
0084      *                struct (i.e. array[i].*member1.*member2 is read).
0085      * \param indexes Determines the offsets into \p array where the values are gathered from/scattered
0086      *                to. The type of indexes can either be an integer vector or a type that supports
0087      *                operator[] access.
0088      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0089      */
0090     template <typename S1, typename S2, typename IT>
0091     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0092                   "instead.") inline void scatter(S1 *array, S2 S1::*member1,
0093                                                   EntryType S2::*member2, IT indexes,
0094                                                   MaskArgument mask) const
0095     {
0096         scatter(Common::SubscriptOperation<S1, IT, std::ratio<1, 1>, true>(
0097                     array, indexes)[member1][member2]
0098                     .scatterArguments(),
0099                 mask);
0100     }
0101
0102     /**
0103      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0104      *
0105      * \param array   A pointer into memory (without alignment restrictions).
0106      * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
0107      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0108      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0109      *                (&(array->*member1))[i])
0110      * \param outerIndexes
0111      * \param innerIndexes
0112      */
0113     template <typename S1, typename IT1, typename IT2>
0114     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0115                   "instead.") inline void scatter(S1 *array, EntryType *S1::*ptrMember1,
0116                                                   IT1 outerIndexes,
0117                                                   IT2 innerIndexes) const
0118     {
0119         scatter(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
0120                     array, outerIndexes)[ptrMember1][innerIndexes]
0121                     .scatterArguments());
0122     }
0123
0124     /**
0125      * \deprecated Use Vc::array or Vc::vector subscripting instead.
0126      *
0127      * \param array   A pointer into memory (without alignment restrictions).
0128      * \param ptrMember1 If \p array points to a struct, \p member1 determines the member in the struct to
0129      *                be read. Thus the offsets in \p indexes are relative to the \p array and not to
0130      *                the size of the gathered type (i.e. array[i].*member1 is accessed instead of
0131      *                (&(array->*member1))[i])
0132      * \param outerIndexes
0133      * \param innerIndexes
0134      * \param mask    If a mask is given only the active entries will be gathered/scattered.
0135      */
0136     template <typename S1, typename IT1, typename IT2>
0137     Vc_DEPRECATED("use the subscript operator to Vc::array or Vc::vector "
0138                   "instead.") inline void scatter(S1 *array, EntryType *S1::*ptrMember1,
0139                                                   IT1 outerIndexes, IT2 innerIndexes,
0140                                                   MaskArgument mask) const
0141     {
0142         scatter(Common::SubscriptOperation<S1, IT1, std::ratio<1, 1>, true>(
0143                     array, outerIndexes)[ptrMember1][innerIndexes]
0144                     .scatterArguments(),
0145                 mask);
0146     }
0147     ///@}