BppStringCache.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 BPPSTRINGCACHE_HPP
#define BPPSTRINGCACHE_HPP
#include <duds/ui/graphics/BppFont.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/composite_key.hpp>

namespace duds { namespace ui { namespace graphics {

class BppStringCache : boost::noncopyable {
    BppFontSptr fnt;
    struct BppString {
        ConstBppImageSptr img;
        std::u32string text;
        BppFont::Flags flags;
    };
    typedef boost::multi_index::multi_index_container<
        BppString,
        boost::multi_index::indexed_by<
            boost::multi_index::hashed_non_unique<
                boost::multi_index::tag<struct index_text>,
                boost::multi_index::composite_key<
                    BppString,
                    boost::multi_index::member<
                        BppString,
                        std::u32string,
                        &BppString::text
                    >,
                    boost::multi_index::member<
                        BppString,
                        BppFont::Flags,
                        &BppString::flags
                    >
                >
            >,
            boost::multi_index::sequenced<
                boost::multi_index::tag<struct index_seq>
            >
        >
    > Cache;
    Cache cache;
    unsigned int maxS;
    unsigned int maxB;
    unsigned int curB = 0;
    duds::general::Spinlock block;
public:
    BppStringCache(
        const BppFontSptr &font,
        unsigned int maxBytes = 256 * 1024,
        unsigned int maxStrings = -1
    );
    BppStringCache(
        BppFontSptr &&font,
        unsigned int maxBytes = 256 * 1024,
        unsigned int maxStrings = -1
    );
    BppStringCache(
        const std::string &path,
        unsigned int maxBytes = 256 * 1024,
        unsigned int maxStrings = -1
    ) : BppStringCache(BppFont::make(path), maxBytes, maxStrings) { }
    static std::shared_ptr<BppStringCache> make(
        const BppFontSptr &font,
        unsigned int maxBytes = 256 * 1024,
        unsigned int maxStrings = -1
    ) {
        return std::make_shared<BppStringCache>(font, maxBytes, maxStrings);
    }
    static std::shared_ptr<BppStringCache> make(
        BppFontSptr &&font,
        unsigned int maxBytes = 256 * 1024,
        unsigned int maxStrings = -1
    ) {
        return std::make_shared<BppStringCache>(
            std::move(font),
            maxBytes,
            maxStrings
        );
    }
    static std::shared_ptr<BppStringCache> make(
        const std::string &path,
        unsigned int maxBytes = 256 * 1024,
        unsigned int maxStrings = -1
    ) {
        return std::make_shared<BppStringCache>(
            BppFont::make(path),
            maxBytes,
            maxStrings
        );
    }
    const BppFontSptr &font() const {
        return fnt;
    }
    unsigned int maxBytes() const {
        return maxB;
    }
    unsigned int maxStrings() const {
        return maxS;
    }
    unsigned int bytes() const {
        return curB;
    }
    unsigned int strings() const {
        return cache.size();
    }
    void clear();
    ConstBppImageSptr text(
        const std::string &str,
        BppFont::Flags flags = BppFont::AlignLeft
    );
    ConstBppImageSptr text(
        const std::u32string &str,
        BppFont::Flags flags = BppFont::AlignLeft
    );
};

typedef std::shared_ptr<BppStringCache>  BppStringCacheSptr;

} } }

#endif        //  #ifndef BPPSTRINGCACHE_HPP