GetDataRefTask.h

// Copyright (c) 2013 by István Váradi
 
// This file is part of XPLRA, a remote-access plugin for X-Plane
 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
 
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
// The views and conclusions contained in the software and documentation are those
// of the authors and should not be interpreted as representing official policies,
// either expressed or implied, of the FreeBSD Project.
 
#ifndef XPLRA_GETDATAREFTASK_H
#define XPLRA_GETDATAREFTASK_H
//------------------------------------------------------------------------------
 
#include "DataRefTask.h"
 
#include <hu/varadiistvan/scpl/io/DataStream.h>
 
//------------------------------------------------------------------------------
 
namespace xplra {
 
//------------------------------------------------------------------------------
 
class GetDataRefTask : public DataRefTask
{
public:
    static GetDataRefTask* create(uint8_t& result,
                                  hu::varadiistvan::scpl::io::DataStream& stream);
 
    GetDataRefTask(const std::string& name);
 
    GetDataRefTask(XPLMDataRef dataRef);
 
    virtual void writeValue(hu::varadiistvan::scpl::io::DataStream& stream) = 0;
};
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
class GetScalarDataRefTask : public GetDataRefTask
{
private:
    T value;
 
public:
    GetScalarDataRefTask(const std::string& name);
 
    GetScalarDataRefTask(XPLMDataRef dataRef);
 
    T getValue() const;
 
protected:
    virtual void process();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class GetIntDataRefTask :
        public GetScalarDataRefTask<int, GetIntDataRefTask>
{
public:
    static int queryData(XPLMDataRef dataRef);
 
    GetIntDataRefTask(const std::string& name);
 
    GetIntDataRefTask(XPLMDataRef dataRef);
 
    virtual void writeValue(hu::varadiistvan::scpl::io::DataStream& stream);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class GetFloatDataRefTask :
        public GetScalarDataRefTask<float, GetFloatDataRefTask>
{
public:
    static float queryData(XPLMDataRef dataRef);
 
    GetFloatDataRefTask(const std::string& name);
 
    GetFloatDataRefTask(XPLMDataRef dataRef);
 
    virtual void writeValue(hu::varadiistvan::scpl::io::DataStream& stream);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class GetDoubleDataRefTask :
        public GetScalarDataRefTask<double, GetDoubleDataRefTask>
{
public:
    static double queryData(XPLMDataRef dataRef);
 
    GetDoubleDataRefTask(const std::string& name);
 
    GetDoubleDataRefTask(XPLMDataRef dataRef);
 
    virtual void writeValue(hu::varadiistvan::scpl::io::DataStream& stream);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
class GetArrayDataRefTask : public GetDataRefTask
{
private:
    int maxCount;
 
    int offset;
 
    T* data;
 
    int length;
 
protected:
    GetArrayDataRefTask(const std::string& name,
                        int maxCount = -1, int offset = 0);
 
    GetArrayDataRefTask(XPLMDataRef dataRef,
                        int maxCount = -1, int offset = 0);
 
public:
    virtual ~GetArrayDataRefTask();
 
    const T* getData() const;
 
    int getLength() const;
 
protected:
    virtual void process();
 
    virtual void writeValue(hu::varadiistvan::scpl::io::DataStream& stream);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class GetFloatArrayDataRefTask :
        public GetArrayDataRefTask<float, GetFloatArrayDataRefTask>
{
public:
    static int queryData(XPLMDataRef dataRef, float* dest,
                         int offset, int count);
 
public:
    GetFloatArrayDataRefTask(const std::string& name,
                            int maxCount = -1, int offset = 0);
 
    GetFloatArrayDataRefTask(XPLMDataRef dataRef,
                             int maxCount = -1, int offset = 0);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class GetIntArrayDataRefTask :
        public GetArrayDataRefTask<int, GetIntArrayDataRefTask>
{
public:
    static int queryData(XPLMDataRef dataRef, int* dest,
                         int offset, int count);
 
public:
    GetIntArrayDataRefTask(const std::string& name,
                           int maxCount = -1, int offset = 0);
 
    GetIntArrayDataRefTask(XPLMDataRef dataRef,
                           int maxCount = -1, int offset = 0);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class GetByteArrayDataRefTask :
        public GetArrayDataRefTask<unsigned char, GetByteArrayDataRefTask>
{
public:
    static int queryData(XPLMDataRef dataRef, void* dest,
                         int offset, int count);
 
public:
    GetByteArrayDataRefTask(const std::string& name,
                            int maxBytes = -1, int offset = 0);
 
    GetByteArrayDataRefTask(XPLMDataRef dataRef,
                            int maxBytes = -1, int offset = 0);
};
 
//------------------------------------------------------------------------------
// Template definitions
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline GetScalarDataRefTask<T, ConcreteClass>::
GetScalarDataRefTask(const std::string& name) :
    GetDataRefTask(name),
    value(0)
{
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline GetScalarDataRefTask<T, ConcreteClass>::
GetScalarDataRefTask(XPLMDataRef dataRef) :
    GetDataRefTask(dataRef),
    value(0)
{
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline T GetScalarDataRefTask<T, ConcreteClass>::getValue() const
{
    return value;
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
void GetScalarDataRefTask<T, ConcreteClass>::process()
{
    value = ConcreteClass::queryData(getDataRef());
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline GetArrayDataRefTask<T, ConcreteClass>::
GetArrayDataRefTask(const std::string& name, int maxCount, int offset) :
    GetDataRefTask(name),
    maxCount(maxCount),
    offset(offset),
    data( (maxCount>0) ? new T[maxCount] : 0 ),
    length(-1)
{
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline GetArrayDataRefTask<T, ConcreteClass>::
GetArrayDataRefTask(XPLMDataRef dataRef, int maxCount, int offset) :
    GetDataRefTask(dataRef),
    maxCount(maxCount),
    offset(offset),
    data( (maxCount>0) ? new T[maxCount] : 0),
    length(-1)
{
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline GetArrayDataRefTask<T, ConcreteClass>::~GetArrayDataRefTask()
{
    delete [] data;
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline const T* GetArrayDataRefTask<T, ConcreteClass>::getData() const
{
    return data;
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
inline int GetArrayDataRefTask<T, ConcreteClass>::getLength() const
{
    return length;
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
void GetArrayDataRefTask<T, ConcreteClass>::process()
{
    if (maxCount<0) {
        maxCount = ConcreteClass::queryData(getDataRef(), 0, 0, 0);
 
        if (maxCount>0) {
            maxCount -= offset;
        }
 
        if (maxCount>0) {
            data = new T[maxCount];
        } else {
            maxCount = 0;
        }
    }
 
    // Util::debug("GetByteArrayDataRefTask::process: dataRef=%p, maxBytes=%d, data=%p, offset\n",
    //             getDataRef(), maxBytes, data, offset);
    if (maxCount>0) {
        length = ConcreteClass::queryData(getDataRef(), data, offset, maxCount);
    } else {
        length = maxCount;
    }
}
 
//------------------------------------------------------------------------------
 
template <typename T, class ConcreteClass>
void GetArrayDataRefTask<T, ConcreteClass>::
writeValue(hu::varadiistvan::scpl::io::DataStream& stream)
{
    stream.writeS32(length);
    if (length>0) {
        stream.write(data, length * sizeof(T));
    }
}
 
//------------------------------------------------------------------------------
// Inline definitions
//------------------------------------------------------------------------------
 
inline GetDataRefTask::GetDataRefTask(const std::string& name) :
    DataRefTask(name)
{
}
 
//------------------------------------------------------------------------------
 
inline GetDataRefTask::GetDataRefTask(XPLMDataRef dataRef) :
    DataRefTask(dataRef)
{
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int GetIntDataRefTask::queryData(XPLMDataRef dataRef)
{
    return XPLMGetDatai(dataRef);
}
 
//------------------------------------------------------------------------------
 
inline GetIntDataRefTask::GetIntDataRefTask(const std::string& name) :
    GetScalarDataRefTask<int, GetIntDataRefTask>(name)
{
}
 
//------------------------------------------------------------------------------
 
inline GetIntDataRefTask::GetIntDataRefTask(XPLMDataRef dataRef) :
    GetScalarDataRefTask<int, GetIntDataRefTask>(dataRef)
{
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline float GetFloatDataRefTask::queryData(XPLMDataRef dataRef)
{
    return XPLMGetDataf(dataRef);
}
 
//------------------------------------------------------------------------------
 
inline GetFloatDataRefTask::GetFloatDataRefTask(const std::string& name) :
    GetScalarDataRefTask<float, GetFloatDataRefTask>(name)
{
}
 
//------------------------------------------------------------------------------
 
inline GetFloatDataRefTask::GetFloatDataRefTask(XPLMDataRef dataRef) :
    GetScalarDataRefTask<float, GetFloatDataRefTask>(dataRef)
{
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline double GetDoubleDataRefTask::queryData(XPLMDataRef dataRef)
{
    return XPLMGetDatad(dataRef);
}
 
//------------------------------------------------------------------------------
 
inline GetDoubleDataRefTask::GetDoubleDataRefTask(const std::string& name) :
    GetScalarDataRefTask<double, GetDoubleDataRefTask>(name)
{
}
 
//------------------------------------------------------------------------------
 
inline GetDoubleDataRefTask::GetDoubleDataRefTask(XPLMDataRef dataRef) :
    GetScalarDataRefTask<double, GetDoubleDataRefTask>(dataRef)
{
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int GetFloatArrayDataRefTask::queryData(XPLMDataRef dataRef, float* dest,
                                               int offset, int count)
{
    return XPLMGetDatavf(dataRef, dest, offset, count);
}
 
//------------------------------------------------------------------------------
 
inline
GetFloatArrayDataRefTask::GetFloatArrayDataRefTask(const std::string& name,
                                                   int maxCount, int offset) :
    GetArrayDataRefTask<float, GetFloatArrayDataRefTask>(name, maxCount, offset)
{
}
 
//------------------------------------------------------------------------------
 
inline
GetFloatArrayDataRefTask::GetFloatArrayDataRefTask(XPLMDataRef dataRef,
                                                 int maxCount, int offset) :
    GetArrayDataRefTask<float, GetFloatArrayDataRefTask>(dataRef,
                                                         maxCount, offset)
{
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int GetIntArrayDataRefTask::queryData(XPLMDataRef dataRef, int* dest,
                                             int offset, int count)
{
    return XPLMGetDatavi(dataRef, dest, offset, count);
}
 
//------------------------------------------------------------------------------
 
inline
GetIntArrayDataRefTask::GetIntArrayDataRefTask(const std::string& name,
                                                   int maxCount, int offset) :
    GetArrayDataRefTask<int, GetIntArrayDataRefTask>(name, maxCount, offset)
{
}
 
//------------------------------------------------------------------------------
 
inline
GetIntArrayDataRefTask::GetIntArrayDataRefTask(XPLMDataRef dataRef,
                                               int maxCount, int offset) :
    GetArrayDataRefTask<int, GetIntArrayDataRefTask>(dataRef,
                                                     maxCount, offset)
{
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int GetByteArrayDataRefTask::queryData(XPLMDataRef dataRef, void* dest,
                                              int offset, int count)
{
    return XPLMGetDatab(dataRef, dest, offset, count);
}
 
//------------------------------------------------------------------------------
 
inline
GetByteArrayDataRefTask::GetByteArrayDataRefTask(const std::string& name,
                                                 int maxBytes, int offset) :
    GetArrayDataRefTask<unsigned char, GetByteArrayDataRefTask>(name, maxBytes,
                                                                offset)
{
}
 
//------------------------------------------------------------------------------
 
inline
GetByteArrayDataRefTask::GetByteArrayDataRefTask(XPLMDataRef dataRef,
                                                 int maxBytes, int offset) :
    GetArrayDataRefTask<unsigned char, GetByteArrayDataRefTask>(dataRef,
                                                                maxBytes,
                                                                offset)
{
}
 
//------------------------------------------------------------------------------
 
} /* namespace xplra */
 
//------------------------------------------------------------------------------
#endif // XPLRA_GETDATAREFTASK_H
 
// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: