RTJmbInParameter.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/VST/ParamDef.h>
#include <pongasoft/VST/MessageHandler.h>
 
namespace pongasoft::VST::RT {
 
using namespace Utils;

class IRTJmbInParameter : public IMessageHandler
{
public:
  // Constructor
  explicit IRTJmbInParameter(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
  ~IRTJmbInParameter() override = default;
 
  // hasUpdate
  virtual bool hasUpdate() const = 0;
 
  // readFromMessage
  virtual tresult readFromMessage(Message const &iMessage) = 0;
 
  // handleMessage
  tresult handleMessage(Message const &iMessage) override { return readFromMessage(iMessage); }
 
  // writeToStream
  virtual void writeToStream(std::ostream &oStream) const = 0;
 
protected:
  std::shared_ptr<IJmbParamDef> fParamDef;
};

template<typename T>
class RTJmbInParameter : public IRTJmbInParameter
{
public:
  using ParamType = T;
 
  explicit RTJmbInParameter(std::shared_ptr<JmbParamDef<T>> iParamDef) :
    IRTJmbInParameter(iParamDef),
    fUpdateQueue{std::make_unique<T>(iParamDef->fDefaultValue), true}
  {}
 
  // getParamDef
  inline JmbParamDef<T> const *getParamDefT() const
  {
    return static_cast<JmbParamDef<T> const *>(getParamDef());
  }
 
  // pop
  inline ParamType *pop() { return fUpdateQueue.pop(); }
 
  // last
  inline ParamType const *last() const { return fUpdateQueue.last(); }
 
  // popOrLast
  inline ParamType const *popOrLast() { return fUpdateQueue.popOrLast(); }
 
  // hasUpdate
  bool hasUpdate() const override { return !fUpdateQueue.isEmpty(); }
 
  // readFromMessage - called to extract the value from the message
  tresult readFromMessage(Message const &iMessage) override;
 
  // writeToStream
  void writeToStream(std::ostream &oStream) const override;
 
private:
  Concurrent::LockFree::SingleElementQueue<T> fUpdateQueue{};
};
 
//------------------------------------------------------------------------
// RTJmbInParameter::readFromMessage
//------------------------------------------------------------------------
template<typename T>
tresult RTJmbInParameter<T>::readFromMessage(Message const &iMessage)
{
  bool res = fUpdateQueue.updateAndPushIf([this, &iMessage](auto oUpdate) -> bool {
    return getParamDefT()->readFromMessage(iMessage, *oUpdate) == kResultOk;
  });
 
  return res ? kResultOk : kResultFalse;
}
 
//------------------------------------------------------------------------
// RTJmbInParameter::writeToStream
//------------------------------------------------------------------------
template<typename T>
void RTJmbInParameter<T>::writeToStream(std::ostream &oStream) const
{
  getParamDefT()->writeToStream(*last(), oStream);
}
 
//------------------------------------------------------------------------
// RTJmbInParam - wrapper to make writing the code much simpler and natural
//------------------------------------------------------------------------
template<typename T>
class RTJmbInParam
{
public:
  RTJmbInParam(RTJmbInParameter<T> *iPtr) : fPtr{iPtr} // NOLINT (not marked explicit on purpose)
  {
    DCHECK_F(fPtr != nullptr);
  }
 
  // getParamID
  inline ParamID getParamID() const { return fPtr->getParamID(); }
 
  // pop - nullptr if no update
  inline T *pop() { return fPtr->pop(); }
 
  // last - last value popped (does not pop!)
  inline T const *last() const { return fPtr->last(); }
 
  // popOrLast - call pop and no new value then call last
  inline T const *popOrLast() { return fPtr->popOrLast(); }
 
  // hasUpdate
  bool hasUpdate() const { return fPtr->hasUpdate(); }
 
  // getValue
  inline T const &getValue() const { return *fPtr->last(); }
 
  // value - synonym
  inline T const &value() const { return *fPtr->last(); }
 
  // allow to use the param as the underlying ParamType (ex: "if(param)" in the case ParamType is bool))
  inline operator T const &() const { return *fPtr->last(); } // NOLINT
 
  // allow writing param->xxx to access the underlying type directly (if not a primitive)
  inline T const *operator->() const { return fPtr->last(); }
 
private:
  RTJmbInParameter<T> *fPtr;
};
 
template<typename T, size_t N>
using RTJmbInParams = std::array<RTJmbInParam<T>, N>;
 
}