StringImpl.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* StringImpl.cc                                               (C) 2000-2026 */
/*                                                                           */
/* Implementation of a UTF-8 or UTF-16 character string.                     */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/base/internal/StringImpl.h"
#include "arccore/base/BasicTranscoder.h"
#include "arccore/base/CStringUtils.h"
#include "arccore/base/StringView.h"
 
#include <cstring>
#include <iostream>
 
//#define ARCCORE_DEBUG_UNISTRING
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool global_arccore_debug_string = false;
 
namespace
{
  const char* const global_empty_string = "";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class StringException
: public std::exception
{
 public:
 
  StringException(const char* where)
  : m_where(where)
  {}
  ~StringException() ARCCORE_NOEXCEPT {}
  virtual const char* what() const ARCCORE_NOEXCEPT
  {
    return m_where;
  }
 
 private:
 
  const char* m_where;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCCORE_DEBUG_UNISTRING
static void
_badStringImplReference(StringImpl* ptr)
{
  cerr << "** FATAL: Trying to use deleted StringImpl " << ptr << '\n';
}
#endif
 
inline void StringImpl::
_checkReference()
{
#ifdef ARCCORE_DEBUG_UNISTRING
  if (m_nb_ref.value() <= 0) {
    _badStringImplReference(this);
  }
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline void StringImpl::
_finalizeUtf8Creation()
{
  m_flags |= eValidUtf8;
  // \a m_utf8_array must always have a null terminator.
  if (m_utf8_array.empty())
    m_utf8_array.add('\0');
  else if (m_utf8_array.back() != '\0')
    m_utf8_array.add('\0');
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline void StringImpl::
_initFromSpan(Span<const Byte> bytes)
{
  m_utf8_array = bytes;
  _finalizeUtf8Creation();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl::
StringImpl(std::string_view str)
: m_nb_ref(0)
, m_flags(0)
{
  auto b = reinterpret_cast<const Byte*>(str.data());
  _initFromSpan(Span<const Byte>(b, str.size()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl::
StringImpl(Span<const UChar> uchars)
: m_nb_ref(0)
, m_flags(0)
{
  _setUtf16(uchars);
  m_flags = eValidUtf16;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl::
StringImpl(const StringImpl& str)
: m_nb_ref(0)
, m_flags(str.m_flags)
, m_utf16_array(str.m_utf16_array)
, m_utf8_array(str.m_utf8_array)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl::
StringImpl(Span<const Byte> bytes)
: m_nb_ref(0)
, m_flags(0)
{
  _initFromSpan(bytes);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl::
StringImpl()
: m_nb_ref(0)
, m_flags(0)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Span<const Byte> StringImpl::
bytes()
{
  Span<const Byte> x = largeUtf8();
  Int64 size = x.size();
  if (size > 0)
    return { x.data(), size - 1 };
  // Should not normally happen, but if it does, we return
  // a view of the empty string because this method guarantees a
  // null terminator at the end.
  // NOTE: No exception is thrown because this method is used in
  // outputs via operator<< and can be used notably in
  // destructors of objects.
  std::cerr << "INTERNAL ERROR: Null size in StringImpl::bytes()";
  return { reinterpret_cast<const Byte*>(global_empty_string), 0 };
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
std::string_view StringImpl::
toStdStringView()
{
  Span<const Byte> x = bytes();
  return std::string_view(reinterpret_cast<const char*>(x.data()), x.size());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringView StringImpl::
view()
{
  return StringView(bytes());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
addReference()
{
  ++m_nb_ref;
  _checkReference();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
removeReference()
{
  _checkReference();
  Int32 r = --m_nb_ref;
#ifndef ARCCORE_DEBUG_UNISTRING
  if (r == 0)
    delete this;
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ConstArrayView<UChar> StringImpl::
utf16()
{
  _checkReference();
  _createUtf16();
  return m_utf16_array.view();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Span<const Byte> StringImpl::
largeUtf8()
{
  _checkReference();
  _createUtf8();
  return m_utf8_array.view();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool StringImpl::
isEqual(StringImpl* str)
{
  _checkReference();
  _createUtf8();
  Span<const Byte> ref_array = str->largeUtf8();
  bool v = CStringUtils::isEqual((const char*)ref_array.data(), (const char*)m_utf8_array.data());
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool StringImpl::
isLessThan(StringImpl* str)
{
  _checkReference();
  _createUtf8();
  if (m_flags & eValidUtf8) {
    Span<const Byte> ref_array = str->largeUtf8();
    bool v = CStringUtils::isLess((const char*)m_utf8_array.data(), (const char*)ref_array.data());
    return v;
  }
  ARCCORE_ASSERT((0), ("InternalError in StringImpl::isEqual()"));
  return true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool StringImpl::
isEqual(StringView str)
{
  _checkReference();
  _createUtf8();
  return str.toStdStringView() == toStdStringView();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool StringImpl::
isLessThan(StringView str)
{
  _checkReference();
  _createUtf8();
  return toStdStringView() < str.toStdStringView();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
clone()
{
  _checkReference();
  _createUtf8();
  StringImpl* n = new StringImpl(*this);
  return n;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool StringImpl::
empty()
{
  _checkReference();
  if (m_flags & eValidUtf8) {
    ARCCORE_ASSERT((!m_utf8_array.empty()), ("Not 0 terminated utf8 encoding"));
    return m_utf8_array.size() <= 1; // Counts the terminal 0
  }
  if (m_flags & eValidUtf16) {
    ARCCORE_ASSERT((!m_utf16_array.empty()), ("Not 0 terminated utf16 encoding"));
    return m_utf16_array.size() <= 1; // Counts the terminal 0
  }
  ARCCORE_ASSERT((0), ("InternalError in StringImpl::empty()"));
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
append(StringImpl* str)
{
  _checkReference();
  _createUtf8();
  Span<const Byte> ref_str = str->largeUtf8();
  _appendUtf8(ref_str);
  return this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
append(StringView str)
{
  Span<const Byte> str_bytes = str.bytes();
  if (!str_bytes.data())
    return this;
 
  _checkReference();
  _createUtf8();
 
  _appendUtf8(Span<const Byte>(str_bytes.data(), str_bytes.size() + 1));
  ;
  return this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_appendUtf8(Span<const Byte> ref_str)
{
  Int64 ref_size = ref_str.size();
  Int64 utf8_size = m_utf8_array.size();
  Int64 current_size = utf8_size - 1;
 
  ARCCORE_ASSERT((ref_size > 0), ("Bad ref_size"));
  ARCCORE_ASSERT((utf8_size > 0), ("Bad utf8_size"));
  ARCCORE_ASSERT((ref_str[ref_size - 1] == 0), ("Bad ref null terminal"));
  ARCCORE_ASSERT((m_utf8_array[utf8_size - 1] == 0), ("Bad ref null terminal"));
 
  m_utf8_array.resize(current_size + ref_size);
  std::memcpy(&m_utf8_array[current_size], ref_str.data(), ref_size);
 
  m_flags |= eValidUtf8;
  _invalidateUtf16();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
replaceWhiteSpace()
{
  _createUtf8();
  _invalidateUtf16();
  Impl::BasicTranscoder::replaceWS(m_utf8_array);
  return this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
collapseWhiteSpace()
{
  _createUtf8();
  _invalidateUtf16();
  Impl::BasicTranscoder::collapseWS(m_utf8_array);
  return this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
toUpper()
{
  _createUtf8();
  _invalidateUtf16();
  Impl::BasicTranscoder::upperCase(m_utf8_array);
  return this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
toLower()
{
  _createUtf8();
  _invalidateUtf16();
  Impl::BasicTranscoder::lowerCase(m_utf8_array);
  return this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringImpl* StringImpl::
substring(StringImpl* str, Int64 pos, Int64 len)
{
  StringImpl* s = new StringImpl();
  Impl::BasicTranscoder::substring(s->m_utf8_array, str->largeUtf8(), pos, len);
  s->m_flags |= eValidUtf8;
  return s;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_createUtf16()
{
  if (m_flags & eValidUtf16)
    return;
 
  if (m_flags & eValidUtf8) {
    ARCCORE_ASSERT(m_utf16_array.empty(), ("Not empty utf16_array"));
    Impl::BasicTranscoder::transcodeFromUtf8ToUtf16(m_utf8_array, m_utf16_array);
    m_flags |= eValidUtf16;
    return;
  }
 
  ARCCORE_ASSERT((0), ("InternalError in StringImpl::_createUtf16()"));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_createUtf8()
{
  if (m_flags & eValidUtf8)
    return;
 
  if (m_flags & eValidUtf16) {
    ARCCORE_ASSERT(m_utf8_array.empty(), ("Not empty utf8_array"));
    Impl::BasicTranscoder::transcodeFromUtf16ToUtf8(m_utf16_array, m_utf8_array);
    _finalizeUtf8Creation();
    return;
  }
 
  ARCCORE_ASSERT((0), ("InternalError in StringImpl::_createUtf16()"));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_setUtf16(Span<const UChar> src)
{
  m_utf16_array = src;
  if (m_utf16_array.empty())
    m_utf16_array.add(0);
  else if (m_utf16_array.back() != '\0')
    m_utf16_array.add(0);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_invalidateUtf16()
{
  m_flags &= ~eValidUtf16;
  m_utf16_array.clear();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_invalidateUtf8()
{
  m_flags &= ~eValidUtf8;
  m_utf8_array.clear();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_printStrUtf16(std::ostream& o, Span<const UChar> str)
{
  Int64 buf_size = str.size();
  o << "(bufsize=" << buf_size
    << " begin=" << str.data() << " - ";
  for (Int64 i = 0; i < buf_size; ++i)
    o << (int)str[i] << ' ';
  o << ")";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
_printStrUtf8(std::ostream& o, Span<const Byte> str)
{
  Int64 buf_size = str.size();
  o << "(bufsize=" << buf_size << " - ";
  for (Int64 i = 0; i < buf_size; ++i)
    o << (int)str[i] << ' ';
  o << ")";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringImpl::
internalDump(std::ostream& ostr)
{
  ostr << "(utf8=valid=" << ((m_flags & eValidUtf8) != 0)
       << ",len=" << m_utf8_array.size() << ",val=";
  _printStrUtf8(ostr, m_utf8_array);
  ostr << ")";
 
  ostr << "(utf16=valid=" << ((m_flags & eValidUtf16) != 0)
       << ",len=" << m_utf16_array.size() << ",val=";
  _printStrUtf16(ostr, m_utf16_array);
  ostr << ")";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/