future_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_FUTURE_MAP_H__
#define __LEGION_FUTURE_MAP_H__
 
#include "legion/api/future.h"
 
namespace Legion {
 
  class FutureMap : public Unserializable {
  public:
    FutureMap(void);
    FutureMap(const FutureMap& map);
    FutureMap(FutureMap&& map) noexcept;
    ~FutureMap(void);
  private:
    Internal::FutureMapImpl* impl;
  protected:
    // Only the runtime should be allowed to make these
    FRIEND_ALL_RUNTIME_CLASSES
    explicit FutureMap(Internal::FutureMapImpl* impl);
  public:
    inline bool exists(void) const { return (impl != nullptr); }
    inline bool operator==(const FutureMap& f) const { return impl == f.impl; }
    inline bool operator<(const FutureMap& f) const { return impl < f.impl; }
    inline Future operator[](const DomainPoint& point) const
    {
      return get_future(point);
    }
    FutureMap& operator=(const FutureMap& f);
    FutureMap& operator=(FutureMap&& f) noexcept;
    std::size_t hash(void) const;
  public:
    template<typename T>
    inline T get_result(
        const DomainPoint& point, bool silence_warnings = false,
        const char* warning_string = nullptr) const;
    Future get_future(const DomainPoint& point) const;
    void get_void_result(
        const DomainPoint& point, bool silence_warnings = false,
        const char* warning_string = nullptr) const;
  public:
    template<typename RT, typename PT, unsigned DIM>
    inline RT get_result(const PT point[DIM]) const;
    template<typename PT, unsigned DIM>
    inline Future get_future(const PT point[DIM]) const;
    template<typename PT, unsigned DIM>
    inline void get_void_result(const PT point[DIM]) const;
  public:
    void wait_all_results(
        bool silence_warnings = false,
        const char* warning_string = nullptr) const;
  public:
    Domain get_future_map_domain(void) const;
  };
 
}  // namespace Legion
 
#include "legion/api/future_map.inl"
 
#endif  // __LEGION_FUTURE_MAP_H__