PointToPointMessageInfo.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* PointToPointMessageInfo.h                                   (C) 2000-2025 */
/*                                                                           */
/* Information for point-to-point messages.                                  */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_MESSAGEPASSING_POINTTOPOINTINFO_H
#define ARCCORE_MESSAGEPASSING_POINTTOPOINTINFO_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/message_passing/MessageId.h"
#include "arccore/message_passing/MessageTag.h"
#include "arccore/message_passing/MessageRank.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::MessagePassing
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCCORE_MESSAGEPASSING_EXPORT PointToPointMessageInfo
{
 public:
 
  enum class Type
  {
    T_RankTag,
    T_MessageId,
    T_Null
  };
 
 public:

  PointToPointMessageInfo() {}

  explicit PointToPointMessageInfo(MessageRank dest_rank)
  : m_destination_rank(dest_rank)
  , m_type(Type::T_RankTag)
  {}

  //mode \a blocking_type
  PointToPointMessageInfo(MessageRank dest_rank, eBlockingType blocking_type)
  : m_destination_rank(dest_rank)
  , m_is_blocking(blocking_type == Blocking)
  , m_type(Type::T_RankTag)
  {}

  PointToPointMessageInfo(MessageRank dest_rank, MessageTag tag)
  : m_destination_rank(dest_rank)
  , m_tag(tag)
  , m_type(Type::T_RankTag)
  {}

  //mode \a blocking_type
  PointToPointMessageInfo(MessageRank dest_rank, MessageTag tag, eBlockingType blocking_type)
  : m_destination_rank(dest_rank)
  , m_tag(tag)
  , m_is_blocking(blocking_type == Blocking)
  , m_type(Type::T_RankTag)
  {}

  explicit PointToPointMessageInfo(MessageId message_id)
  : m_message_id(message_id)
  , m_type(Type::T_MessageId)
  {
    _setInfosFromMessageId();
  }

  PointToPointMessageInfo(MessageId message_id, eBlockingType blocking_type)
  : m_message_id(message_id)
  , m_is_blocking(blocking_type == Blocking)
  , m_type(Type::T_MessageId)
  {
    _setInfosFromMessageId();
  }
 
 public:

  ARCCORE_DEPRECATED_REASON("Y2022: This constructor is internal to Arcane and deprecated")
  PointToPointMessageInfo(MessageRank emiter_rank, MessageRank dest_rank, eBlockingType blocking_type)
  : m_emiter_rank(emiter_rank)
  , m_destination_rank(dest_rank)
  , m_is_blocking(blocking_type == Blocking)
  , m_type(Type::T_RankTag)
  {}

  ARCCORE_DEPRECATED_REASON("Y2022: This constructor is internal to Arcane and deprecated")
  PointToPointMessageInfo(MessageRank emiter_rank, MessageRank dest_rank, MessageTag tag)
  : m_emiter_rank(emiter_rank)
  , m_destination_rank(dest_rank)
  , m_tag(tag)
  , m_type(Type::T_RankTag)
  {}

  ARCCORE_DEPRECATED_REASON("Y2022: This constructor is internal to Arcane and deprecated")
  PointToPointMessageInfo(MessageRank emiter_rank, MessageRank dest_rank)
  : m_emiter_rank(emiter_rank)
  , m_destination_rank(dest_rank)
  , m_type(Type::T_RankTag)
  {}
 
 public:

  PointToPointMessageInfo(MessageRank emiter_rank, MessageRank dest_rank, MessageTag tag, eBlockingType blocking_type)
  : m_emiter_rank(emiter_rank)
  , m_destination_rank(dest_rank)
  , m_tag(tag)
  , m_is_blocking(blocking_type == Blocking)
  , m_type(Type::T_RankTag)
  {}
 
 public:
 
  PointToPointMessageInfo& setBlocking(bool is_blocking)
  {
    m_is_blocking = is_blocking;
    return (*this);
  }
  bool isBlocking() const { return m_is_blocking; }
  bool isMessageId() const { return m_type == Type::T_MessageId; }
  bool isRankTag() const { return m_type == Type::T_RankTag; }
  MessageId messageId() const { return m_message_id; }
  void setMessageId(const MessageId& message_id)
  {
    m_type = Type::T_MessageId;
    m_message_id = message_id;
    _setInfosFromMessageId();
  }

  void setRankTag(MessageRank rank, MessageTag tag)
  {
    m_type = Type::T_RankTag;
    // Attention to properly call the methods to update
    // the associated values of `m_message_id`
    setDestinationRank(rank);
    setTag(tag);
  }

  MessageRank destinationRank() const { return m_destination_rank; }
  void setDestinationRank(MessageRank rank)
  {
    m_destination_rank = rank;
    MessageId::SourceInfo si = m_message_id.sourceInfo();
    si.setRank(rank);
    m_message_id.setSourceInfo(si);
  }

  MessageRank emiterRank() const { return m_emiter_rank; }
  void setEmiterRank(MessageRank rank) { m_emiter_rank = rank; }

  MessageTag tag() const { return m_tag; }
  void setTag(MessageTag tag)
  {
    m_tag = tag;
    MessageId::SourceInfo si = m_message_id.sourceInfo();
    si.setTag(tag);
    m_message_id.setSourceInfo(si);
  }

  void print(std::ostream& o) const;
 
  friend std::ostream& operator<<(std::ostream& o, const PointToPointMessageInfo& pmessage)
  {
    pmessage.print(o);
    return o;
  }
 
 public:
 
  // Indicates if the message is valid (i.e.: it was initialized with a valid message)
  bool isValid() const
  {
    if (m_type == Type::T_Null)
      return false;
    if (m_type == Type::T_MessageId)
      return m_message_id.isValid();
    if (m_type == Type::T_RankTag)
      return true;
    return false;
  }
 
 public:

  ARCCORE_DEPRECATED_REASON("Y2022: Use emiterRank() instead")
  MessageRank sourceRank() const { return m_emiter_rank; }

  ARCCORE_DEPRECATED_REASON("Y2022: Use setEmiterRank() instead")
  void setSourceRank(MessageRank rank) { m_emiter_rank = rank; }
 
 private:
 
  MessageRank m_emiter_rank;
  MessageRank m_destination_rank;
  MessageTag m_tag = MessageTag::defaultTag();
  MessageId m_message_id;
  bool m_is_blocking = true;
  Type m_type = Type::T_Null;
 
  void _setInfosFromMessageId()
  {
    m_destination_rank = m_message_id.sourceInfo().rank();
    m_tag = m_message_id.sourceInfo().tag();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::MessagePassing
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif