1/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef LIBTEXTCLASSIFIER_COMMON_LITTLE_ENDIAN_DATA_H_
18#define LIBTEXTCLASSIFIER_COMMON_LITTLE_ENDIAN_DATA_H_
19
20#include <algorithm>
21#include <string>
22#include <vector>
23
24#include "base.h"
25#include "util/base/logging.h"
26
27namespace libtextclassifier {
28namespace nlp_core {
29
30// Swaps the sizeof(T) bytes that start at addr.  E.g., if sizeof(T) == 2,
31// then (addr[0], addr[1]) -> (addr[1], addr[0]).  Useful for little endian
32// <-> big endian conversions.
33template <class T>
34void SwapBytes(T *addr) {
35  char *char_ptr = reinterpret_cast<char *>(addr);
36  std::reverse(char_ptr, char_ptr + sizeof(T));
37}
38
39// Assuming addr points to a piece of data of type T, with its bytes in the
40// little/big endian order specific to the machine this code runs on, this
41// method will re-arrange the bytes (in place) in little-endian order.
42template <class T>
43void HostToLittleEndian(T *addr) {
44  if (LittleEndian::IsLittleEndian()) {
45    // Do nothing: current machine is little-endian.
46  } else {
47    SwapBytes(addr);
48  }
49}
50
51// Reverse of HostToLittleEndian.
52template <class T>
53void LittleEndianToHost(T *addr) {
54  // It turns out it's the same function: on little-endian machines, do nothing
55  // (source and target formats are identical).  Otherwise, swap bytes.
56  HostToLittleEndian(addr);
57}
58
59// Returns string obtained by concatenating the bytes of the elements from a
60// vector (in order: v[0], v[1], etc).  If the type T requires more than one
61// byte, the byte for each element are first converted to little-endian format.
62template<typename T>
63std::string GetDataBytesInLittleEndianOrder(const std::vector<T> &v) {
64  std::string data_bytes;
65  for (const T element : v) {
66    T little_endian_element = element;
67    HostToLittleEndian(&little_endian_element);
68    data_bytes.append(
69        reinterpret_cast<const char *>(&little_endian_element),
70        sizeof(T));
71  }
72  return data_bytes;
73}
74
75// Performs reverse of GetDataBytesInLittleEndianOrder.
76//
77// I.e., decodes the data bytes from parameter bytes into num_elements Ts, and
78// places them in the vector v (previous content of that vector is erased).
79//
80// We expect bytes to contain the concatenation of the bytes for exactly
81// num_elements elements of type T.  If the type T requires more than one byte,
82// those bytes should be arranged in little-endian form.
83//
84// Returns true on success and false otherwise (e.g., bytes has the wrong size).
85// Note: we do not want to crash on corrupted data (some clients, e..g, GMSCore,
86// have asked us not to do so).  Instead, we report the error and let the client
87// decide what to do.  On error, we also fill the vector with zeros, such that
88// at least the dimension of v matches expectations.
89template<typename T>
90bool FillVectorFromDataBytesInLittleEndian(
91    const std::string &bytes, int num_elements, std::vector<T> *v) {
92  if (bytes.size() != num_elements * sizeof(T)) {
93    TC_LOG(ERROR) << "Wrong number of bytes: actual " << bytes.size()
94                  << " vs expected " << num_elements
95                  << " elements of sizeof(element) = " << sizeof(T)
96                  << " bytes each ; will fill vector with zeros";
97    v->assign(num_elements, static_cast<T>(0));
98    return false;
99  }
100  v->clear();
101  v->reserve(num_elements);
102  const T *start = reinterpret_cast<const T *>(bytes.data());
103  if (LittleEndian::IsLittleEndian() || (sizeof(T) == 1)) {
104    // Fast in the common case ([almost] all hardware today is little-endian):
105    // if same endianness (or type T requires a single byte and endianness
106    // irrelevant), just use the bytes.
107    v->assign(start, start + num_elements);
108  } else {
109    // Slower (but very rare case): this code runs on a big endian machine and
110    // the type T requires more than one byte.  Hence, some conversion is
111    // necessary.
112    for (int i = 0; i < num_elements; ++i) {
113      T temp = start[i];
114      SwapBytes(&temp);
115      v->push_back(temp);
116    }
117  }
118  return true;
119}
120
121}  // namespace nlp_core
122}  // namespace libtextclassifier
123
124#endif  // LIBTEXTCLASSIFIER_COMMON_LITTLE_ENDIAN_DATA_H_
125