char.h

//===-- include/flang/Evaluate/char.h ---------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_EVALUATE_CHAR_H_
#define FORTRAN_EVALUATE_CHAR_H_
 
#include "flang/Evaluate/type.h"
#include <string>
 
namespace Fortran::evaluate::value {

template <int KIND> class Character {
  using Word = Scalar<Type<TypeCategory::Character, KIND>>;
  using CharT = typename Word::value_type;
 
public:
  // rule-of-five
  ~Character() = default;
  Character(const Character &v) : word_(v) {}
  Character(Character &&v) : word_(std::move(v)) {}
  Character &operator=(const Character &v) {
    word_ = v.word_;
    return &this;
  }
  Character &operator=(Character &&v) {
    word_ = std::move(v.word_);
    return *this;
  }
 
  // ctors
  Character() = default;
  Character(const Word &v) : word_(v) {}
  Character(Word &&v) : word_(std::move(v)) {}
  Character &operator=(const Word &v) { word_ = v; }
  Character &operator=(Word &&v) { word_ = std::move(v); }

  auto size() const { return word_.size(); }

  static Word FromRawBytes(const void *raw, std::size_t size) {
    CHECK(size % sizeof(CharT) == 0);
    Word s;
    if (size > 0) {
      s.assign(static_cast<const CharT *>(raw), size / sizeof(CharT));
    }
    return s;
  }

  void StoreRawBytes(void *dst, std::size_t size, bool *changed = nullptr) {
    CHECK(size % sizeof(CharT) == 0);
    if (size > 0) {
      std::size_t payloadSize{std::min(size, sizeof(CharT) * word_.size())};
      std::size_t padSize{size - payloadSize};
 
      // Pad with spaces
      Word strWithPadding{word_};
      strWithPadding.append(padSize / sizeof(CharT), static_cast<CharT>(' '));
 
      if (changed) {
        if (std::memcmp(dst, strWithPadding.data(), size) == 0) {
          return;
        }
        *changed = true;
      }
      std::memcpy(dst, strWithPadding.data(), size);
    }
  }
 
private:
  Word word_;
};
 
} // namespace Fortran::evaluate::value
#endif // FORTRAN_EVALUATE_CHAR_H_