ArrayType.cpp - platform/system/tools/hidl - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * 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.
  */

 #include "ArrayType.h"

 #include <android-base/logging.h>
 #include <hidl-util/Formatter.h>
 #include <iostream>

 #include "ConstantExpression.h"

 namespace android {

 ArrayType::ArrayType(const Reference<Type>& elementType, ConstantExpression* size, Scope* parent)
     : Type(parent, elementType.localName()), mElementType(elementType) {
     CHECK(!elementType.isEmptyReference());

     appendDimension(size);
 }

 void ArrayType::appendDimension(ConstantExpression *size) {
     mSizes.push_back(size);
     mDefinedName = mDefinedName + "[" + size->expression() + "]";
 }

 size_t ArrayType::countDimensions() const {
     return mSizes.size();
 }

 bool ArrayType::isArray() const {
     return true;
 }

 bool ArrayType::deepCanCheckEquality(std::unordered_set<const Type*>* visited) const {
     return mElementType->canCheckEquality(visited);
 }

 const Type* ArrayType::getElementType() const {
     return mElementType.get();
 }

 std::string ArrayType::typeName() const {
     if (dimension() == 1) {
         return "array of " + mElementType->typeName();
     }

     return std::to_string(dimension()) + "d array of " + mElementType->typeName();
 }

 std::vector<const Reference<Type>*> ArrayType::getReferences() const {
     return {&mElementType};
 }

 std::vector<const ConstantExpression*> ArrayType::getConstantExpressions() const {
     std::vector<const ConstantExpression*> ret;
     ret.insert(ret.end(), mSizes.begin(), mSizes.end());
     return ret;
 }

 status_t ArrayType::resolveInheritance() {
     // Resolve for typedefs
     while (mElementType->isArray()) {
         ArrayType* innerArray = static_cast<ArrayType*>(mElementType.get());
         mSizes.insert(mSizes.end(), innerArray->mSizes.begin(), innerArray->mSizes.end());
         mElementType = innerArray->mElementType;
     }
     return Type::resolveInheritance();
 }

 status_t ArrayType::validate() const {
     CHECK(!mElementType->isArray());

     if (mElementType->isInterface()) {
         std::cerr << "ERROR: Arrays of interface types are not supported"
                   << " at " << mElementType.location() << "\n";

         return UNKNOWN_ERROR;
     }
     return Type::validate();
 }

 std::string ArrayType::getCppType(StorageMode mode,
                                   bool specifyNamespaces) const {
     const std::string base = mElementType->getCppStackType(specifyNamespaces);

     std::string space = specifyNamespaces ? "::android::hardware::" : "";
     std::string arrayType = space + "hidl_array<" + base;

     for (size_t i = 0; i < mSizes.size(); ++i) {
         arrayType += ", " + mSizes[i]->cppValue();
     }

     arrayType += ">";

     switch (mode) {
         case StorageMode_Stack:
             return arrayType;

         case StorageMode_Argument:
             return "const " + arrayType + "&";

         case StorageMode_Result:
             return "const " + arrayType + "*";
     }

     CHECK(!"Should not be here");
 }

 std::string ArrayType::getInternalDataCppType() const {
     std::string result = mElementType->getCppStackType();
     for (size_t i = 0; i < mSizes.size(); ++i) {
         result += "[";
         result += mSizes[i]->cppValue();
         result += "]";
     }
     return result;
 }

 std::string ArrayType::getJavaType(bool forInitializer) const {
     std::string base =
         mElementType->getJavaType(forInitializer);

     for (size_t i = 0; i < mSizes.size(); ++i) {
         base += "[";

         if (forInitializer) {
             base += mSizes[i]->javaValue();
         } else {
             base += "/* " + mSizes[i]->expression() + " */";
         }

         base += "]";
     }

     return base;
 }

 std::string ArrayType::getVtsType() const {
     return "TYPE_ARRAY";
 }

 void ArrayType::emitReaderWriter(
         Formatter &out,
         const std::string &name,
         const std::string &parcelObj,
         bool parcelObjIsPointer,
         bool isReader,
         ErrorMode mode) const {
     std::string baseType = mElementType->getCppStackType();

     const std::string parentName = "_hidl_" + name + "_parent";

     out << "size_t " << parentName << ";\n\n";

     const std::string parcelObjDeref =
         parcelObj + (parcelObjIsPointer ? "->" : ".");

     size_t numArrayElements = 1;
     for (auto size : mSizes) {
         numArrayElements *= size->castSizeT();
     }
     if (isReader) {
         out << "_hidl_err = "
             << parcelObjDeref
             << "readBuffer("
             << numArrayElements
             << " * sizeof("
             << baseType
             << "), &"
             << parentName
             << ", "
             << " reinterpret_cast<const void **>("
             << "&" << name
             << "));\n\n";

         handleError(out, mode);
     } else {

         out << "_hidl_err = "
             << parcelObjDeref
             << "writeBuffer("
             << name
             << ".data(), "
             << numArrayElements
             << " * sizeof("
             << baseType
             << "), &"
             << parentName
             << ");\n";

         handleError(out, mode);
     }

     emitReaderWriterEmbedded(
             out,
             0 /* depth */,
             name,
             name /* sanitizedName */,
             isReader /* nameIsPointer */,
             parcelObj,
             parcelObjIsPointer,
             isReader,
             mode,
             parentName,
             "0 /* parentOffset */");
 }

 void ArrayType::emitReaderWriterEmbedded(
         Formatter &out,
         size_t depth,
         const std::string &name,
         const std::string &sanitizedName,
         bool nameIsPointer,
         const std::string &parcelObj,
         bool parcelObjIsPointer,
         bool isReader,
         ErrorMode mode,
         const std::string &parentName,
         const std::string &offsetText) const {
     if (!mElementType->needsEmbeddedReadWrite()) {
         return;
     }

     const std::string nameDeref = name + (nameIsPointer ? "->" : ".");

     std::string baseType = mElementType->getCppStackType();

     std::string iteratorName = "_hidl_index_" + std::to_string(depth);

     out << "for (size_t "
         << iteratorName
         << " = 0; "
         << iteratorName
         << " < "
         << dimension()
         << "; ++"
         << iteratorName
         << ") {\n";

     out.indent();

     mElementType->emitReaderWriterEmbedded(
             out,
             depth + 1,
             nameDeref + "data()[" + iteratorName + "]",
             sanitizedName + "_indexed",
             false /* nameIsPointer */,
             parcelObj,
             parcelObjIsPointer,
             isReader,
             mode,
             parentName,
             offsetText
                 + " + " + iteratorName + " * sizeof("
                 + baseType
                 + ")");

     out.unindent();

     out << "}\n\n";
 }

 void ArrayType::emitJavaDump(
         Formatter &out,
         const std::string &streamName,
         const std::string &name) const {
     out << streamName << ".append(java.util.Arrays."
         << (countDimensions() > 1 ? "deepToString" : "toString")
         << "("
         << name
         << "));\n";
 }


 bool ArrayType::needsEmbeddedReadWrite() const {
     return mElementType->needsEmbeddedReadWrite();
 }

 bool ArrayType::resultNeedsDeref() const {
     return true;
 }

 void ArrayType::emitJavaReaderWriter(
         Formatter &out,
         const std::string &parcelObj,
         const std::string &argName,
         bool isReader) const {
     size_t align, size;
     getAlignmentAndSize(&align, &size);

     if (isReader) {
         out << "new "
             << getJavaType(true /* forInitializer */)
             << ";\n";
     }

     out << "{\n";
     out.indent();

     out << "android.os.HwBlob _hidl_blob = ";

     if (isReader) {
         out << parcelObj
             << ".readBuffer("
             << size
             << " /* size */);\n";
     } else {
         out << "new android.os.HwBlob("
             << size
             << " /* size */);\n";
     }

     emitJavaFieldReaderWriter(
             out,
             0 /* depth */,
             parcelObj,
             "_hidl_blob",
             argName,
             "0 /* offset */",
             isReader);

     if (!isReader) {
         out << parcelObj << ".writeBuffer(_hidl_blob);\n";
     }

     out.unindent();
     out << "}\n";
 }

 void ArrayType::emitJavaFieldInitializer(
         Formatter &out, const std::string &fieldName) const {
     const std::string typeName = getJavaType(false /* forInitializer */);
     const std::string fieldDeclaration = typeName + " " + fieldName;

     emitJavaFieldDefaultInitialValue(out, fieldDeclaration);
 }

 void ArrayType::emitJavaFieldDefaultInitialValue(
         Formatter &out, const std::string &declaredFieldName) const {
     out << declaredFieldName
         << " = new "
         << getJavaType(true /* forInitializer */)
         << ";\n";
 }

 void ArrayType::emitJavaFieldReaderWriter(
         Formatter &out,
         size_t depth,
         const std::string &parcelName,
         const std::string &blobName,
         const std::string &fieldName,
         const std::string &offset,
         bool isReader) const {
     out << "{\n";
     out.indent();

     std::string offsetName = "_hidl_array_offset_" + std::to_string(depth);
     out << "long " << offsetName << " = " << offset << ";\n";

     const bool isPrimitiveArray = mElementType->isScalar();

     /* If the element type corresponds to a Java primitive type we can optimize
        the innermost loop by copying a linear range of memory instead of doing
        a per-element copy. As a result the outer nested loop does not include
        the final dimension. */
     const size_t loopDimensions = mSizes.size() - (isPrimitiveArray ? 1 : 0);

     std::string indexString;
     for (size_t dim = 0; dim < loopDimensions; ++dim) {
         std::string iteratorName =
             "_hidl_index_" + std::to_string(depth) + "_" + std::to_string(dim);

         out << "for (int "
             << iteratorName
             << " = 0; "
             << iteratorName
             << " < "
             << mSizes[dim]->javaValue()
             << "; ++"
             << iteratorName
             << ") {\n";

         out.indent();

         indexString += "[" + iteratorName + "]";
     }

     const bool isIndexed = (loopDimensions > 0);
     const std::string fieldNameWithCast = isIndexed
             ? "(" + getJavaTypeCast(fieldName) + ")" + indexString
             : getJavaTypeCast(fieldName);

     if (isReader && mElementType->isCompoundType()) {
         mElementType->emitJavaFieldDefaultInitialValue(out, fieldNameWithCast);
     }

     if (!isPrimitiveArray) {
         mElementType->emitJavaFieldReaderWriter(
                 out,
                 depth + 1,
                 parcelName,
                 blobName,
                 fieldNameWithCast,
                 offsetName,
                 isReader);

         size_t elementAlign, elementSize;
         mElementType->getAlignmentAndSize(&elementAlign, &elementSize);

         out << offsetName << " += " << std::to_string(elementSize) << ";\n";
     } else {
         if (isReader) {
             out << blobName
                 << ".copyTo"
                 << mElementType->getJavaSuffix()
                 << "Array("
                 << offsetName
                 << ", "
                 << fieldNameWithCast
                 << ", "
                 << mSizes.back()->javaValue()
                 << " /* size */);\n";
         } else {
             std::string elemName = "_hidl_array_item_" + std::to_string(depth);

             out << mElementType->getJavaType(false /* forInitializer */)
                 << "[] "
                 << elemName
                 << " = "
                 << fieldNameWithCast
                 << ";\n\n";

             out << "if ("
                 << elemName
                 << " == null || "
                 << elemName
                 << ".length != "
                 << mSizes.back()->javaValue()
                 << ") {\n";

             out.indent();

             out << "throw new IllegalArgumentException("
                 << "\"Array element is not of the expected length\");\n";

             out.unindent();
             out << "}\n\n";

             out << blobName
                 << ".put"
                 << mElementType->getJavaSuffix()
                 << "Array("
                 << offsetName
                 << ", "
                 << elemName
                 << ");\n";
         }

         size_t elementAlign, elementSize;
         mElementType->getAlignmentAndSize(&elementAlign, &elementSize);

         out << offsetName
             << " += "
             << mSizes.back()->javaValue()
             << " * "
             << elementSize
             << ";\n";
     }

     for (size_t dim = 0; dim < loopDimensions; ++dim) {
         out.unindent();
         out << "}\n";
     }

     out.unindent();
     out << "}\n";
 }

 void ArrayType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << "vector_size: " << mSizes[0]->rawValue() << "\n";
     out << "vector_value: {\n";
     out.indent();
     // Simple array case.
     if (mSizes.size() == 1) {
         mElementType->emitVtsTypeDeclarations(out);
     } else {  // Multi-dimension array case.
         for (size_t index = 1; index < mSizes.size(); index++) {
             out << "type: " << getVtsType() << "\n";
             out << "vector_size: " << mSizes[index]->rawValue() << "\n";
             out << "vector_value: {\n";
             out.indent();
             if (index == mSizes.size() - 1) {
                 mElementType->emitVtsTypeDeclarations(out);
             }
         }
     }
     for (size_t index = 0; index < mSizes.size(); index++) {
         out.unindent();
         out << "}\n";
     }
 }

 bool ArrayType::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
     if (!mElementType->isJavaCompatible(visited)) {
         return false;
     }
     return Type::deepIsJavaCompatible(visited);
 }

 bool ArrayType::deepContainsPointer(std::unordered_set<const Type*>* visited) const {
     if (mElementType->containsPointer(visited)) {
         return true;
     }
     return Type::deepContainsPointer(visited);
 }

 void ArrayType::getAlignmentAndSize(size_t *align, size_t *size) const {
     mElementType->getAlignmentAndSize(align, size);

     for (auto sizeInDimension : mSizes) {
         (*size) *= sizeInDimension->castSizeT();
     }
 }

 size_t ArrayType::dimension() const {
     size_t numArrayElements = 1;
     for (auto size : mSizes) {
         numArrayElements *= size->castSizeT();
     }
     return numArrayElements;
 }

 }  // namespace android
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* 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.
	*/

	#include "ArrayType.h"

	#include <android-base/logging.h>
	#include <hidl-util/Formatter.h>
	#include <iostream>

	#include "ConstantExpression.h"

	namespace android {

	ArrayType::ArrayType(const Reference<Type>& elementType, ConstantExpression* size, Scope* parent)
	: Type(parent, elementType.localName()), mElementType(elementType) {
	CHECK(!elementType.isEmptyReference());

	appendDimension(size);
	}

	void ArrayType::appendDimension(ConstantExpression *size) {
	mSizes.push_back(size);
	mDefinedName = mDefinedName + "[" + size->expression() + "]";
	}

	size_t ArrayType::countDimensions() const {
	return mSizes.size();
	}

	bool ArrayType::isArray() const {
	return true;
	}

	bool ArrayType::deepCanCheckEquality(std::unordered_set<const Type> visited) const {
	return mElementType->canCheckEquality(visited);
	}

	const Type* ArrayType::getElementType() const {
	return mElementType.get();
	}

	std::string ArrayType::typeName() const {
	if (dimension() == 1) {
	return "array of " + mElementType->typeName();
	}

	return std::to_string(dimension()) + "d array of " + mElementType->typeName();
	}

	std::vector<const Reference<Type>*> ArrayType::getReferences() const {
	return {&mElementType};
	}

	std::vector<const ConstantExpression*> ArrayType::getConstantExpressions() const {
	std::vector<const ConstantExpression*> ret;
	ret.insert(ret.end(), mSizes.begin(), mSizes.end());
	return ret;
	}

	status_t ArrayType::resolveInheritance() {
	// Resolve for typedefs
	while (mElementType->isArray()) {
	ArrayType* innerArray = static_cast<ArrayType*>(mElementType.get());
	mSizes.insert(mSizes.end(), innerArray->mSizes.begin(), innerArray->mSizes.end());
	mElementType = innerArray->mElementType;
	}
	return Type::resolveInheritance();
	}

	status_t ArrayType::validate() const {
	CHECK(!mElementType->isArray());

	if (mElementType->isInterface()) {
	std::cerr << "ERROR: Arrays of interface types are not supported"
	<< " at " << mElementType.location() << "\n";

	return UNKNOWN_ERROR;
	}
	return Type::validate();
	}

	std::string ArrayType::getCppType(StorageMode mode,
	bool specifyNamespaces) const {
	const std::string base = mElementType->getCppStackType(specifyNamespaces);

	std::string space = specifyNamespaces ? "::android::hardware::" : "";
	std::string arrayType = space + "hidl_array<" + base;

	for (size_t i = 0; i < mSizes.size(); ++i) {
	arrayType += ", " + mSizes[i]->cppValue();
	}

	arrayType += ">";

	switch (mode) {
	case StorageMode_Stack:
	return arrayType;

	case StorageMode_Argument:
	return "const " + arrayType + "&";

	case StorageMode_Result:
	return "const " + arrayType + "*";
	}

	CHECK(!"Should not be here");
	}

	std::string ArrayType::getInternalDataCppType() const {
	std::string result = mElementType->getCppStackType();
	for (size_t i = 0; i < mSizes.size(); ++i) {
	result += "[";
	result += mSizes[i]->cppValue();
	result += "]";
	}
	return result;
	}

	std::string ArrayType::getJavaType(bool forInitializer) const {
	std::string base =
	mElementType->getJavaType(forInitializer);

	for (size_t i = 0; i < mSizes.size(); ++i) {
	base += "[";

	if (forInitializer) {
	base += mSizes[i]->javaValue();
	} else {
	base += "/* " + mSizes[i]->expression() + " */";
	}

	base += "]";
	}

	return base;
	}

	std::string ArrayType::getVtsType() const {
	return "TYPE_ARRAY";
	}

	void ArrayType::emitReaderWriter(
	Formatter &out,
	const std::string &name,
	const std::string &parcelObj,
	bool parcelObjIsPointer,
	bool isReader,
	ErrorMode mode) const {
	std::string baseType = mElementType->getCppStackType();

	const std::string parentName = "_hidl_" + name + "_parent";

	out << "size_t " << parentName << ";\n\n";

	const std::string parcelObjDeref =
	parcelObj + (parcelObjIsPointer ? "->" : ".");

	size_t numArrayElements = 1;
	for (auto size : mSizes) {
	numArrayElements *= size->castSizeT();
	}
	if (isReader) {
	out << "_hidl_err = "
	<< parcelObjDeref
	<< "readBuffer("
	<< numArrayElements
	<< " * sizeof("
	<< baseType
	<< "), &"
	<< parentName
	<< ", "
	<< " reinterpret_cast<const void **>("
	<< "&" << name
	<< "));\n\n";

	handleError(out, mode);
	} else {

	out << "_hidl_err = "
	<< parcelObjDeref
	<< "writeBuffer("
	<< name
	<< ".data(), "
	<< numArrayElements
	<< " * sizeof("
	<< baseType
	<< "), &"
	<< parentName
	<< ");\n";

	handleError(out, mode);
	}

	emitReaderWriterEmbedded(
	out,
	0 /* depth */,
	name,
	name /* sanitizedName */,
	isReader /* nameIsPointer */,
	parcelObj,
	parcelObjIsPointer,
	isReader,
	mode,
	parentName,
	"0 /* parentOffset */");
	}

	void ArrayType::emitReaderWriterEmbedded(
	Formatter &out,
	size_t depth,
	const std::string &name,
	const std::string &sanitizedName,
	bool nameIsPointer,
	const std::string &parcelObj,
	bool parcelObjIsPointer,
	bool isReader,
	ErrorMode mode,
	const std::string &parentName,
	const std::string &offsetText) const {
	if (!mElementType->needsEmbeddedReadWrite()) {
	return;
	}

	const std::string nameDeref = name + (nameIsPointer ? "->" : ".");

	std::string baseType = mElementType->getCppStackType();

	std::string iteratorName = "_hidl_index_" + std::to_string(depth);

	out << "for (size_t "
	<< iteratorName
	<< " = 0; "
	<< iteratorName
	<< " < "
	<< dimension()
	<< "; ++"
	<< iteratorName
	<< ") {\n";

	out.indent();

	mElementType->emitReaderWriterEmbedded(
	out,
	depth + 1,
	nameDeref + "data()[" + iteratorName + "]",
	sanitizedName + "_indexed",
	false /* nameIsPointer */,
	parcelObj,
	parcelObjIsPointer,
	isReader,
	mode,
	parentName,
	offsetText
	+ " + " + iteratorName + " * sizeof("
	+ baseType
	+ ")");

	out.unindent();

	out << "}\n\n";
	}

	void ArrayType::emitJavaDump(
	Formatter &out,
	const std::string &streamName,
	const std::string &name) const {
	out << streamName << ".append(java.util.Arrays."
	<< (countDimensions() > 1 ? "deepToString" : "toString")
	<< "("
	<< name
	<< "));\n";
	}


	bool ArrayType::needsEmbeddedReadWrite() const {
	return mElementType->needsEmbeddedReadWrite();
	}

	bool ArrayType::resultNeedsDeref() const {
	return true;
	}

	void ArrayType::emitJavaReaderWriter(
	Formatter &out,
	const std::string &parcelObj,
	const std::string &argName,
	bool isReader) const {
	size_t align, size;
	getAlignmentAndSize(&align, &size);

	if (isReader) {
	out << "new "
	<< getJavaType(true /* forInitializer */)
	<< ";\n";
	}

	out << "{\n";
	out.indent();

	out << "android.os.HwBlob _hidl_blob = ";

	if (isReader) {
	out << parcelObj
	<< ".readBuffer("
	<< size
	<< " /* size */);\n";
	} else {
	out << "new android.os.HwBlob("
	<< size
	<< " /* size */);\n";
	}

	emitJavaFieldReaderWriter(
	out,
	0 /* depth */,
	parcelObj,
	"_hidl_blob",
	argName,
	"0 /* offset */",
	isReader);

	if (!isReader) {
	out << parcelObj << ".writeBuffer(_hidl_blob);\n";
	}

	out.unindent();
	out << "}\n";
	}

	void ArrayType::emitJavaFieldInitializer(
	Formatter &out, const std::string &fieldName) const {
	const std::string typeName = getJavaType(false /* forInitializer */);
	const std::string fieldDeclaration = typeName + " " + fieldName;

	emitJavaFieldDefaultInitialValue(out, fieldDeclaration);
	}

	void ArrayType::emitJavaFieldDefaultInitialValue(
	Formatter &out, const std::string &declaredFieldName) const {
	out << declaredFieldName
	<< " = new "
	<< getJavaType(true /* forInitializer */)
	<< ";\n";
	}

	void ArrayType::emitJavaFieldReaderWriter(
	Formatter &out,
	size_t depth,
	const std::string &parcelName,
	const std::string &blobName,
	const std::string &fieldName,
	const std::string &offset,
	bool isReader) const {
	out << "{\n";
	out.indent();

	std::string offsetName = "_hidl_array_offset_" + std::to_string(depth);
	out << "long " << offsetName << " = " << offset << ";\n";

	const bool isPrimitiveArray = mElementType->isScalar();

	/* If the element type corresponds to a Java primitive type we can optimize
	the innermost loop by copying a linear range of memory instead of doing
	a per-element copy. As a result the outer nested loop does not include
	the final dimension. */
	const size_t loopDimensions = mSizes.size() - (isPrimitiveArray ? 1 : 0);

	std::string indexString;
	for (size_t dim = 0; dim < loopDimensions; ++dim) {
	std::string iteratorName =
	"_hidl_index_" + std::to_string(depth) + "_" + std::to_string(dim);

	out << "for (int "
	<< iteratorName
	<< " = 0; "
	<< iteratorName
	<< " < "
	<< mSizes[dim]->javaValue()
	<< "; ++"
	<< iteratorName
	<< ") {\n";

	out.indent();

	indexString += "[" + iteratorName + "]";
	}

	const bool isIndexed = (loopDimensions > 0);
	const std::string fieldNameWithCast = isIndexed
	? "(" + getJavaTypeCast(fieldName) + ")" + indexString
	: getJavaTypeCast(fieldName);

	if (isReader && mElementType->isCompoundType()) {
	mElementType->emitJavaFieldDefaultInitialValue(out, fieldNameWithCast);
	}

	if (!isPrimitiveArray) {
	mElementType->emitJavaFieldReaderWriter(
	out,
	depth + 1,
	parcelName,
	blobName,
	fieldNameWithCast,
	offsetName,
	isReader);

	size_t elementAlign, elementSize;
	mElementType->getAlignmentAndSize(&elementAlign, &elementSize);

	out << offsetName << " += " << std::to_string(elementSize) << ";\n";
	} else {
	if (isReader) {
	out << blobName
	<< ".copyTo"
	<< mElementType->getJavaSuffix()
	<< "Array("
	<< offsetName
	<< ", "
	<< fieldNameWithCast
	<< ", "
	<< mSizes.back()->javaValue()
	<< " /* size */);\n";
	} else {
	std::string elemName = "_hidl_array_item_" + std::to_string(depth);

	out << mElementType->getJavaType(false /* forInitializer */)
	<< "[] "
	<< elemName
	<< " = "
	<< fieldNameWithCast
	<< ";\n\n";

	out << "if ("
	<< elemName
	<< " == null \|\| "
	<< elemName
	<< ".length != "
	<< mSizes.back()->javaValue()
	<< ") {\n";

	out.indent();

	out << "throw new IllegalArgumentException("
	<< "\"Array element is not of the expected length\");\n";

	out.unindent();
	out << "}\n\n";

	out << blobName
	<< ".put"
	<< mElementType->getJavaSuffix()
	<< "Array("
	<< offsetName
	<< ", "
	<< elemName
	<< ");\n";
	}

	size_t elementAlign, elementSize;
	mElementType->getAlignmentAndSize(&elementAlign, &elementSize);

	out << offsetName
	<< " += "
	<< mSizes.back()->javaValue()
	<< " * "
	<< elementSize
	<< ";\n";
	}

	for (size_t dim = 0; dim < loopDimensions; ++dim) {
	out.unindent();
	out << "}\n";
	}

	out.unindent();
	out << "}\n";
	}

	void ArrayType::emitVtsTypeDeclarations(Formatter& out) const {
	out << "type: " << getVtsType() << "\n";
	out << "vector_size: " << mSizes[0]->rawValue() << "\n";
	out << "vector_value: {\n";
	out.indent();
	// Simple array case.
	if (mSizes.size() == 1) {
	mElementType->emitVtsTypeDeclarations(out);
	} else { // Multi-dimension array case.
	for (size_t index = 1; index < mSizes.size(); index++) {
	out << "type: " << getVtsType() << "\n";
	out << "vector_size: " << mSizes[index]->rawValue() << "\n";
	out << "vector_value: {\n";
	out.indent();
	if (index == mSizes.size() - 1) {
	mElementType->emitVtsTypeDeclarations(out);
	}
	}
	}
	for (size_t index = 0; index < mSizes.size(); index++) {
	out.unindent();
	out << "}\n";
	}
	}

	bool ArrayType::deepIsJavaCompatible(std::unordered_set<const Type> visited) const {
	if (!mElementType->isJavaCompatible(visited)) {
	return false;
	}
	return Type::deepIsJavaCompatible(visited);
	}

	bool ArrayType::deepContainsPointer(std::unordered_set<const Type> visited) const {
	if (mElementType->containsPointer(visited)) {
	return true;
	}
	return Type::deepContainsPointer(visited);
	}

	void ArrayType::getAlignmentAndSize(size_t align, size_t size) const {
	mElementType->getAlignmentAndSize(align, size);

	for (auto sizeInDimension : mSizes) {
	(size) = sizeInDimension->castSizeT();
	}
	}

	size_t ArrayType::dimension() const {
	size_t numArrayElements = 1;
	for (auto size : mSizes) {
	numArrayElements *= size->castSizeT();
	}
	return numArrayElements;
	}

	} // namespace android