ParamTable.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/VST/Parameters.h>
#include <pongasoft/VST/RT/RTState.h>
#include <pongasoft/VST/GUI/GUIState.h>

#include "ParamDisplay.h"

#include <string>

namespace pongasoft {
namespace VST {
namespace Debug {

class ParamTable
{
public:
  explicit ParamTable(ParamDisplay iParamDisplay) : fParamDisplay{std::move(iParamDisplay)} {}

public:
  // builder pattern to initialize the table
  ParamTable &precision(int32 iPrecision) { fParamDisplay.precision(iPrecision); return *this; }
  ParamTable &keys(std::vector<ParamDisplay::Key> const &iKeys) { fParamDisplay.keys(iKeys); return *this; };
  ParamTable &key(ParamDisplay::Key iKey) { fParamDisplay.key(iKey); return *this; }
  ParamTable &ids(std::vector<ParamID> const &iParamIDs) { fParamDisplay.ids(iParamIDs); return *this; };
  ParamTable &id(ParamID iParamID) { fParamDisplay.id(iParamID); return *this; };
  ParamTable &header(bool iDisplayHeader = true) { fDisplayHeader = iDisplayHeader; return *this; };
  ParamTable &showHeader() { return header(true); };
  ParamTable &hideHeader() { return header(false); };
  ParamTable &headerSeparation(bool iDisplayHeaderSeparation = true) { fDisplayHeaderSeparation = iDisplayHeaderSeparation; return *this; };
  ParamTable &showHeaderSeparation() { return headerSeparation(true); };
  ParamTable &hideHeaderSeparation() { return headerSeparation(false); };
  ParamTable &lineSeparation(bool iDisplayLineSeparation = true) { fDisplayLineSeparation = iDisplayLineSeparation; return *this; };
  ParamTable &showLineSeparation() { return lineSeparation(true); };
  ParamTable &hideLineSeparation() { return lineSeparation(false); };
  ParamTable &cellSeparation(bool iDisplayCellSeparation = true) { fDisplayCellSeparation = iDisplayCellSeparation; return *this; };
  ParamTable &showCellSeparation() { return cellSeparation(true); };
  ParamTable &hideCellSeparation() { return cellSeparation(false); };

  ParamTable &compact() { return hideHeaderSeparation().hideLineSeparation().hideCellSeparation(); };
  ParamTable &full() { return showHeaderSeparation().showLineSeparation().showCellSeparation(); };

  // returns the table as a vector of rows
  std::vector<std::string> rows() const;

  // returns a tabular representation of the params
  std::string toString() const;

  // print the table
  void print(std::string const &iFirstLine = "") const;

  // returns the table as a vector of rows
  std::vector<std::string> rows(NormalizedState const &iNormalizedState) const;

  // returns a tabular representation of the params
  std::string toString(NormalizedState const &iNormalizedState) const;

  // print the table
  void print(NormalizedState const &iNormalizedState, std::string const &iFirstLine = "") const;

protected:
  // computeSizes
  std::string::size_type computeSizes(ParamDisplay::ValueMap const &iHeader,
                                      ParamDisplay::ParamMap const &iParams,
                                      std::map<ParamDisplay::Key, std::string::size_type> &oSizes) const;

  // computeHeader
  ParamDisplay::ValueMap computeHeader() const;

  // returns the table as a vector of rows
  std::vector<std::string> rows(ParamDisplay::ParamMap const &iParamMap) const;

public:
  static ParamTable from(Parameters const &iParams);

  static ParamTable from(RT::RTState const *iState, bool iSaveStateOnly = false);

  static ParamTable from(GUI::GUIState const *iState, bool iSaveStateOnly = false);

private:
  bool fDisplayHeader{true};
  bool fDisplayHeaderSeparation{false};
  bool fDisplayLineSeparation{false};
  bool fDisplayCellSeparation{false};

  ParamDisplay fParamDisplay;
};

}
}
}