Boost logo

Boost :

From: David B. Held (dheld_at_[hidden])
Date: 2003-02-14 15:51:16

I decided that my serial_ptr implemented a variant at the wrong level
of indirection. So now I'm trying out intrusive_ptr with a variant at the
pointee level. This is what my code looks like now:

    class TRecord
    public: // Interface
                            : ID_(0) { }
                        TRecord(int ID)
                            : ID_(ID) { }
        virtual ~TRecord(void) { }

        void swap(TRecord& Record) { std::swap(ID_,
Record.ID_); }

        int ID(void) const { return ID_; }
    private: // Implementation
        int ID_;

    template <typename T>
    class TCountedRecord
    public: // Interface
                            : Count_(0) { }
                        TCountedRecord(int ID)
                            : Count_(0) { new (Value_)
TRecord(ID); }

        bool IsRecord(void) const; // No-throw
        unsigned Count(void) const; // No-throw
        int ID(void) const;
                        operator T const&(void) const;
                        operator T&(void);

        T* AddRef(void);
        void Release(void); // No-throw
    private: // Implementation
        typedef boost::detail::lightweight_mutex mutex_type;

        mutex_type Mutex_;
        unsigned Count_;
        char Value_[sizeof(T)];

    template <typename T>
    void intrusive_ptr_add_ref(TCountedRecord<T>* p)

    template <typename T>
    void intrusive_ptr_release(TCountedRecord<T>* p)

This code is still being designed, so I haven't tried it. It might not
work as expected. The idea is that my database records will
derive from TRecord, and my pointers will be intrusive_ptrs to

In case it's not obvious, TCountedRecord is a variant of TRecord
and T. The idea is when I just get record IDs, a TCountedRecord
stores a TRecord with the ID in it. When I get a full record, I use
placement new to install it over the TRecord.

I have several issues, however. First, the variant doesn't support
inheritance hierarchies very well. If I have U derived from T, my
problem is that TCountedRecord<U> isn't derived from
TCountedRecord<T>, and so I can't use dynamic_pointer_cast<>
to cast between my intrusive_ptrs. That's not a problem with
dynamic_pointer_cast<>, of course. The problem is that I can't
store base pointers at all, since the pointers aren't related.

Second, I don't like having to use placement new to construct
my records, but I can't use inheritance, because I don't always
have all the data to construct a full record immediately. So the
variant essentially implements "partial construction". If I could
just have T, rather than variant<TRecord, T>, and only construct
the TRecord sub-object, that would be ideal, but obviously, not

Another solution is to use a pointer in TCountedRecord instead
of a value. However, that introduces an unnecessary level of
indirection (though I might be forced to resort to that). Another
thing that's not obvious from the interface is that I'm using the
count as the variant tag. A 0 means that a TRecord is present,
and a non-0 means an actual record is present.

Any suggestions on how to deal with polymorphism, or
restructure the design differently are appreciated.

Also, I think Boost could use a value-based variant type.


Boost list run by bdawes at, gregod at, cpdaniel at, john at