LumiverseEnum.h

Go to the documentation of this file.

#ifndef _LUMIVERSEENUM_
#define _LUMIVERSEENUM_

#pragma once

#include "../LumiverseType.h"
#include <map>
#include <memory>
#include <mutex>
#include <vector>

namespace Lumiverse {
  class LumiverseEnum : public LumiverseType
  {
  public:
    enum Mode {
      FIRST,  
      CENTER, 
      LAST    
    };

    enum InterpolationMode {
      SNAP, 
      SMOOTH_WITHIN_OPTION,
      SMOOTH 
    };

    LumiverseEnum(Mode mode = CENTER, int rangeMax = 255, InterpolationMode interpMode = SMOOTH_WITHIN_OPTION);

    LumiverseEnum(map<string, int> keys, Mode mode = CENTER, int rangeMax = 255, string def = "", InterpolationMode interpMode = SMOOTH_WITHIN_OPTION);

    LumiverseEnum(map<string, int> keys, string mode, string interpMode, int rangeMax = 255, string def = "");

    LumiverseEnum(LumiverseEnum* other);

    LumiverseEnum(const LumiverseEnum& other);

    LumiverseEnum(LumiverseType* other);

    ~LumiverseEnum();

    virtual string getTypeName() { return "enum"; }

    virtual void reset();

    // Returns this object as a JSON node
    virtual JSONNode toJSON(string name);

    virtual string asString();

    void addVal(string name, int start);

    void removeVal(string name);

    bool setVal(string name);

    bool setVal(string name, float tweak);

    bool setVal(string name, float tweak, Mode enumMode, InterpolationMode interpMode);

    bool setVal(float val);

    void setTweak(float tweak);

    void setDefault(string name) { m_default = name; }

    string getVal() { return m_active; }

    int getValIndex() { return m_nameToStart[m_active]; }

    float getTweak() { return m_tweak; }

    string getDefault() { return m_default; }

    void setMode(Mode mode) { m_mode = mode; }

    Mode getMode() { return m_mode; }

    void setInterpMode(InterpolationMode mode) { m_interpMode = mode; }

    InterpolationMode getInterpMode() { return m_interpMode; }

    int getRangeMax() { return m_rangeMax; }

    void setRangeMax(int newMax) { m_rangeMax = newMax; }

    shared_ptr<LumiverseType> lerp(LumiverseEnum* rhs, float t);

    float getRangeVal();

    void setValAsPercent(float val) { setVal(val * (m_rangeMax - getLowestStartValue()) + getLowestStartValue()); }

    float asPercent();

    // Operator overrides woo
    void operator=(string name);
    void operator=(const LumiverseEnum& val);

    virtual bool isDefault();

    vector<string> getVals();

    const map<string, int>& getValsToStart() { return m_nameToStart; }

    const map<int, string>& getStartToVals() { return m_startToName; }

    int getHighestStartValue();

    int getLowestStartValue();

  private:
    void init(map<string, int> keys, string active, Mode mode, string def,
      float tweak, int rangeMax, InterpolationMode interpMode);

    void init(map<string, int> keys, string active, Mode mode, string def,
      float tweak, int rangeMax, InterpolationMode interpMode, map<int, string> vals);

    void setTweakWithMode();

    string modeAsString();

    Mode stringToMode(string input);

    string interpModeAsString();

    InterpolationMode stringToInterpMode(string input);

    string m_active;

    string m_default;

    map<string, int> m_nameToStart;

    map<int, string> m_startToName;

    Mode m_mode;

    InterpolationMode m_interpMode;

    float m_tweak;

    int m_rangeMax;

    mutex m_enumMapMutex;
  };

  // Ops time

  inline bool operator==(LumiverseEnum& a, LumiverseEnum& b) {
    if (a.getTypeName() != "enum" || b.getTypeName() != "enum")
      return false;

    return (a.getVal() == b.getVal() && a.getTweak() == b.getTweak());
  }

  inline bool operator!=(LumiverseEnum& a, LumiverseEnum& b) {
    return !(a == b);
  }

  inline bool operator<(LumiverseEnum& a, LumiverseEnum& b) {
    if (a.getTypeName() != "enum" || b.getTypeName() != "enum")
      return false;

    return a.getRangeVal() < b.getRangeVal();
  }

  inline bool operator>(LumiverseEnum& a, LumiverseEnum& b) {
    return b < a;
  }

  inline bool operator<=(LumiverseEnum& a, LumiverseEnum& b) {
    return !(a > b);
  }

  inline bool operator>=(LumiverseEnum& a, LumiverseEnum& b) {
    return !(a < b);
  }

  // Arithmetic overrides will be a little complicated or non-existant as an enum.
}

#endif