RNBO: src/RNBO_ExternalData.h Source File

Go to the documentation of this file.
 #ifndef _RNBO_ExternalData_h_
 #define _RNBO_ExternalData_h_
  
 #include <memory>
 #include <string>
 #include <functional>
  
 #include "RNBO_Types.h"
 #include "RNBO_String.h"
 #include "RNBO_DataRef.h"
  
 namespace RNBO {
  
     using ExternalDataId    = const char*;
  
     using ExternalDataIndex = int;
  
     using ReleaseCallback = std::function<void(ExternalDataId, char*)>;
  
     class ExternalDataRef {
     public:
         ExternalDataRef(DataRefIndex index, DataRef *ref)
         : _index(index)
         , _dataRef(ref)
         , _name(ref->getName())
         {
             if (ref->getFile() == nullptr) _file.clear();
             else _file = ref->getFile();
             if (ref->getTag() == nullptr) _tag.clear();
             else _tag = ref->getTag();
             _data = _dataRef->getData();
         }
  
         const char* getMemoryId() const {
             return _name.c_str();
         }
  
         const char* getFile() const {
             return _file.c_str();
         }
  
         const char *getTag() const {
             return _tag.c_str();
         }
  
         DataRefIndex getInternalIndex() {
             return _index;
         }
  
         char* getData() const {
             if (_dataRef) return _dataRef->getData();
             else return _data;
         }
  
         bool isValid() const {
             return _dataRef != nullptr;
         }
  
         void invalidate() {
             _dataRef = nullptr;
         }
  
         void revalidate(DataRefIndex index, DataRef *ref) {
             RNBO_ASSERT(!isValid());
             Platform::assertTrue(ref, "ref must be non null");
  
             if (_callback && _data && _data != ref->getData()) {
                 _callback(getMemoryId(), _data);
             }
  
             _index = index;
             _dataRef = ref;
             if (ref->getFile() == nullptr) _file.clear();
             else _file = ref->getFile();
             if (ref->getTag() == nullptr) _tag.clear();
             else _tag = ref->getTag();
         }
  
         void updateDataRef(char* data, size_t sizeInBytes) {
             Platform::assertTrue(_dataRef, "_dataRef must be non null");
  
             if (_callback && _dataRef->getData() && data != _dataRef->getData()) {
                 _callback(getMemoryId(), _dataRef->getData());
             }
  
             _dataRef->setData(data, sizeInBytes);
             _data = data;
         }
  
         void updateDataRef(char* data, size_t sizeInBytes, DataType type) {
             Platform::assertTrue(_dataRef, "_dataRef must be non null");
  
             updateDataRef(data, sizeInBytes);
             _dataRef->setType(type);
         }
  
         void updateDataRef(char* data, size_t sizeInBytes, ReleaseCallback callback) {
             Platform::assertTrue(_dataRef, "_dataRef must be non null");
  
             updateDataRef(data, sizeInBytes);
             _callback = callback;
         }
  
         void updateDataRef(char* data, size_t sizeInBytes, DataType type, ReleaseCallback callback) {
             updateDataRef(data, sizeInBytes, type);
             _callback = callback;
         }
  
         void setTouched(bool value) {
             if (_dataRef) _dataRef->setTouched(value);
         }
  
         bool getTouched() const {
             if (_dataRef) return _dataRef->getTouched();
             else return false;
         }
  
         const DataType getType() const {
             if (_dataRef) return _dataRef->getType();
             else return UntypedDataBuffer();
         }
  
         size_t getSizeInBytes() const {
             if (_dataRef) return _dataRef->getSizeInBytes();
             else return 0;
         }
  
         ReleaseCallback getCallback() {
             return _callback;
         }
  
     private:
         DataRefIndex    _index = -1;
         DataRef*        _dataRef = nullptr;
         std::string     _name;              // make a copy of the name to avoid accessing
                                             // undefined const chars when the old patcher goes away
         std::string     _file;
         std::string     _tag;
         char*           _data = nullptr;    // safe away the data pointer so we can hand it out for freeing
         ReleaseCallback _callback = nullptr;
     };
  
     class ExternalDataEvent
     {
     public:
  
         enum class EventAction {
             Undefined,
             SetExternalData,
             ReleaseExternalData
         };
  
         ExternalDataEvent()
         : _data(nullptr)
         , _sizeInBytes(0)
         , _action(EventAction::Undefined)
         , _callback(nullptr)
         {}
  
         ExternalDataEvent(const ExternalDataEvent& other) = default;
         ExternalDataEvent& operator = (const ExternalDataEvent& other) = default;
  
         ExternalDataEvent(String memoryId, char* data, size_t sizeInBytes, DataType type, EventAction action, ReleaseCallback callback)
         : _memoryId(std::make_shared<String>(memoryId))
         , _data(data)
         , _sizeInBytes(sizeInBytes)
         , _type(type)
         , _action(action)
         , _callback(callback)
         {
         }
  
         const String& getMemoryId() const { return *_memoryId; }
         char *getData() const { return _data; }
         size_t getSizeInBytes() const { return _sizeInBytes; }
         DataType getType() const { return _type; }
         EventAction getAction() const { return _action; }
         ReleaseCallback getCallback() const { return _callback; }
  
     private:
         std::shared_ptr<String> _memoryId;
         char*                   _data;
         size_t                  _sizeInBytes;
         DataType                _type;
  
         EventAction             _action;
         ReleaseCallback         _callback;
     };
  
  
     using UpdateRefCallback = const std::function<void(DataRefIndex, char*, size_t, DataType)>;
     using ReleaseRefCallback = const std::function<void(DataRefIndex)>;
     using ConstRefList = const ExternalDataRef* const*;
  
     class ExternalDataHandler
     {
     public:
         virtual ~ExternalDataHandler() {}
  
         virtual void processBeginCallback(DataRefIndex numRefs, ConstRefList refList, UpdateRefCallback updateDataRef, ReleaseRefCallback releaseDataRef) = 0;
         virtual void processEndCallback(DataRefIndex numRefs, ConstRefList refList) = 0;
     };
  
     struct ExternalDataInfo {
         DataType::Type  type;           
         const char*     file;           
         const char*     tag;            
     };
  
     constexpr const char *InValidExternalDataId = "";
 }
  
 #endif  // _RNBO_ExternalData_h_
C++ Guides

RNBO: src/RNBO_ExternalData.h Source File
