API: Namespaces and Pointers

#Namespaces libscriptobject is defined in the rs::scriptobject namespace. There are a bunch of other libraries we've developed, they all live in their own namespace below the rs namespace.

Apologies if you find the nested namespaces a PITA, they are there for good reason.

#Pointers libscriptobject doesn't create normal C++ objects. They are packed into a single allocated block regardless of how many fields, their types and values your supply.

Underneath we use placement new which makes using std smart pointers a bit funky. To keep things simple libscriptobject uses its own smart pointer type: ScriptItemPtr. The main benefit here is that the reference count value is part of the allocated memory block and not allocated and managed separately.

ScriptItemPtr is defined as follows:

template <typename T>
class ScriptItemPtr final {
public:        
    inline T* get() const noexcept { return ptr_; }
    inline typename T::allocated_type* getRawPtr() const noexcept;
    inline void reset() noexcept;
    inline typename ScriptItemPtrBase<T>::count_type count() const noexcept;
    
    inline void operator=(ScriptItemPtr<T>&& rhs) noexcept;    
    inline void operator=(const ScriptItemPtr<T>& rhs) noexcept;
    
    inline T& operator*() const;
    inline T* operator->() const noexcept;
    inline bool operator!() const noexcept;
    
    inline void swap(ScriptItemPtr<T>& rhs) noexcept;
};

All pointer operations follow std conventions where possible, so should be easy to use.

You are most likely to encounter this pointer type when dealing with object or array instances. Integer, float, string and boolean fields are standard C++ data types.

But why not raw pointers? Well the problem here is that objects can contain other objects and arrays can contain objects so we need a way of controlling object lifetime - reference counted smart pointers are the best way to go under C++ without getting even more funky and electing for garbage collected objects.

ScriptItemPtr is thread safe on all platforms.