RTJmbOutParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2023 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 <pongasoft/Utils/Concurrent/Concurrent.h>
#include <pongasoft/Utils/Disposable.h>
#include <pongasoft/Utils/Metaprogramming.h>
#include <pongasoft/VST/ParamDef.h>
 
namespace pongasoft::VST::RT {
 
using namespace Utils;

class IRTJmbOutParameter
{
public:
  // Constructor
  explicit IRTJmbOutParameter(std::shared_ptr<IJmbParamDef> iParamDef) : fParamDef{std::move(iParamDef)} {}
 
  // getParamDef
  IJmbParamDef const *getParamDef() const { return fParamDef.get(); }
 
  // getParamID
  ParamID getParamID() const { return fParamDef->fParamID; }
 
  // destructor
  virtual ~IRTJmbOutParameter() = default;
 
  // hasUpdate
  virtual bool hasUpdate() const = 0;
 
  // writeToMessage
  virtual tresult writeToMessage(Message &oMessage) = 0;
 
  // writeToStream
  virtual void writeToStream(std::ostream &oStream) const = 0;
 
protected:
  std::shared_ptr<IJmbParamDef> fParamDef;
};

template<typename T>
class RTJmbOutParameter : public IRTJmbOutParameter
{
public:
  using ParamType = T;
 
  explicit RTJmbOutParameter(std::shared_ptr<JmbParamDef<T>> iParamDef) :
    IRTJmbOutParameter(iParamDef),
    fUpdateQueue{std::make_unique<T>(iParamDef->fDefaultValue), true}
  {}
 
  // getParamDef
  JmbParamDef<T> const *getParamDefT() const
  {
    return static_cast<JmbParamDef<T> const *>(getParamDef());
  }

  void broadcastValue(ParamType const &iValue)
  {
    fUpdateQueue.push(iValue);
  }

  template<ElementModifier<T> Modifier>
  void broadcast(Modifier const &iElementModifier)
  {
    fUpdateQueue.updateAndPush(iElementModifier);
  }

  template<ElementPredicate<T> Modifier>
  bool broadcastIf(Modifier const &iElementModifier)
  {
    return fUpdateQueue.updateAndPushIf(iElementModifier);
  }
 
  // hasUpdate
  bool hasUpdate() const override { return !fUpdateQueue.isEmpty(); }
 
  // writeToMessage - called to package and add the value to the message
  tresult writeToMessage(Message &oMessage) override;
 
  // writeToStream
  void writeToStream(std::ostream &oStream) const override;
 
private:
  Concurrent::LockFree::SingleElementQueue<T> fUpdateQueue{};
};
 
//------------------------------------------------------------------------
// RTJmbOutParameter::writeToMessage
//------------------------------------------------------------------------
template<typename T>
tresult RTJmbOutParameter<T>::writeToMessage(Message &oMessage)
{
  auto update = fUpdateQueue.pop();
  if(update)
  {
    tresult res = getParamDefT()->writeToMessage(*update, oMessage);
 
    // Implementation note: this method is called from the UI thread so releasing resources is OK!
    if(auto disposable = safe_dynamic_cast<Disposable *>(update))
      disposable->dispose();
 
    return res;
  }
 
  return kResultFalse;
}
 
//------------------------------------------------------------------------
// RTJmbInParameter::writeToStream
//------------------------------------------------------------------------
template<typename T>
void RTJmbOutParameter<T>::writeToStream(std::ostream &oStream) const
{
  getParamDefT()->writeToStream(*fUpdateQueue.last(), oStream);
}
 
//------------------------------------------------------------------------
// RTJmbOutParam - wrapper to make writing the code much simpler and natural
//------------------------------------------------------------------------
template<typename T>
class RTJmbOutParam
{
public:
  RTJmbOutParam(RTJmbOutParameter<T> *iPtr) : fPtr{iPtr} // NOLINT (not marked explicit on purpose)
  {
    DCHECK_F(fPtr != nullptr);
  }
 
  // getParamID
  ParamID getParamID() const { return fPtr->getParamID(); }

  void broadcast(T const &iValue) { fPtr->broadcastValue(iValue); }

  template<ElementModifier<T> Modifier>
  void broadcast(Modifier const &iElementModifier) { fPtr->broadcast(iElementModifier); }

  template<ElementPredicate<T> Modifier>
  bool broadcastIf(Modifier const &iElementModifier) { return fPtr->broadcastIf(iElementModifier); }
 
private:
  RTJmbOutParameter<T> *fPtr;
};

template<typename T, size_t N>
using RTJmbOutParams = std::array<RTJmbOutParam<T>, N>;
 
}