Remove namespaces from boxing module class definitions

source/ls-std/boxing/Boolean.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,63 +11,71 @@
 #include <ls-std/boxing/Boolean.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Boolean::Boolean(bool _value) : ls::std::core::Class("Boolean"), value(_value)
-{}
+using ls::std::boxing::Boolean;
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using std::string;
+using std::transform;
+
+Boolean::Boolean(bool _value) : Boolean()
+{
+  this->value = _value;
+}
 
-ls::std::boxing::Boolean::Boolean() : ls::std::core::Class("Boolean")
+Boolean::Boolean() : Class("Boolean")
 {}
 
-ls::std::boxing::Boolean::~Boolean() noexcept = default;
+Boolean::~Boolean() noexcept = default;
 
-ls::std::boxing::Boolean &ls::std::boxing::Boolean::operator=(int _value)
+Boolean &Boolean::operator=(int _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls::std::boxing::Boolean &ls::std::boxing::Boolean::operator=(bool _value)
+Boolean &Boolean::operator=(bool _value)
 {
   this->value = _value;
   return *this;
 }
 
-bool ls::std::boxing::Boolean::operator&&(const ls::std::boxing::Boolean &_boolean) const
+bool Boolean::operator&&(const Boolean &_boolean) const
 {
   return this->value && _boolean.getValue();
 }
 
-bool ls::std::boxing::Boolean::operator&&(bool _value) const
+bool Boolean::operator&&(bool _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Boolean::operator&&(int _value) const
+bool Boolean::operator&&(int _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Boolean::operator||(const ls::std::boxing::Boolean &_boolean) const
+bool Boolean::operator||(const Boolean &_boolean) const
 {
   return this->value || _boolean.getValue();
 }
 
-bool ls::std::boxing::Boolean::operator||(bool _value) const
+bool Boolean::operator||(bool _value) const
 {
   return this->value || _value;
 }
 
-bool ls::std::boxing::Boolean::operator||(int _value) const
+bool Boolean::operator||(int _value) const
 {
   return this->value || _value;
 }
 
-void ls::std::boxing::Boolean::parse(::std::string _parseText)
+void Boolean::parse(string _parseText)
 {
-  ::std::transform(_parseText.begin(), _parseText.end(), _parseText.begin(), ::tolower);
+  transform(_parseText.begin(), _parseText.end(), _parseText.begin(), ::tolower);
 
   if (_parseText != this->TRUE_STRING && _parseText != this->FALSE_STRING)
   {
-    throw ls::std::core::IllegalArgumentException{_parseText + " is not a valid string representation"};
+    throw IllegalArgumentException{_parseText + " is not a valid string representation"};
   }
   else
   {
@@ -83,39 +91,39 @@ void ls::std::boxing::Boolean::parse(::std::string _parseText)
   }
 }
 
-::std::string ls::std::boxing::Boolean::toString()
+string Boolean::toString()
 {
   return this->_toString();
 }
 
-bool ls::std::boxing::Boolean::getValue() const
+bool Boolean::getValue() const
 {
   return this->value;
 }
 
-bool ls::std::boxing::Boolean::XOR(const ls::std::boxing::Boolean &_leftExpression, const ls::std::boxing::Boolean &_rightExpression)
+bool Boolean::XOR(const Boolean &_leftExpression, const Boolean &_rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression.getValue());
 }
 
-bool ls::std::boxing::Boolean::XOR(const ls::std::boxing::Boolean &_leftExpression, bool _rightExpression)
+bool Boolean::XOR(const Boolean &_leftExpression, bool _rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls::std::boxing::Boolean::XOR(bool _leftExpression, const ls::std::boxing::Boolean &_rightExpression)
+bool Boolean::XOR(bool _leftExpression, const Boolean &_rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression.getValue());
 }
 
-bool ls::std::boxing::Boolean::XOR(bool _leftExpression, bool _rightExpression)
+bool Boolean::XOR(bool _leftExpression, bool _rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-::std::string ls::std::boxing::Boolean::_toString() const
+string Boolean::_toString() const
 {
-  ::std::string booleanString{};
+  string booleanString{};
 
   if (this->value)
   {

source/ls-std/boxing/Double.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,217 +11,225 @@
 #include <ls-std/boxing/Double.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Double::Double() : ls::std::core::Class("Double")
+using ls::std::boxing::Double;
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using std::fabs;
+using std::stod;
+using std::string;
+using std::to_string;
+
+Double::Double() : Class("Double")
 {
   this->_assignEpsilon(0.00000001);
 }
 
-ls::std::boxing::Double::Double(double _value) : ls::std::core::Class("Double"), value(_value)
+Double::Double(double _value) : Double()
 {
-  this->_assignEpsilon(0.00000001);
+  this->value = _value;
 }
 
-ls::std::boxing::Double::~Double() noexcept = default;
+Double::~Double() noexcept = default;
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator=(double _value)
+Double &Double::operator=(double _value)
 {
   this->value = _value;
   return *this;
 }
 
-double ls::std::boxing::Double::operator-() const
+double Double::operator-() const
 {
   return -this->value;
 }
 
-double ls::std::boxing::Double::operator+(const ls::std::boxing::Double &_double) const
+double Double::operator+(const Double &_double) const
 {
   return this->value + _double.getValue();
 }
 
-double ls::std::boxing::Double::operator+(double _value) const
+double Double::operator+(double _value) const
 {
   return this->value + _value;
 }
 
-double ls::std::boxing::Double::operator*(const ls::std::boxing::Double &_double) const
+double Double::operator*(const Double &_double) const
 {
   return this->value * _double.getValue();
 }
 
-double ls::std::boxing::Double::operator*(double _value) const
+double Double::operator*(double _value) const
 {
   return this->value * _value;
 }
 
-double ls::std::boxing::Double::operator-(const ls::std::boxing::Double &_double) const
+double Double::operator-(const Double &_double) const
 {
   return this->value - _double.getValue();
 }
 
-double ls::std::boxing::Double::operator-(double _value) const
+double Double::operator-(double _value) const
 {
   return this->value - _value;
 }
 
-double ls::std::boxing::Double::operator/(const ls::std::boxing::Double &_double) const
+double Double::operator/(const Double &_double) const
 {
   return this->value / _double.getValue();
 }
 
-double ls::std::boxing::Double::operator/(double _value) const
+double Double::operator/(double _value) const
 {
   return this->value / _value;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator+=(const ls::std::boxing::Double &_double)
+Double &Double::operator+=(const Double &_double)
 {
   this->value += _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator+=(double _value)
+Double &Double::operator+=(double _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator-=(const ls::std::boxing::Double &_double)
+Double &Double::operator-=(const Double &_double)
 {
   this->value -= _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator-=(double _value)
+Double &Double::operator-=(double _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator*=(const ls::std::boxing::Double &_double)
+Double &Double::operator*=(const Double &_double)
 {
   this->value *= _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator*=(double _value)
+Double &Double::operator*=(double _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator/=(const ls::std::boxing::Double &_double)
+Double &Double::operator/=(const Double &_double)
 {
   this->value /= _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator/=(double _value)
+Double &Double::operator/=(double _value)
 {
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Double::operator==(const ls::std::boxing::Double &_double) const
+bool Double::operator==(const Double &_double) const
 {
-  return ::std::fabs(this->value - _double.getValue()) < this->epsilon;
+  return fabs(this->value - _double.getValue()) < this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator==(double _value) const
+bool Double::operator==(double _value) const
 {
-  return ::std::fabs(this->value - _value) < this->epsilon;
+  return fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator!=(const ls::std::boxing::Double &_double) const
+bool Double::operator!=(const Double &_double) const
 {
-  return ::std::fabs(this->value - _double.getValue()) >= this->epsilon;
+  return fabs(this->value - _double.getValue()) >= this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator!=(double _value) const
+bool Double::operator!=(double _value) const
 {
-  return ::std::fabs(this->value - _value) >= this->epsilon;
+  return fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator>(const ls::std::boxing::Double &_double) const
+bool Double::operator>(const Double &_double) const
 {
   return this->value > _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator>(double _value) const
+bool Double::operator>(double _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Double::operator>=(const ls::std::boxing::Double &_double) const
+bool Double::operator>=(const Double &_double) const
 {
   return this->value >= _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator>=(double _value) const
+bool Double::operator>=(double _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Double::operator<(const ls::std::boxing::Double &_double) const
+bool Double::operator<(const Double &_double) const
 {
   return this->value < _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator<(double _value) const
+bool Double::operator<(double _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Double::operator<=(const ls::std::boxing::Double &_double) const
+bool Double::operator<=(const Double &_double) const
 {
   return this->value <= _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator<=(double _value) const
+bool Double::operator<=(double _value) const
 {
   return this->value <= _value;
 }
 
-void ls::std::boxing::Double::operator++()
+void Double::operator++()
 {
   this->value += 1.0f;
 }
 
-void ls::std::boxing::Double::operator--()
+void Double::operator--()
 {
   this->value -= 1.0f;
 }
 
-void ls::std::boxing::Double::parse(::std::string _parseText)
+void Double::parse(string _parseText)
 {
-  this->value = ::std::stod(_parseText);
+  this->value = stod(_parseText);
 }
 
-::std::string ls::std::boxing::Double::toString()
+string Double::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-double ls::std::boxing::Double::getEpsilon() const
+double Double::getEpsilon() const
 {
   return this->epsilon;
 }
 
-double ls::std::boxing::Double::getValue() const
+double Double::getValue() const
 {
   return this->value;
 }
 
-void ls::std::boxing::Double::setEpsilon(double _epsilon)
+void Double::setEpsilon(double _epsilon)
 {
   this->_assignEpsilon(_epsilon);
 }
 
-void ls::std::boxing::Double::_assignEpsilon(double _epsilon)
+void Double::_assignEpsilon(double _epsilon)
 {
   if (_epsilon <= 0.0)
   {
-    throw ls::std::core::IllegalArgumentException{"_epsilon is less than or equal zero"};
+    throw IllegalArgumentException{"_epsilon is less than or equal zero"};
   }
 
   this->epsilon = _epsilon;

source/ls-std/boxing/Float.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,213 +11,223 @@
 #include <ls-std/boxing/Float.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Float::Float() : ls::std::core::Class("Float"), epsilon(0.00001f)
-{}
+using ls::std::boxing::Float;
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using std::fabs;
+using std::stof;
+using std::string;
+using std::to_string;
 
-ls::std::boxing::Float::Float(float _value) : ls::std::core::Class("Float"), epsilon(0.00001f), value(_value)
+Float::Float() : Class("Float"), epsilon(0.00001f)
 {}
 
-ls::std::boxing::Float::~Float() noexcept = default;
+Float::Float(float _value) : Float()
+{
+  this->value = _value;
+}
+
+Float::~Float() noexcept = default;
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator=(float _value)
+Float &Float::operator=(float _value)
 {
   this->value = _value;
   return *this;
 }
 
-float ls::std::boxing::Float::operator-() const
+float Float::operator-() const
 {
   return -this->value;
 }
 
-float ls::std::boxing::Float::operator+(const ls::std::boxing::Float &_float) const
+float Float::operator+(const Float &_float) const
 {
   return this->value + _float.getValue();
 }
 
-float ls::std::boxing::Float::operator+(float _value) const
+float Float::operator+(float _value) const
 {
   return this->value + _value;
 }
 
-float ls::std::boxing::Float::operator*(const ls::std::boxing::Float &_float) const
+float Float::operator*(const Float &_float) const
 {
   return this->value * _float.getValue();
 }
 
-float ls::std::boxing::Float::operator*(float _value) const
+float Float::operator*(float _value) const
 {
   return this->value * _value;
 }
 
-float ls::std::boxing::Float::operator-(const ls::std::boxing::Float &_float) const
+float Float::operator-(const Float &_float) const
 {
   return this->value - _float.getValue();
 }
 
-float ls::std::boxing::Float::operator-(float _value) const
+float Float::operator-(float _value) const
 {
   return this->value - _value;
 }
 
-float ls::std::boxing::Float::operator/(const ls::std::boxing::Float &_float) const
+float Float::operator/(const Float &_float) const
 {
   return this->value / _float.getValue();
 }
 
-float ls::std::boxing::Float::operator/(float _value) const
+float Float::operator/(float _value) const
 {
   return this->value / _value;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator+=(const ls::std::boxing::Float &_float)
+Float &Float::operator+=(const Float &_float)
 {
   this->value += _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator+=(float _value)
+Float &Float::operator+=(float _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator-=(const ls::std::boxing::Float &_float)
+Float &Float::operator-=(const Float &_float)
 {
   this->value -= _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator-=(float _value)
+Float &Float::operator-=(float _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator*=(const ls::std::boxing::Float &_float)
+Float &Float::operator*=(const Float &_float)
 {
   this->value *= _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator*=(float _value)
+Float &Float::operator*=(float _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator/=(const ls::std::boxing::Float &_float)
+Float &Float::operator/=(const Float &_float)
 {
   this->value /= _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator/=(float _value)
+Float &Float::operator/=(float _value)
 {
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Float::operator==(const ls::std::boxing::Float &_float) const
+bool Float::operator==(const Float &_float) const
 {
-  return ::std::fabs(this->value - _float.getValue()) < this->epsilon;
+  return fabs(this->value - _float.getValue()) < this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator==(float _value) const
+bool Float::operator==(float _value) const
 {
-  return ::std::fabs(this->value - _value) < this->epsilon;
+  return fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator!=(const ls::std::boxing::Float &_float) const
+bool Float::operator!=(const Float &_float) const
 {
-  return ::std::fabs(this->value - _float.getValue()) >= this->epsilon;
+  return fabs(this->value - _float.getValue()) >= this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator!=(float _value) const
+bool Float::operator!=(float _value) const
 {
-  return ::std::fabs(this->value - _value) >= this->epsilon;
+  return fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator>(const ls::std::boxing::Float &_float) const
+bool Float::operator>(const Float &_float) const
 {
   return this->value > _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator>(float _value) const
+bool Float::operator>(float _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Float::operator>=(const ls::std::boxing::Float &_float) const
+bool Float::operator>=(const Float &_float) const
 {
   return this->value >= _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator>=(float _value) const
+bool Float::operator>=(float _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Float::operator<(const ls::std::boxing::Float &_float) const
+bool Float::operator<(const Float &_float) const
 {
   return this->value < _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator<(float _value) const
+bool Float::operator<(float _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Float::operator<=(const ls::std::boxing::Float &_float) const
+bool Float::operator<=(const Float &_float) const
 {
   return this->value <= _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator<=(float _value) const
+bool Float::operator<=(float _value) const
 {
   return this->value <= _value;
 }
 
-void ls::std::boxing::Float::operator++()
+void Float::operator++()
 {
   this->value += 1.0f;
 }
 
-void ls::std::boxing::Float::operator--()
+void Float::operator--()
 {
   this->value -= 1.0f;
 }
 
-void ls::std::boxing::Float::parse(::std::string _parseText)
+void Float::parse(string _parseText)
 {
-  this->value = ::std::stof(_parseText);
+  this->value = stof(_parseText);
 }
 
-::std::string ls::std::boxing::Float::toString()
+string Float::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-float ls::std::boxing::Float::getEpsilon() const
+float Float::getEpsilon() const
 {
   return this->epsilon;
 }
 
-float ls::std::boxing::Float::getValue() const
+float Float::getValue() const
 {
   return this->value;
 }
 
-void ls::std::boxing::Float::setEpsilon(float _epsilon)
+void Float::setEpsilon(float _epsilon)
 {
   this->_assignEpsilon(_epsilon);
 }
 
-void ls::std::boxing::Float::_assignEpsilon(float _epsilon)
+void Float::_assignEpsilon(float _epsilon)
 {
   if (_epsilon <= 0.0)
   {
-    throw ls::std::core::IllegalArgumentException{"epsilon is less than or equal zero"};
+    throw IllegalArgumentException{"epsilon is less than or equal zero"};
   }
 
   this->epsilon = _epsilon;

source/ls-std/boxing/Integer.cpp

@@ -3,261 +3,270 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/boxing/Integer.hpp>
 #include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Integer::Integer(int _value) : ls::std::core::Class("Integer"), value(_value)
-{}
+using ls::std::boxing::Integer;
+using ls::std::core::Class;
+using ls::std::core::IllegalArithmeticOperationException;
+using std::stoi;
+using std::string;
+using std::to_string;
+
+Integer::Integer(int _value) : Integer()
+{
+  this->value = _value;
+}
 
-ls::std::boxing::Integer::Integer() : ls::std::core::Class("Integer")
+Integer::Integer() : Class("Integer")
 {}
 
-ls::std::boxing::Integer::~Integer() noexcept = default;
+Integer::~Integer() noexcept = default;
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator=(int _value)
+Integer &Integer::operator=(int _value)
 {
   this->value = _value;
   return *this;
 }
 
-int ls::std::boxing::Integer::operator-() const
+int Integer::operator-() const
 {
   return -this->value;
 }
 
-int ls::std::boxing::Integer::operator+(const ls::std::boxing::Integer &_integer) const
+int Integer::operator+(const Integer &_integer) const
 {
   return this->value + _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator+(int _value) const
+int Integer::operator+(int _value) const
 {
   return this->value + _value;
 }
 
-int ls::std::boxing::Integer::operator*(const ls::std::boxing::Integer &_integer) const
+int Integer::operator*(const Integer &_integer) const
 {
   return this->value * _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator*(int _value) const
+int Integer::operator*(int _value) const
 {
   return this->value * _value;
 }
 
-int ls::std::boxing::Integer::operator-(const ls::std::boxing::Integer &_integer) const
+int Integer::operator-(const Integer &_integer) const
 {
   return this->value - _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator-(int _value) const
+int Integer::operator-(int _value) const
 {
   return this->value - _value;
 }
 
-int ls::std::boxing::Integer::operator/(const ls::std::boxing::Integer &_integer) const
+int Integer::operator/(const Integer &_integer) const
 {
   if (_integer == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   return this->value / _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator/(int _value) const
+int Integer::operator/(int _value) const
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   return this->value / _value;
 }
 
-int ls::std::boxing::Integer::operator%(const ls::std::boxing::Integer &_integer) const
+int Integer::operator%(const Integer &_integer) const
 {
   return this->value % _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator%(int _value) const
+int Integer::operator%(int _value) const
 {
   return this->value % _value;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator+=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator+=(const Integer &_integer)
 {
   this->value += _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator+=(int _value)
+Integer &Integer::operator+=(int _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator-=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator-=(const Integer &_integer)
 {
   this->value -= _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator-=(int _value)
+Integer &Integer::operator-=(int _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator*=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator*=(const Integer &_integer)
 {
   this->value *= _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator*=(int _value)
+Integer &Integer::operator*=(int _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator/=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator/=(const Integer &_integer)
 {
   if (_integer == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   this->value /= _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator/=(int _value)
+Integer &Integer::operator/=(int _value)
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Integer::operator==(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator==(const Integer &_integer) const
 {
   return this->value == _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator==(int _value) const
+bool Integer::operator==(int _value) const
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::Integer::operator!=(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator!=(const Integer &_integer) const
 {
   return this->value != _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator!=(int _value) const
+bool Integer::operator!=(int _value) const
 {
   return this->value != _value;
 }
 
-bool ls::std::boxing::Integer::operator>(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator>(const Integer &_integer) const
 {
   return this->value > _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator>(int _value) const
+bool Integer::operator>(int _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Integer::operator>=(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator>=(const Integer &_integer) const
 {
   return this->value >= _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator>=(int _value) const
+bool Integer::operator>=(int _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Integer::operator<(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator<(const Integer &_integer) const
 {
   return this->value < _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator<(int _value) const
+bool Integer::operator<(int _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Integer::operator<=(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator<=(const Integer &_integer) const
 {
   return this->value <= _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator<=(int _value) const
+bool Integer::operator<=(int _value) const
 {
   return this->value <= _value;
 }
 
-bool ls::std::boxing::Integer::operator&&(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator&&(const Integer &_integer) const
 {
   return this->value && _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator&&(int _value) const
+bool Integer::operator&&(int _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Integer::operator&&(bool _expression) const
+bool Integer::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls::std::boxing::Integer::operator||(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator||(const Integer &_integer) const
 {
   return this->value || _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator||(int _value) const
+bool Integer::operator||(int _value) const
 {
   return this->value || _value;
 }
 
-bool ls::std::boxing::Integer::operator||(bool _expression) const
+bool Integer::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls::std::boxing::Integer::operator++()
+void Integer::operator++()
 {
   this->value += 1;
 }
 
-void ls::std::boxing::Integer::operator--()
+void Integer::operator--()
 {
   this->value -= 1;
 }
 
-void ls::std::boxing::Integer::parse(::std::string _parseText)
+void Integer::parse(string _parseText)
 {
-  this->value = ::std::stoi(_parseText);
+  this->value = stoi(_parseText);
 }
 
-std::string ls::std::boxing::Integer::toString()
+string Integer::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-int ls::std::boxing::Integer::getValue() const
+int Integer::getValue() const
 {
   return this->value;
 }

source/ls-std/boxing/Long.cpp

@@ -3,261 +3,271 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/boxing/Long.hpp>
 #include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Long::Long(ls::std::core::type::long_type _value) : ls::std::core::Class("Long"), value(_value)
-{}
+using ls::std::boxing::Long;
+using ls::std::core::Class;
+using ls::std::core::IllegalArithmeticOperationException;
+using ls::std::core::type::long_type;
+using std::stoll;
+using std::string;
+using std::to_string;
+
+Long::Long(long_type _value) : Long()
+{
+  this->value = _value;
+}
 
-ls::std::boxing::Long::Long() : ls::std::core::Class("Long")
+Long::Long() : Class("Long")
 {}
 
-ls::std::boxing::Long::~Long() noexcept = default;
+Long::~Long() noexcept = default;
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator=(ls::std::core::type::long_type _value)
+Long &Long::operator=(long_type _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator-() const
+long_type Long::operator-() const
 {
   return -this->value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator+(const ls::std::boxing::Long &_long) const
+long_type Long::operator+(const Long &_long) const
 {
   return this->value + _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator+(ls::std::core::type::long_type _value) const
+long_type Long::operator+(long_type _value) const
 {
   return this->value + _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator*(const ls::std::boxing::Long &_long) const
+long_type Long::operator*(const Long &_long) const
 {
   return this->value * _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator*(ls::std::core::type::long_type _value) const
+long_type Long::operator*(long_type _value) const
 {
   return this->value * _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator-(const ls::std::boxing::Long &_long) const
+long_type Long::operator-(const Long &_long) const
 {
   return this->value - _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator-(ls::std::core::type::long_type _value) const
+long_type Long::operator-(long_type _value) const
 {
   return this->value - _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator/(const ls::std::boxing::Long &_long) const
+long_type Long::operator/(const Long &_long) const
 {
-  if (_long == (ls::std::core::type::long_type) 0)
+  if (_long == (long_type) 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   return this->value / _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator/(ls::std::core::type::long_type _value) const
+long_type Long::operator/(long_type _value) const
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   return this->value / _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator%(const ls::std::boxing::Long &_long) const
+long_type Long::operator%(const Long &_long) const
 {
   return this->value % _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator%(ls::std::core::type::long_type _value) const
+long_type Long::operator%(long_type _value) const
 {
   return this->value % _value;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator+=(const ls::std::boxing::Long &_long)
+Long &Long::operator+=(const Long &_long)
 {
   this->value += _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator+=(ls::std::core::type::long_type _value)
+Long &Long::operator+=(long_type _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator-=(const ls::std::boxing::Long &_long)
+Long &Long::operator-=(const Long &_long)
 {
   this->value -= _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator-=(ls::std::core::type::long_type _value)
+Long &Long::operator-=(long_type _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator*=(const ls::std::boxing::Long &_long)
+Long &Long::operator*=(const Long &_long)
 {
   this->value *= _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator*=(ls::std::core::type::long_type _value)
+Long &Long::operator*=(long_type _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator/=(const ls::std::boxing::Long &_long)
+Long &Long::operator/=(const Long &_long)
 {
-  if (_long == (ls::std::core::type::long_type) 0)
+  if (_long == (long_type) 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   this->value /= _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator/=(ls::std::core::type::long_type _value)
+Long &Long::operator/=(long_type _value)
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Long::operator==(const ls::std::boxing::Long &_long) const
+bool Long::operator==(const Long &_long) const
 {
   return this->value == _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator==(ls::std::core::type::long_type _value) const
+bool Long::operator==(long_type _value) const
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::Long::operator!=(const ls::std::boxing::Long &_long) const
+bool Long::operator!=(const Long &_long) const
 {
   return this->value != _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator!=(ls::std::core::type::long_type _value) const
+bool Long::operator!=(long_type _value) const
 {
   return this->value != _value;
 }
 
-bool ls::std::boxing::Long::operator>(const ls::std::boxing::Long &_long) const
+bool Long::operator>(const Long &_long) const
 {
   return this->value > _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator>(ls::std::core::type::long_type _value) const
+bool Long::operator>(long_type _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Long::operator>=(const ls::std::boxing::Long &_long) const
+bool Long::operator>=(const Long &_long) const
 {
   return this->value >= _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator>=(ls::std::core::type::long_type _value) const
+bool Long::operator>=(long_type _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Long::operator<(const ls::std::boxing::Long &_long) const
+bool Long::operator<(const Long &_long) const
 {
   return this->value < _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator<(ls::std::core::type::long_type _value) const
+bool Long::operator<(long_type _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Long::operator<=(const ls::std::boxing::Long &_long) const
+bool Long::operator<=(const Long &_long) const
 {
   return this->value <= _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator<=(ls::std::core::type::long_type _value) const
+bool Long::operator<=(long_type _value) const
 {
   return this->value <= _value;
 }
 
-bool ls::std::boxing::Long::operator&&(const ls::std::boxing::Long &_long) const
+bool Long::operator&&(const Long &_long) const
 {
   return this->value && _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator&&(ls::std::core::type::long_type _value) const
+bool Long::operator&&(long_type _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Long::operator&&(bool _expression) const
+bool Long::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls::std::boxing::Long::operator||(const ls::std::boxing::Long &_long) const
+bool Long::operator||(const Long &_long) const
 {
   return this->value || _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator||(ls::std::core::type::long_type _value) const
+bool Long::operator||(long_type _value) const
 {
   return this->value || _value;
 }
 
-bool ls::std::boxing::Long::operator||(bool _expression) const
+bool Long::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls::std::boxing::Long::operator++()
+void Long::operator++()
 {
   this->value += 1;
 }
 
-void ls::std::boxing::Long::operator--()
+void Long::operator--()
 {
   this->value -= 1;
 }
 
-void ls::std::boxing::Long::parse(::std::string _parseText)
+void Long::parse(string _parseText)
 {
-  this->value = ::std::stoll(_parseText);
+  this->value = stoll(_parseText);
 }
 
-std::string ls::std::boxing::Long::toString()
+string Long::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::getValue() const
+long_type Long::getValue() const
 {
   return this->value;
 }

source/ls-std/boxing/String.cpp

@@ -3,184 +3,198 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <algorithm>
 #include <ls-std/boxing/String.hpp>
 
-ls::std::boxing::String::String() : ls::std::core::Class("String")
-{}
+using ls::std::boxing::String;
+using ls::std::core::Class;
+using ls::std::core::type::byte;
+using std::move;
+using std::reverse;
+using std::string;
+using std::transform;
+using std::vector;
 
-ls::std::boxing::String::String(::std::string _value) : ls::std::core::Class("String"), value(::std::move(_value))
+String::String() : Class("String")
 {}
 
-ls::std::boxing::String::~String() noexcept = default;
+String::String(string _value) : String()
+{
+  this->value = ::move(_value);
+}
+
+String::~String() noexcept = default;
 
-ls::std::boxing::String &ls::std::boxing::String::operator=(::std::string _value)
+String &String::operator=(string _value)
 {
-  this->value = ::std::move(_value);
+  this->value = ::move(_value);
   return *this;
 }
 
-::std::string ls::std::boxing::String::operator+(ls::std::boxing::String _string) const
+string String::operator+(String _string) const
 {
   return this->value + _string.toString();
 }
 
-::std::string ls::std::boxing::String::operator+(const ::std::string &_string) const
+string String::operator+(const string &_string) const
 {
   return this->value + _string;
 }
 
-::std::string ls::std::boxing::String::operator+(const char *_string) const
+string String::operator+(const char *_string) const
 {
   return this->value + _string;
 }
 
-::std::string ls::std::boxing::String::operator-(int _number)
+string String::operator-(int _number)
 {
-  ::std::string copy = this->value;
+  string copy = this->value;
   return copy.substr(0, copy.size() - _number);
 }
 
-ls::std::boxing::String &ls::std::boxing::String::operator+=(ls::std::boxing::String _string)
+String &String::operator+=(String _string)
 {
   this->value = this->value + _string.toString();
   return *this;
 }
 
-ls::std::boxing::String &ls::std::boxing::String::operator+=(const ::std::string &_text)
+String &String::operator+=(const string &_text)
 {
   this->value = this->value + _text;
   return *this;
 }
 
-bool ls::std::boxing::String::operator==(ls::std::boxing::String _string)
+bool String::operator==(String _string)
 {
   return this->value == _string.toString();
 }
 
-bool ls::std::boxing::String::operator==(const ::std::string &_value)
+bool String::operator==(const string &_value)
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::String::operator==(const char *_value)
+bool String::operator==(const char *_value)
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::String::operator!=(ls::std::boxing::String _string)
+bool String::operator!=(String _string)
 {
   return this->value != _string.toString();
 }
 
-bool ls::std::boxing::String::operator!=(const ::std::string &_value)
+bool String::operator!=(const string &_value)
 {
   return this->value != _value;
 }
 
-bool ls::std::boxing::String::operator!=(const char *_value)
+bool String::operator!=(const char *_value)
 {
   return this->value != _value;
 }
 
-void ls::std::boxing::String::parse(::std::string _parseText)
+void String::parse(string _parseText)
 {
-  this->value = ::std::move(_parseText);
+  this->value = ::move(_parseText);
 }
 
-::std::string ls::std::boxing::String::toString()
+string String::toString()
 {
   return this->value;
 }
 
-bool ls::std::boxing::String::contains(const ::std::string &_text)
+bool String::contains(const string &_text)
 {
-  return this->value.find(_text) != ::std::string::npos;
+  return this->value.find(_text) != string::npos;
 }
 
-bool ls::std::boxing::String::endsWith(const ::std::string &_text)
+bool String::endsWith(const string &_text)
 {
   return this->value.rfind(_text) == (this->value.size() - _text.size());
 }
 
-bool ls::std::boxing::String::equalsIgnoreCase(ls::std::boxing::String _string)
+bool String::equalsIgnoreCase(String _string)
 {
   return this->toLowerCase() == _string.toLowerCase();
 }
 
-bool ls::std::boxing::String::equalsIgnoreCase(::std::string _text)
+bool String::equalsIgnoreCase(string _text)
 {
-  return this->toLowerCase() == ls::std::boxing::String{::std::move(_text)}.toLowerCase();
+  return this->toLowerCase() == String{::move(_text)}.toLowerCase();
 }
 
-::std::vector<ls::std::core::type::byte> ls::std::boxing::String::getByteData()
+vector<byte> String::getByteData()
 {
-  ::std::vector<ls::std::core::type::byte> byteData(this->value.begin(), this->value.end());
+  vector<byte> byteData(this->value.begin(), this->value.end());
   byteData.push_back('\0');
 
   return byteData;
 }
 
-::std::string ls::std::boxing::String::padLeft(size_t _width, const char _fillCharacter)
+string String::padLeft(size_t _width, const char _fillCharacter)
 {
-  return ls::std::boxing::String::_createFillContent(this->value, _width, _fillCharacter) + this->value;
+  return String::_createFillContent(this->value, _width, _fillCharacter) + this->value;
 }
 
-::std::string ls::std::boxing::String::padRight(size_t _width, const char _fillCharacter)
+string String::padRight(size_t _width, const char _fillCharacter)
 {
-  return this->value + ls::std::boxing::String::_createFillContent(this->value, _width, _fillCharacter);
+  return this->value + String::_createFillContent(this->value, _width, _fillCharacter);
 }
 
-::std::string ls::std::boxing::String::reverse()
+string String::reverse()
 {
-  ::std::string copy = this->value;
-  ::std::reverse(copy.begin(), copy.end());
+  string copy = this->value;
+  ::reverse(copy.begin(), copy.end());
 
   return copy;
 }
 
-bool ls::std::boxing::String::startsWith(const ::std::string &_text)
+bool String::startsWith(const string &_text)
 {
   return this->value.rfind(_text, 0) == 0;
 }
 
-::std::string ls::std::boxing::String::toLowerCase()
+string String::toLowerCase()
 {
-  ::std::string copy = this->value;
-  ::std::transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
+  string copy = this->value;
+  transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
 
   return copy;
 }
 
-::std::string ls::std::boxing::String::toUpperCase()
+string String::toUpperCase()
 {
-  ::std::string copy = this->value;
-  ::std::transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
+  string copy = this->value;
+  transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
 
   return copy;
 }
 
-::std::string ls::std::boxing::String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
+string String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
 {
-  ::std::string fillContent{};
+  string fillContent{};
 
-  for (size_t iteration{}; iteration < _amount; iteration++) { fillContent += _fillCharacter; }
+  for (size_t iteration{}; iteration < _amount; iteration++)
+  {
+    fillContent += _fillCharacter;
+  }
 
   return fillContent;
 }
 
-::std::string ls::std::boxing::String::_createFillContent(const ::std::string &_text, size_t _width, const char _fillCharacter)
+string String::_createFillContent(const string &_text, size_t _width, const char _fillCharacter)
 {
   size_t fillSize = _text.size() > _width ? 0 : _width - _text.size();
-  ::std::string fillContent{};
+  string fillContent{};
 
   if (fillSize > 0)
   {
-    fillContent = ls::std::boxing::String::_buildCharacterChain(fillSize, _fillCharacter);
+    fillContent = String::_buildCharacterChain(fillSize, _fillCharacter);
   }
 
   return fillContent;