X-Developer Cross-platform development in C++, Flight Simulation

XPLM_API XPLMDataRef          XPLMRegisterDataAccessor(
                                   const char *         inDataName,
                                   XPLMDataTypeID       inDataType,
                                   int                  inIsWritable,
                                   XPLMGetDatai_f       inReadInt,
                                   XPLMSetDatai_f       inWriteInt,
                                   XPLMGetDataf_f       inReadFloat,
                                   XPLMSetDataf_f       inWriteFloat,
                                   XPLMGetDatad_f       inReadDouble,
                                   XPLMSetDatad_f       inWriteDouble,
                                   XPLMGetDatavi_f      inReadIntArray,
                                   XPLMSetDatavi_f      inWriteIntArray,
                                   XPLMGetDatavf_f      inReadFloatArray,
                                   XPLMSetDatavf_f      inWriteFloatArray,
                                   XPLMGetDatab_f       inReadData,
                                   XPLMSetDatab_f       inWriteData,
                                   void *               inReadRefcon,
                                   void *               inWriteRefcon);

XPLMGetDatab_f   inReadData, XPLMSetDatab_f   inWriteData

typedef long (* XPLMGetDatab_f)(
                                   void *               inRefcon,
                                   void *               outValue,    /* Can be NULL */
                                   int                  inOffset,
                                   long                 inMaxLength);

#include  <cstring> // for strcpy
#include  <string>  // for std::string
 
std::string global_string = "hello world";
 
long readFuncStr(void* inRefCon, void* outValue, int inOffset, long inMaxLength)
{
    // we were asked to return the length of the string
    if (outValue == NULL)
        return global_string.length();
    // we have to copy the characters from offset to maxlength into outValue
    // c_str() is the conversion function from std::string to const char*
    strcpy(static_cast<char* >(outValue), global_string.substr(inOffset,inMaxLength).c_str());
    return inMaxLength;
}

void writeFuncStr(void* inRefCon, void* inValue, int inOffset, long inMaxLength)
{
    char* str = static_cast<char* >(inValue);
    // replace global string with required substring of inValue
    // note that the std::string c'tor is overloaded to take a char*
    global_string = std::string(str).substr(inOffset, inMaxLength);
}

long readFuncStr(void* inRefCon, void* outValue, int inOffset, long inMaxLength)
{
    std::string* p_data = static_cast<std::string* >(inRefCon);
    if (outValue == NULL)
        return p_data->length() + 1;
    strcpy(static_cast<char* >(outValue), p_data->substr(inOffset,inMaxLength).c_str());
    return inMaxLength;
}
 
void writeFuncStr(void* inRefCon, void* inValue, int inOffset, long inMaxLength)
{
    std::string* p_data = static_cast<std::string* >(inRefCon);
    char* str = static_cast<char* >(inValue);
    *p_data = std::string(str).substr(inOffset,inMaxLength);
}

XPLMDataRef my_data_ref = XPLMRegisterDataAccessor(
    "my/plugin/data/textdata" , // dataref
    xplmType_Data,  // data type
    1,   // writeable
    NULL, NULL, // no int functions
    NULL, NULL, // no float functions
    NULL, NULL, // no double functions
    NULL, NULL, // no int-array functions
    NULL, NULL, // no float-array functions
    &readFuncStr, // our read function
    &writeFuncStr, // our write function
    &global_string, // refcon-pointer for read function
    &global_string  // refcon-pointer for write function
);

long readFuncStr(void* inRefCon, void* outValue, int inOffset, long inMaxlength)
{
    OwnedData* p_owned_data = static_cast<OwnedData* >(inRefCon);
    long length = p_owned_data->value().length();
    if (outValue == NULL)
        return length;
    long maxlen = std::min(inMaxLength,length);
    strcpy(static_cast<char* >(outValue), p_owned_data->value().substr(inOffset, maxlen).c_str());
    return inMaxLength;
}
 
void writeFuncStr(void* inRefCon, void* inValue, int inOffset, long inMaxLength)
{
    OwnedData* p_owned_data = static_cast<OwnedData* >(inRefCon);
    char* str = static_cast<char* >(inValue);
    p_owned_data->setValue(std::string(str).substr(inOffset,inMaxLength));
}
 
class OwnedData{
public:
 
    OwnedData(const std::string& identifier):
        m_data_ref_identifier(identifier),
        m_data_ref(0),
        m_value(std::string(""))
    {
        m_data_ref = XPLMRegisterDataAccessor( m_data_ref_identifier.c_str(), xplmType_Data, 1,
                                                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                                                 NULL, NULL, readFuncStr, writeFuncStr, this, this );
    }
 
    ~OwnedData()
    {
        if (m_data_ref)
        {
            XPLMUnregisterDataAccessor(m_data_ref);
            m_data_ref = 0;
        }
    }
 
    std::string value() const { return m_value; }
 
    void setValue(const std::string&amp; val) { m_value = val; }
 
private:
        friend long readFuncStr(void* inRefCon, void* outValue, int inOffset, long inMaxLength);
        friend void writeFuncStr(void* inRefCon, void* inValue, int inOffset, long inLength);
 
    XPLMDataRef m_data_ref;
    std::string m_value;
};

PLUGIN_API void XPluginReceiveMessage(XPLMPluginID, long inMessage, void* inParam)

/* warning: DOING IT WRONG !!!1! */
PLUGIN_API void XPluginReceiveMessage(XPLMPluginID, long inMessage, void* inParam)
{
    if( inMessage == XPLM_MSG_PLANE_LOADED )
    {
        int* planeNo = (int*)(inParam);
        if ( *planeNo == 0) /* BOOOM! SEGFAULT!! */
        {
            // do some stuff
        }
    }
}

inParam == 0   /*doing it right*/

*inParam == 0 /* doing it wrong*/

int planeNo = (*(static_cast<int*>(inParam))); /* wrong */
int planeNo = reinterpret_cast<int>(inParam);   /* right */