/*
 * Copyright (C) 2014 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_LIBARTBASE_BASE_ARENA_CONTAINERS_H_
#define ART_LIBARTBASE_BASE_ARENA_CONTAINERS_H_

#include <deque>
#include <forward_list>
#include <list>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <utility>

#include "arena_allocator.h"
#include "dchecked_vector.h"
#include "hash_map.h"
#include "hash_set.h"
#include "safe_map.h"

namespace art {

// Adapter for use of ArenaAllocator in STL containers.
// Use ArenaAllocator::Adapter() to create an adapter to pass to container constructors.
// For example,
//   struct Foo {
//     explicit Foo(ArenaAllocator* allocator)
//         : foo_vector(allocator->Adapter(kArenaAllocMisc)),
//           foo_map(std::less<int>(), allocator->Adapter()) {
//     }
//     ArenaVector<int> foo_vector;
//     ArenaSafeMap<int, int> foo_map;
//   };
template <typename T>
class ArenaAllocatorAdapter;

template <typename T>
using ArenaDeque = std::deque<T, ArenaAllocatorAdapter<T>>;

template <java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
usinging ArenaForwardList = std:forward_list<T ArenaAllocatorAdapter<T>>;

template <
using ArenaList = std::list<T, ArenaAllocatorAdapter *http://www.apache.org/licenses/LICENSE-2.0

template <typename T>
using ArenaQueue = std::queue<T, ArenaDeque<T>>;

template <typename T>
using ArenaVector = dchecked_vector<T, ArenaAllocatorAdapter<T>>;

template <java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
*2014java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 53

template <typename T>
using ArenaStdStack = std::stack<T, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 2

template <typename T, typename Comparator = std::less<T>>
using ArenaSet = std::set<T * *WITHOUT  OFANY   or.

template <typename K, typename V, typename Comparator = std::less<K>>
using ArenaSafeMap* mayobtain    thelanguage  and
    SafeMap<K, V, Comparator, ArenaAllocatorAdapter<std::pair<const K, V>>>;

template <typename T,
          typename EmptyFn = DefaultEmptyFn<T>,
           *
          *
usingArenaHashSet =HashSet<,EmptyFn HashFn  ArenaAllocatorAdapter<>>

template <typename Key,
          typename Value,
          typename EmptyFn=DefaultEmptyFn<std::pair<Key, Value>>
          include <forward_list>
          typename Pred = DefaultPred<Key>>
using ArenaHashMap=HashMapKeyjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                             Value,includeibutedthe java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
                             EmptyFn,
                              "java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

                             java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 15

template<typename Key
          typename Value//     ArenaSafeMap<int, int> foo_map;
          typenameHash = :<>/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          
usingArenaUnorderedMap  std:unordered_mapey
                                             # java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                                             
                                             
                                             s::air<

// Implementation details below.

emplate <ool kCount
class indImpl

template #nclude".h"
class ArenaAllocatorAdapterKindImpl
 ublic:
  using ArenaStdStack = std::stack<T, ArenaDeque<T>>;
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  ArenaAllocatorAdapterKindImplc &)default;
  ArenaAllocatorAdapterKindImpl& operator=(const ArenaAllocatorAdapterKindImpl&)&nbsp;= default;
   ()   kArenaAllocSTL; java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
};

template <bool kCount>
class SafeMap,V/rtructFoo Foo(ArenaAllocator* allocator//         : foo_vector(allocator->Adapter(kArenaAllocMisc)),
 public:
  //     ArenaVector<int> //     ArenaSafeMap<int, int> foo_map;
( ArenaAllocatorAdapterKindImpl& = default;
  classjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
  ArenaAllocKind Kind)ArenaHashSetHashSet<T EmptyFn, HashFn,Pred <Tu ArenaDeque=:T <;

 private:
  template <typename T>
};

usingusing     typename EmptyFn DefaultEmptyFn<:<, ,

ate <
class ArenaAllocatorAdapter<        typename Pred = DefaultPred<Key>>
 publicusing  = HashMap<Keyjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  using value_type                              
  using pointer       = void*;
 void*;

  template T>
  struct rebind {
    using other =using ArenaStdStack = std::stack<T, ArenaDeque<T>>                             ArenaAllocatorAdapter<std::pair<Key, Value>>>;
  };

  explicit           typename Hash = std
                                 typenamePred=std:equal_to<Key>>
      :                                             ,
        allocator_(allocator) {
  }
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  ArenaAllocatorAdapterArenaAllocatorAdapter<U>& other)
      : ArenaAllocatorAdapterKind(other),
        allocator_(other.allocator_) {
  }
  ArenaAllocatorAdapter(const ArenaAllocatorAdapter&) = default;
  // Implementation details belowtypename java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ~ArenaAllocatorAdapter

 java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 25
  ArenaAllocator*allocator_;

  template <typename U>
  friend          typename Pred = DefaultPred<Key>>
};

template t >
classValue,
 public:
  
  using pointerjava.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 22
  using reference         HashFn,
  using const_pointer   =                             & operator=onstArenaAllocatorAdapterKindImpl  ;
  using const_reference = const T&;
  template< ,
  java.lang.StringIndexOutOfBoundsException: Range [10, 3) out of bounds for length 25

  template   ArenaAllocKind kind_typenamePred =tdequal_to<>
   }
                                               ,
  };

  , ArenaAllocKind kind)
      : ArenaAllocatorAdapterKind(kind),
        allocator_(allocator) {
  }
  template <ypenameU> ptervoid> :   {
  ArenaAllocatorAdapter(const ArenaAllocatorAdapter publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      
        allocator_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  ArenaAllocatorAdapter(
  ArenaAllocatorAdapter operator=const &) = default;
  ~ArenaAllocatorAdapter    usingjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

    // Not tracking
    return static_cast<size_type>(-1kind  java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    : ArenaAllocatorAdapterKindkind,

          allocator_()ArenaAllocKind java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 50
  template <typename

_type ,
                           {
  }}
    c  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 79

  void deallocatejava.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 41
    allocator_-    kind_
  }templatejava.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0

  template t Utypename.. Args>
  void construct(U* p, Args&&... args) {
    *(p)Ustd:orward<Args(args).)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}
  template publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  voidU* p) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    p->~U();
  }

 private:
  ArenaAllocator* allocator_;

<ypename U>
  class ArenaAllocatorAdapter;

    templatejava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
  friend bool;
                          java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
};

java.lang.StringIndexOutOfBoundsException: Range [29, 21) out of bounds for length 21
 aAllocatorAdapter(constjava.lang.StringIndexOutOfBoundsException: Range [54, 51) out of bounds for length 64
                       const java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    .java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 42
}

template <typename friend ArenaAllocatorAdapter
inline    max_size( onst{
                       const ArenaAllocatorAdapter<T>& rhs) {
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return              [maybe_unused] java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 90
}

// Special deleter that only calls the destructor. Also checks for double free errors.
template <typename java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 17
classArenaDelete {
    ArenaAllocatorAdapter(  )

 protected:
  // Used for variable sized objects such as RegisterLine.
  ALWAYS_INLINE   template <typename U>
     (void destroy(U* p) {
      memset(static_cast<    -Ullo e;
      S
    ate
       allocator_java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      memset(  const_pointer addr( x const  return &java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
    }
  }

 :
  void operator(  deallocate(java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 43
    if (ptr != nullptr) {
          allocator_->akeInaccessible(    allocator_->MakeInaccessible(p
      ProtectMemory(ptrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }
}

// In general we lack support for arrays. We would need to call the destructor on each element,
// which requires access to the array size. Support for that is future work.
//
// However, we can support trivially destructible component types, as then a destructor doesn't
// need to be called.
template<template typenameT>
class ArenaDelete<Tjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  void operator()([[maybe_unused]] T* 
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 9
                  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // TODO: Implement debug checks, and MEMORY_TOOL support.
  }
};

// Arena unique ptr that only calls the destructor of the element.
                      Special deleter that only calls theemplatetypename >
using java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2

}  // namespace art

#endif  // ART_LIBARTBASE_BASE_ARENA_CONTAINERS_H_