/*
 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_GC_SHARED_OOPSTORAGESET_HPP
#define SHARE_GC_SHARED_OOPSTORAGESET_HPP

#include "memory/allocation.hpp"
#include "utilities/debug.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"

class OopStorage;

class OopStorageSet : public AllStatic {
private:
  friend void oopstorage_init();

  enum {
    singular_index,             // For singular iterator.

    all_start,

    // Strong
    strong_start = all_start,
    jni_global_index = strong_start,
    vm_global_index,
    strong_end,

    // Weak
    weak_start = strong_end,
    jni_weak_index = weak_start,
    vm_weak_index,
    string_table_weak_index,
    resolved_method_table_weak_index,
    weak_end,

    all_end = weak_end
  };

  static OopStorage* storages[all_end];

  static void verify_initialized(uint index) NOT_DEBUG_RETURN;

  static OopStorage* storage(uint index) {
    verify_initialized(index);
    return storages[index];
  }

  static void initialize();

public:
  class Iterator;

  static const uint strong_count = (strong_end - strong_start);
  static const uint weak_count = (weak_end - weak_start);
  static const uint all_count = (all_end - all_start);

  static Iterator strong_iterator();
  static Iterator weak_iterator();
  static Iterator all_iterator();

  // Strong
  static OopStorage* jni_global() { return storage(jni_global_index); }
  static OopStorage* vm_global()  { return storage(vm_global_index); }

  // Weak
  static OopStorage* jni_weak()   { return storage(jni_weak_index); }
  static OopStorage* vm_weak()    { return storage(vm_weak_index); }

  static OopStorage* string_table_weak() {
    return storage(string_table_weak_index);
  }

  static OopStorage* resolved_method_table_weak() {
    return storage(resolved_method_table_weak_index);
  }
};

class OopStorageSet::Iterator {
  friend class OopStorageSet;

  enum Category { singular, strong, weak, all };

  uint _index;
  uint _limit;
  DEBUG_ONLY(Category _category;)

  Iterator(uint index, uint limit, Category category) :
    _index(index), _limit(limit) DEBUG_ONLY(COMMA _category(category)) {}

  void verify_nonsingular() const NOT_DEBUG_RETURN;
  void verify_category_match(const Iterator& other) const NOT_DEBUG_RETURN;
  void verify_dereferenceable() const NOT_DEBUG_RETURN;

public:
  // Construct a singular iterator for later assignment.  The only valid
  // operations are destruction and assignment.
  Iterator() :
    _index(singular_index),
    _limit(singular_index)
    DEBUG_ONLY(COMMA _category(singular)) {}

  bool is_end() const {
    verify_nonsingular();
    return _index == _limit;
  }

  bool operator==(const Iterator& other) const {
    verify_category_match(other);
    return _index == other._index;
  }

  bool operator!=(const Iterator& other) const {
    return !operator==(other);
  }

  OopStorage* operator*() const {
    verify_dereferenceable();
    return storage(_index);
  }

  OopStorage* operator->() const {
    return operator*();
  }

  Iterator& operator++() {
    verify_dereferenceable();
    ++_index;
    return *this;
  }

  Iterator operator++(int) {
    Iterator result = *this;
    operator++();
    return result;
  }

  Iterator begin() const {
    verify_nonsingular();
    return *this;
  }

  Iterator end() const {
    verify_nonsingular();
    Iterator result = *this;
    result._index = _limit;
    return result;
  }
};

inline OopStorageSet::Iterator OopStorageSet::strong_iterator() {
  return Iterator(strong_start, strong_end, Iterator::strong);
}

inline OopStorageSet::Iterator OopStorageSet::weak_iterator() {
  return Iterator(weak_start, weak_end, Iterator::weak);
}

inline OopStorageSet::Iterator OopStorageSet::all_iterator() {
  return Iterator(all_start, all_end, Iterator::all);
}

#endif // SHARE_GC_SHARED_OOPSTORAGESET_HPP