FileTranslatorOptions.h

#pragma once
#include "AL/maya/Common.h"

#include "maya/MString.h"

#include <map>
#include <vector>
#include <string>

namespace AL {
namespace maya {

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class OptionsParser
{
  friend class FileTranslatorOptions;
public:

  OptionsParser();

  ~OptionsParser();

  MStatus parse(const MString& optionString);

  bool getBool(const char* const str) const
  {
    auto it = m_niceNameToValue.find(str);
    if(it != m_niceNameToValue.end())
    {
      return it->second->m_bool;
    }
    return false;
  }

  int getInt(const char* const str) const
  {
    auto it = m_niceNameToValue.find(str);
    if(it != m_niceNameToValue.end())
    {
      return it->second->m_int;
    }
    return 0;
  }

  float getFloat(const char* const str) const
  {
    auto it = m_niceNameToValue.find(str);
    if(it != m_niceNameToValue.end())
    {
      return it->second->m_float;
    }
    return 0.0f;
  }

  MString getString(const char* const str) const
  {
    auto it = m_niceNameToValue.find(str);
    if(it != m_niceNameToValue.end())
    {
      return it->second->m_string.c_str();
    }
    return kNullString;
  }

private:
#ifndef AL_GENERATING_DOCS
  enum OptionType
  {
    kBool,
    kInt,
    kFloat,
    kString
  };

  static const MString kNullString;
  struct OptionValue
  {
    void init()
    {
      switch(m_type)
      {
      case kBool: m_bool = m_defaultBool; break;
      case kInt: m_int = m_defaultInt; break;
      case kFloat: m_float = m_defaultFloat; break;
      case kString: m_string = m_defaultString; break;
      default: break;
      }
    }

    void parse(MString& str)
    {
      switch(m_type)
      {
      case kBool: m_bool = str.asInt() ? true : false; break;
      case kInt: m_int = str.asInt(); break;
      case kFloat: m_float = str.asFloat(); break;
      case kString: m_string = str.asChar(); break;  
      default: break;
      }
    }

    OptionType m_type;
    union
    {
      bool m_defaultBool;
      int m_defaultInt;
      float m_defaultFloat;
    };
    std::string m_defaultString;
    union
    {
      bool m_bool;
      int m_int;
      float m_float;
    };
    std::string m_string;
  };
  std::map<std::string, OptionValue*> m_optionNameToValue;
  std::map<std::string, OptionValue*> m_niceNameToValue;
#endif
};


//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class FileTranslatorOptions
{
public:

  FileTranslatorOptions(const char* fileTranslatorName);


  bool addFrame(const char* frameName);


  bool addBool(const char* optionName, bool defaultValue = false);

  bool addInt(const char* optionName, int defaultValue = 0);

  bool addFloat(const char* optionName, float defaultValue = 0.0f);

  bool addString(const char* optionName, const char* const defaultValue = "");

  bool boolControlsVisibility(const char* controller, const char* controlled, bool invertBehaviour = false);


  MStatus generateScript(OptionsParser& optionParser, MString& defaultOptionString);

protected:
#ifndef AL_GENERATING_DOCS
  bool hasOption(const char* const optionName) const;
  bool hasOption(const MString& optionName) const { return hasOption(optionName.asChar()); }
  void generateBoolGlobals(const MString& niceName, const MString& optionName, bool defaultValue);
  void generateIntGlobals(const MString& niceName, const MString& optionName, int defaultValue);
  void generateFloatGlobals(const MString& niceName, const MString& optionName, float defaultValue);
  void generateStringGlobals(const MString& niceName, const MString& optionName, MString defaultValue);
#endif
private:
#ifndef AL_GENERATING_DOCS
  enum OptionType
  {
    kBool,
    kInt,
    kFloat,
    kString
  };
  struct FrameLayout
  {
    FrameLayout(const char* frameName)
      : m_frameName(frameName), m_options()
    {}
    MString m_frameName;
    struct Option
    {
      MString optionName;
      MString niceName;
      OptionType type;
      union
      {
        bool defaultBool;
        int defaultInt;
        float defaultFloat;
        const char* defaultString;
      };
    };
    std::vector<Option> m_options;
  };
  FrameLayout& lastFrame()
  {
    return *(m_frames.end() - 1);
  }
  std::vector<FrameLayout> m_frames;
  std::vector<std::pair<MString, MString> > m_visibility;
  MString m_translatorName;
  MString m_code;
#endif
};

//----------------------------------------------------------------------------------------------------------------------
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------