namespace property {
    template <typename T>
    struct default_accessor {
        typedef T value_type;
        typedef value_type& reference;
        typedef const reference const_reference;

        default_accessor(reference ref) : m_object(ref)
        {
            // Do nothing.
        }

        const_reference operator()() const noexcept
        {
            return m_object;
        }

        reference operator()() noexcept
        {
            return m_object;
        }
    private:
        reference m_object;
    };

    template <typename T>
    struct default_mutator {
        typedef T value_type;
        typedef value_type& reference;
        typedef const reference const_reference;

        default_mutator(reference ref) : m_object(ref)
        {
            // Do nothing.
        }

        void operator()(value_type value) noexcept
        {
            m_object = value;
        }
    private:
        reference m_object;
    };

    template <typename T, class AccessorT = default_accessor<T>, class MutatorT = default_mutator<T>>
    class readwrite {
    public:
        typedef AccessorT accessor_type;
        typedef MutatorT mutator_type;
        typedef T value_type;
        typedef value_type& reference;
        typedef const reference const_reference;

        readwrite() : m_getter(m_object), m_setter(m_object)
        {
            // Do nothing.
        }

        readwrite(accessor_type getter, mutator_type setter) : m_getter(getter), m_setter(setter)
        {
            // Do nothing.
        }

        readwrite(value_type value) : m_getter(m_object), m_setter(m_object)
        {
            m_object = value;
        }

        operator T() const noexcept
        {
            return m_getter();
        }

        operator T() noexcept
        {
            return m_getter();
        }

        void operator=(const_reference ref) noexcept
        {
            m_setter(ref);
        }
        // can overload arithmetic operators, ->, [], etc.
    private:
        value_type m_object;
        accessor_type m_getter;
        mutator_type m_setter;
    };

    template <typename T>
    struct null_mutator {
        typedef T value_type;
        typedef value_type& reference;
        typedef const reference const_reference;

        null_mutator(const_reference ignored)
        {
            ((void)ignored);
        }

        void operator()(const_reference) = delete;
    };

    template <typename T, class AccessorT = default_accessor<T>>
    class readonly : public readwrite<T, AccessorT, null_mutator<T>> {
    public:
        typedef T value_type;
        typedef value_type& reference;
        typedef const reference const_reference;
        typedef AccessorT accessor_type;

        readonly(value_type value, accessor_type getter = accessor_type()) : base(value), m_getter(getter)
        {
            // Do nothing.
        }

        readonly(const readonly&) = delete;

        void operator=(const readonly&) = delete;
    private:
        typedef readwrite<T, AccessorT, null_mutator<T>> base;
        accessor_type m_getter;
    };
}