ParamSerializers.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 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/logging/logging.h>
#include <pluginterfaces/vst/vsttypes.h>
#include <base/source/fstreamer.h>
#include <string>
#include <iostream>
#include <memory>
#include <sstream>

namespace pongasoft {
namespace VST {

using namespace Steinberg;
using namespace Steinberg::Vst;

template<typename T>
class IParamSerializer
{
public:
  using ParamType = T;
  virtual tresult readFromStream(IBStreamer &iStreamer, ParamType &oValue) const = 0;
  virtual tresult writeToStream(const ParamType &iValue, IBStreamer &oStreamer) const = 0;
  // by default does nothing -- subclasses can override
  virtual void writeToStream(ParamType const &iValue, std::ostream &oStream) const {}
  virtual std::string toString(ParamType const &iValue, int32 iPrecision) const
  {
    std::ostringstream s;
    s.precision(iPrecision);
    s.setf(std::ios::fixed);
    writeToStream(iValue, s);
    return s.str();
  }
};

namespace IBStreamHelper {

// readDouble - contrary to IBStreamer.readDouble, this method does NOT modify oValue if cannot be read
inline tresult readDouble(IBStreamer &iStreamer, double &oValue)
{
  double value;
  if(!iStreamer.readDouble(value))
    return kResultFalse;
  oValue = value;
  return kResultOk;
}

// readFloat - contrary to IBStreamer.readFloat, this method does NOT modify oValue if cannot be read
inline tresult readFloat(IBStreamer &iStreamer, float &oValue)
{
  float value;
  if(!iStreamer.readFloat(value))
    return kResultFalse;
  oValue = value;
  return kResultOk;
}

// readFloatArray - contrary to IBStreamer.readFloatArray, this method returns tresult and can use any Int type
template<typename Int>
inline tresult readFloatArray(IBStreamer &iStreamer, float *oValue, Int iCount)
{
  for(Int i = 0; i < iCount; i++)
  {
    if(!iStreamer.readFloat(oValue[i]))
      return kResultFalse;
  }
  return kResultOk;
}


// readInt64 - contrary to IBStreamer.readInt64, this method does NOT modify oValue if cannot be read
inline tresult readInt64(IBStreamer &iStreamer, int64 &oValue)
{
  int64 value;
  if(!iStreamer.readInt64(value))
    return kResultFalse;
  oValue = value;
  return kResultOk;
}

// readInt64 - contrary to IBStreamer.readInt64, this method does NOT modify oValue if cannot be read
inline tresult readInt64u(IBStreamer &iStreamer, uint64 &oValue)
{
  uint64 value;
  if(!iStreamer.readInt64u(value))
    return kResultFalse;
  oValue = value;
  return kResultOk;
}

// readInt32 - contrary to IBStreamer.readInt32, this method does NOT modify oValue if cannot be read
inline tresult readInt32(IBStreamer &iStreamer, int32 &oValue)
{
  int32 value;
  if(!iStreamer.readInt32(value))
    return kResultFalse;
  oValue = value;
  return kResultOk;
}

// readBool - contrary to IBStreamer.readBool, this method does NOT modify oValue if cannot be read
inline tresult readBool(IBStreamer &iStreamer, bool &oValue)
{
  bool value;
  if(!iStreamer.readBool(value))
    return kResultFalse;
  oValue = value;
  return kResultOk;
}

}

class RawParamSerializer : public IParamSerializer<ParamValue>
{
public:
  tresult readFromStream(IBStreamer &iStreamer, ParamType &oValue) const override
  {
    return IBStreamHelper::readDouble(iStreamer, oValue);
  }

  tresult writeToStream(const ParamType &iValue, IBStreamer &oStreamer) const override
  {
    oStreamer.writeDouble(iValue);
    return kResultOk;
  }

  void writeToStream(ParamType const &iValue, std::ostream &oStream) const override
  {
    oStream << iValue;
  }
};

class DoubleParamSerializer : public IParamSerializer<double>
{
public:
  tresult readFromStream(IBStreamer &iStreamer, ParamType &oValue) const override
  {
    return IBStreamHelper::readDouble(iStreamer, oValue);
  }

  tresult writeToStream(const ParamType &iValue, IBStreamer &oStreamer) const override
  {
    oStreamer.writeDouble(iValue);
    return kResultOk;
  }

  void writeToStream(ParamType const &iValue, std::ostream &oStream) const override
  {
    oStream << iValue;
  }
};

template<int size = 128>
class CStringParamSerializer : public IParamSerializer<char[size]>
{
public:
  using ParamType = char[size];

  // readFromStream
  inline tresult readFromStream(IBStreamer &iStreamer, ParamType &oValue) const override
  {
    if(iStreamer.readRaw(static_cast<void*>(oValue), size) == size)
    {
      oValue[size - 1] = 0; // making sure it is null terminated
      return kResultOk;
    }
    else
      return kResultFalse;
  }

  // writeToStream - IBStreamer
  inline tresult writeToStream(const ParamType &iValue, IBStreamer &oStreamer) const override
  {
    if(oStreamer.writeRaw(static_cast<void const *>(iValue), size) == size)
      return kResultOk;
    else
      return kResultFalse;
  }

  // writeToStream - std::ostream
  void writeToStream(ParamType const &iValue, std::ostream &oStream) const override
  {
    if(std::find(std::begin(iValue), std::end(iValue), 0) != std::end(iValue))
    {
      // this means that the string is null terminated... we are good
      oStream << iValue;
    }
    else
    {
      char8 str[size];
      std::copy(std::begin(iValue), std::end(iValue), std::begin(str));
      str[size - 1] = 0; // make the copy null terminated
      oStream << str;
      DLOG_F(WARNING, "%s not properly null terminated!", str);
    }
  }
};

}
}