argument_map.h

/* Copyright 2026 Stanford University, NVIDIA Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __LEGION_ARGUMENT_MAP_H__
#define __LEGION_ARGUMENT_MAP_H__
 
#include "legion/api/future_map.h"
 
namespace Legion {
 
  //==========================================================================
  //                    Pass-By-Value Argument Classes
  //==========================================================================
 
  class UntypedBuffer : public Unserializable {
  public:
    UntypedBuffer(void) : args(nullptr), arglen(0) { }
    UntypedBuffer(const void* arg, size_t argsize)
      : args(const_cast<void*>(arg)), arglen(argsize)
    { }
    UntypedBuffer(const UntypedBuffer& rhs) : args(rhs.args), arglen(rhs.arglen)
    { }
    UntypedBuffer(UntypedBuffer&& rhs) noexcept
      : args(rhs.args), arglen(rhs.arglen)
    { }
  public:
    inline size_t get_size(void) const { return arglen; }
    inline void* get_ptr(void) const { return args; }
  public:
    inline bool operator==(const UntypedBuffer& arg) const
    {
      return (args == arg.args) && (arglen == arg.arglen);
    }
    inline bool operator<(const UntypedBuffer& arg) const
    {
      return (args < arg.args) && (arglen < arg.arglen);
    }
    inline UntypedBuffer& operator=(const UntypedBuffer& rhs)
    {
      args = rhs.args;
      arglen = rhs.arglen;
      return *this;
    }
    inline UntypedBuffer& operator=(UntypedBuffer&& rhs) noexcept
    {
      args = rhs.args;
      arglen = rhs.arglen;
      return *this;
    }
  private:
    void* args;
    size_t arglen;
  };
  // This typedef is here for backwards compatibility since we
  // used to call an UntypedBuffer a TaskArgument
  typedef UntypedBuffer TaskArgument;
 
  class ArgumentMap : public Unserializable {
  public:
    ArgumentMap(void);
    ArgumentMap(const FutureMap& rhs);
    ArgumentMap(const ArgumentMap& rhs);
    ArgumentMap(ArgumentMap&& rhs) noexcept;
    ~ArgumentMap(void);
  public:
    ArgumentMap& operator=(const FutureMap& rhs);
    ArgumentMap& operator=(const ArgumentMap& rhs);
    ArgumentMap& operator=(ArgumentMap&& rhs) noexcept;
    inline bool operator==(const ArgumentMap& rhs) const
    {
      return (impl == rhs.impl);
    }
    inline bool operator<(const ArgumentMap& rhs) const
    {
      return (impl < rhs.impl);
    }
    inline bool exists(void) const { return (impl != nullptr); }
  public:
    bool has_point(const DomainPoint& point);
    void set_point(
        const DomainPoint& point, const UntypedBuffer& arg,
        bool replace = true);
    void set_point(
        const DomainPoint& point, const Future& f, bool replace = true);
    bool remove_point(const DomainPoint& point);
    UntypedBuffer get_point(const DomainPoint& point) const;
  public:
    template<typename PT, unsigned DIM>
    inline void set_point_arg(
        const PT point[DIM], const UntypedBuffer& arg, bool replace = false);
    template<typename PT, unsigned DIM>
    inline bool remove_point(const PT point[DIM]);
  private:
    FRIEND_ALL_RUNTIME_CLASSES
    Internal::ArgumentMapImpl* impl;
  private:
    explicit ArgumentMap(Internal::ArgumentMapImpl* i);
  };
 
}  // namespace Legion
 
#include "legion/api/argument_map.inl"
 
#endif  // __LEGION_ARGUMENT_MAP_H__