ArrayMap.h

 
#ifndef MFRAME_B20AC9B6_95F9_498A_80A8_01F0884D207D
#define MFRAME_B20AC9B6_95F9_498A_80A8_01F0884D207D
 
/* ***************************************************************************************
 * Include
 */
 
//----------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------
#include "./../lang/Memory.h"
#include "./../util/Iterator.h"
#include "./../util/Map.h"
#include "./../util/PArray.h"
 
/* ***************************************************************************************
 * Namespace
 */
namespace mframe::util {
  class ArrayMap;
}
 
/* ***************************************************************************************
 * Class/Interface/Struct/Enum
 */
class mframe::util::ArrayMap : public mframe::lang::Object,
                               public mframe::util::Map<> {
  /* *************************************************************************************
   * SubClass
   */
 private:
  struct Block {
    int   vKey;
    void* vValue;
  };
 
 public:
  class Entry : public mframe::lang::Object,
                public mframe::util::MapEntry<> {
    /* ***********************************************************************************
     * Variable
     */
    friend ArrayMap;
 
   private:
    ArrayMap::Block& vBlock;
 
    /* ***********************************************************************************
     * Abstract Method
     */
 
    /* ***********************************************************************************
     * Construct Method
     */
   public:
    Entry(ArrayMap::Block& block);
 
    virtual ~Entry(void) override;
    /* ***********************************************************************************
     * Operator Method
     */
   public:
    template <typename T>
    inline operator const MapEntry<T>&(void) const {
      const MapEntry<>* src = this;
      return *reinterpret_cast<const MapEntry<T>*>(src);
    }
 
    template <typename T>
    inline operator MapEntry<T>&(void) {
      MapEntry<>* src = this;
      return *reinterpret_cast<MapEntry<T>*>(src);
    }
 
    /* ***********************************************************************************
     * Public Method <Override>
     */
   public:
    virtual int getKey(void) override;
 
    virtual void* getValue(void) override;
 
    virtual void* setValue(void* value) override;
 
    virtual void remove(void) override;
 
    /* ***********************************************************************************
     * Public Method
     */
 
    /* ***********************************************************************************
     * Protected Method
     */
 
    /* ***********************************************************************************
     * Private Method
     */
   private:
    void setBlock(ArrayMap::Block& block);
 
    /* ***********************************************************************************
     * Static Variable
     */
 
    /* ***********************************************************************************
     * Static Method
     */
  };
  class Iterator : public mframe::lang::Object,
                   public mframe::util::Iterator<mframe::util::MapEntry<>> {
    /* ***********************************************************************************
     * Variable
     */
   private:
    ArrayMap&       vArrayMap;
    ArrayMap::Entry vEntry;
    int             vIndex;
    /* ***********************************************************************************
     * Abstract Method
     */
 
    /* ***********************************************************************************
     * Construct Method
     */
   public:
    Iterator(ArrayMap& arrayMap);
 
    virtual ~Iterator(void) override;
    /* ***********************************************************************************
     * Operator Method
     */
   public:
    template <typename V>
    inline operator const mframe::util::Iterator<mframe::util::MapEntry<V>>&(void) const {
      const mframe::util::Iterator<mframe::util::MapEntry<>>* src = this;
      return *reinterpret_cast<const mframe::util::Iterator<mframe::util::MapEntry<V>>*>(src);
    }
 
    template <typename V>
    inline operator mframe::util::Iterator<mframe::util::MapEntry<V>>&(void) {
      mframe::util::Iterator<mframe::util::MapEntry<>>* src = this;
      return *reinterpret_cast<mframe::util::Iterator<mframe::util::MapEntry<V>>*>(src);
    }
 
    /* ***********************************************************************************
     * Public Method <Override> - mframe::util::Iterator<>
     */
   public:
    virtual bool hasNext(void) override;
 
    virtual mframe::util::MapEntry<>* next(void) override;
 
    virtual void reset(void) override;
    /* ***********************************************************************************
     * Public Method
     */
 
    /* ***********************************************************************************
     * Protected Method
     */
 
    /* ***********************************************************************************
     * Private Method
     */
 
    /* ***********************************************************************************
     * Static Variable
     */
 
    /* ***********************************************************************************
     * Static Method
     */
  };
  /* *************************************************************************************
   * Variable
   */
 private:
  mframe::util::PArray vPArray;
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 public:
  ArrayMap(int size);
 
  ArrayMap(const mframe::lang::Memory& other);
 
  virtual ~ArrayMap(void) override;
 
  /* *************************************************************************************
   * Operator Method
   */
 public:
  template <typename T>
  inline operator const mframe::util::Map<T>&(void) const {
    const mframe::util::Map<>* src = this;
    return *reinterpret_cast<const mframe::util::Map<T>*>(src);
  }
 
  template <typename T>
  inline operator mframe::util::Map<T>&(void) {
    mframe::util::Map<>* src = this;
    return *reinterpret_cast<mframe::util::Map<T>*>(src);
  }
 
  /* *************************************************************************************
   * Public Method <Override> - mframe::util::Map<>
   */
 public:
  virtual bool containsKey(Interface& key) const override;
 
  virtual bool containsValue(void* value) const override;
 
  virtual void* get(Interface& key) const override;
 
  virtual void* put(Interface& key, void* value) override;
 
  virtual void* remove(Interface& key) override;
 
  virtual void* replace(Interface& key, void* value) override;
 
  /* *************************************************************************************
   * Public Method <Override> - mframe::util::Collection<mframe::util::MapSet<void>>
   */
 public:
  virtual void clear(void) override;
 
  virtual bool isEmpty(void) const override;
 
  virtual int size(void) const override;
 
  /* *************************************************************************************
   * Public Method <Override> - mframe::util::Collection<mframe::util::MapSet<void>>
   */
  virtual void forEach(mframe::func::Consumer<mframe::util::MapEntry<void>&>& action) override;
 
  /* *************************************************************************************
   * Public Method
   */
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
};
 
#endif /* MFRAME_B20AC9B6_95F9_498A_80A8_01F0884D207D */