memory.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_MEMORY_H_
#define _UCOMMON_MEMORY_H_
 
#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif
 
#ifndef _UCOMMON_PROTOCOLS_H_
#include <ucommon/protocols.h>
#endif
 
#ifndef  _UCOMMON_LINKED_H_
#include <ucommon/linked.h>
#endif
 
#ifndef _UCOMMON_STRING_H_
#include <ucommon/string.h>
#endif
 
namespace ucommon {
 
class PagerPool;
 
class __EXPORT memalloc : public __PROTOCOL MemoryProtocol
{
private:
    friend class bufpager;
 
    size_t pagesize, align;
    unsigned count;
 
    typedef struct mempage {
        struct mempage *next;
        union {
            void *memalign;
            unsigned used;
        };
    }   page_t;
 
    page_t *page;
 
protected:
    unsigned limit;
 
    page_t *pager(void);
 
public:
    memalloc(size_t page = 0);
 
    memalloc(const memalloc& copy);
 
    virtual ~memalloc();
 
    inline unsigned pages(void) const {
        return count;
    }
 
    inline unsigned max(void) const {
        return limit;
    }
 
    inline size_t size(void) const {
        return pagesize;
    }
 
    unsigned utilization(void) const;
 
    void purge(void);
 
protected:
    virtual void *_alloc(size_t size) __OVERRIDE;
 
public:
    void assign(memalloc& source);
};
 
class __EXPORT mempager : public memalloc, public __PROTOCOL LockingProtocol
{
private:
    mutable pthread_mutex_t mutex;
 
protected:
    virtual void _lock(void) __OVERRIDE;
 
    virtual void _unlock(void) __OVERRIDE;
 
public:
    mempager(size_t page = 0);
 
    mempager(const mempager& copy);
 
    virtual ~mempager();
 
    unsigned utilization(void);
 
    void purge(void);
 
    virtual void dealloc(void *memory);
 
protected:
    virtual void *_alloc(size_t size) __OVERRIDE;
 
public:
    void assign(mempager& source);
};
 
class __EXPORT ObjectPager : protected memalloc
{
public:
    class __EXPORT member : public LinkedObject
    {
    private:
        void *mem;
 
    protected:
        friend class ObjectPager;
 
        inline void set(member *node) {
            Next = node;
        }
 
        inline void *get(void) const {
            return mem;
        }
 
        member(LinkedObject **root);
        member();
 
    public:
        inline void *operator*() const {
            return mem;
        }
    };
 
private:
    unsigned members;
    LinkedObject *root;
    size_t typesize;
    member *last;
    void **index;
 
    __DELETE_COPY(ObjectPager);
 
protected:
    ObjectPager(size_t objsize, size_t pagesize = 256);
 
    void *get(unsigned item) const;
 
    void *add(void);
 
    void *push(void);
 
    void *pull(void);
 
    void *pop(void);
 
    void *invalid(void) const;
 
public:
    void clear(void);
 
    inline ObjectPager::member *begin(void) {
        return static_cast<ObjectPager::member *>(root);
    }
 
    inline operator bool() const {
        return members > 0;
    }
 
    inline bool operator!() const {
        return !members;
    }
 
    inline unsigned count(void) const {
        return members;
    }
 
    typedef linked_pointer<ObjectPager::member> iterator;
 
    inline size_t size(void) {
        return memalloc::size();
    }
 
    inline unsigned pages(void) {
        return memalloc::pages();
    }
 
protected:
    void **list(void);
 
public:
    void assign(ObjectPager& source);
};
 
class __EXPORT StringPager : protected memalloc
{
private:
    unsigned members;
    LinkedObject *root;
 
public:
    virtual bool filter(char *text, size_t size);
 
    class __EXPORT member : public LinkedObject
    {
    private:
        const char *text;
 
    protected:
        friend class StringPager;
 
        inline void set(member *node)
            {Next = node;}
 
        member(LinkedObject **root, const char *data);
        member(const char *data);
 
    public:
        inline const char *operator*() const {
            return text;
        }
 
        inline const char *get(void) const {
            return text;
        }
    };
 
    StringPager(size_t pagesize = 256);
 
    StringPager(char **list, size_t pagesize = 256);
 
    inline unsigned count(void) const {
        return members;
    }
 
    const char *get(unsigned item) const;
 
    void set(unsigned item, const char *string);
 
    void add(const char *text);
 
    void push(const char *text);
 
    void push(char **text);
 
    const char *pull(void);
 
    const char *pop(void);
 
    void add(char **list);
 
    void set(char **list);
 
    void clear(void);
 
    inline const char *operator[](unsigned item) const {
        return get(item);
    }
 
    inline const char *at(unsigned item) const {
        return get(item);
    }
 
    inline StringPager::member *begin(void) const {
        return static_cast<StringPager::member *>(root);
    }
 
    inline void operator+=(const char *text) {
        add(text);
    }
 
    inline StringPager& operator<<(const char *text) {
        add(text); 
        return *this;
    }
 
    inline StringPager& operator>>(const char *text) {
        push(text); 
        return *this;
    }
 
    void sort(void);
 
    char **list(void);
 
    unsigned token(const char *text, const char *list, const char *quote = NULL, const char *end = NULL);
 
    unsigned split(const char *text, const char *string, unsigned flags = 0);
 
    unsigned split(stringex_t& expr, const char *string, unsigned flags = 0);
 
    String join(const char *prefix = NULL, const char *middle = NULL, const char *suffix = NULL);
 
    inline operator bool() const {
        return members > 0;
    }
 
    inline bool operator!() const {
        return !members;
    }
 
    inline StringPager& operator=(char **list) {
        set(list); 
        return *this;
    }
 
    inline const char *operator*() {
        return pull();
    }
 
    inline operator char **() {
        return list();
    }
 
    typedef linked_pointer<StringPager::member> iterator;
 
    inline size_t size(void) const {
        return memalloc::size();
    }
 
    inline unsigned pages(void) const {
        return memalloc::pages();
    }
 
private:
    member *last;
    char **index;
 
public:
    void assign(StringPager& source);
};
 
class __EXPORT DirPager : protected StringPager
{
private:
    __DELETE_COPY(DirPager);
 
protected:
    const char *dir;
 
    virtual bool filter(char *filename, size_t size) __OVERRIDE;
 
    bool load(const char *path);
 
public:
    DirPager();
 
    DirPager(const char *path);
 
    void operator=(const char *path);
 
    inline const char *operator*() const {
        return dir;
    }
 
    inline operator bool() const {
        return dir != NULL;
    }
 
    inline bool operator!() const {
        return dir == NULL;
    }
 
    inline unsigned count(void) const {
        return StringPager::count();
    }
 
    inline const char *operator[](unsigned item) const {
        return StringPager::get(item);
    }
 
    inline const char *get(unsigned item) const {
        return StringPager::get(item);
    }
 
    inline const char *at(unsigned item) const {
        return StringPager::get(item);
    }
 
    inline size_t size(void) const {
        return memalloc::size();
    }
 
    inline unsigned pages(void) const {
        return memalloc::pages();
    }
 
public:
    void assign(DirPager& source);
};
 
class __EXPORT autorelease
{
private:
    LinkedObject *pool;
 
    __DELETE_COPY(autorelease);
 
public:
    autorelease();
 
    ~autorelease();
 
    void release(void);
 
    void operator+=(LinkedObject *object);
};
 
class __EXPORT PagerObject : public LinkedObject, public CountedObject
{
private:
    __DELETE_COPY(PagerObject);
 
protected:
    friend class PagerPool;
 
    PagerPool *pager;
 
    PagerObject();
 
    void reset(void);
 
    void retain(void) __OVERRIDE;
 
    void release(void) __OVERRIDE;
 
    void dealloc(void) __OVERRIDE;
};
 
class __EXPORT PagerPool : public __PROTOCOL MemoryProtocol
{
private:
    LinkedObject *freelist;
    mutable pthread_mutex_t mutex;
 
    __DELETE_COPY(PagerPool);
 
protected:
    PagerPool();
    virtual ~PagerPool();
 
    PagerObject *get(size_t size);
 
public:
    void put(PagerObject *object);
};
 
template <typename T>
class pager : private MemoryRedirect, private PagerPool
{
private:
    __DELETE_COPY(pager);
 
public:
    inline pager(mempager *heap = NULL) : MemoryRedirect(heap), PagerPool() {}
 
    inline T *operator()(void) {
        return new(get(sizeof(T))) T;
    }
 
    inline T *operator*() {
        return new(get(sizeof(T))) T;
    }
};
 
typedef StringPager stringlist_t;
 
typedef StringPager::member stringlistitem_t;
 
typedef DirPager dirlist_t;
 
inline String str(StringPager& list, const char *prefix = NULL, const char *middle = NULL, const char *suffix = NULL) {
    return list.join(prefix, middle, suffix);
}
 
} // namespace ucommon
 
#endif