MultiBuffer.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 HU_VARADIISTVAN_XPLRA_MULTIBUFFER_H
#define HU_VARADIISTVAN_XPLRA_MULTIBUFFER_H
//------------------------------------------------------------------------------
 
#include "Exception.h"
 
#include <string>
#include <vector>
 
#include <inttypes.h>
 
//------------------------------------------------------------------------------
 
namespace hu { namespace varadiistvan { namespace xplra {
 
//------------------------------------------------------------------------------
 
class XPlane;
 
//------------------------------------------------------------------------------
 
class MultiBuffer
{
protected:
    class DataRef
    {
    public:
        std::string name;
 
        uint8_t type;
 
        size_t length;
 
        size_t offset;
 
        size_t dataOffset;
 
        DataRef(const std::string& name, uint8_t type,
                const DataRef* previous = 0,
                size_t length = 0, size_t offset = 0) noexcept;
 
        size_t getSize() const noexcept;
 
        size_t getAlignment() const noexcept;
 
        bool isArray() const noexcept;
 
        size_t getCopyLength(size_t userLength, size_t userOffset) const noexcept;
    };
 
    std::vector<DataRef> dataRefs;
 
    mutable unsigned char* data;
 
    XPlane& xplane;
 
    uint8_t registerCommand;
 
    uint8_t unregisterCommand;
 
    int registeredID;
 
protected:
    MultiBuffer(XPlane& xplane, uint8_t registerCommand,
                uint8_t unregisterCommand) noexcept;
 
    virtual ~MultiBuffer() noexcept;
 
public:
    XPlane& getXPlane() const noexcept;
 
    size_t addInt(const std::string& name) noexcept;
 
    size_t addFloat(const std::string& name) noexcept;
 
    size_t addDouble(const std::string& name) noexcept;
 
    size_t addFloatArray(const std::string& name, size_t length,
                         size_t offset = 0) noexcept;
 
    size_t addIntArray(const std::string& name, size_t length,
                       size_t offset = 0) noexcept;
 
    size_t addByteArray(const std::string& name, size_t length,
                        size_t offset = 0) noexcept;
 
    bool finalize() const;
 
    void registerInXPlane();
 
    void unregisterFromXPlane();
 
    bool unregisterSafelyFromXPlane() noexcept;
 
    void execute();
 
    void setInt(size_t id, int value);
 
    int getInt(size_t id) const;
 
    const int32_t& getIntRef(size_t id) const;
 
    int32_t& getIntRef(size_t id);
 
    void setFloat(size_t id, float value);
 
    float getFloat(size_t id) const;
 
    const float& getFloatRef(size_t id) const;
 
    float& getFloatRef(size_t id);
 
    void setDouble(size_t id, double value);
 
    double getDouble(size_t id) const;
 
    const double& getDoubleRef(size_t id) const;
 
    double& getDoubleRef(size_t id);
 
    size_t setFloatArray(size_t id, const float* value,
                         size_t length = 0, size_t offset = 0);
 
    size_t getFloatArray(size_t id, float* value,
                         size_t length = 0, size_t offset = 0) const;
 
    const float* getFloatArray(size_t id, size_t offset = 0) const;
 
    size_t setIntArray(size_t id, const int32_t* value,
                       size_t length = 0, size_t offset = 0);
 
    size_t getIntArray(size_t id, int32_t* value,
                       size_t length = 0, size_t offset = 0) const;
 
    const int32_t* getIntArray(size_t id, size_t offset = 0) const;
 
    size_t setByteArray(size_t id, const uint8_t* value,
                        size_t length = 0, size_t offset = 0);
 
    size_t getByteArray(size_t id, uint8_t* value,
                        size_t length = 0, size_t offset = 0) const;
 
    const uint8_t* getByteArray(size_t id, size_t offset = 0) const;
 
 
    size_t setString(size_t id, const std::string& value,
                     size_t offset = 0);
 
    std::string getString(size_t id, size_t offset = 0) const;
    
    const char* getStringPtr(size_t id, size_t offset = 0) const;
 
protected:
    virtual void doExecute() = 0;
 
    virtual void doExecuteUnregistered() = 0;
 
    void writeSpec(uint8_t command) const;
 
    void reregisterInXPlane();
 
private:
    void unfinalize() noexcept;
 
    void forgetRegistration() noexcept;
 
    const DataRef* getLastDataRef() const noexcept;
 
    const DataRef& getDataRef(size_t id, uint8_t type) const;
 
    void* getData(size_t id, uint8_t type);
 
    const void* getData(size_t id, uint8_t type) const;
 
    template <typename T, uint8_t type> size_t
    setArray(size_t id, const T* value, size_t length, size_t offset);
 
    template <typename T, uint8_t type> size_t
    getArray(size_t id, T* value, size_t length, size_t offset) const;
 
    template <typename T, uint8_t type> const T*
    getArray(size_t id, size_t offset) const;
 
    friend class XPlane;
};
 
//------------------------------------------------------------------------------
// Inline definitions
//------------------------------------------------------------------------------
 
inline XPlane& MultiBuffer::getXPlane() const noexcept
{
    return xplane;
}
 
//------------------------------------------------------------------------------
 
} /* namespace hu::varadiistvan::xplra */ } /* namespace hu::varadiistvan */ } /* namespace hu */
 
//------------------------------------------------------------------------------
#endif // HU_VARADIISTVAN_XPLRA_MULTIBUFFER_H
 
// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: