Solution to void* and const void* for function parameter -> struct member - c++

Question

So I am using this telegram/message dispatcher system for my A.I. which comes from Matt Buckland's "Programming Game A.I. by Example" book.
I have this method for the MessageDispatcher class:
void DispatchMsg(double delay, int sender, int receiver, int msg, void *additionalInfo = nullptr);
Which then uses a Telegram struct:
struct Telegram
{
// Messages can be either dispatched immediately or delayed for
// a specified amount of time. If a delay is necessary, this
// field is stamped with the time the message should be dispatched.
double DispatchTime;
// Who is sending this message
int Sender;
// Who should the component give this message to
// may be set to -1 if not required
int Receiver;
// Message itself, should be one of the several enumerated types
int Msg;
// Additional information that might want to be passed along
void *ExtraInfo;
Telegram():DispatchTime(-1),
Sender(-1),
Receiver(-1),
Msg(-1)
{
// Empty
}
Telegram(double time,
int sender,
int receiver,
int msg,
void *info = nullptr):DispatchTime(time),
Sender(sender),
Receiver(receiver),
Msg(msg),
ExtraInfo(info)
{
// Empty
}
};
With a cast like:
template <class T>
inline T DereferenceToType(void *p)
{
return *(T*)(p);
}
The trouble lies here:
void Player::playerFeed() {
if (!Target)
return;
Courier->DispatchMsg(SEND_MSG_IMMEDIATELY, PLAYER_ID, TargetedActor, MessageType::PLAYER_FED, &ActorNode->getPosition());
}
Where ActorNode->getPosition() is from Ogre3d Ogre::SceneNode:
virtual const Vector3 & getPosition (void) const
Gets the position of the node relative to it's parent.
I then get it back doing:
Ogre::Vector3 attackerPos = DereferenceToType<Ogre::Vector3>(msg.ExtraInfo);
I would prefer to use a const Ogre::Vector3 here and that can be done writing a const dereference helper function.
Anyway, the problem is:
xxx|90|warning: invalid conversion from 'const void*' to 'void*' [-fpermissive]|
I understand the warning; but I'm not sure how to correct the problem.
I tried fixing it by writing a second method for DispatchMsg:
void DispatchMsg(double delay, int sender, int receiver, int msg, void *additionalInfo = nullptr);
// For const void*
void DispatchMsg(double delay, int sender, int receiver, int msg, const void *additionalInfo);
But that moved the warning into the function at the creation of the Telegram.
So I tried some things like making a second parameter in my Telegram structure called const void *ConstExtraInfo, the trouble is this seems to make the Telegram structure messy imo.
Basically my question is: is there a clean way implementation for this or if it must be done by having extra members within the Telegram to find out which type of information is stored?
Can it be done with a template for void* or const void* like: Telegram or would this complicate the receiving end of the telegram?
Please let me know if I need to post more information on this.
Thanks.

Answer 1

Your first problem is that the additionalInfo-pointer should be const-qualified.
Then, your template should also use const.
Finally, it should return a reference and not copy the data:
template <class T> inline const T& DereferenceToType(const void *p)
{
return *(const T*)p;
}
Anyway, why hide the cast? Instead, do it like this in the receipient:
const auto& extra = *(T*)p;

Answer 2

You could use a const_cast or a plain C style cast to throw away const. This would be the quickest and dirtiest way.
Now, what you are really trying to achieve here is to covert to an intermediate data type that can be cast back and forth from an abstract type to a concrete type. One possible way of doing this is to use what some refer to as a Variant, which is a class/struct that holds some opaque data and a tag that identifies this data. Something similar to:
enum DataTag {
DATA_INT,
DATA_STRING,
DATA_VEC3,
// etcetera
};
struct Variant {
virtual DataTag GetTypeTag() const = 0;
virtual int AsInt() const = 0;
virtual string AsString() const = 0;
virtual Vec3 AsVector() const = 0;
// same goes for assigning a value. I.e: FromInt()/FromString()
};
template<class T>
struct VariantImpl : public Variant {
// add constructors as needed
VariantImpl(const T & data, DataTag tag)
{
this->data = data;
this->tag = tag;
}
// implement the proper conversions
int AsInt() const { }
string AsString() const { }
Vec3 AsVector() const { }
DataTag GetTypeTag() const { return tag; }
T data;
DataTag tag;
};
Then you could have a pointer to a Variant in the Telegram struct and set the ExtraInfo with:
telegram->ExtraInfo = new VariantImpl<int>(42);
And then access it at any time with AsInt(), as long as you check the type tag first to ensure the conversion is allowed.
From this, you can add a lot to it to fit your needs. Hope it helps.