<commit_before>// Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file Tuple.h
/// @author <NAME>

#ifndef OPENVDB_MATH_TUPLE_HAS_BEEN_INCLUDED
#define OPENVDB_MATH_TUPLE_HAS_BEEN_INCLUDED

#include "Math.h"
#include <cmath>
#include <sstream>
#include <string>
#include <type_traits>


namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace math {

/// @brief Dummy class for tag dispatch of conversion constructors
struct Conversion {};


/// @class Tuple "Tuple.h"
/// A base class for homogenous tuple types
template<int SIZE, typename T>
class Tuple
{
public:
    using value_type = T;
    using ValueType = T;

    static const int size = SIZE;

    /// Trivial constructor, the Tuple is NOT initialized
    /// @note destructor, copy constructor, assignment operator and
    ///   move constructor are left to be defined by the compiler (default)
    Tuple() = default;

    /// @brief Conversion constructor.
    /// @details Tuples with different value types and different sizes can be
    /// interconverted using this member.  Converting from a larger tuple
    /// results in truncation; converting from a smaller tuple results in
    /// the extra data members being zeroed out.  This function assumes that
    /// the integer 0 is convertible to the tuple's value type.
    template <int src_size, typename src_valtype>
    explicit Tuple(Tuple<src_size, src_valtype> const &src) {
        enum { COPY_END = (SIZE < src_size ? SIZE : src_size) };

        for (int i = 0; i < COPY_END; ++i) {
            mm[i] = src[i];
        }
        for (int i = COPY_END; i < SIZE; ++i) {
            mm[i] = 0;
        }
    }

    // @brief  const access to an element in the tuple. The offset idx must be
    //   an integral type. A copy of the tuple data is returned.
    template <typename IdxT,
        typename std::enable_if<std::is_integral<IdxT>::value, bool>::type = true>
    T operator[](IdxT i) const {
        assert(i >= IdxT(0) && i < IdxT(SIZE));
        return mm[i];
    }

    // @brief  non-const access to an element in the tuple. The offset idx must be
    //   an integral type. A reference to the tuple data is returned.
    template <typename IdxT,
        typename std::enable_if<std::is_integral<IdxT>::value, bool>::type = true>
    T& operator[](IdxT i) {
        assert(i >= IdxT(0) && i < IdxT(SIZE));
        return mm[i];
    }

    // These exist solely to provide backwards compatibility with [] access of
    // non-integer types that were castable to 'int' (such as floating point type).
    // The above templates allow for any integer type to be used as an offset into
    // the tuple data.
    T operator[](int i) const { return this->operator[]<int>(i); }
    T& operator[](int i) { return this->operator[]<int>(i); }

    /// @name Compatibility
    /// These are mostly for backwards compatibility with functions that take
    /// old-style Vs (which are just arrays).
    //@{
    /// Copies this tuple into an array of a compatible type
    template <typename S>
    void toV(S *v) const {
        for (int i = 0; i < SIZE; ++i) {
            v[i] = mm[i];
        }
    }

    /// Exposes the internal array.  Be careful when using this function.
    value_type *asV() {
        return mm;
    }
    /// Exposes the internal array.  Be careful when using this function.
    value_type const *asV() const {
        return mm;
    }
    //@}  Compatibility

    /// @return string representation of Classname<commit_msg>fixed VS2017 build issue in Tuple.h<commit_after>// Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file Tuple.h
/// @author <NAME>

#ifndef OPENVDB_MATH_TUPLE_HAS_BEEN_INCLUDED
#define OPENVDB_MATH_TUPLE_HAS_BEEN_INCLUDED

#include "Math.h"
#include <cmath>
#include <sstream>
#include <string>
#include <type_traits>


namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace math {

/// @brief Dummy class for tag dispatch of conversion constructors
struct Conversion {};


/// @class Tuple "Tuple.h"
/// A base class for homogenous tuple types
template<int SIZE, typename T>
class Tuple
{
public:
    using value_type = T;
    using ValueType = T;

    static const int size = SIZE;

    /// Trivial constructor, the Tuple is NOT initialized
    /// @note destructor, copy constructor, assignment operator and
    ///   move constructor are left to be defined by the compiler (default)
    Tuple() = default;

    /// @brief Conversion constructor.
    /// @details Tuples with different value types and different sizes can be
    /// interconverted using this member.  Converting from a larger tuple
    /// results in truncation; converting from a smaller tuple results in
    /// the extra data members being zeroed out.  This function assumes that
    /// the integer 0 is convertible to the tuple's value type.
    template <int src_size, typename src_valtype>
    explicit Tuple(Tuple<src_size, src_valtype> const &src) {
        enum { COPY_END = (SIZE < src_size ? SIZE : src_size) };

        for (int i = 0; i < COPY_END; ++i) {
            mm[i] = src[i];
        }
        for (int i = COPY_END; i < SIZE; ++i) {
            mm[i] = 0;
        }
    }

    // @brief  const access to an element in the tuple. The offset idx must be
    //   an integral type. A copy of the tuple data is returned.
    template <typename IdxT,
        typename std::enable_if<std::is_integral<IdxT>::value, bool>::type = true>
    T operator[](IdxT i) const {
        assert(i >= IdxT(0) && i < IdxT(SIZE));
        return mm[i];
    }

    // @brief  non-const access to an element in the tuple. The offset idx must be
    //   an integral type. A reference to the tuple data is returned.
    template <typename IdxT,
        typename std::enable_if<std::is_integral<IdxT>::value, bool>::type = true>
    T& operator[](IdxT i) {
        assert(i >= IdxT(0) && i < IdxT(SIZE));
        return mm[i];
    }

    // These exist solely to provide backwards compatibility with [] access of
    // non-integer types that were castable to 'int' (such as floating point type).
    // The above templates allow for any integer type to be used as an offset into
    // the tuple data.
    T operator[](int i) const { return this->template operator[]<int>(i); }
    T& operator[](int i) { return this->template operator[]<int>(i); }

    /// @name Compatibility
    /// These are mostly for backwards compatibility with functions that take
    /// old-style Vs (which are just arrays).
    //@{
    /// Copies this tuple into an array of a compatible type
    template <typename S>
    void toV(S *v) const {
        for (int i = 0; i < SIZE; ++i) {
            v[i] = mm[i];
        }
    }

    /// Exposes the internal array.  Be careful when using this function.
    value_type *asV() {
        return mm;
    }
    /// Exposes the internal array.  Be careful when using this function.
    value_type const *asV() const {
        return mm;
    }
    //@}  Compatibility

    /// @return string representation of Classname
{'fraction_non_alphanumeric': 0.10792273236282195, 'fraction_numerical': 0.002799552071668533, 'mean_word_length': 2.610409297625063, 'pattern_counts': {'":': 0, '<': 49, '<?xml version=': 0, '>': 45, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '95368', 'n_tokens_mistral': 2184, 'n_tokens_neox': 2119, 'n_words': 810}