LazyEvaluate.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef KERNEL_UTILITIES_LAZYEVALUATE_H
#define KERNEL_UTILITIES_LAZYEVALUATE_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/utilities/utility.h"  // for pedigree_std::move

template <class T, class M, T *(*create)(const M &), void (*destroy)(T *)>
class LazyEvaluate
{
  public:
    // Default constructor builds a version that can never be evaluated.
    LazyEvaluate() : m_Metadata(), m_Field(nullptr), m_Ok(false)
    {
    }
    // Lazy variant (only evaluates on access)
    LazyEvaluate(const M &metadata)
        : m_Metadata(metadata), m_Field(nullptr), m_Ok(true)
    {
    }
    LazyEvaluate(M &&metadata)
        : m_Metadata(pedigree_std::move(metadata)), m_Field(nullptr), m_Ok(true)
    {
    }
    // Explicit variants (if the result of evaluation is known already)
    LazyEvaluate(T *value) : m_Metadata(), m_Field(value), m_Ok(true)
    {
    }
    LazyEvaluate(T *value, const M &metadata)
        : m_Metadata(metadata), m_Field(value), m_Ok(true)
    {
    }
    LazyEvaluate(T *value, M &&metadata)
        : m_Metadata(pedigree_std::move(metadata)), m_Field(value), m_Ok(true)
    {
    }
    virtual ~LazyEvaluate()
    {
        reset();
    }

    bool active() const
    {
        return m_Ok && (m_Field != nullptr);
    }

    void reset()
    {
        if (active())
        {
            destroy(m_Field);
            m_Field = nullptr;
        }
    }

    T *get()
    {
        if (active())
        {
            return m_Field;
        }
        else if (m_Ok)
        {
            m_Field = create(m_Metadata);
        }

        return m_Field;
    }

    T *operator->()
    {
        return get();
    }

    T &operator*()
    {
        return *get();
    }

    operator bool() const
    {
        // !ok = default constructed
        return m_Ok;
    }

    operator T *()
    {
        return get();
    }

  private:
    NOT_COPYABLE_OR_ASSIGNABLE(LazyEvaluate);

    M m_Metadata;
    T *m_Field;
    bool m_Ok;
};

#endif  // KERNEL_UTILITIES_LAZYEVALUATE_H