DYT/Tool/matlab/include/MatlabDataArray/ArrayFactory.hpp

/* Copyright 2014-2020 The MathWorks, Inc. */

#ifndef MATLAB_DATA_ARRAY_FACTORY_HPP_
#define MATLAB_DATA_ARRAY_FACTORY_HPP_

#include "TypedArray.hpp"
#include "ArrayDimensions.hpp"
#include "CharArray.hpp"
#include "StructArray.hpp"
#include "SparseArray.hpp"
#include "ObjectArray.hpp"
#include "Object.hpp"
#include "Enumeration.hpp"
#include "EnumArray.hpp"
#include "Exception.hpp"
#include "GetArrayType.hpp"
#include "String.hpp"
#include "matlab_extdata_defs.hpp"
#include "TypedIterator.hpp"
#include "Optional.hpp"
#include "GetReturnType.hpp"
#include "MemoryLayout.hpp"

#include "detail/ArrayFactoryHelpers.hpp"
#include "detail/StringHelpers.hpp"
#include "detail/HelperFunctions.hpp"
#include "detail/FunctionType.hpp"
#include "detail/ExceptionHelpers.hpp"
#include "detail/publish_util.hpp"

#include <string>
#include <initializer_list>
#include <stdint.h>
#include <iterator>
#include <vector>

namespace matlab {
namespace data {
namespace impl {
class ArrayFactoryImpl;
class ObjectImpl;
}

namespace detail {
class NameListImpl;
}

/**
 * The ArrayFactory base class provides all of the general APIs that
 * each of the concrete factories needs to support.
 */
class ArrayFactory {
  public:
    /**
     * Construct an ArrayFactory
     *
     * @throw FailedToLoadLibMatlabDataArrayException if necessary libraries are not found
     */
    ArrayFactory() {
        typedef int (*CreateArrayFactoryFcnPtr)(typename impl::ArrayFactoryImpl**);
        static const CreateArrayFactoryFcnPtr fcn =
            detail::resolveFunction<CreateArrayFactoryFcnPtr>(
                detail::FunctionType::CREATE_ARRAY_FACTORY);

        impl::ArrayFactoryImpl* impl = nullptr;
        detail::throwIfError(fcn(&impl));
        pImpl = std::shared_ptr<impl::ArrayFactoryImpl>(impl, [](impl::ArrayFactoryImpl* ptr) {
            typedef void (*DestroyArrayFactoryFcnPtr)(typename impl::ArrayFactoryImpl*);
            static const DestroyArrayFactoryFcnPtr destroyFcn =
                detail::resolveFunction<DestroyArrayFactoryFcnPtr>(
                    detail::FunctionType::DESTROY_ARRAY_FACTORY);
            destroyFcn(ptr);
        });
    }

    /**
     * ArrayFactory destructor
     *
     * @throw none
     */
    ~ArrayFactory() MW_NOEXCEPT {
    }

    /**
     * Creates a TypedArray<T> with the given dimensions
     *
     * @param dims - the dimensions for the Array
     *
     * @return TypedArray<T> - an Array with the appropriate type and dimensions
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw InvalidArrayType - if array type of the new array is not recognized as valid
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     */
    template <typename T>
    TypedArray<T> createArray(ArrayDimensions dims) {
        typedef int (*CreateArrayWithDimsFcnPtr)(typename impl::ArrayFactoryImpl*, int, size_t*, size_t,
                                                 typename impl::ArrayImpl**);
        static const CreateArrayWithDimsFcnPtr fcn =
            detail::resolveFunction<CreateArrayWithDimsFcnPtr>(
                detail::FunctionType::CREATE_ARRAY_WITH_DIMS);
        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(fcn(pImpl.get(), static_cast<int>(GetArrayType<T>::type), &dims[0],
                                 dims.size(), &impl));
        return detail::Access::createObj<TypedArray<T>>(impl);
    }

    /**
     * Creates a TypedArray<T> with the given dimensions and filled in with the
     * data specified by the begin and end iterators. Data is copied and must be in column major
     * order. The data type for the array is determined by the value_type of the iterator.
     *
     * @param dims - the dimensions for the Array
     * @param begin - start of the user supplied data
     * @param end - end of the user supplied data
     *
     * @return TypedArray<T> - an Array with the appropriate type, dimensions and data
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw InvalidArrayType - if array type of the new array is not recognized as valid
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     */
    template <typename ItType,
              typename T =
                  typename std::remove_cv<typename std::iterator_traits<ItType>::value_type>::type>
    TypedArray<typename GetReturnType<T>::type> createArray(ArrayDimensions dims,
                                                            ItType begin,
                                                            ItType end) {
        return detail::createArrayWithIterator(pImpl.get(), std::move(dims), begin, end);
    }

    /**
     * Creates a TypedArray<T> with the given dimensions and filled in with the
     * supplied data in the initializer list. Data must be in column major order.
     *
     * @param dims - the dimensions for the Array
     * @param data - initializer list containing the data
     *
     * @return TypedArray<T> - an Array with the appropriate type, dimensions and data
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw InvalidArrayType - if array type of the new array is not recognized as valid
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     */
    template <typename T>
    TypedArray<typename GetReturnType<T>::type> createArray(ArrayDimensions dims,
                                                            std::initializer_list<T> data) {
        return detail::createArrayWithIterator(pImpl.get(), std::move(dims), data.begin(),
                                               data.end());
    };

    /**
     * Creates a TypedArray<T> with the given dimensions and filled in with the
     * data specified by C-style begin and end pointers. Data is copied and must be in column major
     * order. This methods supports all arithmetic types.
     *
     * @param dims - the dimensions for the Array
     * @param T*  - start of the user supplied data
     * @param T*  - end of the user supplied data
     *
     * @return TypedArray<T> - an Array with the appropriate type, dimensions and data
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw InvalidArrayType - if array type of the new array is not recognized as valid
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     */
    template <typename T>
    typename std::enable_if<std::is_arithmetic<T>::value || is_complex<T>::value, TypedArray<T>>::type
    createArray(ArrayDimensions dims, const T* const begin, const T* const end) {
        typedef int (*CreateArrayWithDimsAndDataFcnPtr)(
            typename impl::ArrayFactoryImpl * impl, int arrayType, size_t* dims, size_t numDims,
            const void* const dataStart, size_t numEl, typename impl::ArrayImpl**);
        static const CreateArrayWithDimsAndDataFcnPtr fcn =
            detail::resolveFunction<CreateArrayWithDimsAndDataFcnPtr>(
                detail::FunctionType::CREATE_ARRAY_WITH_DIMS_AND_DATA);

        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(fcn(pImpl.get(), static_cast<int>(GetArrayType<T>::type), &dims[0],
                                 dims.size(), begin, (end - begin), &impl));
        return detail::Access::createObj<TypedArray<T>>(impl);
    }


    /**
     * Creates a scalar TypedArray<T> with the given value. This methods supports
     * all arithmetic types.
     *
     * @param val - the value to be inserted into the scalar
     *
     * @return TypedArray<T> - an Array with the appropriate type and data
     *
     * @throw InvalidArrayType - if array type of the new array is not recognized as valid
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    template <typename T>
    typename std::enable_if<std::is_arithmetic<T>::value, TypedArray<T>>::type createScalar(
        const T val) {
        typedef int (*CreateScalarArrayFcnPtr)(typename impl::ArrayFactoryImpl * impl, int arrayType,
                                               const void* data, typename impl::ArrayImpl**);
        static const CreateScalarArrayFcnPtr fcn = detail::resolveFunction<CreateScalarArrayFcnPtr>(
            detail::FunctionType::CREATE_SCALAR_ARRAY);
        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(
            fcn(pImpl.get(), static_cast<int>(GetArrayType<T>::type), &val, &impl));
        return detail::Access::createObj<TypedArray<T>>(impl);
    }

    /**
     * Creates a scalar TypedArray<T> with the given value. This methods supports
     * all complex types.
     *
     * @param val - the value to be inserted into the scalar
     *
     * @return TypedArray<T> - an Array with the appropriate type and data
     *
     * @throw InvalidArrayType - if array type of the new array is not recognized as valid
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    template <typename T>
    typename std::enable_if<is_complex<T>::value, TypedArray<T>>::type createScalar(const T val) {
        auto arr = createArray<T>({1, 1});
        arr[0] = val;
        return arr;
    }

    /**
     * Creates a scalar TypedArray<MATLABString> with the given value
     *
     * @param val - the string to be inserted into the scalar
     *
     * @return TypedArray<MATLABString> - a newly created TypedArray of MATLABString
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    TypedArray<MATLABString> createScalar(const String val) {
        typedef int (*CreateScalarStringFcnPtr)(typename impl::ArrayFactoryImpl * impl, const char16_t* data,
                                                size_t strlen, typename impl::ArrayImpl**);
        static const CreateScalarStringFcnPtr fcn =
            detail::resolveFunction<CreateScalarStringFcnPtr>(
                detail::FunctionType::CREATE_SCALAR_STRING);
        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(fcn(pImpl.get(), val.c_str(), val.size(), &impl));
        return detail::Access::createObj<TypedArray<MATLABString>>(impl);
    }

    /**
     * Creates a scalar TypedArray<MATLABString> with the given value
     *
     * @param val - the string to be inserted into the scalar
     *
     * @return TypedArray<MATLABString> - an Array containing data of MATLABString type
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    TypedArray<MATLABString> createScalar(const MATLABString val) {
        impl::ArrayImpl* impl = nullptr;
        if (val) {
            typedef int (*CreateScalarStringFcnPtr)(typename impl::ArrayFactoryImpl * impl,
                                                    const char16_t* data, size_t strlen,
                                                    typename impl::ArrayImpl**);
            static const CreateScalarStringFcnPtr fcn =
                detail::resolveFunction<CreateScalarStringFcnPtr>(
                    detail::FunctionType::CREATE_SCALAR_STRING);
            String str = *val;
            detail::throwIfError(fcn(pImpl.get(), str.c_str(), str.size(), &impl));
        } else {
            typedef int (*CreateScalarMissingStringFcnPtr)(typename impl::ArrayFactoryImpl * impl,
                                                           typename impl::ArrayImpl**);
            static const CreateScalarMissingStringFcnPtr fcn2 =
                detail::resolveFunction<CreateScalarMissingStringFcnPtr>(
                    detail::FunctionType::CREATE_SCALAR_MISSING_STRING);
            detail::throwIfError(fcn2(pImpl.get(), &impl));
        }
        return detail::Access::createObj<TypedArray<MATLABString>>(impl);
    }

    /**
     * Creates a CellArray with specified dimensions.
     *
     * @param dims - the dimensions of the CellArray
     *
     * @return CellArray - newly created Cell Array
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     */
    CellArray createCellArray(ArrayDimensions dims) {
        return createArray<Array>(std::move(dims));
    }

    /**
     * Creates a CellArray with the data specified. Data is specified in column major order
     *
     * @param dims - the dimensions of the CellArray
     * @params data - elements to be inserted into the cell array. Primitive types, strings and
     *                Arrays are allowable inputs.
     *
     * @return CellArray - newly created Cell Array
     *
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    template <typename... Targs>
    TypedArray<Array> createCellArray(ArrayDimensions dims, Targs... data) {
        auto retVal = createArray<Array>(std::move(dims));
        if (retVal.getNumberOfElements() != 0) {
            setCellValues(retVal.begin(), retVal.end(), data...);
        }
        return retVal;
    }

    /**
     * Creates a scalar TypedArray<MATLABString> from 7-bit ascii input data
     * Input is converted to UTF16 prior to creating a TypedArray<MATLABString>
     *
     * @param val - std::string to be inserted into the scalar StringArray
     *
     * @return TypedArray<MATLABString> - a TypedArray with data of type MATLABString
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw NonAsciiCharInInputDataException - if input contains non-ascii data
     */
    TypedArray<MATLABString> createScalar(const std::string& val) {
        if (!detail::isAscii7(val)) {
            throw NonAsciiCharInInputDataException(
                std::string("Input data can only contain ASCII characters"));
        }
        return createScalar(String(val.begin(), val.end()));
    }

    /**
     * Creates a scalar ObjectArray
     *
     * @param val - val Object to be used to create the ObjectArray scalar
     *
     * @return ObjectArray - ObjectArray containing the object
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    ObjectArray createScalar(const Object& val) {
        impl::ArrayImpl* impl = nullptr;
        typedef int (*CreateScalarObjectFcnPtr)(typename impl::ArrayFactoryImpl* impl,
                                                impl::ObjectImpl* objImpl,
                                                typename impl::ArrayImpl**);
        static const CreateScalarObjectFcnPtr fcn =
            detail::resolveFunction<CreateScalarObjectFcnPtr>(
                detail::FunctionType::CREATE_SCALAR_OBJECT);
        detail::throwIfError(fcn(pImpl.get(),
                                 detail::Access::getImpl<impl::ObjectImpl>(val),
                                 &impl));
        return detail::Access::createObj<ObjectArray>(impl);
    }

    /**
     * Creates a 1xn CharArray from the specified char16_t string, where n is the
     * string length
     *
     * @param str - String containing the data to be filled into the Array
     *
     * @return CharArray - a CharArray object containing data copied from str
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    CharArray createCharArray(String str) {
        typedef int (*CreateCharArrayFromChar16FcnPtr)(
            typename impl::ArrayFactoryImpl * impl, const char16_t* data, size_t strlen, 
            typename impl::ArrayImpl**);
        static const CreateCharArrayFromChar16FcnPtr fcn =
            detail::resolveFunction<CreateCharArrayFromChar16FcnPtr>(
                detail::FunctionType::CREATE_CHAR_ARRAY_FROM_CHAR16);
        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(fcn(pImpl.get(), str.c_str(), str.size(), &impl));
        return detail::Access::createObj<CharArray>(impl);
    }

    /**
     * Creates a 1xn CharArray from the specified std::string, where n is the
     * string length.  Data is checked for 7-bit ascii and converted from
     * std::string<char> to std::string<CHAR16_T>.
     *
     * @param str - std::string containing the data to be filled into the Array
     *
     * @return CharArray - a CharArray object containing data copied from str
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw NonAsciiCharInInputDataException - if data contains non-ascii characters
     */
    CharArray createCharArray(const std::string& str) {
        if (!detail::isAscii7(str)) {
            throw NonAsciiCharInInputDataException(
                std::string("Input data can only contain ASCII characters"));
        }
        typedef int (*CreateCharArrayFromStringFcnPtr)(
            typename impl::ArrayFactoryImpl * impl, const char* data, size_t strlen, 
            typename impl::ArrayImpl**);
        static const CreateCharArrayFromStringFcnPtr fcn =
            detail::resolveFunction<CreateCharArrayFromStringFcnPtr>(
                detail::FunctionType::CREATE_CHAR_ARRAY_FROM_STRING);
        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(fcn(pImpl.get(), str.c_str(), str.size(), &impl));
        return detail::Access::createObj<CharArray>(impl);
    }

    /**
     * Creates a StructArray with the given dimensions and fieldnames
     *
     * @param dims - the dimensions for the Array
     * @param fieldNames - vector of the field names for the struct
     *
     * @return StructArray - an Array with the appropriate dimensions and fieldNames
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     * @throw DuplicateFieldNameInStructArrayException - if duplicate field names are specified
     */
    StructArray createStructArray(ArrayDimensions dims, std::vector<std::string> fieldNames) {
        typedef detail::NameListImpl* (*CreateNamesFcnPtr)(size_t num);
        static const CreateNamesFcnPtr fcn3 =
            detail::resolveFunction<CreateNamesFcnPtr>(detail::FunctionType::CREATE_NAMES);
        NameList field_names(fcn3(fieldNames.size()));
        for (const auto& field : fieldNames) {
            typedef void (*AddNameFcnPtr)(typename detail::NameListImpl * impl, const char* name,
                                          size_t nameLen);
            static const AddNameFcnPtr fcn =
                detail::resolveFunction<AddNameFcnPtr>(detail::FunctionType::ADD_NAME);
            fcn(field_names.getImpl(), field.c_str(), field.size());
        }
        impl::ArrayImpl* impl = nullptr;
        typedef int (*CreateStructArrayFcnPtr)(typename impl::ArrayFactoryImpl * impl, size_t * dims,
                                               size_t numDims, typename detail::NameListImpl * names,
                                               typename impl::ArrayImpl**);
        static const CreateStructArrayFcnPtr fcn2 =
            detail::resolveFunction<CreateStructArrayFcnPtr>(
                detail::FunctionType::CREATE_STRUCT_ARRAY);
        detail::throwIfError(
            fcn2(pImpl.get(), &dims[0], dims.size(), field_names.getImpl(), &impl));
        return detail::Access::createObj<StructArray>(impl);
    }

    /**
     * Creates an Enumeration array. The class of the EnumArray is indicated by className.
     * The array is initialized with the list of enumeration names provided by the caller.
     *
     * @param dims array dimensions
     * @param className class name of the enumeration array
     * @param enums List of the enumeration names
     *
     * @return EnumArray - the EnumArray that was created
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw MustSpecifyClassNameException - if an empty class name is specified
     * @throw WrongNumberOfEnumsSuppliedException - if the wrong number of enumerations is provided
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     */
    EnumArray createEnumArray(ArrayDimensions dims,
                              std::string className,
                              std::vector<std::string> enums) {
        typedef detail::NameListImpl* (*CreateNamesFcnPtr)(size_t num);
        static const CreateNamesFcnPtr fcn3 =
            detail::resolveFunction<CreateNamesFcnPtr>(detail::FunctionType::CREATE_NAMES);
        NameList enum_names(fcn3(enums.size()));
        for (const auto& e : enums) {
            typedef void (*AddNameFcnPtr)(typename detail::NameListImpl * impl, const char* name,
                                          size_t nameLen);
            static const AddNameFcnPtr fcn =
                detail::resolveFunction<AddNameFcnPtr>(detail::FunctionType::ADD_NAME);
            fcn(enum_names.getImpl(), e.c_str(), e.size());
        }
        impl::ArrayImpl* impl = nullptr;
        typedef int (*CreateEnumArrayWithEnumsFcnPtr)(
            typename impl::ArrayFactoryImpl * impl, size_t * dims, size_t numDims, const char* cls,
            size_t clsSize, typename detail::NameListImpl* names, typename impl::ArrayImpl** retVal);
        static const CreateEnumArrayWithEnumsFcnPtr fcn2 =
            detail::resolveFunction<CreateEnumArrayWithEnumsFcnPtr>(
                detail::FunctionType::CREATE_ENUM_ARRAY_WITH_ENUMS);
        detail::throwIfError(fcn2(pImpl.get(), &dims[0], dims.size(), className.c_str(),
                                  className.size(), enum_names.getImpl(), &impl));
        return detail::Access::createObj<EnumArray>(impl);
    }

    /**
     * Creates an Enumeration array. The class of the EnumArray is indicated by className.
     *
     * @param dims array dimensions
     * @param className class name of the enumeration array
     *
     * @return EnumArray - the EnumArray that was created
     *
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     * @throw NumberOfElementsExceedsMaximumException - if the ArrayDimensions create an Array which exceeds the max
     * @throw MustSpecifyClassNameException - if an empty class name is specified
     */
    EnumArray createEnumArray(ArrayDimensions dims, std::string className) {
        typedef int (*CreateEnumArrayFcnPtr)(typename impl::ArrayFactoryImpl*, size_t*, size_t, const char*,
                                             size_t, typename impl::ArrayImpl**);
        static const CreateEnumArrayFcnPtr fcn =
            detail::resolveFunction<CreateEnumArrayFcnPtr>(detail::FunctionType::CREATE_ENUM_ARRAY);
        impl::ArrayImpl* impl = nullptr;
        detail::throwIfError(
            fcn(pImpl.get(), &dims[0], dims.size(), className.c_str(), className.size(), &impl));
        return detail::Access::createObj<EnumArray>(impl);
    }

    /**
     * Creates an empty Array. It contains no elements.
     *
     * @return Array - an empty Array
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    Array createEmptyArray() {
        return createArray<double>({0, 0});
    }

    /**
     * Creates a buffer which can be passed into createArrayFromBuffer()
     * No data copies are made when creating an Array from a buffer. Data
     * must be in column major order.
     *
     * @param numberOfElements - the number of elements, not the actual buffer size
     *
     * @return buffer_ptr<T> - unique_ptr containing the buffer
     *
     * @throw InvalidArrayTypeException - if buffer type is not recognized as valid
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    template <typename T>
    buffer_ptr_t<T> createBuffer(size_t numberOfElements) {
        void* buffer = nullptr;
        buffer_deleter_t deleter = nullptr;
        typedef int (*CreateBufferFcnPtr)(typename impl::ArrayFactoryImpl * impl, void** buffer,
                                          void (**deleter)(void*), int dataType,
                                          size_t numElements);
        static const CreateBufferFcnPtr fcn =
            detail::resolveFunction<CreateBufferFcnPtr>(detail::FunctionType::CREATE_BUFFER);
        detail::throwIfError(fcn(pImpl.get(), &buffer, &deleter,
                                 static_cast<int>(GetArrayType<T>::type), numberOfElements));
        return buffer_ptr_t<T>(static_cast<T*>(buffer), deleter);
    }

    /**
     * Creates a TypedArray<T> using the given buffer
     * No data copies are made when creating an Array from a buffer. The TypedArray<T>
     * takes ownership of the buffer.
     *
     * @param dims - the dimensions for the Array
     * @param buffer - buffer containing the data. Buffer will not be copied. Array takes ownership
     *
     * @return TypedArray<T> - TypedArray<T> which wraps the buffer
     *
     * @throw InvalidArrayTypeException - if buffer type is not recognized as valid
     * @throw FeatureNotSupportedException - if creating an array with a row major layout using a release prior to R2019a
     * @throw matlab::InvalidMemoryLayoutException - if the array could not be allocated
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     */
    template <typename T>
    TypedArray<T> createArrayFromBuffer(ArrayDimensions dims,
                                        buffer_ptr_t<T> buffer,
                                        MemoryLayout memoryLayout = MemoryLayout::COLUMN_MAJOR) {
        buffer_deleter_t deleter = buffer.get_deleter();
        impl::ArrayImpl* impl = nullptr;
        typedef int (*CreateArrayFromBufferV2FcnPtr)(
            typename impl::ArrayFactoryImpl * impl, int arrayType, size_t* dims, size_t numDims,
            void* buffer, void (*deleter)(void*), typename impl::ArrayImpl**, int memoryLayout);
        static const CreateArrayFromBufferV2FcnPtr fcn =
            detail::resolveFunctionNoExcept<CreateArrayFromBufferV2FcnPtr>(
                detail::FunctionType::CREATE_ARRAY_FROM_BUFFER_V2);
        if (fcn != nullptr) {
            detail::throwIfError(fcn(pImpl.get(), static_cast<int>(GetArrayType<T>::type), &dims[0],
                                     dims.size(), buffer.release(), deleter, &impl,
                                     static_cast<int>(memoryLayout)));
        }
        else {
            // new version is not available
            // if asking for a row-major need to throw
            if (memoryLayout == MemoryLayout::ROW_MAJOR) {
                throw FeatureNotSupportedException(std::string("Row-major buffers require ") +
                                                   std::string("2019a"));
            }
            typedef int (*CreateArrayFromBufferFcnPtr)(
                typename impl::ArrayFactoryImpl * impl, int arrayType, size_t* dims, size_t numDims,
                void* buffer, void (*deleter)(void*), typename impl::ArrayImpl**);
            static const CreateArrayFromBufferFcnPtr fcn =
                detail::resolveFunction<CreateArrayFromBufferFcnPtr>(
                    detail::FunctionType::CREATE_ARRAY_FROM_BUFFER);
            
            detail::throwIfError(fcn(pImpl.get(), static_cast<int>(GetArrayType<T>::type), &dims[0],
                                     dims.size(), buffer.release(), deleter, &impl));
        }
        return detail::Access::createObj<TypedArray<T>>(impl);
    }

    /**
     * Creates a SparseArray<T> with the given dimensions.
     * Only two dimensions are allowed for sparse arrays.
     *
     * @param dims - the dimensions for the Array
     * @param nnz - number of non-zero elements
     * @param data - buffer containing the non-zero elements. Buffer will not be copied. Array takes
     * ownership
     * @param rows - buffer containing the row value for each element. Buffer will not be copied.
     * Array takes ownership
     * @param cols - buffer containing the column value for each element. Buffer will not be copied.
     * Array takes ownership
     *
     * @return SparseArray<T> - a sparse array with the appropriate type and dimensions, and data
     *
     * @throw InvalidArrayTypeException - if array type is not recognized as valid
     * @throw InvalidDimensionsInSparseArrayException if more than two dimensions are specified.
     * @throw matlab::OutOfMemoryException - if the array could not be allocated
     *
     */
    template <typename T>
    typename std::enable_if<std::is_same<double, T>::value || std::is_same<bool, T>::value ||
                                std::is_same<std::complex<double>, T>::value,
                            SparseArray<T>>::type
    createSparseArray(ArrayDimensions dims,
                      size_t nnz,
                      buffer_ptr_t<T> data,
                      buffer_ptr_t<size_t> rows,
                      buffer_ptr_t<size_t> cols) {

        // If more than two dimensions are specified, throw an exception
        if (dims.size() > 2) {
            throw InvalidDimensionsInSparseArrayException(
                std::string("Sparse Array can only have 2 dimensions"));
        }

        buffer_deleter_t data_deleter = data.get_deleter();
        buffer_deleter_t rows_deleter = rows.get_deleter();
        buffer_deleter_t cols_deleter = cols.get_deleter();

        impl::ArrayImpl* impl = nullptr;
        typedef int (*CreateSparseArrayFromBufferFcnPtr)(
            typename impl::ArrayFactoryImpl * impl, int arrayType, size_t* dims, size_t numDims, size_t nnz,
            void* dataBuffer, void (*dataDeleter)(void*), size_t* rowsBuffer,
            void (*rowsDeleter)(void*), size_t* colsBuffer, void (*colsDeleter)(void*),
            typename impl::ArrayImpl**);
        static const CreateSparseArrayFromBufferFcnPtr fcn =
            detail::resolveFunction<CreateSparseArrayFromBufferFcnPtr>(
                detail::FunctionType::CREATE_SPARSE_ARRAY_FROM_BUFFER);
        detail::throwIfError(fcn(pImpl.get(), static_cast<int>(GetSparseArrayType<T>::type),
                                 &dims[0], dims.size(), nnz, data.release(), data_deleter,
                                 rows.release(), rows_deleter, cols.release(), cols_deleter,
                                 &impl));
        return detail::Access::createObj<SparseArray<T>>(impl);
    }


  protected:
    std::shared_ptr<impl::ArrayFactoryImpl> pImpl;

  private:
    ArrayFactory& operator=(ArrayFactory const& rhs) = delete;
    ArrayFactory(const ArrayFactory& rhs) = delete;

    class NameList {
      public:
        NameList(detail::NameListImpl* impl)
            : pImpl(std::shared_ptr<detail::NameListImpl>(impl, [](detail::NameListImpl* ptr) {
                typedef void (*DestroyNamesFcnPtr)(typename detail::NameListImpl * impl);
                static const DestroyNamesFcnPtr destroyFcn =
                    detail::resolveFunction<DestroyNamesFcnPtr>(
                        detail::FunctionType::DESTROY_NAMES);
                destroyFcn(ptr);
            })) {
        }

        detail::NameListImpl* getImpl() const {
            return pImpl.get();
        }

      private:
        std::shared_ptr<detail::NameListImpl> pImpl;
    };
    template <typename T>
    typename std::enable_if<!std::is_base_of<Array, T>::value, Array>::type createValue(T value) {
        return createScalar(std::move(value));
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Array, T>::value, Array>::type createValue(T value) {
        return matlab::data::Array(std::move(value));
    }
    template <typename T>
    void setCellValues(TypedIterator<Array> it, TypedIterator<Array> end, T value) {
        *it = createValue(std::move(value));
    }
    template <typename T, typename... Targs>
    void setCellValues(TypedIterator<Array> it, TypedIterator<Array> end, T value, Targs... args) {
        *it = createValue(std::move(value));
        if (++it != end) {
            setCellValues(std::move(it), std::move(end), args...);
        }
    }
};
} // namespace data
} // namespace matlab

#endif