Pointer.h

 
#ifndef MFRAME_D6412968_F88E_43C3_9B72_FA8611376187
#define MFRAME_D6412968_F88E_43C3_9B72_FA8611376187
 
/* ***************************************************************************************
 * Include
 */
#include "./../lang/Object.h"
#include "./../lang/Pointers.h"
 
/* ***************************************************************************************
 * Namespace
 */
namespace mframe::lang {
  class Pointer;
  class Memory;
}  // namespace mframe::lang
 
/* ***************************************************************************************
 * Class/struct/Struct
 */
 
class mframe::lang::Pointer : public mframe::lang::Object {
  friend Memory;
  /* *************************************************************************************
   * Variable
   */
 private:
  void* mPointer;
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 public:
  Pointer(void);
 
  Pointer(const void* pointer);
 
  Pointer(void* pointer);
 
  Pointer(uint32 pointer);
 
  Pointer(const Pointer& other);
 
  virtual ~Pointer(void) override;
 
  /* *************************************************************************************
   * Operator Method
   */
 public:
  inline operator void*(void) {
    return this->mPointer;
  }
 
  inline operator const char*(void) {
    return reinterpret_cast<const char*>(this->mPointer);
  }
 
  inline bool operator==(const void* pointer) {
    return (this->mPointer == pointer);
  }
 
  inline bool operator==(const Pointer& pointer) {
    return (this->mPointer == pointer.mPointer);
  }
 
  template <typename E>
  inline operator E*(void) {
    return static_cast<E*>(this->mPointer);
  }
 
  template <typename E>
  inline operator E*(void) const {
    return static_cast<E*>(this->mPointer);
  }
 
  /* *************************************************************************************
   * Public Method <Inline>
   */
 public:
  inline int copyTo(void* destination, int length) const {
    return this->copyTo(destination, 0, 0, length);
  }
 
  inline int copyTo(void* destination, int start, int length) const {
    return this->copyTo(destination, 0, start, length);
  }
 
  inline bool compairStrings(const char* str) const {
    return this->compairStrings(str, 0);
  }
 
  inline bool compairStrings(const char* str, int start) const {
    return this->compair(str, 0, start, static_cast<int>(Pointers::getStringLength(str)));
  }
 
  inline bool compair(const void* source, int length) const {
    return this->compair(source, 0, 0, length);
  }
 
  inline bool compair(const void* source, int start, int length) const {
    return this->compair(source, 0, start, length);
  }
 
  inline int indexOf(char ch, int start, int limit) const {
    return this->indexOfData(&ch, 1, start, limit);
  }
 
  inline int indexOfStrings(const char* str, int limit) const {
    return this->indexOfStrings(str, 0, limit);
  }
 
  inline int indexOfStrings(const char* str, int start, int limit) const {
    return this->indexOfData(str, static_cast<int>(Pointers::getStringLength(str)),
                             start, limit);
  }
 
  inline int copy(const void* source, int length) {
    return this->copy(source, 0, 0, length);
  }
 
  inline int copy(const void* source, int offset, int length) {
    return this->copy(source, offset, 0, length);
  }
 
  inline char getByte(int shift) const {
    const char* p = (*this);
    return p[shift];
  }
 
  inline int getInteger(int shift) const {
    const int* p = (*this);
    return p[shift];
  }
 
  inline short getShort(int shift) const {
    const short* p = (*this);
    return p[shift];
  }
 
  inline Pointer getPointer(int offset) const {
    return Pointer(&(static_cast<char*>(this->mPointer))[offset]);
  }
 
  inline uint32 getAddress(void) const {
    return reinterpret_cast<uint32>(this->mPointer);
  }
 
  inline bool isAlignment32Bit(void) {
    return ((this->getAddress() & 0x00000003) == 0);
  }
 
  inline bool isAlignment64Bit(void) {
    return ((this->getAddress() & 0x00000007) == 0);
  }
 
  inline bool isNull(void) const {
    return (this->mPointer == nullptr);
  }
 
  template <typename E = void*>
  inline E* pointer(void) const {
    return static_cast<E*>(this->mPointer);
  }
 
  template <typename E = void*>
  inline E* pointer(int offset) const {
    return reinterpret_cast<E*>(static_cast<char*>(this->mPointer) + offset);
  }
 
  template <typename E = void*>
  inline E* pointer(uint32 offset) const {
    return reinterpret_cast<E*>(static_cast<char*>(this->mPointer) + offset);
  }
 
  /* *************************************************************************************
   * Public Method
   */
 public:
  virtual int copy(const void* source, int offset, int sourceOffset, int length);
 
  virtual int copyTo(void* destination, int offset, int destinationOffset, int length) const;
 
  virtual bool compair(const void* source, int offset, int sourceOffset, int length) const;
 
  virtual int indexOfData(const void* destination, int destinationLen, int start = 0, int limit = 0) const;
 
  virtual void move(int head, int offset, int length);
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
};
 
#endif /* MFRAME_D6412968_F88E_43C3_9B72_FA8611376187 */