typeref.h

Go to the documentation of this file.

// 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_TYPEREF_H_
#define _UCOMMON_TYPEREF_H_
 
#ifndef _UCOMMON_CPR_H_
#include <ucommon/cpr.h>
#endif
 
#ifndef _UCOMMON_ATOMIC_H_
#include <ucommon/atomic.h>
#endif
 
#ifndef _UCOMMON_PROTOCOLS_H_
#include <ucommon/protocols.h>
#endif
 
#ifndef _UCOMMON_GENERICS_H_
#include <ucommon/generics.h>
#endif
 
#ifndef _UCOMMON_OBJECT_H_
#include <ucommon/object.h>
#endif
 
#ifndef _UCOMMON_THREAD_H_
#include <ucommon/thread.h>
#endif
 
namespace ucommon {
 
class TypeRelease;
class typeref_guard;
 
class __EXPORT TypeRef
{
protected:
    friend class ArrayRef;
    friend class SharedRef;
    friend class MapRef;
    friend class TypeRelease;
 
    class Release;
 
public:
    class __EXPORT Counted : public __PROTOCOL ObjectProtocol
    {
    private:
        __DELETE_COPY(Counted);
 
    protected:
        friend class TypeRef;
        friend class TypeRelease;
 
        union {
            TypeRelease *autorelease;           
            Counted *linkrelease;
        };
 
        mutable Atomic::counter count;
        unsigned offset;
        size_t size;
 
        explicit Counted(void *address, size_t size, TypeRelease *ar = NULL);
 
        virtual void dealloc(void);
 
    public:
        inline bool is() const {
            return (count.get() > 0);
        }
 
        inline unsigned copies() const {
            return ((unsigned)count.get());
        }
 
        inline TypeRelease *getRelease() const {
            return autorelease;
        }
 
        void operator delete(void *address);
 
        void retain();
 
        void release();
    };      
 
protected:
    Counted *ref;       // heap reference...
 
    TypeRef(Counted *object);
 
    TypeRef(const TypeRef& pointer);
 
    TypeRef();
 
    void set(Counted *object);
 
    void assign(const typeref_guard& ref);
 
    static caddr_t mem(caddr_t address);
 
public:
    virtual ~TypeRef();
 
    void set(const TypeRef& pointer);
 
    void clear(void);
 
    size_t size(void) const;
 
    unsigned copies() const;
    
    inline operator bool() const {
        return ref != NULL;
    }
 
    inline bool operator!() const {
        return ref == NULL;
    }
 
    inline static void put(TypeRef& target, Counted *object) {
        target.set(object);
    }
 
    bool is_released(void);
};
 
class __EXPORT TypeRelease
{
public:
    inline TypeRelease() {
        delegate = nullptr;
    }
 
    inline TypeRelease(TypeRelease *target) {
        delegate = target;
    }
 
    virtual unsigned purge();
 
    virtual caddr_t allocate(size_t size);
 
protected:
    friend class TypeRef::Counted;
 
    TypeRelease *delegate;
 
    void enlist(TypeRef::Counted **root, TypeRef::Counted *obj);
    
    TypeRef::Counted *delist(TypeRef::Counted **root);
 
    virtual void release(TypeRef::Counted *obj);
 
    void dealloc(TypeRef::Counted *obj);
 
    inline size_t size(TypeRef::Counted *obj) {
        return obj->size;
    }
};
 
extern __EXPORT TypeRelease auto_release;
extern __EXPORT TypeRelease secure_release;
extern __EXPORT TypeRelease release_later;
 
class __EXPORT typeref_guard : protected TypeRef
{
private:
    friend class TypeRef;
    
    mutable Mutex sync;
 
public:
    inline typeref_guard() : TypeRef() {}
 
    inline typeref_guard(const typeref_guard& copy) : TypeRef(copy) {}
 
    inline typeref_guard(const TypeRef& pointer) : TypeRef(pointer) {}
 
    void set(const TypeRef& pointer);
 
    inline typeref_guard& operator=(const TypeRef& pointer) {
        set(pointer);
        return *this;
    }
};
 
template<typename T, TypeRelease& R = auto_release>
class typeref : public TypeRef
{
private:
    class value : public Counted
    {
    private:
        __DELETE_COPY(value);
 
    public:
        T data;
 
        inline value(caddr_t mem, const T& object, TypeRelease *ar = &R) : 
        Counted(mem, sizeof(value), ar) {
            data = object;
        }
    };
 
public:
    inline typeref() :  TypeRef() {}
 
    inline typeref(const typeref_guard& global) : TypeRef() {
        TypeRef::assign(global);
    }
 
    inline typeref(const typeref& copy) : TypeRef(copy) {}
 
    inline typeref(const T& object, TypeRelease *ar = &R) : TypeRef() {
        caddr_t p = R.allocate(sizeof(value));
        TypeRef::set(new(mem(p)) value(p, object, ar)); 
    }
 
    inline explicit typeref(Counted *object) : TypeRef(object) {}
 
    inline const T* operator->() const {
        if(!ref)
            return NULL;
        value *v = polystatic_cast<value *>(ref);
        return &(v->data);
    }
 
    inline const T& operator*() const {
        value *v = polystatic_cast<value*>(ref);
        __THROW_DEREF(v);
        return *(&(v->data));
    }
 
    inline const T* operator()() const {
        value *v = polystatic_cast<value*>(ref);
        if(!v)
            return nullptr;
 
        return &(v->data);
    }
 
    inline operator const T&() const {
        value *v = polystatic_cast<value*>(ref);
        __THROW_DEREF(v);
        return *(&(v->data));
    }
 
    inline typeref& operator=(const typeref_guard& ptr) {
        TypeRef::assign(ptr);
        return *this;
    }
 
    inline typeref& operator=(const typeref& ptr) {
        TypeRef::set(ptr);
        return *this;
    }
 
    inline bool operator==(const typeref& ptr) const {
        value *v1 = polystatic_cast<value*>(ref);
        value *v2 = polystatic_cast<value*>(ptr.ref);
        if(!v1 || !v2)
            return false;
        return v1->data == v2->data;
    }   
 
    inline bool operator==(const T& obj) const {
        value *v = polystatic_cast<value *>(ref);
        if(!v)
            return false;
        return v->data == obj;
    }
 
    inline bool operator!=(const typeref& ptr) const {
        return !(*this == ptr);
    }
 
    inline bool operator!=(const T& obj) const {
        return !(*this == obj);
    }
 
    inline void set(T& object, TypeRelease *pool = &R) {
        clear();
        caddr_t p = R.allocate(sizeof(value));
        TypeRef::set(new(mem(p)) value(p, object, pool));
    }
 
    inline typeref& operator=(T& object) {
        set(object);
        return *this;
    }
};
 
// The specializations are done as simple template specializations so that the
// hard parts can be hard-coded rather than inline members.  This means we do
// not pass the autorelease as a specialization here, but we can do a secondary
// template that does use releases with a lot less overhead.
 
template<>
class __EXPORT typeref<const char *> : public TypeRef
{
public:
    class value : public Counted
    {
    private:
        __DELETE_COPY(value);
 
    protected:
        friend class typeref;
 
        char mem[1];
 
        value(caddr_t addr, size_t size, const char *str, TypeRelease *ar = &auto_release);
 
        void destroy(void);
 
    public:
        inline char *get() {
            return &mem[0];
        }
 
        inline size_t len() {
            return strlen(mem);
        }
 
        inline size_t max() {
            return size;
        }
 
        inline operator char *() {
            return &mem[0];
        }
    };
 
    typeref();
    
    typeref(const typeref& copy);
 
    typeref(const char *str, TypeRelease *ar = &auto_release);
 
    typeref(size_t size, TypeRelease *ar = &auto_release);
 
    inline typeref(const typeref_guard& global) : TypeRef() {
        TypeRef::assign(global);
    }
 
    inline explicit typeref(Counted *object) : TypeRef(object) {}
 
    inline explicit typeref(value *value) : TypeRef(value) {}
 
    const char *operator*() const;
 
    inline operator const char *() const {
        return operator*();
    }
 
    size_t len() const;
 
    bool operator==(const typeref& ptr) const;
 
    bool operator==(const char *obj) const;
 
    bool operator==(value *chars) const;
 
    inline bool operator!=(const typeref& ptr) const {
        return !(*this == ptr);
    }
 
    inline bool operator!=(value *chars) const {
        return !(*this == chars);
    }
 
    inline bool operator!=(const char *obj) const {
        return !(*this == obj);
    }
 
    bool operator<(const typeref& ptr) const;
 
    inline bool operator>(const typeref& ptr) const {
        return (ptr < *this);
    }
 
    inline bool operator<=(const typeref& ptr) const {
        return !(*this > ptr);
    }
 
    inline bool operator>=(const typeref& ptr) const {
        return !(*this < ptr);
    }
 
    typeref& operator=(const typeref& objref);
 
    typeref& operator=(const char *str);
 
    typeref& operator=(value *chars);
 
    const typeref operator+(const char *str) const;
 
    const typeref operator+(const typeref& ptr) const;
 
    const char *operator()(ssize_t offset) const;
 
    void set(const char *str, TypeRelease *ar = &auto_release);
 
    void hex(const uint8_t *mem, size_t size, TypeRelease *ar = &auto_release);
 
    void b64(const uint8_t *mem, size_t size, TypeRelease *ar = &auto_release);
 
    void assign(value *chars);
 
    static void expand(value **handle, size_t size);
 
    static value *create(size_t size, TypeRelease *ar = &auto_release);
 
    static void destroy(value *bytes);
};
 
template<>
class __EXPORT typeref<const uint8_t *> : public TypeRef
{
public:
    class value : public Counted
    {
    private:
        __DELETE_COPY(value);
 
    protected:
        friend class typeref;
 
        uint8_t mem[1];
 
        value(caddr_t addr, size_t size, const uint8_t *data = nullptr, TypeRelease *ar = &auto_release);
 
        void destroy(void);
 
    public:
        inline size_t max() {
            return size;
        }
 
        inline uint8_t *get() {
            return &mem[0];
        }
 
        inline operator uint8_t*() {
            return &mem[0];
        }
    };
 
    typeref();
    
    typeref(const typeref& copy);
 
    typeref(uint8_t *str, size_t size, TypeRelease *ar = &auto_release);
 
    typeref(size_t size, TypeRelease *ar = &auto_release);
 
    typeref(bool mode, size_t bits, TypeRelease *ar = &auto_release);
 
    inline typeref(const typeref_guard& global) : TypeRef() {
        TypeRef::assign(global);
    }
 
    inline explicit typeref(Counted *object) : TypeRef(object) {}
 
    const uint8_t *operator*() const;
 
    inline operator const uint8_t *() const {
        return operator*();
    }
 
    typeref& operator=(const typeref& objref);
 
    typeref& operator=(value *bytes);
 
    bool operator==(const typeref& ptr) const;
 
    bool operator==(value *bytes) const;
 
    inline bool operator!=(const typeref& ptr) const {
        return !(*this == ptr);
    }
 
    inline bool operator!=(value *bytes) const {
        return !(*this == bytes);
    }
 
    const typeref operator+(const typeref& ptr) const;
 
    void set(const uint8_t *str, size_t size, TypeRelease *ar = &auto_release);
 
    size_t set(bool bit, size_t offset, size_t bits = 1);
 
    size_t hex(const char *str, bool ws = false, TypeRelease *ar = &auto_release);
 
    size_t b64(const char *str, bool ws = false, TypeRelease *ar = &auto_release);
 
    uint8_t *data(void);
 
    bool get(size_t offset);
 
    size_t count(size_t offset, size_t bits = 1);   
 
    void assign(value *bytes);
 
    typeref<const char *> hex();
 
    typeref<const char *> b64();
 
    static value *create(size_t size, TypeRelease *ar = &auto_release);
 
    static void destroy(value *bytes);
};
 
// convenience classes that roll up autorelease behavior for strings and
// byte arrays into templates.
 
template<TypeRelease& R>
class stringref : public typeref<const char *>
{
public:
    inline stringref() : typeref<const char *>() {} 
    
    inline stringref(const stringref& copy) : typeref<const char *>(copy) {}
 
    inline stringref(const char *str) : typeref<const char *>(str, &R) {}
 
    inline stringref(size_t size) : typeref<const char *>(size, &R) {}
 
    inline explicit stringref(Counted *object) : typeref<const char *>(object) {}
 
    inline void set(const char *str) {
        typeref<const char *>::set(str, &R);
    }
 
    inline static value *create(size_t size) {
        return typeref<const char *>::create(size, &R);
    }
 
    inline static stringref promote(typeref<const char *>& str) {
        stringref result = *str;
        return result;
    }
};
 
template<TypeRelease& R>
class byteref : public typeref<const uint8_t *>
{
public:
    inline byteref() : typeref<const uint8_t *>() {}
 
    inline byteref(uint8_t *str, size_t size) : typeref<const uint8_t *>(str, size, &R) {}
 
    inline byteref(size_t size) : typeref<const uint8_t *>(size, &R) {}
 
    inline byteref(bool mode, size_t bits) : typeref<const uint8_t *>(mode, bits, &R) {}
 
    inline explicit byteref(Counted *object) : typeref<const uint8_t *>(object) {}
 
    inline void set(const uint8_t *str, size_t size) {
        typeref<const uint8_t *>::set(str, size, &R);
    }
 
    inline size_t hex(const char *str, bool ws = false) {
        return typeref<const uint8_t *>::hex(str, ws, &R);
    }
 
    inline size_t b64(const char *str, bool ws = false) {
        return typeref<const uint8_t *>::b64(str, ws, &R);
    }
 
    inline stringref<R> hex() {
        typeref<const char *> str = typeref<const uint8_t *>::hex();
        stringref<R> result = *str;
        return result;
    }
 
    inline stringref<R> b64() {
        typeref<const char *> str = typeref<const uint8_t *>::b64();
        stringref<R> result = *str;
        return result;
    }
 
    inline static value *create(size_t size) {
        return typeref<const uint8_t *>::create(size, &R);
    }
 
    inline static byteref promote(typeref<const uint8_t *>& str) {
        byteref result = *str;
        return result;
    }
};
 
// a namespace for aliasing things we may typically use as a typeref
 
namespace Type {
    typedef int32_t Integer;
    typedef double Real;
    typedef const char *Chars;
    typedef const uint8_t *Bytes;
    typedef const uint8_t *Bools;
}
 
typedef typeref<Type::Chars>::value *charvalues_t;
typedef typeref<Type::Bytes>::value *bytevalues_t;
typedef typeref<Type::Chars> stringref_t;
typedef typeref<Type::Bytes> byteref_t;
typedef typeref<Type::Bools> boolref_t;
 
template<typename T>
inline typeref<T> typeref_cast(T x) {
    return typeref<T>(x);
}
 
} // namespace
 
#endif