Menu.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2019  Jeff Jackowski
 */
#ifndef MENU_HPP
#define MENU_HPP

//#include <duds/ui/menu/MenuErrors.hpp>
#include <boost/noncopyable.hpp>
#include <thread>
#include <shared_mutex>
#include <string>
#include <vector>
#include <map>
#include <memory>

namespace duds { namespace ui {

namespace menu {

class MenuAccess;
class MenuItem;
class MenuOutput;
class MenuOutputAccess;
class MenuView;

class Menu : public std::enable_shared_from_this<Menu>, boost::noncopyable {
public:
    typedef std::vector< std::shared_ptr<MenuItem> >  ItemVec;
    typedef std::map< MenuView*, std::weak_ptr<MenuView> >  ViewMap;
private:
    ItemVec items;
    ViewMap views;
    std::shared_timed_mutex block;
    std::thread::id lockOwner;
    std::string lbl;
    std::size_t invis;
    std::size_t toggles;
    int lockCnt;
    int updateIdx;
    friend MenuAccess;
    friend MenuItem;
    friend MenuOutput;
    friend MenuOutputAccess;
    friend MenuView;
public:
    Menu(std::size_t reserve = 0);
    Menu(const std::string &title, std::size_t reserve = 0);
    static std::shared_ptr<Menu> make(std::size_t reserve = 0) {
        return std::make_shared<Menu>(reserve);
    }
    static std::shared_ptr<Menu> make(
        const std::string &title,
        std::size_t reserve = 0
    ) {
        return std::make_shared<Menu>(title, reserve);
    }
    const std::string &title() const {
        return lbl;
    }
    std::size_t size() const {
        return items.size();
    }
    std::size_t invisible() const {
        return invis;
    }
    std::size_t visible() const {
        return items.size() - invis;
    }
    bool empty() const {
        return items.empty();
    }
    int updateIndex() const {
        return updateIdx;
    }
    bool haveToggles() const {
        return toggles > 0;
    }
private:
    void exclusiveLock();
    void exclusiveUnlock();
    void addView(const std::shared_ptr<MenuView> &view);
    void informViews(void (MenuView::* eventFunc)(std::size_t), std::size_t idx);
    ItemVec::const_iterator iterator(std::size_t index) const;
    ItemVec::const_iterator cbegin() const {
        return items.cbegin();
    }
    ItemVec::const_iterator cend() const {
        return items.cend();
    }

    // the following functions must only be invoked by MenuAccess

    void clear() noexcept;
    void title(const std::string &newTitle) noexcept;
    void append(std::shared_ptr<MenuItem> &&mi);
    void append(const std::shared_ptr<MenuItem> &mi);
    void insert(std::size_t index, std::shared_ptr<MenuItem> &&mi);
    void insert(std::size_t index, const std::shared_ptr<MenuItem> &mi);
    void remove(const std::shared_ptr<MenuItem> &mi);
    void remove(std::size_t index);
};

typedef std::shared_ptr<Menu>  MenuSptr;

typedef std::weak_ptr<Menu>  MenuWptr;

} } }

#endif        //  #ifndef MENU_HPP