StringVector.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* StringVector.cc                                             (C) 2000-2026 */
/*                                                                           */
/* List of 'String'.                                                         */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/common/StringVector.h"
 
#include "arccore/base/String.h"
 
#include "arccore/common/Array.h"
#include "arccore/common/List.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class StringVector::Impl
{
 public:
 
  UniqueArray<String> m_values;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringVector::
_checkNeedCreate()
{
  if (!m_p)
    m_p = new Impl();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringVector::
StringVector(const StringList& string_list)
{
  Int32 n = string_list.count();
  if (n == 0)
    return;
  _checkNeedCreate();
  m_p->m_values.resize(n);
  for (Int32 i = 0; i < n; ++i)
    m_p->m_values[i] = string_list[i];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringVector::
StringVector(const StringVector& rhs)
{
  if (rhs.m_p)
    m_p = new Impl(*rhs.m_p);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringVector::
StringVector(StringVector&& rhs) noexcept
: m_p(rhs.m_p)
{
  rhs.m_p = nullptr;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringVector& StringVector::
operator=(const StringVector& rhs)
{
  if (&rhs != this) {
    Impl* new_mp = nullptr;
    if (rhs.m_p)
      new_mp = new Impl(*rhs.m_p);
    delete m_p;
    m_p = new_mp;
  }
  return (*this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringVector::
~StringVector()
{
  delete m_p;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Int32 StringVector::
size() const
{
  return (m_p ? m_p->m_values.size() : 0);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StringVector::
add(const String& str)
{
  _checkNeedCreate();
  m_p->m_values.add(str);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String StringVector::
operator[](Int32 index) const
{
  ARCCORE_CHECK_POINTER(m_p);
  return m_p->m_values[index];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StringList StringVector::
toStringList() const
{
  StringList sl;
  if (!m_p)
    return sl;
  ConstArrayView<String> v = m_p->m_values;
  Int32 nb_string = v.size();
  sl.resize(nb_string);
  for (Int32 i = 0; i < nb_string; ++i)
    sl[i] = v[i];
  return sl;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/