object.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_OBJECT_H_
#define _UCOMMON_OBJECT_H_
 
#ifndef _UCOMMON_CPR_H_
#include <ucommon/cpr.h>
#endif
 
#ifndef _UCOMMON_GENERICS_H_
#include <ucommon/generics.h>
#endif
 
#ifndef _UCOMMON_PROTOCOLS_H_
#include <ucommon/protocols.h>
#endif
 
#include <stdlib.h>
 
namespace ucommon {
 
class __EXPORT CountedObject : public __PROTOCOL ObjectProtocol
{
private:
    volatile unsigned count;
 
protected:
    CountedObject();
 
    CountedObject(const ObjectProtocol &ref);
 
    virtual void dealloc(void);
 
    inline void reset(void) {
        count = 0;
    }
 
public:
    inline bool is_copied(void) const {
        return count > 1;
    }
 
    inline bool is_retained(void) const {
        return count > 0;
    }
 
    inline unsigned copied(void) const {
        return count;
    }
 
    void retain(void) __OVERRIDE;
 
    void release(void) __OVERRIDE;
};
 
class __EXPORT AutoObject
{
protected:
    ObjectProtocol *object;
 
    AutoObject();
 
    AutoObject(ObjectProtocol *object);
 
    AutoObject(const AutoObject &pointer);
 
    ~AutoObject();
 
    void set(ObjectProtocol *object);
 
public:
    void release(void);
 
    bool operator!() const;
 
    operator bool() const;
 
};
 
class __EXPORT SparseObjects
{
private:
    ObjectProtocol **vector;
    unsigned max;
 
    __DELETE_DEFAULTS(SparseObjects);
 
protected:
    virtual ObjectProtocol *create(void) = 0;
 
    void purge(void);
 
    virtual ObjectProtocol *invalid(void) const;
 
    ObjectProtocol *get(unsigned offset);
 
    SparseObjects(unsigned size);
 
    virtual ~SparseObjects();
 
public:
    unsigned count(void);
};
 
template <class T>
class sarray : public SparseObjects
{
private:
    __DELETE_DEFAULTS(sarray);
 
public:
    inline sarray(unsigned size) : SparseObjects(size) {}
 
    inline T *get(unsigned offset) {
        return static_cast<T*>(SparseObjects::get(offset));
    }
 
    inline T& operator[](unsigned offset) {
        return reference_cast<T>(get(offset));
    }
 
    inline T& at(unsigned offset) {
        return reference_cast<T>(SparseObjects::get(offset));
    }
 
    inline const T* operator()(unsigned offset) const {
        return get(offset);
    }
 
    inline void operator()(unsigned offset, T value) {
        T& ref = at(offset);
        ref = value;
    }
 
private:
    __LOCAL ObjectProtocol *create(void) __FINAL {
        return new T;
    }
};
 
template <class T>
class object_pointer : public AutoObject
{
public:
    inline object_pointer() : AutoObject() {}
 
    inline object_pointer(T* object) : AutoObject(object) {}
 
    inline object_pointer(const object_pointer& copy) : AutoObject(copy) {}
 
    inline T* operator*() const {
        return protocol_cast<T*>(object);
    }
 
    inline T& operator()() const {
        return reference_cast<T>(object);
    }
 
    inline T* operator->() const {
        return protocol_cast<T*>(object);
    }
 
    inline T* get(void) const {
        return protocol_cast<T*>(object);
    }
 
    inline object_pointer& operator=(T *typed) {
        AutoObject::set(polypointer_cast<ObjectProtocol*>(typed));
        return *this;
    }
 
    inline object_pointer& operator=(const object_pointer& from) {
        AutoObject::set(polypointer_cast<ObjectProtocol*>(from.object));
        return *this;
    }
 
    inline operator bool() const {
        return object != NULL;
    }
 
    inline bool operator!() const {
        return object == NULL;
    }
};
 
} // namespace ucommon
 
#endif