ExFuture.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2022 Daniel Barrientos <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
#include <core/Future.h>
namespace mel
{
    namespace execution
    {
        using mel::core::Future;
        template <class ExecutorAgent> class Executor; // predeclarationj
        template <typename ExecutorAgent, typename ResultType>
        class ExFuture : public Future<ResultType>
        {
          public:
            ExFuture() = default;
            ExFuture( const ExFuture& ob ) noexcept
                : Future<ResultType>( ob ), agent( ob.agent )
            {
            }
            ExFuture( ExFuture&& ob ) noexcept
                : Future<ResultType>( std::move( ob ) ),
                  agent( std::move( ob.agent ) )
            {
            }
            ExFuture( Executor<ExecutorAgent> aEx ) noexcept : agent( aEx ) {}
            ExFuture( Executor<ExecutorAgent> aEx, const ResultType& val )
                : Future<ResultType>( val ), agent( aEx )
            {
            }
            ExFuture( Executor<ExecutorAgent> aEx, ResultType&& val )
                : Future<ResultType>( std::move( val ) ), agent( aEx )
            {
            }
 
            ExFuture& operator=( const ExFuture& f ) noexcept
            {
                Future<ResultType>::operator=( f );
                agent = f.agent;
                return *this;
            };
            ExFuture& operator=( ExFuture&& f ) noexcept
            {
                Future<ResultType>::operator=( std::move( f ) );
                agent = std::move( f.agent );
                return *this;
            };
            Executor<ExecutorAgent>
                agent; 
        };
 
        // for reference type
        template <typename ExecutorAgent, typename ResultType>
        class ExFuture<ExecutorAgent, ResultType&> : public Future<ResultType&>
        {
          public:
            ExFuture() = default;
            ExFuture( const ExFuture& ob )
                : Future<ResultType&>( ob ), agent( ob.agent )
            {
            }
            ExFuture( ExFuture&& ob )
                : Future<ResultType&>( std::move( ob ) ),
                  agent( std::move( ob.agent ) )
            {
            }
            ExFuture( Executor<ExecutorAgent> aEx ) : agent( aEx ) {}
            ExFuture( Executor<ExecutorAgent> aEx, ResultType& val )
                : Future<ResultType&>( val ), agent( aEx )
            {
            }
 
            ExFuture& operator=( const ExFuture& f )
            {
                Future<ResultType&>::operator=( f );
                agent = f.agent;
                return *this;
            };
            ExFuture& operator=( ExFuture&& f )
            {
                Future<ResultType&>::operator=( std::move( f ) );
                agent = std::move( f.agent );
                return *this;
            };
            Executor<ExecutorAgent>
                agent; 
        };
        // specialization for void
        template <typename ExecutorAgent>
        class ExFuture<ExecutorAgent, void> : public Future<void>
        {
          public:
            ExFuture() = default;
            ExFuture( const ExFuture& ob )
                : Future<void>( ob ), agent( ob.agent )
            {
            }
            ExFuture( ExFuture&& ob )
                : Future<void>( std::move( ob ) ),
                  agent( std::move( ob.agent ) )
            {
            }
            ExFuture( Executor<ExecutorAgent> aEx ) : agent( aEx ) {}
            ExFuture( Executor<ExecutorAgent> aEx, int dummy )
                : Future<void>( dummy ), agent( aEx )
            {
            }
            ExFuture& operator=( const ExFuture& f )
            {
                Future<void>::operator=( f );
                agent = f.agent;
                return *this;
            };
            ExFuture& operator=( ExFuture&& f )
            {
                Future<void>::operator=( std::move( f ) );
                agent = std::move( f.agent );
                return *this;
            };
 
            Executor<ExecutorAgent>
                agent; 
        };
    } // namespace execution
} // namespace mel