Generator.inl

/*
 * Copyright(c) Sophist Solutions, Inc. 1990-2026.  All rights reserved
 */
#include "Stroika/Foundation/Debug/Assertions.h"
#include "Stroika/Foundation/Debug/Cast.h"
#include "Stroika/Foundation/Memory/BlockAllocated.h"
#include "Stroika/Foundation/Traversal/IterableFromIterator.h"
 
namespace Stroika::Foundation::Traversal {
 
    /**
     */
    template <typename T>
    Iterator<T> CreateGeneratorIterator (const function<optional<T> ()>& getNext)
    {
        struct GenItWrapper_ : Iterator<T>::IRep, public Memory::UseBlockAllocationIfAppropriate<GenItWrapper_> {
            function<optional<T> ()> fFun_;
            optional<T>              fCur_;
            GenItWrapper_ () = delete;
            GenItWrapper_ (const function<optional<T> ()>& f)
                : fFun_{f}
                , fCur_{fFun_ ()}
            {
            }
            virtual bool AtEnd () const override
            {
                return not fCur_.has_value ();
            }
            virtual optional<T> Current () const override
            {
                return fCur_;
            }
            virtual optional<T> More () override
            {
                Require (fCur_.has_value ()); // not at end
                fCur_ = fFun_ ();
                return fCur_;
            }
            virtual bool Equals (const typename Iterator<T>::IRep* rhs) const override
            {
                RequireNotNull (rhs);
                const GenItWrapper_& rrhs = *Debug::UncheckedDynamicCast<const GenItWrapper_*> (rhs);
                // No way to tell equality (so must rethink definition in Iterator<T>::Equals()!!! @todo
                WeakAssert (not fCur_.has_value () or not rrhs.fCur_.has_value ());
                return fCur_.has_value () == rrhs.fCur_.has_value ();
            }
            virtual unique_ptr<typename Iterator<T>::IRep> Clone () const override
            {
                return make_unique<GenItWrapper_> (*this);
            }
        };
        return Iterator<T>{make_unique<GenItWrapper_> (getNext)};
    }
 
    /**
     */
    template <typename T>
    inline Iterable<T> CreateGenerator (const function<optional<T> ()>& getNext)
    {
        return MakeIterableFromIterator (CreateGeneratorIterator (getNext));
    }
 
}