Messaging.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include <pluginterfaces/base/ftypes.h>
#include <pluginterfaces/vst/ivstmessage.h>
#include <algorithm>
#include <public.sdk/source/vst/vstpresetfile.h>
#include <pongasoft/VST/VstUtils/ReadOnlyMemoryStream.h>
#include <pongasoft/VST/VstUtils/FastWriteMemoryStream.h>
 
#include "ParamSerializers.h"
 
namespace pongasoft::VST {
 
using namespace Steinberg;
using namespace Steinberg::Vst;
 
static const auto ATTR_MSG_ID = "ATTR_MSG_ID";
 
using MessageID = int;

class Message
{
public:
  explicit Message(IMessage *message) : fMessage(message) {}
 
  MessageID getMessageID() const
  {
    return static_cast<MessageID>(getInt(ATTR_MSG_ID, -1));
  }
 
  void setMessageID(MessageID messageID)
  {
    fMessage->getAttributes()->setInt(ATTR_MSG_ID, messageID);
  }
 
  int64 getInt(IAttributeList::AttrID id, int64 defaultValue) const
  {
    int64 value;
    if(fMessage->getAttributes()->getInt(id, value) != kResultOk)
      value = defaultValue;
    return value;
  }
 
  void setInt(IAttributeList::AttrID id, int64 value)
  {
    fMessage->getAttributes()->setInt(id, value);
  }
 
  double getFloat(IAttributeList::AttrID id, double defaultValue) const
  {
    double value;
    if(fMessage->getAttributes()->getFloat(id, value) != kResultOk)
      value = defaultValue;
    return value;
  }
 
  void setFloat(IAttributeList::AttrID id, double value)
  {
    fMessage->getAttributes()->setFloat(id, value);
  }

  template<typename T>
  tresult setBinary(IAttributeList::AttrID id, const T *iData, uint32 iSize)
  {
    return fMessage->getAttributes()->setBinary(id, iData, iSize * sizeof(T));
  }

  template<typename T>
  int32 getBinary(IAttributeList::AttrID id, T *iData, uint32 iSize) const;

  template<typename T>
  tresult setSerializableValue(IAttributeList::AttrID id, IParamSerializer<T> const &iSerializer, T const &iValue);

  template<typename T>
  tresult getSerializableValue(IAttributeList::AttrID id, IParamSerializer<T> const &iSerializer, T &oValue) const;
 
private:
  IMessage *fMessage;
};
 
//------------------------------------------------------------------------
// Message::getBinary
//------------------------------------------------------------------------
template<typename T>
int32 Message::getBinary(IAttributeList::AttrID id, T *iData, uint32 iSize) const
{
  const void *data;
  uint32 size;
 
  if(fMessage->getAttributes()->getBinary(id, data, size) != kResultOk)
    return -1;
 
  uint32 oSize = size / sizeof(T);
  oSize = std::min(iSize, oSize);
 
  memcpy(iData, data, oSize * sizeof(T));
 
  return oSize;
}
 
//------------------------------------------------------------------------
// Message::setSerializableValue
//------------------------------------------------------------------------
template<typename T>
tresult Message::setSerializableValue(IAttributeList::AttrID id, const IParamSerializer<T> &iSerializer, const T &iValue)
{
  VstUtils::FastWriteMemoryStream stream{};
 
  IBStreamer streamer{&stream};
 
  tresult res = iSerializer.writeToStream(iValue, streamer);
  if(res == kResultOk)
  {
    return setBinary(id, stream.getData(), static_cast<uint32>(stream.getSize()));
  }
  return res;
}
 
//------------------------------------------------------------------------
// Message::getSerializableValue
//------------------------------------------------------------------------
template<typename T>
tresult Message::getSerializableValue(IAttributeList::AttrID id, const IParamSerializer<T> &iSerializer, T &oValue) const
{
  const void *data;
  uint32 size;
 
  tresult res = fMessage->getAttributes()->getBinary(id, data, size);
 
  if(res != kResultOk)
    return res;
 
  VstUtils::ReadOnlyMemoryStream stream(static_cast<char const *>(data), size);
  stream.seek(IBStream::kIBSeekSet, 0, nullptr); // make sure it is at the beginning of the stream
 
  IBStreamer streamer{&stream};
 
  return iSerializer.readFromStream(streamer, oValue);
}
 
}