LumiverseFloat.h

Go to the documentation of this file.

#ifndef _LumiverseFLOAT_H_
#define _LumiverseFLOAT_H_
#pragma once

#include "../LumiverseType.h"
#include <string>
#include <stdio.h>

namespace Lumiverse {
  class LumiverseFloat : public LumiverseType
  {
  public:
    LumiverseFloat(float val = 0.0f, float def = 0.0f, float max = 1.0f, float min = 0.0f);

    LumiverseFloat(LumiverseFloat* other);

    LumiverseFloat(LumiverseType* other);

    ~LumiverseFloat();

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

    // Override for =
    void operator=(float val);
    void operator=(LumiverseFloat val);

    // Arithmetic overrides
    LumiverseFloat& operator+=(float val);
    LumiverseFloat& operator+=(LumiverseFloat& val);

    LumiverseFloat& operator-=(float val);
    LumiverseFloat& operator-=(LumiverseFloat& val);

    LumiverseFloat& operator*=(float val);
    LumiverseFloat& operator*=(LumiverseFloat& val);

    LumiverseFloat& operator/=(float val);
    LumiverseFloat& operator/=(LumiverseFloat& val);

    float getVal() { return m_val; }

    void setVal(float val) { m_val = val; clamp(); }

    void setVals(float val, float def, float min, float max);

    void setMax(float val) { m_max = val; }
    
    float getMax() { return m_max; }

    void setMin(float val) { m_min = val; }
    
    float getMin() { return m_min; }

    void setDefault(float val) { m_default = val; }
    
    float getDefault() { return m_default; }

    virtual void reset();

    void setValAsPercent(float val);

    float asPercent();

    // Converts a float to a JSON object with specified name.
    virtual JSONNode toJSON(string name);

    virtual string asString();

    virtual bool isDefault();

  private:
    void clamp();

    float m_val;

    float m_default;

    float m_max;

    float m_min;
  };

  // Ops ops ops all overloaded woo

  // Compares two LumiverseFloats. Uses normal float comparison
  inline bool operator==(LumiverseFloat& a, LumiverseFloat& b) {
    if (a.getTypeName() != "float" || b.getTypeName() != "float")
      return false;

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

  inline bool operator==(LumiverseFloat& a, float b) {
    if (a.getTypeName() != "float")
      return false;

    return a.getVal() == b;
  }

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

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

  // LumiverseFloat uses the normal < op for floats.
  inline bool operator<(LumiverseFloat& a, LumiverseFloat& b) {
    if (a.getTypeName() != "float" || b.getTypeName() != "float")
      return false;

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

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

    return a.getVal() < b;
  }

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

    return a < b.getVal();
  }

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

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

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

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

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

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

  // Arithmetic overrides
  inline LumiverseFloat operator+(LumiverseFloat& lhs, float rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val += rhs;
    return val;
  }

  //inline LumiverseFloat operator+(LumiverseFloat& lhs, LumiverseFloat& rhs) {
  //  LumiverseFloat val = LumiverseFloat(lhs);
  //  val += rhs;
  //  return val;
  //}

  // Apparently clang needs this form of the overload to make it happy
  inline LumiverseFloat operator+(LumiverseFloat lhs, LumiverseFloat rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val += rhs;
    return val;
  }

  inline LumiverseFloat operator-(LumiverseFloat& lhs, float rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val -= rhs;
    return val;
  }

  inline LumiverseFloat operator-(LumiverseFloat& lhs, LumiverseFloat& rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val -= rhs;
    return val;
  }

  inline LumiverseFloat operator*(LumiverseFloat& lhs, float rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val *= rhs;
    return val;
  }

  inline LumiverseFloat operator*(LumiverseFloat& lhs, LumiverseFloat& rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val *= rhs;
    return val;
  }

  inline LumiverseFloat operator/(LumiverseFloat& lhs, float rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val /= rhs;
    return val;
  }

  inline LumiverseFloat operator/(LumiverseFloat& lhs, LumiverseFloat& rhs) {
    LumiverseFloat val = LumiverseFloat(lhs);
    val /= rhs;
    return val;
  }
}

#endif