Pure virtual member function has to process a templated buffer - how to? - c++

Question

I have a base class PixelBuffer which has a virtual function to copy the content of the PixelBuffer to a templated Buffer object. PixelBuffer may have several inherited implementations like OpenGLPixelBuffer/DXPixelBuffer which implement a pure virtual copyToBuffer function (pseudo code):
class PixelBuffer
{
public:
virtual void copyToBuffer(? buffer) = 0; // how to declare this?
};
The PixelBuffer has an internal data type which can be of different base types (int, uint, float, char, ...).
More important is the data type of the Buffer I want to copy to.
The buffer class (may) look something like this:
template <typename T>
class Buffer
{
public:
Buffer() : m_data(), m_size(0) {}
Buffer(std::size_t buffsize) : m_data(new std::vector<T>(buffsize)), m_size(buffsize) { }
std::shared_ptr<std::vector<T>> data() { return m_data; }
std::size_t size() { return m_size; }
void allocate(std::size_t buffsize) {
m_data = std::shared_ptr<std::vector<T>>(new std::vector<T>(buffsize));
m_size = buffsize;
}
private:
std::shared_ptr<std::vector<T>> m_data;
std::size_t m_size;
};
typedef Buffer<float> FloatBuffer;
typedef Buffer<char> ByteBuffer;
I am searching for a way to do something like this:
PixelBuffer* pbObj = ...;
FloatBuffer dest;
pbObj->copyToBuffer(dest); // does allocation and copying
Since it is not possible to template the PixelBuffer member functions, I don't know how to solve this right now. I know I need many implementations for copying the different buffer data types, but I don't know where to implement them and how this could be done without adding a bunch of functions to PixelBuffer (for each type of Buffer).
Maybe this could be done using the visitor pattern or with policies?
Edit:
To answer a comment: Yes, it should be possible to copy from any PixelBuffer type to any Buffer type. However, only those types for which the copying is implemented should be supported!

Answer 1

I'm still not exactly certain what you require, but if you want to be able to pass various specializations of Buffer then you need unique methods rather than a single virtual method:
virtual void copyToBuffer(Buffer<char> & buffer) = 0;
virtual void copyToBuffer(Buffer<float> & buffer) = 0;
You would probably then override these in the subclass, and probably throw an exception for any cases where the copy operation wasn't supported. Your question suggests you don't want to do this, although I feel it's the best solution if you have a limited set of buffer specialisations that you need to deal with.
If you want only a single method, you need to abstract out functionality common to each specialization of Buffer into a class which each specialisation extends, and take a reference to that instead:
virtual void copyToBuffer(BufferBase & buffer) = 0;
template <typename T>
class Buffer : public BufferBase
{
// ...
The implementations of the copyToBuffer method are then going to be limited to the functionality provided in BufferBase, in this case, so I doubt this solution would prove workable for you.
On the other hand, if you want to only have a single method which accepts a specific type of buffer and the type differs from subclass to subclass, then the method shouldn't be declared in the base class at all - you should simply declare the method with the appropriate argument type in each of the subclasses. Probably the cleanest solution in this case is to parameterize the PixelBuffer class according to the element type of the buffer it supports:
template <typename E>
class PixelBuffer : public PixelBufferBase
{
public:
virtual void copyToBuffer(Buffer<E> &) = 0;
}
Your example then becomes:
PixelBufferBase* pbObj = ...;
PixelBuffer<float> *fpbObj = dynamic_cast<PixelBuffer<float> *>(pbObj);
FloatBuffer dest;
fpbObj->copyToBuffer(dest); // does allocation and copying
(You can probably use a static_cast instead for performance, at the cost of certain safety).
You don't actually need a policy-based design; you would get a benefit from policies only if the copyToBuffer implementation could be shared between different PixelBuffer subclasses (which sounds unlikely) and in any case you'd still need to parameterise the PixelBuffer type.
I also don't believe the visitor patterns helps you with this problem - it requires multiple functions to deal with multiple PixelBuffer/Buffer types; you might move the overloaded method around to a different class, but you don't avoid the need for it.

Answer 2

I have met the same problem. I used a void * as the type and convert the pointer to the correct Buffer in the implements.
It's not beautiful, but It works and has no penalty on the performance.
But if your PixelBuffer will copy to more than one type of Buffer with only one copyToBuffer function. You will have to add another argument to distinct different type of buffers:
enum class BufferType
{
INT,
CHAR,
FLOAT,
//...
};
class PixelBuffer
{
public:
//....
virtual void copyToBuffer(void* buffer, BufferType buffertype) = 0;
}
virtual void DXPixelBuffer::copyToBuffer(void* buffer, BufferType buffertype)
{
switch(buffertype){
case BufferType::FLOAT:
Buffer<float>* pbuffer = static_cast<Buffer<float>*>(buffer);
//...
break;
//...
And you can use a traits class and a wrap function to make the call to copyToBuffer more safe.
template<typename T> struct BufferTraits;
template<> struct BufferTraits<float>{
static constexpr BufferType Type = BufferType::FLOAT;
};
template<> struct BufferTraits<char> {
static constexpr BufferType Type = BufferType::CHAR;
};
class PixelBuffer
{
public:
template<typename T> void PixelBuffer::copyToBuffer(Buffer<T>& buffer){this->copyToBuffer(reinterpret_cast<void *>(&buffer), BufferTraits<T>::Type);}
//...
}
Your example will remain the same:)
PixelBuffer* pbObj = ...;
FloatBuffer dest;
pbObj->copyToBuffer(dest);