/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef ART_RUNTIME_LAMBDA_BOX_CLASS_TABLE_H_
#define ART_RUNTIME_LAMBDA_BOX_CLASS_TABLE_H_

#include "base/allocator.h"
#include "base/hash_map.h"
#include "gc_root.h"
#include "base/macros.h"
#include "base/mutex.h"
#include "object_callbacks.h"

#include <stdint.h>

namespace art {

class ArtMethod;  // forward declaration
template<class T> class Handle;  // forward declaration

namespace mirror {
class Class;  // forward declaration
class ClassLoader;  // forward declaration
class LambdaProxy;  // forward declaration
class Object;  // forward declaration
}  // namespace mirror

namespace lambda {
struct Closure;  // forward declaration

/*
 * Store a table of boxed lambdas. This is required to maintain object referential equality
 * when a lambda is re-boxed.
 *
 * Conceptually, we store a mapping of Class Name -> Weak Reference<Class>.
 * When too many objects get GCd, we shrink the underlying table to use less space.
 */
class BoxClassTable FINAL {
 public:
  // TODO: This should take a LambdaArtMethod instead, read class name from that.
  // Note: null class_loader means bootclasspath.
  mirror::Class* GetOrCreateBoxClass(const char* class_name,
                                     const Handle<mirror::ClassLoader>& class_loader)
      REQUIRES(!Locks::lambda_class_table_lock_, !Roles::uninterruptible_)
      SHARED_REQUIRES(Locks::mutator_lock_);

  // Sweep strong references to lambda class boxes. Update the addresses if the objects
  // have been moved, and delete them from the table if the objects have been cleaned up.
  template <typename Visitor>
  void VisitRoots(const Visitor& visitor)
      NO_THREAD_SAFETY_ANALYSIS  // for object marking requiring heap bitmap lock
      REQUIRES(!Locks::lambda_class_table_lock_)
      SHARED_REQUIRES(Locks::mutator_lock_);

  BoxClassTable();
  ~BoxClassTable();

 private:
  // We only store strong GC roots in our table.
  using ValueType = GcRoot<mirror::Class>;

  // Attempt to look up the class in the map, or return null if it's not there yet.
  ValueType FindBoxedClass(const std::string& class_name) const
      SHARED_REQUIRES(Locks::lambda_class_table_lock_);

  // Store the key as a string so that we can have our own copy of the class name.
  using UnorderedMapKeyType = std::string;

  // EmptyFn implementation for art::HashMap
  struct EmptyFn {
    void MakeEmpty(std::pair<UnorderedMapKeyType, ValueType>& item) const
        NO_THREAD_SAFETY_ANALYSIS;
        // SHARED_REQUIRES(Locks::mutator_lock_);

    bool IsEmpty(const std::pair<UnorderedMapKeyType, ValueType>& item) const;
  };

  // HashFn implementation for art::HashMap
  struct HashFn {
    size_t operator()(const UnorderedMapKeyType& key) const
        NO_THREAD_SAFETY_ANALYSIS;
        // SHARED_REQUIRES(Locks::mutator_lock_);
  };

  // EqualsFn implementation for art::HashMap
  struct EqualsFn {
    bool operator()(const UnorderedMapKeyType& lhs, const UnorderedMapKeyType& rhs) const
        NO_THREAD_SAFETY_ANALYSIS;
        // SHARED_REQUIRES(Locks::mutator_lock_);
  };

  using UnorderedMap = art::HashMap<UnorderedMapKeyType,
                                    ValueType,
                                    EmptyFn,
                                    HashFn,
                                    EqualsFn,
                                    TrackingAllocator<std::pair<UnorderedMapKeyType, ValueType>,
                                                      kAllocatorTagLambdaProxyClassBoxTable>>;

  // Map of strong GC roots (lambda interface name -> lambda proxy class)
  UnorderedMap map_ GUARDED_BY(Locks::lambda_class_table_lock_);

  // Shrink the map when we get below this load factor.
  // (This is an arbitrary value that should be large enough to prevent aggressive map erases
  // from shrinking the table too often.)
  static constexpr double kMinimumLoadFactor = UnorderedMap::kDefaultMinLoadFactor / 2;

  DISALLOW_COPY_AND_ASSIGN(BoxClassTable);
};

}  // namespace lambda
}  // namespace art

#endif  // ART_RUNTIME_LAMBDA_BOX_CLASS_TABLE_H_