RangeBase.hpp

#ifndef FIBEROPERATIONS_RANGEBASE_HPP
#define FIBEROPERATIONS_RANGEBASE_HPP 20241206
 
#include <field/MemBase.hpp>
#include <grid/Representation.hpp>
#include <memcore/typemap.hpp>
#include <memcore/Profiler.hpp>
 
#include "fiberopDllApi.h"
 
#ifndef RangeVerbose
#define RangeVerbose(X) AppVerbose("Range",X)
#endif
 
namespace Fiber
{
 
#if (__cplusplus == 201703L)
#define RangeAttributeName  "Range"
#define RangeFragmentsAttributeName "RangeFragments"
#else
static constinit auto RangeAttributeName = "Range";
 [[maybe_unused]] static constinit auto RangeFragmentsAttributeName = "RangeFragments";
#endif
 
 
 
 
struct  fiberop_API DataRangeBase : public Interface<DataRangeBase>, public MemCore::Ageable
{
        struct fiberop_API NoDataRange : std::exception
        {
                ~NoDataRange() noexcept;
                const char* what() const noexcept override;
        };
 
        DataRangeBase(DataRangeBase&Db);
 
        DataRangeBase();
 
        DataRangeBase(const MemCore::Ageable&Age);
 
        virtual ~DataRangeBase() = 0;
 
        virtual void expandRange(const RefPtr<DataRangeBase>&DRB) = 0;
 
        virtual RefPtr<DataRangeBase>   getFloatRange() const = 0;
 
        virtual std::string     str() const = 0;
 
 
        virtual RefPtr<DataRangeBase>   getIndexedRange(const RefPtr<MemBase>&ArrayBase, const std::vector<uint32_t>&index_array) const = 0;
        virtual RefPtr<DataRangeBase>   getIndexedRange(const RefPtr<MemBase>&ArrayBase, const std::vector<size_t>&index_array) const = 0;
 
 
static  void    clear(CreativeArrayBase&CAB)
        {
                CAB.removeInterface<DataRangeBase>();
                CAB.removeAttribute( RangeAttributeName );
        }
 
static  void    clear(Field&F);
 
static  RefPtr<MemCore::ChunkBase> get_range_attribute(const Field&F)
        {
                return  F.getAttribute( RangeAttributeName );
        }
 
static  RefPtr<DataRangeBase> get_cached_rangebase_if_older_than_field(const Field&F)
        {
                if (RefPtr<DataRangeBase> DR = interface_cast<DataRangeBase>(F) )
                {
                        if ( !DR->isOlderThan( F ) )
                                return DR;
                }
                return  nullptr;
        }
 
 
static  bool    need_to_recompute(const Field&F);
 
 
static  void    setRangeCompleteness(Field&F, unsigned nFragments, unsigned FragmentsNotUsedForRangeComputation);
static  bool    isRangeComplete(Field&F);
 
        typedef RefPtr<DataRangeBase> compute_range_and_set_attribute_func(CreativeArrayBase&CAB, const RefPtr<MemBase>&ArrayBase);
        typedef RefPtr<DataRangeBase> get_range_if_older_than_creator_data_func(CreativeArrayBase&CAB);
 
 
static  void    computeRangeOnAvailableFragments(Field&F,
                                                 compute_range_and_set_attribute_func*typed_compute_function,
                                                 get_range_if_older_than_creator_data_func*range_determinator,
                                                 bool RequestToLoadMore = false);
 
};
 
 
extern fiberop_API RefPtr<DataRangeBase>
        getFragmentRange(CreativeArrayBase&CAB, bool AsynchRequest=false, bool theAvoidDataLoading = false, const RefPtr<MemBase>&PossibleData = nullptr);
 
 
inline  RefPtr<DataRangeBase>
getFragmentRange(Field&F, const RefPtr<FragmentID>& f, bool AsynchRequest=false, bool theAvoidDataLoading = false, const RefPtr<MemBase>&PossibleData = nullptr)
{
        if (RefPtr<CreativeArrayBase> CAB = F.getCreator(f))
                return  getFragmentRange( *CAB, AsynchRequest, theAvoidDataLoading, PossibleData);
 
        return nullptr;
}
 
 
 
 
 
extern fiberop_API RefPtr<DataRangeBase>
        getFieldRange_internal(Field&F, std::string&ErrorMessage, bool AsynchRequest=false, bool theAvoidDataLoading = false)
        ;
 
 
inline  RefPtr<DataRangeBase>
        getFieldRange(Field&F, std::string&ErrorMessage, bool AsynchRequest=false, bool theAvoidDataLoading = false)
        PERFORMANCE_WARNING_2(" data may be needed to be loaded from disc during this function call. Use getQuickFieldRange() to avoid this warning and data loading.")
        ;
 
inline  RefPtr<DataRangeBase>
        getFieldRange(Field&F, std::string&ErrorMessage, bool AsynchRequest, bool theAvoidDataLoading)
{
        return  getFieldRange_internal(F, ErrorMessage, AsynchRequest, theAvoidDataLoading);
}
 
 
inline RefPtr<DataRangeBase>
getQuickFieldRange(Field&F, std::string&ErrorMessage, bool AsynchRequest=false)
{
        return  getFieldRange_internal(F, ErrorMessage, AsynchRequest, true);
}
 
inline  RefPtr<DataRangeBase> getFieldRange(Field& F, bool AsynchRequest = false,  bool theAvoidDataLoading = false)
        PERFORMANCE_WARNING_1();
 
inline  RefPtr<DataRangeBase> getFieldRange(Field& F, bool AsynchRequest,  bool theAvoidDataLoading)
{
std::string     ErrorMessage;
        return  getFieldRange(F, ErrorMessage, AsynchRequest, theAvoidDataLoading);
}
 
inline  RefPtr<DataRangeBase> getFieldRange(const RefPtr<Field>& F, bool AsynchRequest = false,  bool theAvoidDataLoading = false)
{
        if (!F) return nullptr;
 
std::string     ErrorMessage;
        return  getFieldRange(*F, ErrorMessage, AsynchRequest, theAvoidDataLoading);
}
 
 
 
 
} // namespace Fiber
 
namespace std
{
fiberop_API string to_string(const Fiber::DataRangeBase& a);
}
 
#endif // FIBEROPERATIONS_RANGEBASE_HPP