calendar.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "calendaritem.h"
 
// External Includes
#include <nap/resource.h>
#include <nap/resourceptr.h>
#include <nap/core.h>
#include <nap/logger.h>
#include <nap/signalslot.h>
#include <mathutils.h>
 
namespace nap
{
    class CalendarInstance;
    using CalendarItemList = std::vector<nap::ResourcePtr<CalendarItem>>;
    constexpr const char* calendarDirectory = "calendar";       
 
    class NAPAPI ICalendar : public Resource
    {
        RTTI_ENABLE(Resource)
 
    public:
        // Constructor
        ICalendar(nap::Core& core);
 
        virtual CalendarInstance& getInstance() = 0;
 
        virtual const CalendarInstance& getInstance() const = 0;
 
    protected:
        nap::Core& mCore;                   
    };
 
 
    // Calendar
 
    class NAPAPI Calendar : public ICalendar
    {
        RTTI_ENABLE(ICalendar)
    public:
        // Constructor
        Calendar(nap::Core& core);
 
        // Destructor
        virtual ~Calendar();
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        CalendarInstance& getInstance() override                { assert(mInstance != nullptr);  return *mInstance; }
 
        const CalendarInstance& getInstance() const override    { assert(mInstance != nullptr);  return *mInstance; }
 
        CalendarItemList mItems;                                
        bool mAllowFailure = true;                              
 
    private:
        std::unique_ptr<CalendarInstance> mInstance = nullptr;  
    };
 
 
    // Calendar runtime instance
 
    using OwnedCalendarItemList = std::vector<std::unique_ptr<CalendarItem>>;
 
    class NAPAPI CalendarInstance final
    {
        friend class Calendar;
        RTTI_ENABLE()
    public:
        // Default constructor
        CalendarInstance(nap::Core& core);
 
        // Calendar can't be copied
        CalendarInstance(const CalendarInstance& rhs) = delete;
        CalendarInstance& operator=(const CalendarInstance& rhs) = delete;
 
        bool init(const std::string& name, bool allowFailure, CalendarItemList defaultItems, utility::ErrorState& error);
 
        const std::string& getName() const                          { assert(!mName.empty()); return mName; }
 
        std::string getPath() const                                 { assert(!mPath.empty()); return mPath; }
 
        const OwnedCalendarItemList&  getItems() const              { return mItems; }
 
        template<typename T>
        void getItems(std::vector<T*>& outItems) const;
 
        void addItem(std::unique_ptr<CalendarItem> item);
 
        template<typename T, typename... Args>
        T* addItem(Args&&... args);
 
        bool removeItem(const std::string& id);
 
        CalendarItem* findByID(const std::string& id);
 
        template<typename T>
        T* findByID(const std::string& id)                      { return rtti_cast<T>(this->findByID(id)); }
 
        CalendarItem* findByTitle(const std::string& title);
 
        template<typename T>
        T* findByTitle(const std::string& title)        { return rtti_cast<T>(this->findByTitle(title)); }
 
        bool save(utility::ErrorState& error);
 
        Signal<const CalendarItem&> itemRemoved;    
        Signal<const CalendarItem&> itemAdded;      
 
        OwnedCalendarItemList mItems;       
        std::string mName;                  
        std::string mPath;                  
        nap::Core& mCore;                   
 
    private:
        bool load(utility::ErrorState& error);
    };
 
 
    // Template Definitions
 
    template<typename T, typename... Args>
    T* nap::CalendarInstance::addItem(Args&&... args)
    {
        // Construct using given (forwarded) arguments
        assert(RTTI_OF(T).is_derived_from(RTTI_OF(nap::CalendarItem)));
        std::unique_ptr<T> item = std::make_unique<T>(std::forward<Args>(args)...);
 
        // Initialize, on failure return and don't add as valid item
        item->mID = math::generateUUID();
        utility::ErrorState error;
        if (!item->init(error))
        {
            nap::Logger::error(error.toString());
            return nullptr;
        }
 
        T* item_ptr = item.get();
        mItems.emplace_back(std::move(item));
        return item_ptr;
    }
 
    template<typename T>
    void nap::CalendarInstance::getItems(std::vector<T*>& outItems) const
    {
        outItems.clear();
        for (const auto& item : mItems)
        {
            T* c_item = rtti_cast<T>(item.get());
            if (c_item != nullptr)
            {
                outItems.emplace_back(c_item);
            }
        }
    }
}