RTJmbOutParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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
  inline 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
  inline JmbParamDef<T> const *getParamDefT() const
  {
    return static_cast<JmbParamDef<T> const *>(getParamDef());
  }

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

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

  template<class ElementModifier>
  bool broadcastIf(ElementModifier 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!
    auto disposable = Cast<Disposable *>::dynamic(update);
    if(disposable)
      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
  inline ParamID getParamID() const { return fPtr->getParamID(); }

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

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

  template<class ElementModifier>
  bool broadcastIf(ElementModifier const &iElementModifier) { return fPtr->broadcastIf(iElementModifier); }

private:
  RTJmbOutParameter<T> *fPtr;
};

}