MeshHandle.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshHandle.cc                                               (C) 2000-2023 */
/*                                                                           */
/* Handle on a mesh.                                                         */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/MeshHandle.h"
 
#include "arcane/utils/UserDataList.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/Observable.h"
#include "arcane/utils/ValueConvert.h"
 
#include "arcane/core/ISubDomain.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/IMeshBase.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// TODO make this constructor private to IMeshMng to avoid
// possible duplicates for MeshHandles associated with the same mesh name.
MeshHandle::MeshHandleRef::
MeshHandleRef(ISubDomain* sd, const String& name)
: m_mesh_name(name)
, m_sub_domain(sd)
, m_is_null(name.null())
{
  if (!m_is_null)
    m_user_data_list = new UserDataList();
  ARCANE_CHECK_POINTER(sd);
  m_trace_mng = sd->traceMng();
  m_mesh_mng = sd->meshMng();
  m_variable_mng = sd->variableMng();
  m_on_destroy_observable = new Observable();
  if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_DO_FATAL_IN_MESHHANDLE", true))
    m_do_fatal_in_mesh_method = v.value() != 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle::MeshHandleRef::
~MeshHandleRef()
{
  delete m_user_data_list;
  delete m_on_destroy_observable;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshHandle::MeshHandleRef::
_setMesh(IMesh* mesh)
{
  m_mesh_ptr = mesh;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshHandle::MeshHandleRef::
_destroyMesh()
{
  // TODO: protect against multiple calls
  IMesh* mesh = m_mesh_ptr;
  if (!mesh)
    return;
  m_on_destroy_observable->notifyAllObservers();
  m_user_data_list->clear();
  // Be careful not to set to null until the end of this routine because the
  // users of \a m_user_data might need this MeshHandle.
  m_mesh_ptr = nullptr;
  delete mesh;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle::
MeshHandle(ISubDomain* sd, const String& name)
: m_ref(new MeshHandleRef(sd, name))
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandle::
MeshHandle()
: m_ref(new MeshHandleRef())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMeshMng* MeshHandle::
meshMng() const
{
  return m_ref->meshMng();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool MeshHandle::
hasMesh() const
{
  IMesh* m = m_ref->mesh();
  return m;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMesh* MeshHandle::
mesh() const
{
  IMesh* m = m_ref->mesh();
  if (m)
    return m;
  // Eventually, make a fatal error if the mesh is null. For reasons of
  // compatibility with the existing code, we return 'nullptr'.
  bool do_fatal = m_ref->isDoFatalInMeshMethod();
  if (do_fatal)
    ARCANE_FATAL("Invalid call for null mesh. Call MeshHandle::hasMesh() before to make sure mesh is valid");
  return nullptr;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMesh* MeshHandle::
meshOrNull() const
{
  return m_ref->mesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ITraceMng* MeshHandle::
traceMng() const
{
  return m_ref->traceMng();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IVariableMng* MeshHandle::
variableMng() const
{
  return m_ref->variableMng();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IApplication* MeshHandle::
application() const
{
  return m_ref->subDomain()->application();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IObservable* MeshHandle::
onDestroyObservable() const
{
  return m_ref->onDestroyObservable();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandleOrMesh::
MeshHandleOrMesh(const MeshHandle& handle)
: m_handle(handle)
{}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshHandleOrMesh::
MeshHandleOrMesh(IMesh* mesh)
{
  if (mesh)
    m_handle = mesh->handle();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/