StateOfKey.h

Go to the documentation of this file.

 
//
// Created by tony on 02/12/22.
//
 
#ifndef INTELLISTREAM_STATEOFKEY_H
#define INTELLISTREAM_STATEOFKEY_H
#include <stdint.h>
#include <string>
#include <memory>
#include <Common/Tuples.h>
#include <vector>
namespace OoOJoin {
 
class AbstractStateOfKey {
 public:
  AbstractStateOfKey() {
 
  }
  ~AbstractStateOfKey() {}
  keyType key = 0;
};
typedef std::shared_ptr<class AbstractStateOfKey> AbstractStateOfKeyPtr;
class StateOfKeyBucket;
typedef std::shared_ptr<class StateOfKeyBucket> StateOfKeyBucketPtr;
class StateOfKeyBucket {
 private:
  std::mutex m_mut;
  //vector<NPJTuplePtr>tuples;
  size_t bucketSize;
  class StateOfKeyBucket_Iterator {
   private:
    AbstractStateOfKeyPtr cellPtr = nullptr;
    StateOfKeyBucket *bucketPtr = nullptr;
    size_t bucketPos = 0;
   public:
    StateOfKeyBucket_Iterator(AbstractStateOfKeyPtr cp = nullptr, StateOfKeyBucket *bp = nullptr, size_t bkpos = 0)
        : cellPtr(cp), bucketPtr(bp), bucketPos(bkpos) {}
    AbstractStateOfKeyPtr operator*() const {
      return cellPtr;
    }
 
    AbstractStateOfKeyPtr first() {
      return cellPtr;
    }
    StateOfKeyBucket *second() {
      return bucketPtr;
    }
    StateOfKeyBucket *operator->() const {
      return bucketPtr;
    }
 
    bool operator==(const StateOfKeyBucket_Iterator &t) const {
      return t.cellPtr == this->cellPtr;
    }
 
    bool operator!=(const StateOfKeyBucket_Iterator &t) const {
      return t.cellPtr != this->cellPtr;
    }
    StateOfKeyBucket_Iterator &operator++() {
      bucketPos++;
      if (bucketPos == bucketPtr->count) {
        bucketPtr = bucketPtr->next.get();
        bucketPos = 0;
      }
      if (bucketPtr) {
        cellPtr = bucketPtr->cells[bucketPos];
      } else {
        cellPtr = nullptr;
      }
      return *this;
    }
    /*StateOfKeyBucket_Iterator operator++(int) {
        AbstractStateOfKeyPtr tempCell=cellPtr;
        StateOfKeyBucket *tempBucket=bucketPtr;
        size_t tempPos=bucketPos;
        bucketPos++;
        if(bucketPos==bucketPtr->count){
            bucketPtr=bucketPtr->next.get();
            bucketPos=0;
        }
        if(bucketPtr) {
           cellPtr=bucketPtr->cells[bucketPos];
        } else {
            cellPtr= nullptr;
        }
 
        return StateOfKeyBucket_Iterator(tempCell,tempBucket,tempPos);
    }*/
  };
 public:
  typedef StateOfKeyBucket_Iterator iterator;
  size_t count = 0;
  std::vector<AbstractStateOfKeyPtr> cells;
  StateOfKeyBucketPtr next = nullptr;
  void setCellCount(size_t cnt) {
    cells = std::vector<AbstractStateOfKeyPtr>(cnt);
    bucketSize = cnt;
  }
  void lock() {
    while (!m_mut.try_lock());
  }
  void unlock() {
    m_mut.unlock();
  }
  void insert(AbstractStateOfKeyPtr ask);
  AbstractStateOfKeyPtr getByKey(keyType probeKey);
  iterator begin() {
    return StateOfKeyBucket_Iterator(cells[0], this, 0);
  }
 
  //返回链表尾部指针
  iterator end() {
    return StateOfKeyBucket_Iterator(nullptr, this, 0);
  }
  /*MtBucketPtr getNext(){
    return next;
  }*/
};
class StateOfKeyHashTable {
 private:
 
 public:
  keyType hash_mask;
  keyType skip_bits;
  std::vector<StateOfKeyBucket> buckets;
  StateOfKeyHashTable() {}
  StateOfKeyHashTable(size_t bks, size_t cells = 4);
  ~StateOfKeyHashTable() {}
  void insert(AbstractStateOfKeyPtr ask);
  void insertSafe(AbstractStateOfKeyPtr ask);
  AbstractStateOfKeyPtr getByKey(keyType probeKey);
 
};
typedef std::shared_ptr<StateOfKeyHashTable> StateOfKeyHashTablePtr;
#define  newStateOfKeyHashTable std::make_shared<OoOJoin::StateOfKeyHashTable>
#define ImproveStateOfKeyTo(n, ru) std::static_pointer_cast<n>(ru)
 
}
#endif //INTELLISTREAM_STATEOFKEY_H