/*

 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#ifndef SHARE_VM_JFR_WRITERS_JFRENCODERS_HPP

#define SHARE_VM_JFR_WRITERS_JFRENCODERS_HPP

#include "memory/allocation.hpp"

#include "utilities/bytes.hpp"

#include "utilities/debug.hpp"

#include "utilities/globalDefinitions.hpp"

//

// The Encoding policy prescribes a template

// method taking a first parameter of type T.

// This is the value to be encoded. The second

// parameter is a memory address - where to write

// the encoded value.

// The encoder method(s) should return the

// number of bytes encoded into that memory address.

//

// template <typename T>

// size_t encoder(T value, u1* dest);

//

// The caller ensures the destination

// address is not null and that T can be fitted

// in encoded form.

//

// Encoding policy classes

class BigEndianEncoderImpl {

 public:

  template <typename T>

  static size_t encode(T value, u1* dest);

  template <typename T>

  static size_t encode(const T* src, size_t len, u1* dest);

  template <typename T>

  static size_t encode_padded(T value, u1* dest);

  template <typename T>

  static size_t encode_padded(const T* src, size_t len, u1* dest);

};

template <typename T>

inline size_t BigEndianEncoderImpl::encode(T value, u1* dest) {

  assert(dest != NULL, "invariant");

  switch (sizeof(T)) {

    case 1: {

      ShouldNotReachHere();

       return 0;

     }

     case 2: {

       Bytes::put_Java_u2(dest, value);

       return 2;

     }

     case 4: {

       Bytes::put_Java_u4(dest, value);

       return 4;

     }

     case 8: {

       Bytes::put_Java_u8(dest, value);

       return 8;

     }

  }

  ShouldNotReachHere();

  return 0;

}

template <typename T>

inline size_t BigEndianEncoderImpl::encode(const T* src, size_t len, u1* dest) {

  assert(dest != NULL, "invariant");

  assert(len >= 1, "invariant");

  if (1 == sizeof(T)) {

    memcpy(dest, src, len);

    return len;

  }

  size_t size = encode(*src, dest);

  if (len > 1) {

    for (size_t i = 1; i < len; ++i) {

      size += encode(*(src + i), dest + size);

    }

  }

  return size;

}

template <typename T>

inline size_t BigEndianEncoderImpl::encode_padded(T value, u1* dest) {

  return encode(value, dest);

}

template <typename T>

inline size_t BigEndianEncoderImpl::encode_padded(const T* src, size_t len, u1* dest) {

  assert(dest != NULL, "invariant");

  assert(len >= 1, "invariant");

  if (1 == sizeof(T)) {

    memcpy(dest, src, len);

    return len;

  }

  size_t size = encode_padded(*src, dest);

  if (len > 1) {

    for (size_t i = 1; i < len; ++i) {

      size += encode_padded(*(src + i), dest + size);

    }

  }

  return size;

}

// The Varint128 encoder implements encoding according to

// msb(it) 128bit encoding (1 encode bit | 7 value bits),

// using least significant byte order.

//

// Example (little endian platform):

// Value: 25674

// Binary: 00000000 0000000 01100100 01001010

// Varint encoded (3 bytes):

// Value: 13289473

// Varint encoded: 11001010 11001000 00000001

//

class Varint128EncoderImpl {

 private:

  template <typename T>

  static u8 to_u8(T value);

 public:

  template <typename T>

  static size_t encode(T value, u1* dest);

  template <typename T>

  static size_t encode(const T* src, size_t len, u1* dest);

  template <typename T>

  static size_t encode_padded(T value, u1* dest);

  template <typename T>

  static size_t encode_padded(const T* src, size_t len, u1* dest);

};

template <typename T>

inline u8 Varint128EncoderImpl::to_u8(T value) {

  switch(sizeof(T)) {

    case 1:

     return static_cast<u8>(static_cast<u1>(value) & static_cast<u1>(0xff));

    case 2:

      return static_cast<u8>(static_cast<u2>(value) & static_cast<u2>(0xffff));

    case 4:

      return static_cast<u8>(static_cast<u4>(value) & static_cast<u4>(0xffffffff));

    case 8:

      return static_cast<u8>(value);

    default:

      fatal("unsupported type");

  }

  return 0;

}

static const u1 ext_bit = 0x80;

#define GREATER_THAN_OR_EQUAL_TO_128(v) (((u8)(~(ext_bit - 1)) & (v)))

#define LESS_THAN_128(v) !GREATER_THAN_OR_EQUAL_TO_128(v)

template <typename T>

inline size_t Varint128EncoderImpl::encode(T value, u1* dest) {

  assert(dest != NULL, "invariant");

  const u8 v = to_u8(value);

  if (LESS_THAN_128(v)) {

    *dest = static_cast<u1>(v); // set bit 0-6, no extension

    return 1;

  }

  *dest = static_cast<u1>(v | ext_bit); // set bit 0-6, with extension

  if (LESS_THAN_128(v >> 7)) {

    *(dest + 1) = static_cast<u1>(v >> 7); // set bit 7-13, no extension

    return 2;

  }

  *(dest + 1) = static_cast<u1>((v >> 7) | ext_bit); // set bit 7-13, with extension

  if (LESS_THAN_128(v >> 14)) {

    *(dest + 2) = static_cast<u1>(v >> 14); // set bit 14-20, no extension

    return 3;

  }

  *(dest + 2) = static_cast<u1>((v >> 14) | ext_bit); // set bit 14-20, with extension

  if (LESS_THAN_128(v >> 21)) {

    *(dest + 3) = static_cast<u1>(v >> 21); // set bit 21-27, no extension

    return 4;

  }

  *(dest + 3) = static_cast<u1>((v >> 21) | ext_bit); // set bit 21-27, with extension

  if (LESS_THAN_128(v >> 28)) {

    *(dest + 4) = static_cast<u1>(v >> 28); // set bit 28-34, no extension

    return 5;

  }

  *(dest + 4) = static_cast<u1>((v >> 28) | ext_bit); // set bit 28-34, with extension

  if (LESS_THAN_128(v >> 35)) {

    *(dest + 5) = static_cast<u1>(v >> 35); // set bit 35-41, no extension

    return 6;

  }

  *(dest + 5) = static_cast<u1>((v >> 35) | ext_bit); // set bit 35-41, with extension

  if (LESS_THAN_128(v >> 42)) {

    *(dest + 6) = static_cast<u1>(v >> 42); // set bit 42-48, no extension

    return 7;

  }

  *(dest + 6) = static_cast<u1>((v >> 42) | ext_bit); // set bit 42-48, with extension

  if (LESS_THAN_128(v >> 49)) {

    *(dest + 7) = static_cast<u1>(v >> 49); // set bit 49-55, no extension

    return 8;

  }

  *(dest + 7) = static_cast<u1>((v >> 49) | ext_bit); // set bit 49-55, with extension

  // no need to extend since only 64 bits allowed.

  *(dest + 8) = static_cast<u1>(v >> 56);  // set bit 56-63

  return 9;

}

template <typename T>

inline size_t Varint128EncoderImpl::encode(const T* src, size_t len, u1* dest) {

  assert(dest != NULL, "invariant");

  assert(len >= 1, "invariant");

  size_t size = encode(*src, dest);

  if (len > 1) {

    for (size_t i = 1; i < len; ++i) {

      size += encode(*(src + i), dest + size);

    }

  }

  return size;

}

template <typename T>

inline size_t Varint128EncoderImpl::encode_padded(T value, u1* dest) {

  assert(dest != NULL, "invariant");

  const u8 v = to_u8(value);

  switch (sizeof(T)) {

    case 1:

      dest[0] = static_cast<u1>(v);

      return 1;

    case 2:

      dest[0] = static_cast<u1>(v | 0x80);

      dest[1] = static_cast<u1>(v >> 7);

      return 2;

    case 4:

      dest[0] = static_cast<u1>(v | 0x80);

      dest[1] = static_cast<u1>(v >> 7 | 0x80);

      dest[2] = static_cast<u1>(v >> 14 | 0x80);

      dest[3] = static_cast<u1>(v >> 21);

      return 4;

    case 8:

      dest[0] = static_cast<u1>(v | 0x80);

      dest[1] = static_cast<u1>(v >> 7 | 0x80);

      dest[2] = static_cast<u1>(v >> 14 | 0x80);

      dest[3] = static_cast<u1>(v >> 21 | 0x80);

      dest[4] = static_cast<u1>(v >> 28 | 0x80);

      dest[5] = static_cast<u1>(v >> 35 | 0x80);

      dest[6] = static_cast<u1>(v >> 42 | 0x80);

      dest[7] = static_cast<u1>(v >> 49);

      return 8;

    default:

      ShouldNotReachHere();

    }

  return 0;

}

template <typename T>

inline size_t Varint128EncoderImpl::encode_padded(const T* src, size_t len, u1* dest) {

  assert(dest != NULL, "invariant");

  assert(len >= 1, "invariant");

  size_t size = encode_padded(*src, dest);

  if (len > 1) {

    for (size_t i = 1; i < len; ++i) {

      size += encode_padded(*(src + i), dest + size);

    }

  }

  return size;

}

#endif // SHARE_VM_JFR_WRITERS_JFRENCODERS_HPP