chromium/third_party/tflite/src/tensorflow/lite/array.h

/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#ifndef TENSORFLOW_LITE_ARRAY_H_
#define TENSORFLOW_LITE_ARRAY_H_

#include <cstring>
#include <initializer_list>
#include <memory>
#include <type_traits>
#include <vector>

#include "tensorflow/lite/core/c/common.h"

namespace tflite {

/// TfLite*Array helpers

namespace array_internal {

// Function object used as a deleter for unique_ptr holding TFLite*Array
// objects.
struct TfLiteArrayDeleter { … };

// Maps T to the corresponding TfLiteArray type.
template <class T>
struct TfLiteArrayInfo;

template <>
struct TfLiteArrayInfo<int> { … };

template <>
struct TfLiteArrayInfo<float> { … };

}  // namespace array_internal

TfLiteArrayUniquePtr;

// `unique_ptr` wrapper for `TfLiteIntArray`s.
IntArrayUniquePtr;

// `unique_ptr` wrapper for `TfLiteFloatArray`s.
FloatArrayUniquePtr;

// Allocates a TfLiteArray of given size using malloc.
//
// This builds an int array by default as this is the overwhelming part of the
// use cases.
template <class T = int>
TfLiteArrayUniquePtr<T> BuildTfLiteArray(int size);

// Allocates a TfLiteIntArray of given size using malloc.
template <>
inline IntArrayUniquePtr BuildTfLiteArray<int>(const int size) { … }

// Allocates a TfLiteFloatArray of given size using malloc.
template <>
inline FloatArrayUniquePtr BuildTfLiteArray<float>(const int size) { … }

// Allocates a TFLiteArray of given size and initializes it with the given
// values.
//
// `values` is expected to holds `size` elements.
//
// If T is explicitely specified and the type of values is not the same as T,
// then a static_cast is performed.
template <class T = void, class U,
          class Type = std::conditional_t<std::is_same<T, void>::value, U, T>>
TfLiteArrayUniquePtr<Type> BuildTfLiteArray(const int size,
                                            const U* const values) { … }

// Allocates a TFLiteArray and initializes it with the given array.
//
// `values` is expected to holds `size` elements.
template <class T, size_t N>
TfLiteArrayUniquePtr<T> BuildTfLiteArray(const T (&values)[N]) { … }

// Allocates a TFLiteArray and initializes it with the given values.
//
// This uses SFINAE to only be picked up by for types that implement `data()`
// and `size()` member functions. We cannot reuse detection facilities provided
// by Abseil in this code.
//
// To conform with the other overloads, we allow specifying the type of the
// array as well as deducing it from the container.
template <
    class T = void, class Container,
    class ElementType =
        std::decay_t<decltype(*std::declval<Container>().data())>,
    class SizeType = std::decay_t<decltype(std::declval<Container>().size())>,
    class Type =
        std::conditional_t<std::is_same<T, void>::value, ElementType, T>>
TfLiteArrayUniquePtr<Type> BuildTfLiteArray(const Container& values) { … }

// Allocates a TFLiteArray and initializes it with the given values.
template <class T>
TfLiteArrayUniquePtr<T> BuildTfLiteArray(
    const std::initializer_list<T>& values) { … }

// Allocates a TFLiteArray and initializes it with the given array.
inline IntArrayUniquePtr BuildTfLiteArray(const TfLiteIntArray& other) { … }

// Allocates a TFLiteArray and initializes it with the given array.
inline FloatArrayUniquePtr BuildTfLiteArray(const TfLiteFloatArray& other) { … }

}  // namespace tflite

#endif  // TENSORFLOW_LITE_ARRAY_H_