arguments.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MEXPLUS_ARGUMENTS_H_
#define INCLUDE_MEXPLUS_ARGUMENTS_H_
 
#include <cstdarg>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include "mexplus/mxarray.h"
 
namespace mexplus {
 
class InputArguments {
 public:
  struct CaseInsensitiveComparator {
    struct CaseInsensitiveElementComparator {
      bool operator() (const char& c1, const char& c2) const {
          return tolower(c1) < tolower(c2);
      }
    };
    bool operator() (const std::string & s1, const std::string & s2) const {
      return std::lexicographical_compare(s1.begin(),
                                          s1.end(),
                                          s2.begin(),
                                          s2.end(),
                                          CaseInsensitiveElementComparator());
    }
  };
 
  typedef std::map<std::string, const mxArray*, CaseInsensitiveComparator>
      OptionMap;
  typedef struct Definition_tag {
    std::vector<const mxArray*> mandatories;
    OptionMap optionals;
  } Definition;
 
  InputArguments() {}
  InputArguments(int nrhs,
                 const mxArray* prhs[],
                 int mandatory_size = 1,
                 int option_size = 0,
                 ...) {
    Definition* definition = &definitions_["default"];
    definition->mandatories.resize(mandatory_size, NULL);
    va_list variable_list;
    va_start(variable_list, option_size);
    fillOptionalDefinition(option_size, &definition->optionals, variable_list);
    va_end(variable_list);
    parse(nrhs, prhs);
  }
  virtual ~InputArguments() {}
  void define(const std::string name,
              int mandatory_size,
              int option_size = 0,
              ...) {
    Definition* definition = &definitions_[name];
    definition->mandatories.resize(mandatory_size);
    va_list variable_list;
    va_start(variable_list, option_size);
    fillOptionalDefinition(option_size, &definition->optionals, variable_list);
    va_end(variable_list);
  }
  void parse(int nrhs,
             const mxArray* prhs[],
             bool ignore_multi_signatures = false) {
    if (definitions_.empty())
      mexErrMsgIdAndTxt("mexplus:arguments:error", "No format defined.");
    std::map<std::string, Definition>::iterator entry;
    std::vector<std::map<std::string, Definition>::iterator> delete_positions;
    for (entry = definitions_.begin(); entry != definitions_.end(); ++entry)
      if (!parseDefinition(nrhs, prhs, &entry->second))
        delete_positions.push_back(entry);
    for (size_t i = 0; i < delete_positions.size(); ++i)
      definitions_.erase(delete_positions[i]);
    if (definitions_.empty())
      mexErrMsgIdAndTxt("mexplus:arguments:error",
                        (error_message_.empty()) ?
                        "Invalid arguments." : error_message_.c_str());
    if (definitions_.size() > 1 && !ignore_multi_signatures)
      mexWarnMsgIdAndTxt("mexplus:arguments:warning",
                         "Input arguments match more than one signature.");
  }
  bool is(const std::string& name) const {
    std::map<std::string, Definition>::const_iterator entry =
        definitions_.find(name);
    return (entry != definitions_.end());
  }
  const mxArray* get(size_t index) const {
    if (definitions_.empty())
      mexErrMsgIdAndTxt("mexplus:arguments:error", "No format defined.");
    const Definition& definition = definitions_.begin()->second;
    if (index >= definition.mandatories.size())
      mexErrMsgIdAndTxt("mexplus:arguments:error", "Index out of range.");
    return definition.mandatories[index];
  }
  template <typename T>
  T get(size_t index) const;
  template <typename T>
  void get(size_t index, T* value) const;
  const mxArray* get(const std::string& option_name) const {
    if (definitions_.empty())
      mexErrMsgIdAndTxt("mexplus:arguments:error", "No format defined.");
    const Definition& definition = definitions_.begin()->second;
    OptionMap::const_iterator entry =
        definition.optionals.find(option_name);
    if (entry == definition.optionals.end())
      mexErrMsgIdAndTxt("mexplus:arguments:error",
                        "Unknown option %s.",
                        option_name.c_str());
    return entry->second;
  }
  template <typename T>
  T get(const std::string& option_name, const T& default_value) const;
  template <typename T>
  void get(const std::string& option_name,
           const T& default_value,
           T* value) const;
  const mxArray* operator[] (size_t index) const { return get(index); }
  const mxArray* operator[] (const std::string& option_name) const {
    return get(option_name);
  }
 
 private:
  void fillOptionalDefinition(int option_size,
                              OptionMap* optionals,
                              va_list variable_list) {
    for (int i = 0; i < option_size; ++i) {
      const char* option_name = va_arg(variable_list, const char*);
      (*optionals)[std::string(option_name)] = NULL;
    }
  }
  bool parseDefinition(size_t nrhs,
                       const mxArray* prhs[],
                       Definition* definition) {
    const size_t kMaxOptionNameSize = 64;
    std::stringstream message;
    std::string option_name;
    if (nrhs < definition->mandatories.size()) {
      message << "Too few arguments: " << nrhs << " for at least "
              << definition->mandatories.size() << ".";
      error_message_.assign(message.str());
      return false;
    }
    size_t index = 0;
    for (; index < definition->mandatories.size(); ++index)
      definition->mandatories[index] = prhs[index];
 
    /* If the first argument behind all mandatories is the least one and
     * represents a structure array with only one element, it is assumed to be
     * a config structure with fields for all optionals.
     */
    if (nrhs - index == 1 &&
        mxIsStruct(prhs[index]) &&
        mxGetNumberOfElements(prhs[index]) == 1) {
      MxArray config(prhs[index]);
      for (int field_index = 0;
           field_index < config.fieldSize();
           ++field_index) {
        // Check the config structure for fields.
        option_name = config.fieldName(field_index);
        if (option_name.size() > kMaxOptionNameSize) {
          message << "Option name too long: " << option_name.size()
                  << " characters for " << kMaxOptionNameSize - 1;
          error_message_.assign(message.str());
          return false;
        }
        OptionMap::iterator entry =
            definition->optionals.find(option_name);
        if (entry == definition->optionals.end()) {
          message << "Invalid option name: '" << option_name << "'.";
          error_message_.assign(message.str());
          return false;
        }
        // Get optional value from "config structure".
        entry->second = config.at(config.fieldName(field_index));
      }
    }
    else {  // Conventional option list.
      while (true) {
        if (index >= nrhs) break;
        // Check if the option name is valid.
        MxArray option_name_array(prhs[index++]);
        if (!option_name_array.isChar()) {
          message << "Option name must be char but is given "
                  << option_name_array.className() << ".";
          error_message_.assign(message.str());
          return false;
        }
        option_name = option_name_array.to<std::string>();
        if (option_name.size() > kMaxOptionNameSize) {
          message << "Option name too long: " << option_name.size()
                  << " characters for " << kMaxOptionNameSize - 1;
          error_message_.assign(message.str());
          return false;
        }
        OptionMap::iterator entry =
            definition->optionals.find(option_name);
        if (entry == definition->optionals.end()) {
          message << "Invalid option name: '" << option_name << "'.";
          error_message_.assign(message.str());
          return false;
        }
        // Check if options are even.
        if (index >= nrhs) {
          message << "Missing option value for option '" << option_name
                  << "'.";
          error_message_.assign(message.str());
          return false;
        }
        // Check if the option is already filled.
        if (entry->second)
          mexWarnMsgIdAndTxt("mexplus:arguments:warning",
                             "Option '%s' appeared more than once.",
                             option_name.c_str());
        // Assign optional value.
        entry->second = prhs[index++];
      }
    }
    return true;
  }
  std::map<std::string, Definition> definitions_;
  std::string error_message_;
};
 
template <typename T>
T InputArguments::get(size_t index) const {
  T value;
  get<T>(index, &value);
  return value;
}
 
template <typename T>
void InputArguments::get(size_t index, T* value) const {
  MxArray::to<T>(get(index), value);
}
 
template <typename T>
T InputArguments::get(const std::string& option_name,
                      const T& default_value) const {
  T value;
  get<T>(option_name, default_value, &value);
  return value;
}
 
template <typename T>
void InputArguments::get(const std::string& option_name,
                         const T& default_value,
                         T* value) const {
  MxArray option(get(option_name));
  if (option)
    option.to<T>(value);
  else
    *value = default_value;
}
 
class OutputArguments {
 public:
  OutputArguments(int nlhs,
                  mxArray** plhs,
                  int maximum_size = 1,
                  int mandatory_size = 0) : nlhs_(nlhs), plhs_(plhs) {
    if (mandatory_size > nlhs)
      mexErrMsgIdAndTxt("mexplus:arguments:error",
                        "Too few output: %d for %d.",
                        nlhs,
                        mandatory_size);
    if (maximum_size < nlhs)
      mexErrMsgIdAndTxt("mexplus:arguments:error",
                        "Too many output: %d for %d.",
                        nlhs,
                        maximum_size);
  }
  void set(size_t index, mxArray* value) {
    if (index < nlhs_)
      plhs_[index] = value;
  }
  template <typename T>
  void set(size_t index, const T& value) {
    set(index, MxArray::from(value));
  }
  size_t size() const { return nlhs_; }
  mxArray* const& operator[] (size_t index) const {
    if (index >= nlhs_)
      mexErrMsgIdAndTxt("mexplus:arguments:error",
                        "Output index out of range: %d.",
                        index);
    return plhs_[index];
  }
  mxArray*& operator[] (size_t index) {
    if (index >= nlhs_)
      mexErrMsgIdAndTxt("mexplus:arguments:error",
                        "Output index out of range: %d.",
                        index);
    return plhs_[index];
  }
 
 private:
  size_t nlhs_;
  mxArray** plhs_;
};
 
}  // namespace mexplus
 
#endif  // INCLUDE_MEXPLUS_ARGUMENTS_H_