Subversion Repositories Kolibri OS

// This file was GENERATED by command:

//     pump.py gtest-param-util-generated.h.pump

// DO NOT EDIT BY HAND!!!

// Copyright 2008 Google Inc.

// All Rights Reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: vladl@google.com (Vlad Losev)

// Type and function utilities for implementing parameterized tests.

// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!

//

// Currently Google Test supports at most 50 arguments in Values,

// and at most 10 arguments in Combine. Please contact

// googletestframework@googlegroups.com if you need more.

// Please note that the number of arguments to Combine is limited

// by the maximum arity of the implementation of tr1::tuple which is

// currently set at 10.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_

// scripts/fuse_gtest.py depends on gtest's own header being #included

// *unconditionally*.  Therefore these #includes cannot be moved

// inside #if GTEST_HAS_PARAM_TEST.

#include "gtest/internal/gtest-param-util.h"

#include "gtest/internal/gtest-port.h"

#if GTEST_HAS_PARAM_TEST

namespace testing {

// Forward declarations of ValuesIn(), which is implemented in

// include/gtest/gtest-param-test.h.

template 

internal::ParamGenerator<

  typename ::testing::internal::IteratorTraits::value_type>

ValuesIn(ForwardIterator begin, ForwardIterator end);

template 

internal::ParamGenerator ValuesIn(const T (&array)[N]);

template 

internal::ParamGenerator ValuesIn(

    const Container& container);

namespace internal {

// Used in the Values() function to provide polymorphic capabilities.

template 

class ValueArray1 {

 public:

  explicit ValueArray1(T1 v1) : v1_(v1) {}

  template 

  operator ParamGenerator() const { return ValuesIn(&v1_, &v1_ + 1); }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray1& other);

  const T1 v1_;

};

template 

class ValueArray2 {

 public:

  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray2& other);

  const T1 v1_;

  const T2 v2_;

};

template 

class ValueArray3 {

 public:

  ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray3& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

};

template 

class ValueArray4 {

 public:

  ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray4& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

};

template 

class ValueArray5 {

 public:

  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4), v5_(v5) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray5& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

};

template 

    typename T6>

class ValueArray6 {

 public:

  ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),

      v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray6& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

};

template 

    typename T6, typename T7>

class ValueArray7 {

 public:

  ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),

      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray7& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

};

template 

    typename T6, typename T7, typename T8>

class ValueArray8 {

 public:

  ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,

      T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray8& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

};

template 

    typename T6, typename T7, typename T8, typename T9>

class ValueArray9 {

 public:

  ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,

      T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray9& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10>

class ValueArray10 {

 public:

  ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray10& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11>

class ValueArray11 {

 public:

  ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),

      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray11& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12>

class ValueArray12 {

 public:

  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),

      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray12& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13>

class ValueArray13 {

 public:

  ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),

      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),

      v12_(v12), v13_(v13) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray13& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14>

class ValueArray14 {

 public:

  ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),

      v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray14& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15>

class ValueArray15 {

 public:

  ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),

      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),

      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray15& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16>

class ValueArray16 {

 public:

  ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),

      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),

      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),

      v16_(v16) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray16& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17>

class ValueArray17 {

 public:

  ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,

      T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),

      v15_(v15), v16_(v16), v17_(v17) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray17& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18>

class ValueArray18 {

 public:

  ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),

      v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray18& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19>

class ValueArray19 {

 public:

  ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),

      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),

      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray19& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20>

class ValueArray20 {

 public:

  ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),

      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),

      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),

      v19_(v19), v20_(v20) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_), static_cast(v20_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray20& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

  const T20 v20_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21>

class ValueArray21 {

 public:

  ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),

      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),

      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),

      v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_), static_cast(v20_),

        static_cast(v21_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray21& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

  const T20 v20_;

  const T21 v21_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22>

class ValueArray22 {

 public:

  ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),

      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),

      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),

      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_), static_cast(v20_),

        static_cast(v21_), static_cast(v22_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray22& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

  const T20 v20_;

  const T21 v21_;

  const T22 v22_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23>

class ValueArray23 {

 public:

  ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),

      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),

      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),

      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),

      v23_(v23) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_), static_cast(v20_),

        static_cast(v21_), static_cast(v22_), static_cast(v23_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray23& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

  const T20 v20_;

  const T21 v21_;

  const T22 v22_;

  const T23 v23_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24>

class ValueArray24 {

 public:

  ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),

      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),

      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),

      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),

      v22_(v22), v23_(v23), v24_(v24) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_), static_cast(v20_),

        static_cast(v21_), static_cast(v22_), static_cast(v23_),

        static_cast(v24_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray24& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

  const T20 v20_;

  const T21 v21_;

  const T22 v22_;

  const T23 v23_;

  const T24 v24_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25>

class ValueArray25 {

 public:

  ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,

      T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),

      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),

      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),

        static_cast(v18_), static_cast(v19_), static_cast(v20_),

        static_cast(v21_), static_cast(v22_), static_cast(v23_),

        static_cast(v24_), static_cast(v25_)};

    return ValuesIn(array);

  }

 private:

  // No implementation - assignment is unsupported.

  void operator=(const ValueArray25& other);

  const T1 v1_;

  const T2 v2_;

  const T3 v3_;

  const T4 v4_;

  const T5 v5_;

  const T6 v6_;

  const T7 v7_;

  const T8 v8_;

  const T9 v9_;

  const T10 v10_;

  const T11 v11_;

  const T12 v12_;

  const T13 v13_;

  const T14 v14_;

  const T15 v15_;

  const T16 v16_;

  const T17 v17_;

  const T18 v18_;

  const T19 v19_;

  const T20 v20_;

  const T21 v21_;

  const T22 v22_;

  const T23 v23_;

  const T24 v24_;

  const T25 v25_;

};

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26>

class ValueArray26 {

 public:

  ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,

      T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),

      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),

      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),

      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}

  template 

  operator ParamGenerator() const {

    const T array[] = {static_cast(v1_), static_cast(v2_),

        static_cast(v3_), static_cast(v4_), static_cast(v5_),

        static_cast(v6_), static_cast(v7_), static_cast(v8_),

        static_cast(v9_), static_cast(v10_), static_cast(v11_),

        static_cast(v12_), static_cast(v13_), static_cast(v14_),

        static_cast(v15_), static_cast(v16_), static_cast(v17_),