object.h

Go to the documentation of this file.

#ifndef __MEOWPP_UTILITY_OBJECT_H__
#define __MEOWPP_UTILITY_OBJECT_H__

#include <cstdlib>
#include <cstdint>

namespace meow {


class Object {
 protected:

  Object() {}
  
  Object(Object const& b);

 public:

  virtual ~Object() {}

  virtual Object* Copy() const {
    return NULL;
  }

  virtual Object* CopyFrom(Object const* ptr) {
    return NULL;
  }

  virtual bool Equals(Object const* ptr) const {
    return false;
  }
  
  Object& operator=(Object const& b);
};


template<typename DataType>
class BaseNumberType : public Object {
 private:
  DataType value_;
 public:
  BaseNumberType() : BaseNumberType(static_cast<DataType>(0)) {}
  BaseNumberType(BaseNumberType const& b) : BaseNumberType(b.value_) {}
  BaseNumberType(DataType const& arg_init_value) : value_(arg_init_value) {}
  ~BaseNumberType() {}
  Object* Copy() const { return new BaseNumberType(value_); }
  Object* CopyFrom(Object const* ptr) {
    value_ = static_cast<BaseNumberType const*>(ptr)->value_;
    return this;
  }
  bool Equals(Object const* ptr) const {
    return (value_ == static_cast<BaseNumberType const*>(ptr)->value_);
  }
  operator DataType() const { return value_; }
  BaseNumberType& operator=(DataType const& b) { value_ = b; return *this; }
  BaseNumberType& operator+=(DataType const& b) { value_ += b; return *this; }
  BaseNumberType& operator-=(DataType const& b) { value_ -= b; return *this; }
  BaseNumberType& operator*=(DataType const& b) { value_ *= b; return *this; }
  BaseNumberType& operator/=(DataType const& b) { value_ /= b; return *this; }
  BaseNumberType& operator&=(DataType const& b) { value_ &= b; return *this; }
  BaseNumberType& operator|=(DataType const& b) { value_ |= b; return *this; }
  BaseNumberType& operator^=(DataType const& b) { value_ ^= b; return *this; }
  BaseNumberType& operator<<=(int64_t const& b) { value_ <<= b; return *this; }
  BaseNumberType& operator>>=(int64_t const& b) { value_ >>= b; return *this; }
};


template<typename DataType>
class BaseFloatingType : public Object {
 private:
  DataType value_;
 public:
  BaseFloatingType() : BaseFloatingType(static_cast<DataType>(0)) {}
  BaseFloatingType(BaseFloatingType const& b) : BaseFloatingType(b.value_) {}
  BaseFloatingType(DataType const& arg_init_value) : value_(arg_init_value) {}
  ~BaseFloatingType() {}
  Object* Copy() const { return new BaseFloatingType(value_); }
  Object* CopyFrom(Object const* ptr) {
    value_ = static_cast<BaseFloatingType const*>(ptr)->value_;
    return this;
  }
  bool Equals(Object const* ptr) const {
    return (value_ == static_cast<BaseFloatingType const*>(ptr)->value_);
  }
  operator DataType() const { return value_; }
  BaseFloatingType& operator=(DataType const& b) { value_ = b; return *this; }
  BaseFloatingType& operator+=(DataType const& b) { value_ += b; return *this; }
  BaseFloatingType& operator-=(DataType const& b) { value_ -= b; return *this; }
  BaseFloatingType& operator*=(DataType const& b) { value_ *= b; return *this; }
  BaseFloatingType& operator/=(DataType const& b) { value_ /= b; return *this; }
};


typedef BaseNumberType<int8_t> Int8;  
typedef BaseNumberType<int16_t> Int16;  
typedef BaseNumberType<int32_t> Int32;  
typedef BaseNumberType<int64_t> Int64;  

typedef BaseNumberType<uint8_t> UInt8;  
typedef BaseNumberType<uint16_t> UInt16;  
typedef BaseNumberType<uint32_t> UInt32;  
typedef BaseNumberType<uint64_t> UInt64;  

typedef BaseFloatingType<float> Float;  
typedef BaseFloatingType<double> Double;  
typedef BaseFloatingType<long double> LDouble;  

}  // meow

#endif  // __MEOWPP_UTILITY_OBJECT_H__