character-value.h

//===-- include/flang/Evaluate/character-value.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_CHARACTER_VALUE_H_
#define FORTRAN_EVALUATE_CHARACTER_VALUE_H_
 
#include "flang/Evaluate/common.h"
#include "flang/Evaluate/object-sizes.h"
#include "flang/Evaluate/type.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
#include <cstddef>
#include <iosfwd>
#include <optional>
#include <string>
 
namespace Fortran::evaluate::value {
class CharacterValueImpl;

class CharacterValue {
public:
  // rule-of-five
  ~CharacterValue();
  CharacterValue(const CharacterValue &);
  CharacterValue(CharacterValue &&);
  CharacterValue &operator=(const CharacterValue &);
  CharacterValue &operator=(CharacterValue &&);
 
  // ctors

  CharacterValue();
 
  explicit CharacterValue(int kind, std::string s);
  explicit CharacterValue(int kind, std::u16string s);
  explicit CharacterValue(int kind, std::u32string s);

  CharacterValue(int kind, std::size_t n, char32_t c);
 
  // Named ctors
  static CharacterValue Zero(int kind);
 
  static CharacterValue FromRawBytes(
      int kind, const void *raw, size_t byteSize);
 
  void print(llvm::raw_ostream &os) const;
 
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  LLVM_DUMP_METHOD void dump() const;
#endif

  bool IsNull() const;

  int kind() const;
 
  bool empty() const;
  std::size_t size() const;
  std::size_t length() const { return size(); }

  std::size_t charSize() const { return kind(); }

  size_t bytesStored() const { return length() * charSize(); }
 
  // Casting to other representations
  std::optional<llvm::StringRef> AsStringRef() const;
  std::optional<std::string> AsStdString() const {
    if (auto str{AsStringRef()}) {
      return str->str();
    }
    return std::nullopt;
  }
  std::optional<std::u16string> AsU16String() const;
  std::optional<std::u32string> AsU32String() const;

  std::string ToStdString() const;
 
  template <typename CharT, typename = std::void_t<std::basic_string<CharT>>>
  std::optional<std::basic_string<CharT>> AsBasicString() const {
    if constexpr (std::is_same_v<char, CharT>) {
      return AsStdString();
    } else if constexpr (std::is_same_v<char16_t, CharT>) {
      return AsU16String();
    } else if constexpr (std::is_same_v<char32_t, CharT>) {
      return AsU32String();
    } else {
      static_assert(
          !sizeof(CharT), "Must be one of the supported character types");
    }
  }
 
  // Comparisons
  Ordering Compare(const CharacterValue &y) const;
  bool operator<(const CharacterValue &y) const;
  bool operator<=(const CharacterValue &y) const { return !(y < *this); }
  bool operator==(const CharacterValue &y) const;
  bool operator!=(const CharacterValue &y) const { return !(*this == y); }
  bool operator>=(const CharacterValue &y) const { return !(*this < y); }
  bool operator>(const CharacterValue &y) const { return y < *this; }
 
  CharacterValue ToAscii(int kind) const;

  void assign(int kind, std::size_t n, char32_t c);

  void assign(const char *p, std::size_t n);
  void assign(const char16_t *p, std::size_t n);
  void assign(const char32_t *p, std::size_t n);

  void erase(std::size_t pos);

  void append(std::size_t n, char32_t c);

  CharacterValue &replace(
      std::size_t pos, std::size_t len, const CharacterValue &other);

  CharacterValue substr(std::size_t pos) const;

  CharacterValue substr(std::size_t pos, std::size_t len) const;

  void reserve(std::size_t n);

  char32_t operator[](std::size_t i) const;

  CharacterValue operator+(const CharacterValue &y) const;

  CharacterValue &operator+=(const CharacterValue &y);

  CharacterValue &operator+=(char32_t c);

  static constexpr std::size_t npos{std::string::npos};
 
  // Find-family methods; return npos when not found.
  std::size_t find(const CharacterValue &pattern) const;
  std::size_t rfind(const CharacterValue &pattern) const;
  std::size_t find_first_of(const CharacterValue &set) const;
  std::size_t find_last_of(const CharacterValue &set) const;
  std::size_t find_first_not_of(char32_t c) const;
  std::size_t find_last_not_of(char32_t c) const;
  std::size_t find_first_not_of(const CharacterValue &set) const;
  std::size_t find_last_not_of(const CharacterValue &set) const;

  void *data();
  const void *data() const;

  char *charData() { return static_cast<char *>(data()); }
  const char *charData() const { return static_cast<const char *>(data()); }
 
  void *at(size_t pos) { return &charData()[pos * charSize()]; }
  const void *at(size_t pos) const { return &charData()[pos * charSize()]; }

  void StoreRawBytes(void *dst, size_t size, bool *changed = nullptr) const;
 
  template <typename F>
  static auto withCharProto(int kind, F &&f)
      -> decltype(std::declval<F>()(std::declval<char>())) {
    switch (kind) {
    case 1:
      return f(char{});
    case 2:
      return f(char16_t{});
    case 4:
      return f(char32_t{});
    default:
      DIE("unsupported character kind/null state");
    }
  }
 
  template <typename F> decltype(auto) withStdString(F &&f) const {
    switch (kind()) {
    case 1:
      return f(*AsStdString());
    case 2:
      return f(*AsU16String());
    case 4:
      return f(*AsU32String());
    default:
      DIE("unsupported kind/null state");
    }
  }
 
private:
  static CharacterValue FromImpl(const CharacterValueImpl &y);
  static CharacterValue FromImpl(CharacterValueImpl &&y);
 
  CharacterValueImpl &impl() {
    return *reinterpret_cast<CharacterValueImpl *>(this);
  }
  const CharacterValueImpl &impl() const {
    return *reinterpret_cast<const CharacterValueImpl *>(this);
  }
 
  [[maybe_unused]] alignas(
      detail::kCharacterObjectAlign) char opaque_[detail::kCharacterObjectSize];
};
 
} // namespace Fortran::evaluate::value
 
namespace llvm {
inline raw_ostream &operator<<(
    raw_ostream &os, const Fortran::evaluate::value::CharacterValue &v) {
  v.print(os);
  return os;
}
} // namespace llvm
 
#endif // FORTRAN_EVALUATE_CHARACTER_VALUE_H_