text:
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_CONTAINER_FLAT_MAP_HPP
#define BOOST_CONTAINER_FLAT_MAP_HPP

#if (defined _MSC_VER) && (_MSC_VER >= 1200)
#  pragma once
#endif

#include <boost/container/detail/config_begin.hpp>
#include <boost/container/detail/workaround.hpp>

#include <boost/container/container_fwd.hpp>
#include <utility>
#include <functional>
#include <memory>
#include <stdexcept>
#include <boost/container/detail/flat_tree.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/container/allocator_traits.hpp>
#include <boost/move/move.hpp>

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
namespace container {
#else
namespace boost {
namespace container {
#endif

/// @cond
// Forward declarations of operators == and <, needed for friend declarations.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
template <class Key, class T, class Pred = std::less< std::pair< Key, T> >, class A = std::allocator<T> >
#else
template <class Key, class T, class Pred, class A>
#endif
class flat_map;

template <class Key, class T, class Pred, class A>
inline bool operator==(const flat_map<Key,T,Pred,A>& x,
                       const flat_map<Key,T,Pred,A>& y);

template <class Key, class T, class Pred, class A>
inline bool operator<(const flat_map<Key,T,Pred,A>& x,
                      const flat_map<Key,T,Pred,A>& y);

namespace container_detail{

template<class D, class S>
static D &force(const S &s)
{  return *const_cast<D*>((reinterpret_cast<const D*>(&s))); }

template<class D, class S>
static D force_copy(S s)
{
   D *vp = reinterpret_cast<D *>(&s);
   return D(*vp);
}

}  //namespace container_detail{

/// @endcond

//! A flat_map is a kind of associative container that supports unique keys (contains at
//! most one of each key value) and provides for fast retrieval of values of another
//! type T based on the keys. The flat_map class supports random-access iterators.
//!
//! A flat_map satisfies all of the requirements of a container and of a reversible
//! container and of an associative container. A flat_map also provides
//! most operations described for unique keys. For a
//! flat_map<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
//! (unlike std::map<Key, T> which value_type is std::pair<const Key, T>).
//!
//! Pred is the ordering function for Keys (e.g. std::less<Key>).
//!
//! A is the allocator to allocate the value_types
//! (e.g. allocator< std::pair<Key, T> >).
//!
//! flat_map is similar to std::map but it's implemented like an ordered vector.
//! This means that inserting a new element into a flat_map invalidates
//! previous iterators and references
//!
//! Erasing an element of a flat_map invalidates iterators and references
//! pointing to elements that come after (their keys are bigger) the erased element.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
template <class Key, class T, class Pred = std::less< std::pair< Key, T> >, class A = std::allocator<T> >
#else
template <class Key, class T, class Pred, class A>
#endif
class flat_map
{
   /// @cond
   private:
   BOOST_COPYABLE_AND_MOVABLE(flat_map)
   //This is the tree that we should store if pair was movable
   typedef container_detail::flat_tree<Key,
                           std::pair<Key, T>,
                           container_detail::select1st< std::pair<Key, T> >,
                           Pred,
                           A> tree_t;

   //This is the real tree stored here. It's based on a movable pair
   typedef container_detail::flat_tree<Key,
                           container_detail::pair<Key, T>,
                           container_detail::select1st<container_detail::pair<Key, T> >,
                           Pred,
                           typename allocator_traits::template portable_rebind_alloc
                              <container_detail::pair<Key, T> >::type> impl_tree_t;
   impl_tree_t m_flat_tree;  // flat tree representing flat_map

   typedef typename impl_tree_t::value_type              impl_value_type;
   typedef typename impl_tree_t::pointer                 impl_pointer;
   typedef typename impl_tree_t::const_pointer           impl_const_pointer;
   typedef typename impl_tree_t::reference               impl_reference;
   typedef typename impl_tree_t::const_reference         impl_const_reference;
   typedef typename impl_tree_t::value_compare           impl_value_compare;
   typedef typename impl_tree_t::iterator                impl_iterator;
   typedef typename impl_tree_t::const_iterator          impl_const_iterator;
   typedef typename impl_tree_t::reverse_iterator        impl_reverse_iterator;
   typedef typename impl_tree_t::const_reverse_iterator  impl_const_reverse_iterator;
   typedef typename impl_tree_t::allocator_type          impl_allocator_type;
   typedef allocator_traits                           allocator_traits_type;

   /// @endcond

   public:

   // typedefs:
   typedef Key                                              key_type;
   typedef T                                                mapped_type;
   typedef typename std::pair<key_type, mapped_type>        value_type;
   typedef typename allocator_traits_type::pointer          pointer;
   typedef typename allocator_traits_type::const_pointer    const_pointer;
   typedef typename allocator_traits_type::reference        reference;
   typedef typename allocator_traits_type::const_reference  const_reference;
   typedef typename impl_tree_t::size_type                  size_type;
   typedef typename impl_tree_t::difference_type            difference_type;

   typedef container_detail::flat_tree_value_compare
      < Pred
      , container_detail::select1st< std::pair<Key, T> >
      , std::pair<Key, T> >                                 value_compare;
   typedef Pred                                             key_compare;
   typedef typename container_detail::
      get_flat_tree_iterators<pointer>::iterator            iterator;
   typedef typename container_detail::
      get_flat_tree_iterators<pointer>::const_iterator      const_iterator;
   typedef typename container_detail::
      get_flat_tree_iterators
         <pointer>::reverse_iterator                        reverse_iterator;
   typedef typename container_detail::
      get_flat_tree_iterators
         <pointer>::const_reverse_iterator                  const_reverse_iterator;
   typedef A                                                allocator_type;

   //!Standard extension
   typedef A                                                stored_allocator_type;

   //!Standard extension for C++03 compilers with non-movable std::pair
   typedef impl_value_type                                  movable_value_type;

   public:
   //! Effects: Default constructs an empty flat_map.
   //!
   //! Complexity: Constant.
   flat_map()
      : m_flat_tree() {}

   //! Effects: Constructs an empty flat_map using the specified
   //! comparison object and allocator.
   //!
   //! Complexity: Constant.
   explicit flat_map(const Pred& comp, const allocator_type& a = allocator_type())
      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) {}

   //! Effects: Constructs an empty flat_map using the specified comparison object and
   //! allocator, and inserts elements from the range [first ,last ).
   //!
   //! Complexity: Linear in N if the range [first ,last ) is already sorted using
   //! comp and otherwise N logN, where N is last - first.
   template <class InputIterator>
   flat_map(InputIterator first, InputIterator last, const Pred& comp = Pred(),
         const allocator_type& a = allocator_type())
      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
      { m_flat_tree.insert_unique(first, last); }

   //! Effects: Constructs an empty flat_map using the specified comparison object and
   //! allocator, and inserts elements from the ordered unique range [first ,last). This function
   //! is more efficient than the normal range creation for ordered ranges.
   //!
   //! Requires: [first ,last) must be ordered according to the predicate and must be
   //! unique values.
   //!
   //! Complexity: Linear in N.
   //!
   //! Note: Non-standard extension.
   template <class InputIterator>
   flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
           , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
      : m_flat_tree(ordered_range, first, last, comp, a)
   {}

   //! Effects: Copy constructs a flat_map.
   //!
   //! Complexity: Linear in x.size().
   flat_map(const flat_map& x)
      : m_flat_tree(x.m_flat_tree) {}

   //! Effects: Move constructs a flat_map.
   //!   Constructs *this using x's resources.
   //!
   //! Complexity: Constant.
   //!
   //! Postcondition: x is emptied.
   flat_map(BOOST_RV_REF(flat_map) x)
      : m_flat_tree(boost::move(x.m_flat_tree))
   {}

   //! Effects: Copy constructs a flat_map using the specified allocator.
   //!
   //! Complexity: Linear in x.size().
   flat_map(const flat_map& x, const allocator_type &a)
      : m_flat_tree(x.m_flat_tree, a)
   {}

   //! Effects: Move constructs a flat_map using the specified allocator.
   //!   Constructs *this using x's resources.
   //!
   //! Complexity: Constant if x.get_allocator() == a, linear otherwise.
   flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
      : m_flat_tree(boost::move(x.m_flat_tree), a)
   {}

   //! Effects: Makes *this a copy of x.
   //!
   //! Complexity: Linear in x.size().
   flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
   {  m_flat_tree = x.m_flat_tree;   return *this;  }

   //! Effects: Move constructs a flat_map.
   //!   Constructs *this using x's resources.
   //!
   //! Complexity: Construct.
   //!
   //! Postcondition: x is emptied.
   flat_map& operator=(BOOST_RV_REF(flat_map) mx)
   {  m_flat_tree = boost::move(mx.m_flat_tree);   return *this;  }

   //! Effects: Returns the comparison object out
   //!   of which a was constructed.
   //!
   //! Complexity: Constant.
   key_compare key_comp() const
      { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }

   //! Effects: Returns an object of value_compare constructed out
   //!   of the comparison object.
   //!
   //! Complexity: Constant.
   value_compare value_comp() const
      { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }

   //! Effects: Returns a copy of the Allocator that
   //!   was passed to the object's constructor.
   //!
   //! Complexity: Constant.
   allocator_type get_allocator() const
      { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }

   const stored_allocator_type &get_stored_allocator() const
      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

   stored_allocator_type &get_stored_allocator()
      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

   //! Effects: Returns an iterator to the first element contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   iterator begin()
      { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }

   //! Effects: Returns a const_iterator to the first element contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator begin() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }

   //! Effects: Returns an iterator to the end of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   iterator end()
      { return container_detail::force_copy<iterator>(m_flat_tree.end()); }

   //! Effects: Returns a const_iterator to the end of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator end() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }

   //! Effects: Returns a reverse_iterator pointing to the beginning
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   reverse_iterator rbegin()
      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }

   //! Effects: Returns a const_reverse_iterator pointing to the beginning
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator rbegin() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }

   //! Effects: Returns a reverse_iterator pointing to the end
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   reverse_iterator rend()
      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }

   //! Effects: Returns a const_reverse_iterator pointing to the end
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator rend() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }

   //! Effects: Returns a const_iterator to the first element contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator cbegin() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }

   //! Effects: Returns a const_iterator to the end of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator cend() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }

   //! Effects: Returns a const_reverse_iterator pointing to the beginning
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator crbegin() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }

   //! Effects: Returns a const_reverse_iterator pointing to the end
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator crend() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }

   //! Effects: Returns true if the container contains no elements.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   bool empty() const
      { return m_flat_tree.empty(); }

   //! Effects: Returns the number of the elements contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   size_type size() const
      { return m_flat_tree.size(); }

   //! Effects: Returns the largest possible size of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   size_type max_size() const
      { return m_flat_tree.max_size(); }

   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
   //! Effects: If there is no key equivalent to x in the flat_map, inserts
   //!   value_type(x, T()) into the flat_map.
   //!
   //! Returns: A reference to the mapped_type corresponding to x in *this.
   //!
   //! Complexity: Logarithmic.
   mapped_type &operator[](const key_type& k);

   //! Effects: If there is no key equivalent to x in the flat_map, inserts
   //! value_type(move(x), T()) into the flat_map (the key is move-constructed)
   //!
   //! Returns: A reference to the mapped_type corresponding to x in *this.
   //!
   //! Complexity: Logarithmic.
   mapped_type &operator[](key_type &&k) ;

   #else
   BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, priv_subscript)
   #endif

   //! Returns: A reference to the element whose key is equivalent to x.
   //! Throws: An exception object of type out_of_range if no such element is present.
   //! Complexity: logarithmic.
   T& at(const key_type& k)
   {
      iterator i = this->find(k);
      if(i == this->end()){
         throw std::out_of_range("key not found");
      }
      return i->second;
   }

   //! Returns: A reference to the element whose key is equivalent to x.
   //! Throws: An exception object of type out_of_range if no such element is present.
   //! Complexity: logarithmic.
   const T& at(const key_type& k) const
   {
      const_iterator i = this->find(k);
      if(i == this->end()){
         throw std::out_of_range("key not found");
      }
      return i->second;
   }

   //! Effects: Swaps the contents of *this and x.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   void swap(flat_map& x)
   { m_flat_tree.swap(x.m_flat_tree); }

   //! Effects: Inserts x if and only if there is no element in the container
   //!   with key equivalent to the key of x.
   //!
   //! Returns: The bool component of the returned pair is true if and only
   //!   if the insertion takes place, and the iterator component of the pair
   //!   points to the element with key equivalent to the key of x.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   std::pair<iterator,bool> insert(const value_type& x)
      { return container_detail::force_copy<std::pair<iterator,bool> >(
         m_flat_tree.insert_unique(container_detail::force<impl_value_type>(x))); }

   //! Effects: Inserts a new value_type move constructed from the pair if and
   //! only if there is no element in the container with key equivalent to the key of x.
   //!
   //! Returns: The bool component of the returned pair is true if and only
   //!   if the insertion takes place, and the iterator component of the pair
   //!   points to the element with key equivalent to the key of x.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
   {  return container_detail::force_copy<std::pair<iterator,bool> >(
      m_flat_tree.insert_unique(boost::move(container_detail::force<impl_value_type>(x)))); }

   //! Effects: Inserts a new value_type move constructed from the pair if and
   //! only if there is no element in the container with key equivalent to the key of x.
   //!
   //! Returns: The bool component of the returned pair is true if and only
   //!   if the insertion takes place, and the iterator component of the pair
   //!   points to the element with key equivalent to the key of x.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
   {
      return container_detail::force_copy<std::pair<iterator,bool> >
      (m_flat_tree.insert_unique(boost::move(x)));
   }

   //! Effects: Inserts a copy of x in the container if and only if there is
   //!   no element in the container with key equivalent to the key of x.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent
   //!   to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant if x is inserted
   //!   right before p) plus insertion linear to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const_iterator position, const value_type& x)
   {
      return container_detail::force_copy<iterator>(
         m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(position)
                                  , container_detail::force<impl_value_type>(x)));
   }

   //! Effects: Inserts an element move constructed from x in the container.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant if x is inserted
   //!   right before p) plus insertion linear to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
   {
      return container_detail::force_copy<iterator>
         (m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(position)
                                   , boost::move(container_detail::force<impl_value_type>(x))));
   }

   //! Effects: Inserts an element move constructed from x in the container.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant if x is inserted
   //!   right before p) plus insertion linear to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const_iterator position, BOOST_RV_REF(movable_value_type) x)
   {
      return container_detail::force_copy<iterator>(
         m_flat_tree.insert_unique(container_detail::force_copy<impl_const_iterator>(position), boost::move(x)));
   }

   //! Requires: first, last are not iterators into *this.
   //!
   //! Effects: inserts each element from the range [first,last) if and only
   //!   if there is no element with key equivalent to the key of that element.
   //!
   //! Complexity: At most N log(size()+N) (N is the distance from first to last)
   //!   search time plus N*size() insertion time.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class InputIterator>
   void insert(InputIterator first, InputIterator last)
   {  m_flat_tree.insert_unique(first, last);  }

   //! Requires: first, last are not iterators into *this.
   //!
   //! Requires: [first ,last) must be ordered according to the predicate and must be
   //! unique values.
   //!
   //! Effects: inserts each element from the range [first,last) if and only
   //!   if there is no element with key equivalent to the key of that element. This
   //!   function is more efficient than the normal range creation for ordered ranges.
   //!
   //! Complexity: At most N log(size()+N) (N is the distance from first to last)
   //!   search time plus N*size() insertion time.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class InputIterator>
   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
      {  m_flat_tree.insert_unique(ordered_unique_range, first, last); }

   #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

   //! Effects: Inserts an object x of type T constructed with
   //!   std::forward<Args>(args)... if and only if there is no element in the container
   //!   with key equivalent to the key of x.
   //!
   //! Returns: The bool component of the returned pair is true if and only
   //!   if the insertion takes place, and the iterator component of the pair
   //!   points to the element with key equivalent to the key of x.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class... Args>
   std::pair<iterator,bool> emplace(Args&&... args)
   {  return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }

   //! Effects: Inserts an object of type T constructed with
   //!   std::forward<Args>(args)... in the container if and only if there is
   //!   no element in the container with key equivalent to the key of x.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent
   //!   to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant if x is inserted
   //!   right before p) plus insertion linear to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class... Args>
   iterator emplace_hint(const_iterator hint, Args&&... args)
   {
      return container_detail::force_copy<iterator>
         (m_flat_tree.emplace_hint_unique( container_detail::force_copy<impl_const_iterator>(hint)
                                         , boost::forward<Args>(args)...));
   }

   #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   #define BOOST_PP_LOCAL_MACRO(n)                                                                 \
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          \
   std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))            \
   {  return container_detail::force_copy< std::pair<iterator, bool> >                             \
         (m_flat_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); }    \
                                                                                \
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          \
   iterator emplace_hint(const_iterator hint                                                       \
                         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              \
   {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_unique                \
            (container_detail::force_copy<impl_const_iterator>(hint)                               \
               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); }                 \
   //!
   #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
   #include BOOST_PP_LOCAL_ITERATE()

   #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   //! Effects: Erases the element pointed to by position.
   //!
   //! Returns: Returns an iterator pointing to the element immediately
   //!   following q prior to the element being erased. If no such element exists,
   //!   returns end().
   //!
   //! Complexity: Linear to the elements with keys bigger than position
   //!
   //! Note: Invalidates elements with keys
   //!   not less than the erased element.
   iterator erase(const_iterator position)
   {
      return container_detail::force_copy<iterator>
         (m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(position)));
   }

   //! Effects: Erases all elements in the container with key equivalent to x.
   //!
   //! Returns: Returns the number of erased elements.
   //!
   //! Complexity: Logarithmic search time plus erasure time
   //!   linear to the elements with bigger keys.
   size_type erase(const key_type& x)
      { return m_flat_tree.erase(x); }

   //! Effects: Erases all the elements in the range [first, last).
   //!
   //! Returns: Returns last.
   //!
   //! Complexity: size()*N where N is the distance from first to last.
   //!
   //! Complexity: Logarithmic search time plus erasure time
   //!   linear to the elements with bigger keys.
   iterator erase(const_iterator first, const_iterator last)
   {
      return container_detail::force_copy<iterator>(
         m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
                          , container_detail::force_copy<impl_const_iterator>(last)));
   }

   //! Effects: erase(a.begin(),a.end()).
   //!
   //! Postcondition: size() == 0.
   //!
   //! Complexity: linear in size().
   void clear()
      { m_flat_tree.clear(); }

   //! Effects: Tries to deallocate the excess of memory created
   //    with previous allocations. The size of the vector is unchanged
   //!
   //! Throws: If memory allocation throws, or T's copy constructor throws.
   //!
   //! Complexity: Linear to size().
   void shrink_to_fit()
      { m_flat_tree.shrink_to_fit(); }

   //! Returns: An iterator pointing to an element with the key
   //!   equivalent to x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic.
   iterator find(const key_type& x)
      { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }

   //! Returns: A const_iterator pointing to an element with the key
   //!   equivalent to x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic.s
   const_iterator find(const key_type& x) const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }

   //! Returns: The number of elements with key equivalent to x.
   //!
   //! Complexity: log(size())+count(k)
   size_type count(const key_type& x) const
      {  return m_flat_tree.find(x) == m_flat_tree.end() ? 0 : 1;  }

   //! Returns: An iterator pointing to the first element with key not less
   //!   than k, or a.end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   iterator lower_bound(const key_type& x)
      {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }

   //! Returns: A const iterator pointing to the first element with key not
   //!   less than k, or a.end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   const_iterator lower_bound(const key_type& x) const
      {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }

   //! Returns: An iterator pointing to the first element with key not less
   //!   than x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   iterator upper_bound(const key_type& x)
      {  return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }

   //! Returns: A const iterator pointing to the first element with key not
   //!   less than x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   const_iterator upper_bound(const key_type& x) const
      {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }

   //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
   //!
   //! Complexity: Logarithmic
   std::pair<iterator,iterator> equal_range(const key_type& x)
      {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x)); }

   //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
   //!
   //! Complexity: Logarithmic
   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
      {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x)); }

   //! Effects: Number of elements for which memory has been allocated.
   //!   capacity() is always greater than or equal to size().
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   size_type capacity() const
      { return m_flat_tree.capacity(); }

   //! Effects: If n is less than or equal to capacity(), this call has no
   //!   effect. Otherwise, it is a request for allocation of additional memory.
   //!   If the request is successful, then capacity() is greater than or equal to
   //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
   //!
   //! Throws: If memory allocation allocation throws or T's copy constructor throws.
   //!
   //! Note: If capacity() is less than "count", iterators and references to
   //!   to values might be invalidated.
   void reserve(size_type count)
      { m_flat_tree.reserve(count);   }

   /// @cond
   template <class K1, class T1, class C1, class A1>
   friend bool operator== (const flat_map<K1, T1, C1, A1>&,
                           const flat_map<K1, T1, C1, A1>&);
   template <class K1, class T1, class C1, class A1>
   friend bool operator< (const flat_map<K1, T1, C1, A1>&,
                           const flat_map<K1, T1, C1, A1>&);

   private:
   mapped_type &priv_subscript(const key_type& k)
   {
      iterator i = lower_bound(k);
      // i->first is greater than or equivalent to k.
      if (i == end() || key_comp()(k, (*i).first)){
         container_detail::value_init<mapped_type> m;
         i = insert(i, impl_value_type(k, ::boost::move(m.m_t)));
      }
      return (*i).second;
   }
   mapped_type &priv_subscript(BOOST_RV_REF(key_type) mk)
   {
      key_type &k = mk;
      iterator i = lower_bound(k);
      // i->first is greater than or equivalent to k.
      if (i == end() || key_comp()(k, (*i).first)){
         container_detail::value_init<mapped_type> m;
         i = insert(i, impl_value_type(boost::move(k), ::boost::move(m.m_t)));
      }
      return (*i).second;
   }
   /// @endcond
};

template <class Key, class T, class Pred, class A>
inline bool operator==(const flat_map<Key,T,Pred,A>& x,
                       const flat_map<Key,T,Pred,A>& y)
   {  return x.m_flat_tree == y.m_flat_tree;  }

template <class Key, class T, class Pred, class A>
inline bool operator<(const flat_map<Key,T,Pred,A>& x,
                      const flat_map<Key,T,Pred,A>& y)
   {  return x.m_flat_tree < y.m_flat_tree;   }

template <class Key, class T, class Pred, class A>
inline bool operator!=(const flat_map<Key,T,Pred,A>& x,
                       const flat_map<Key,T,Pred,A>& y)
   {  return !(x == y); }

template <class Key, class T, class Pred, class A>
inline bool operator>(const flat_map<Key,T,Pred,A>& x,
                      const flat_map<Key,T,Pred,A>& y)
   {  return y < x;  }

template <class Key, class T, class Pred, class A>
inline bool operator<=(const flat_map<Key,T,Pred,A>& x,
                       const flat_map<Key,T,Pred,A>& y)
   {  return !(y < x);  }

template <class Key, class T, class Pred, class A>
inline bool operator>=(const flat_map<Key,T,Pred,A>& x,
                       const flat_map<Key,T,Pred,A>& y)
   {  return !(x < y);  }

template <class Key, class T, class Pred, class A>
inline void swap(flat_map<Key,T,Pred,A>& x,
                 flat_map<Key,T,Pred,A>& y)
   {  x.swap(y);  }

/// @cond

}  //namespace container {
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
template <class K, class T, class C, class A>
struct has_trivial_destructor_after_move<boost::container::flat_map<K, T, C, A> >
{
   static const bool value = has_trivial_destructor::value && has_trivial_destructor<C>::value;
};
*/
namespace container {

// Forward declaration of operators < and ==, needed for friend declaration.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
template <class Key, class T, class Pred = std::less< std::pair< Key, T> >, class A = std::allocator<T> >
#else
template <class Key, class T, class Pred, class A>
#endif
class flat_multimap;

template <class Key, class T, class Pred, class A>
inline bool operator==(const flat_multimap<Key,T,Pred,A>& x,
                       const flat_multimap<Key,T,Pred,A>& y);

template <class Key, class T, class Pred, class A>
inline bool operator<(const flat_multimap<Key,T,Pred,A>& x,
                      const flat_multimap<Key,T,Pred,A>& y);
/// @endcond

//! A flat_multimap is a kind of associative container that supports equivalent keys
//! (possibly containing multiple copies of the same key value) and provides for
//! fast retrieval of values of another type T based on the keys. The flat_multimap
//! class supports random-access iterators.
//!
//! A flat_multimap satisfies all of the requirements of a container and of a reversible
//! container and of an associative container. For a
//! flat_multimap<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
//! (unlike std::multimap<Key, T> which value_type is std::pair<const Key, T>).
//!
//! Pred is the ordering function for Keys (e.g. std::less<Key>).
//!
//! A is the allocator to allocate the value_types
//! (e.g. allocator< std::pair<Key, T> >).
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
template <class Key, class T, class Pred = std::less< std::pair< Key, T> >, class A = std::allocator<T> >
#else
template <class Key, class T, class Pred, class A>
#endif
class flat_multimap
{
   /// @cond
   private:
   BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
   typedef container_detail::flat_tree<Key,
                           std::pair<Key, T>,
                           container_detail::select1st< std::pair<Key, T> >,
                           Pred,
                           A> tree_t;
   //This is the real tree stored here. It's based on a movable pair
   typedef container_detail::flat_tree<Key,
                           container_detail::pair<Key, T>,
                           container_detail::select1st<container_detail::pair<Key, T> >,
                           Pred,
                           typename allocator_traits::template portable_rebind_alloc
                              <container_detail::pair<Key, T> >::type> impl_tree_t;
   impl_tree_t m_flat_tree;  // flat tree representing flat_map

   typedef typename impl_tree_t::value_type              impl_value_type;
   typedef typename impl_tree_t::pointer                 impl_pointer;
   typedef typename impl_tree_t::const_pointer           impl_const_pointer;
   typedef typename impl_tree_t::reference               impl_reference;
   typedef typename impl_tree_t::const_reference         impl_const_reference;
   typedef typename impl_tree_t::value_compare           impl_value_compare;
   typedef typename impl_tree_t::iterator                impl_iterator;
   typedef typename impl_tree_t::const_iterator          impl_const_iterator;
   typedef typename impl_tree_t::reverse_iterator        impl_reverse_iterator;
   typedef typename impl_tree_t::const_reverse_iterator  impl_const_reverse_iterator;
   typedef typename impl_tree_t::allocator_type          impl_allocator_type;
   typedef allocator_traits                           allocator_traits_type;

   /// @endcond

   public:

   // typedefs:
   typedef Key                                              key_type;
   typedef T                                                mapped_type;
   typedef Pred                                             key_compare;
   typedef typename std::pair<key_type, mapped_type>        value_type;
   typedef typename allocator_traits_type::pointer          pointer;
   typedef typename allocator_traits_type::const_pointer    const_pointer;
   typedef typename allocator_traits_type::reference        reference;
   typedef typename allocator_traits_type::const_reference  const_reference;
   typedef typename impl_tree_t::size_type                  size_type;
   typedef typename impl_tree_t::difference_type            difference_type;
   typedef container_detail::flat_tree_value_compare
      < Pred
      , container_detail::select1st< std::pair<Key, T> >
      , std::pair<Key, T> >                                 value_compare;

   typedef typename container_detail::
      get_flat_tree_iterators<pointer>::iterator            iterator;
   typedef typename container_detail::
      get_flat_tree_iterators<pointer>::const_iterator      const_iterator;
   typedef typename container_detail::
      get_flat_tree_iterators
         <pointer>::reverse_iterator                        reverse_iterator;
   typedef typename container_detail::
      get_flat_tree_iterators
         <pointer>::const_reverse_iterator                  const_reverse_iterator;
   typedef A                                                allocator_type;
   //Non-standard extension
   typedef A                                                stored_allocator_type;
   //!Standard extension for C++03 compilers with non-movable std::pair
   typedef impl_value_type                                  movable_value_type;

   //! Effects: Default constructs an empty flat_map.
   //!
   //! Complexity: Constant.
   flat_multimap()
      : m_flat_tree() {}

   //! Effects: Constructs an empty flat_multimap using the specified comparison
   //!   object and allocator.
   //!
   //! Complexity: Constant.
   explicit flat_multimap(const Pred& comp,
                          const allocator_type& a = allocator_type())
      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) { }

   //! Effects: Constructs an empty flat_multimap using the specified comparison object
   //!   and allocator, and inserts elements from the range [first ,last ).
   //!
   //! Complexity: Linear in N if the range [first ,last ) is already sorted using
   //! comp and otherwise N logN, where N is last - first.
   template <class InputIterator>
   flat_multimap(InputIterator first, InputIterator last,
            const Pred& comp        = Pred(),
            const allocator_type& a = allocator_type())
      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
      { m_flat_tree.insert_equal(first, last); }

   //! Effects: Constructs an empty flat_multimap using the specified comparison object and
   //! allocator, and inserts elements from the ordered range [first ,last). This function
   //! is more efficient than the normal range creation for ordered ranges.
   //!
   //! Requires: [first ,last) must be ordered according to the predicate.
   //!
   //! Complexity: Linear in N.
   //!
   //! Note: Non-standard extension.
   template <class InputIterator>
   flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
            const Pred& comp        = Pred(),
            const allocator_type& a = allocator_type())
      : m_flat_tree(ordered_range, first, last, comp, a)
   {}

   //! Effects: Copy constructs a flat_multimap.
   //!
   //! Complexity: Linear in x.size().
   flat_multimap(const flat_multimap& x)
      : m_flat_tree(x.m_flat_tree) { }

   //! Effects: Move constructs a flat_multimap. Constructs *this using x's resources.
   //!
   //! Complexity: Constant.
   //!
   //! Postcondition: x is emptied.
   flat_multimap(BOOST_RV_REF(flat_multimap) x)
      : m_flat_tree(boost::move(x.m_flat_tree))
   { }

   //! Effects: Copy constructs a flat_multimap using the specified allocator.
   //!
   //! Complexity: Linear in x.size().
   flat_multimap(const flat_multimap& x, const allocator_type &a)
      : m_flat_tree(x.m_flat_tree, a)
   {}

   //! Effects: Move constructs a flat_multimap using the specified allocator.
   //!                 Constructs *this using x's resources.
   //!
   //! Complexity: Constant if a == x.get_allocator(), linear otherwise.
   flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
      : m_flat_tree(boost::move(x.m_flat_tree), a)
   { }

   //! Effects: Makes *this a copy of x.
   //!
   //! Complexity: Linear in x.size().
   flat_multimap& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
      {  m_flat_tree = x.m_flat_tree;   return *this;  }

   //! Effects: this->swap(x.get()).
   //!
   //! Complexity: Constant.
   flat_multimap& operator=(BOOST_RV_REF(flat_multimap) mx)
      {  m_flat_tree = boost::move(mx.m_flat_tree);   return *this;  }

   //! Effects: Returns the comparison object out
   //!   of which a was constructed.
   //!
   //! Complexity: Constant.
   key_compare key_comp() const
      { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }

   //! Effects: Returns an object of value_compare constructed out
   //!   of the comparison object.
   //!
   //! Complexity: Constant.
   value_compare value_comp() const
      { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }

   //! Effects: Returns a copy of the Allocator that
   //!   was passed to the object's constructor.
   //!
   //! Complexity: Constant.
   allocator_type get_allocator() const
      { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }

   const stored_allocator_type &get_stored_allocator() const
      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

   stored_allocator_type &get_stored_allocator()
      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

   //! Effects: Returns an iterator to the first element contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   iterator begin()
      { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }

   //! Effects: Returns a const_iterator to the first element contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator begin() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }

   //! Effects: Returns an iterator to the end of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   iterator end()
      { return container_detail::force_copy<iterator>(m_flat_tree.end()); }

   //! Effects: Returns a const_iterator to the end of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator end() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }

   //! Effects: Returns a reverse_iterator pointing to the beginning
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   reverse_iterator rbegin()
      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }

   //! Effects: Returns a const_reverse_iterator pointing to the beginning
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator rbegin() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }

   //! Effects: Returns a reverse_iterator pointing to the end
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   reverse_iterator rend()
      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }

   //! Effects: Returns a const_reverse_iterator pointing to the end
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator rend() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }

   //! Effects: Returns a const_iterator to the first element contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator cbegin() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }

   //! Effects: Returns a const_iterator to the end of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_iterator cend() const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }

   //! Effects: Returns a const_reverse_iterator pointing to the beginning
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator crbegin() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }

   //! Effects: Returns a const_reverse_iterator pointing to the end
   //! of the reversed container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   const_reverse_iterator crend() const
      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }

   //! Effects: Returns true if the container contains no elements.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   bool empty() const
      { return m_flat_tree.empty(); }

   //! Effects: Returns the number of the elements contained in the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   size_type size() const
      { return m_flat_tree.size(); }

   //! Effects: Returns the largest possible size of the container.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   size_type max_size() const
      { return m_flat_tree.max_size(); }

   //! Effects: Swaps the contents of *this and x.
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   void swap(flat_multimap& x)
   { m_flat_tree.swap(x.m_flat_tree); }

   //! Effects: Inserts x and returns the iterator pointing to the
   //!   newly inserted element.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const value_type& x)
   {
      return container_detail::force_copy<iterator>(
         m_flat_tree.insert_equal(container_detail::force<impl_value_type>(x)));
   }

   //! Effects: Inserts a new value move-constructed from x and returns
   //!   the iterator pointing to the newly inserted element.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(BOOST_RV_REF(value_type) x)
   { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }

   //! Effects: Inserts a new value move-constructed from x and returns
   //!   the iterator pointing to the newly inserted element.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(BOOST_RV_REF(impl_value_type) x)
      { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }

   //! Effects: Inserts a copy of x in the container.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent
   //!   to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant time if the value
   //!   is to be inserted before p) plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const_iterator position, const value_type& x)
   {
      return container_detail::force_copy<iterator>
         (m_flat_tree.insert_equal( container_detail::force_copy<impl_const_iterator>(position)
                                  , container_detail::force<impl_value_type>(x)));
   }

   //! Effects: Inserts a value move constructed from x in the container.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent
   //!   to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant time if the value
   //!   is to be inserted before p) plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
   {
      return container_detail::force_copy<iterator>
         (m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(position)
                                  , boost::move(x)));
   }

   //! Effects: Inserts a value move constructed from x in the container.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent
   //!   to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant time if the value
   //!   is to be inserted before p) plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
   {
      return container_detail::force_copy<iterator>(
         m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(position), boost::move(x)));
   }

   //! Requires: first, last are not iterators into *this.
   //!
   //! Effects: inserts each element from the range [first,last) .
   //!
   //! Complexity: At most N log(size()+N) (N is the distance from first to last)
   //!   search time plus N*size() insertion time.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class InputIterator>
   void insert(InputIterator first, InputIterator last)
      {  m_flat_tree.insert_equal(first, last); }

   //! Requires: first, last are not iterators into *this.
   //!
   //! Requires: [first ,last) must be ordered according to the predicate.
   //!
   //! Effects: inserts each element from the range [first,last) if and only
   //!   if there is no element with key equivalent to the key of that element. This
   //!   function is more efficient than the normal range creation for ordered ranges.
   //!
   //! Complexity: At most N log(size()+N) (N is the distance from first to last)
   //!   search time plus N*size() insertion time.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class InputIterator>
   void insert(ordered_range_t, InputIterator first, InputIterator last)
      {  m_flat_tree.insert_equal(ordered_range, first, last); }

   #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

   //! Effects: Inserts an object of type T constructed with
   //!   std::forward<Args>(args)... and returns the iterator pointing to the
   //!   newly inserted element.
   //!
   //! Complexity: Logarithmic search time plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class... Args>
   iterator emplace(Args&&... args)
   {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }

   //! Effects: Inserts an object of type T constructed with
   //!   std::forward<Args>(args)... in the container.
   //!   p is a hint pointing to where the insert should start to search.
   //!
   //! Returns: An iterator pointing to the element with key equivalent
   //!   to the key of x.
   //!
   //! Complexity: Logarithmic search time (constant time if the value
   //!   is to be inserted before p) plus linear insertion
   //!   to the elements with bigger keys than x.
   //!
   //! Note: If an element is inserted it might invalidate elements.
   template <class... Args>
   iterator emplace_hint(const_iterator hint, Args&&... args)
   {
      return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal
         (container_detail::force_copy<impl_const_iterator>(hint), boost::forward<Args>(args)...));
   }

   #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   #define BOOST_PP_LOCAL_MACRO(n)                                                                 \
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          \
   iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                            \
   {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal                      \
               (BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); }                         \
                                                                                \
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          \
   iterator emplace_hint(const_iterator hint                                                       \
                         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              \
   {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal                 \
            (container_detail::force_copy<impl_const_iterator>(hint)                               \
               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); }                 \
   //!
   #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
   #include BOOST_PP_LOCAL_ITERATE()

   #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   //! Effects: Erases the element pointed to by position.
   //!
   //! Returns: Returns an iterator pointing to the element immediately
   //!   following q prior to the element being erased. If no such element exists,
   //!   returns end().
   //!
   //! Complexity: Linear to the elements with keys bigger than position
   //!
   //! Note: Invalidates elements with keys
   //!   not less than the erased element.
   iterator erase(const_iterator position)
   {
      return container_detail::force_copy<iterator>(
         m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(position)));
   }

   //! Effects: Erases all elements in the container with key equivalent to x.
   //!
   //! Returns: Returns the number of erased elements.
   //!
   //! Complexity: Logarithmic search time plus erasure time
   //!   linear to the elements with bigger keys.
   size_type erase(const key_type& x)
      { return m_flat_tree.erase(x); }

   //! Effects: Erases all the elements in the range [first, last).
   //!
   //! Returns: Returns last.
   //!
   //! Complexity: size()*N where N is the distance from first to last.
   //!
   //! Complexity: Logarithmic search time plus erasure time
   //!   linear to the elements with bigger keys.
   iterator erase(const_iterator first, const_iterator last)
   {
      return container_detail::force_copy<iterator>
         (m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
                           , container_detail::force_copy<impl_const_iterator>(last)));
   }

   //! Effects: erase(a.begin(),a.end()).
   //!
   //! Postcondition: size() == 0.
   //!
   //! Complexity: linear in size().
   void clear()
      { m_flat_tree.clear(); }

   //! Effects: Tries to deallocate the excess of memory created
   //    with previous allocations. The size of the vector is unchanged
   //!
   //! Throws: If memory allocation throws, or T's copy constructor throws.
   //!
   //! Complexity: Linear to size().
   void shrink_to_fit()
      { m_flat_tree.shrink_to_fit(); }

   //! Returns: An iterator pointing to an element with the key
   //!   equivalent to x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic.
   iterator find(const key_type& x)
      { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }

   //! Returns: An const_iterator pointing to an element with the key
   //!   equivalent to x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic.
   const_iterator find(const key_type& x) const
      { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }

   //! Returns: The number of elements with key equivalent to x.
   //!
   //! Complexity: log(size())+count(k)
   size_type count(const key_type& x) const
      { return m_flat_tree.count(x); }

   //! Returns: An iterator pointing to the first element with key not less
   //!   than k, or a.end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   iterator lower_bound(const key_type& x)
      {return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }

   //! Returns: A const iterator pointing to the first element with key
   //!   not less than k, or a.end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   const_iterator lower_bound(const key_type& x) const
      {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x));  }

   //! Returns: An iterator pointing to the first element with key not less
   //!   than x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   iterator upper_bound(const key_type& x)
      {return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }

   //! Returns: A const iterator pointing to the first element with key
   //!   not less than x, or end() if such an element is not found.
   //!
   //! Complexity: Logarithmic
   const_iterator upper_bound(const key_type& x) const
      {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }

   //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
   //!
   //! Complexity: Logarithmic
   std::pair<iterator,iterator> equal_range(const key_type& x)
      {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x));   }

   //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
   //!
   //! Complexity: Logarithmic
   std::pair<const_iterator,const_iterator>
      equal_range(const key_type& x) const
      {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x));   }

   //! Effects: Number of elements for which memory has been allocated.
   //!   capacity() is always greater than or equal to size().
   //!
   //! Throws: Nothing.
   //!
   //! Complexity: Constant.
   size_type capacity() const
      { return m_flat_tree.capacity(); }

   //! Effects: If n is less than or equal to capacity(), this call has no
   //!   effect. Otherwise, it is a request for allocation of additional memory.
   //!   If the request is successful, then capacity() is greater than or equal to
   //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
   //!
   //! Throws: If memory allocation allocation throws or T's copy constructor throws.
   //!
   //! Note: If capacity() is less than "count", iterators and references to
   //!   to values might be invalidated.
   void reserve(size_type count)
      { m_flat_tree.reserve(count);   }

   /// @cond
   template <class K1, class T1, class C1, class A1>
   friend bool operator== (const flat_multimap<K1, T1, C1, A1>& x,
                           const flat_multimap<K1, T1, C1, A1>& y);

   template <class K1, class T1, class C1, class A1>
   friend bool operator< (const flat_multimap<K1, T1, C1, A1>& x,
                          const flat_multimap<K1, T1, C1, A1>& y);
   /// @endcond
};

template <class Key, class T, class Pred, class A>
inline bool operator==(const flat_multimap<Key,T,Pred,A>& x,
                       const flat_multimap<Key,T,Pred,A>& y)
   {  return x.m_flat_tree == y.m_flat_tree;  }

template <class Key, class T, class Pred, class A>
inline bool operator<(const flat_multimap<Key,T,Pred,A>& x,
                      const flat_multimap<Key,T,Pred,A>& y)
   {  return x.m_flat_tree < y.m_flat_tree;   }

template <class Key, class T, class Pred, class A>
inline bool operator!=(const flat_multimap<Key,T,Pred,A>& x,
                       const flat_multimap<Key,T,Pred,A>& y)
   {  return !(x == y);  }

template <class Key, class T, class Pred, class A>
inline bool operator>(const flat_multimap<Key,T,Pred,A>& x,
                      const flat_multimap<Key,T,Pred,A>& y)
   {  return y < x;  }

template <class Key, class T, class Pred, class A>
inline bool operator<=(const flat_multimap<Key,T,Pred,A>& x,
                       const flat_multimap<Key,T,Pred,A>& y)
   {  return !(y < x);  }

template <class Key, class T, class Pred, class A>
inline bool operator>=(const flat_multimap<Key,T,Pred,A>& x,
                       const flat_multimap<Key,T,Pred,A>& y)
   {  return !(x < y);  }

template <class Key, class T, class Pred, class A>
inline void swap(flat_multimap<Key,T,Pred,A>& x, flat_multimap<Key,T,Pred,A>& y)
   {  x.swap(y);  }

}}

/// @cond

namespace boost {
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
template <class K, class T, class C, class A>
struct has_trivial_destructor_after_move< boost::container::flat_multimap<K, T, C, A> >
{
   static const bool value = has_trivial_destructor::value && has_trivial_destructor<C>::value;
};
*/
}  //namespace boost {

/// @endcond

#include <boost/container/detail/config_end.hpp>

#endif /* BOOST_CONTAINER_FLAT_MAP_HPP */


text:
describe("test", function() {
	it("should be defined", function() {
		let myClass = new MyClass("xyz");
		expect(myClass.name).toEqual("xyz");

		myClass.name = "zzz";
		expect(myClass.name).toEqual("zzz");
	})
});

redpajama_set_name: RedPajamaGithub


text:
package com.alorma.github.ui.view.issue;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.text.Html;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.alorma.github.R;
import com.alorma.github.StoreCredentials;
import com.alorma.github.sdk.bean.dto.response.Issue;
import com.alorma.github.sdk.bean.dto.response.IssueState;
import com.alorma.github.sdk.bean.info.RepoInfo;
import com.alorma.github.ui.activity.ProfileActivity;
import com.alorma.github.ui.activity.repo.RepoDetailActivity;
import com.alorma.github.ui.listeners.IssueDetailRequestListener;
import com.alorma.github.ui.view.LabelView;
import com.alorma.github.ui.view.UserAvatarView;
import com.alorma.github.utils.AttributesUtils;
import com.alorma.github.utils.TimeUtils;
import com.gh4a.utils.UiUtils;
import com.github.mobile.util.HtmlUtils;
import com.github.mobile.util.HttpImageGetter;
import com.mikepenz.iconics.IconicsDrawable;
import com.mikepenz.iconics.typeface.IIcon;
import com.mikepenz.octicons_typeface_library.Octicons;
import com.wefika.flowlayout.FlowLayout;
import core.User;
import core.issues.Label;
import core.repositories.Repo;
import java.util.ArrayList;
import java.util.List;

public class IssueDetailView extends LinearLayout {

  private Issue issue;

  private TextView title;
  private TextView body;
  private ViewGroup labelsLayout;
  private UserAvatarView profileIcon;
  private TextView profileName;
  private TextView createdAt;
  private TextView textMilestone;
  private RecyclerView assignees;
  private TextView textRepository;
  private IssueDetailRequestListener issueDetailRequestListener;
  private ReactionsView reactionsLy;
  private View editComment;

  public IssueDetailView(Context context) {
    super(context);
    init();
  }

  public IssueDetailView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
  }

  public IssueDetailView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init();
  }

  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
  public IssueDetailView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    init();
  }

  private void init() {
    inflate(getContext(), R.layout.issue_detail_issue_view, this);
    setOrientation(VERTICAL);
    title = (TextView) findViewById(R.id.textTitle);
    body = (TextView) findViewById(R.id.textBody);
    labelsLayout = (ViewGroup) findViewById(R.id.labelsLayout);
    profileIcon = (UserAvatarView) findViewById(R.id.profileIcon);
    profileName = (TextView) findViewById(R.id.name);
    createdAt = (TextView) findViewById(R.id.time);
    textMilestone = (TextView) findViewById(R.id.textMilestone);
    assignees = (RecyclerView) findViewById(R.id.assignees);
    textRepository = (TextView) findViewById(R.id.textRepository);
    reactionsLy = (ReactionsView) findViewById(R.id.reactionsLy);
    editComment = findViewById(R.id.editComment);
  }

  public void setIssue(RepoInfo repoInfo, final Issue issue) {
    if (this.issue == null) {
      this.issue = issue;
      parseTitle(issue);
      parseUser(issue);
      parseBody(repoInfo, issue);
      parseLabels(issue);
      parseReactions(issue);
      parseMilestone(issue);
      parseAssignee(issue);
      parseRepository(issue);
      checkEditable(repoInfo, issue);
    }
  }

  private void parseTitle(Issue issue) {
    title.setText(issue.title);
  }

  private void parseUser(Issue issue) {
    if (issue.user != null) {
      profileName.setText(issue.user.getLogin());
      createdAt.setText(TimeUtils.getTimeAgoString(issue.created_at));

      profileIcon.setUser(issue.user);
      OnClickListener issueUserClick = v -> {
        Intent launcherIntent = ProfileActivity.createLauncherIntent(v.getContext(), issue.user);
        v.getContext().startActivity(launcherIntent);
      };
      profileName.setOnClickListener(issueUserClick);
      createdAt.setOnClickListener(issueUserClick);
      profileIcon.setOnClickListener(issueUserClick);
    }
  }

  private void checkEditable(RepoInfo repoInfo, Issue issue) {
    StoreCredentials credentials = new StoreCredentials(getContext());
    if (repoInfo.permissions != null && repoInfo.permissions.push || issue.user.getLogin().equals(credentials.getUserName())) {
      editComment.setVisibility(VISIBLE);
      OnClickListener editClickListener = v -> {
        if (issueDetailRequestListener != null) {
          if (v.getId() == R.id.textTitle) {
            issueDetailRequestListener.onTitleEditRequest();
          } else if (v.getId() == R.id.editComment) {
            issueDetailRequestListener.onContentEditRequest();
          }
        }
      };

      title.setOnClickListener(editClickListener);

      editComment.setOnClickListener(editClickListener);
    }
  }

  private void parseRepository(Issue issue) {
    if (textRepository != null) {
      final Repo repo = issue.repository;
      if (repo != null) {
        textRepository.setCompoundDrawables(getIcon(Octicons.Icon.oct_repo), null, null, null);
        textRepository.setText(repo.getFullName());
        textRepository.setVisibility(View.VISIBLE);
        textRepository.setOnClickListener(v -> {
          RepoInfo repoInfo1 = new RepoInfo();
          repoInfo1.owner = repo.getOwner().getLogin();
          repoInfo1.name = repo.name;
          repoInfo1.permissions = repo.permissions;
          Intent launcherIntent = RepoDetailActivity.createLauncherIntent(v.getContext(), repoInfo1);
          v.getContext().startActivity(launcherIntent);
        });
      } else {
        textRepository.setVisibility(View.GONE);
      }
    }
  }

  private void parseAssignee(Issue issue) {
    if (assignees != null) {
      List<User> assignees = issue.assignees;
      if (assignees == null) {
        assignees = new ArrayList<>();
      }
      if (assignees.isEmpty()) {
        User assignee = issue.assignee;
        if (assignee != null) {
          assignees.add(assignee);
        }
      }

      if (!assignees.isEmpty()) {
        AssigneesAdapter assigneesAdapter = new AssigneesAdapter(LayoutInflater.from(getContext()));
        assigneesAdapter.addAll(assignees);
        this.assignees.setLayoutManager(new LinearLayoutManager(getContext(), LinearLayoutManager.HORIZONTAL, false));
        this.assignees.setAdapter(assigneesAdapter);
        this.assignees.setVisibility(View.VISIBLE);
        assigneesAdapter.setCallback(item -> {
          Intent launcherIntent = ProfileActivity.createLauncherIntent(getContext(), item);
          getContext().startActivity(launcherIntent);
        });
      } else {
        this.assignees.setVisibility(View.GONE);
      }
    }
  }

  private void parseMilestone(Issue issue) {
    if (textMilestone != null) {
      if (issue.milestone != null) {
        textMilestone.setCompoundDrawables(getIcon(Octicons.Icon.oct_milestone), null, null, null);
        textMilestone.setText(issue.milestone.title);
        textMilestone.setVisibility(View.VISIBLE);
      } else {
        textMilestone.setVisibility(View.GONE);
      }
    }
  }

  private void parseReactions(Issue issue) {
    if (reactionsLy != null) {
      if (issue.reactions != null) {
        reactionsLy.setReactions(issue.reactions);
      } else {
        reactionsLy.setVisibility(View.GONE);
      }
    }
  }

  private void parseLabels(Issue issue) {
    if (issue.labels != null && issue.labels.size() > 0) {
      labelsLayout.setVisibility(View.VISIBLE);
      int margin = getResources().getDimensionPixelOffset(R.dimen.gapSmall);
      for (Label label : issue.labels) {
        LabelView labelView = new LabelView(getContext());
        labelView.setLabel(label);
        labelsLayout.addView(labelView);

        if (labelView.getLayoutParams() != null && labelView.getLayoutParams() instanceof FlowLayout.LayoutParams) {
          FlowLayout.LayoutParams layoutParams = (FlowLayout.LayoutParams) labelView.getLayoutParams();
          layoutParams.height = FlowLayout.LayoutParams.WRAP_CONTENT;
          layoutParams.width = FlowLayout.LayoutParams.WRAP_CONTENT;
          layoutParams.setMargins(margin, margin, margin, margin);
          labelView.setLayoutParams(layoutParams);
        }
      }
    } else {
      labelsLayout.setVisibility(View.GONE);
    }
  }

  private void parseBody(RepoInfo repoInfo, Issue issue) {
    if (!TextUtils.isEmpty(issue.body_html)) {
      String htmlCode = HtmlUtils.format(issue.body_html).toString();
      HttpImageGetter imageGetter = new HttpImageGetter(getContext());

      imageGetter.repoInfo(repoInfo);
      imageGetter.bind(body, htmlCode, issue.number);

      body.setMovementMethod(UiUtils.CHECKING_LINK_METHOD);
    } else {
      body.setText(Html.fromHtml("<i>" + getResources().getString(R.string.no_description_provided) + "</i>"));
      body.setTextColor(AttributesUtils.getIconsColor(getContext()));
    }
  }

  private IconicsDrawable getIcon(IIcon icon) {
    return new IconicsDrawable(getContext(), icon).actionBar().colorRes(getColorIcons());
  }

  public int getColorIcons() {
    if (issue.state == IssueState.open) {
      return R.color.issue_state_open;
    } else {
      return R.color.issue_state_close;
    }
  }

  public void setIssueDetailRequestListener(IssueDetailRequestListener issueDetailRequestListener) {
    this.issueDetailRequestListener = issueDetailRequestListener;
  }
}


text:
using System;
using System.Collections.Generic;

namespace ClosedXML.Excel
{
    public enum XLAllowedValues { AnyValue, WholeNumber, Decimal, Date, Time, TextLength, List, Custom }

    public enum XLErrorStyle { Stop, Warning, Information }

    public enum XLOperator { EqualTo, NotEqualTo, GreaterThan, LessThan, EqualOrGreaterThan, EqualOrLessThan, Between, NotBetween }

    public interface IXLDataValidation
    {
        XLAllowedValues AllowedValues { get; set; }

        XLDateCriteria Date { get; }

        XLDecimalCriteria Decimal { get; }

        String ErrorMessage { get; set; }

        XLErrorStyle ErrorStyle { get; set; }

        String ErrorTitle { get; set; }

        Boolean IgnoreBlanks { get; set; }

        Boolean InCellDropdown { get; set; }

        String InputMessage { get; set; }

        String InputTitle { get; set; }

        String MaxValue { get; set; }

        String MinValue { get; set; }

        XLOperator Operator { get; set; }

        /// <summary>
        /// A collection of ranges the data validation rule applies too.
        /// </summary>
        IEnumerable<IXLRange> Ranges { get; }

        Boolean ShowErrorMessage { get; set; }

        //void Delete();
        //void CopyFrom(IXLDataValidation dataValidation);
        Boolean ShowInputMessage { get; set; }

        XLTextLengthCriteria TextLength { get; }

        XLTimeCriteria Time { get; }

        String Value { get; set; }

        XLWholeNumberCriteria WholeNumber { get; }

        /// <summary>
        /// Add a range to the collection of ranges this rule applies to.
        /// If the specified range does not belong to the worksheet of the data validation
        /// rule it is transferred to the target worksheet.
        /// </summary>
        /// <param name="range">A range to add.</param>
        void AddRange(IXLRange range);

        /// <summary>
        /// Add a collection of ranges to the collection of ranges this rule applies to.
        /// Ranges that do not belong to the worksheet of the data validation
        /// rule are transferred to the target worksheet.
        /// </summary>
        /// <param name="ranges">Ranges to add.</param>
        void AddRanges(IEnumerable<IXLRange> ranges);

        void Clear();

        /// <summary>
        /// Detach data validation rule of all ranges it applies to.
        /// </summary>
        void ClearRanges();

        void Custom(String customValidation);

        Boolean IsDirty();

        void List(String list);

        void List(String list, Boolean inCellDropdown);

        void List(IXLRange range);

        void List(IXLRange range, Boolean inCellDropdown);

        /// <summary>
        /// Remove the specified range from the collection of range this rule applies to.
        /// </summary>
        /// <param name="range">A range to remove.</param>
        bool RemoveRange(IXLRange range);
    }
}


text:
/*
 * D_OPEN.C.
 *
 * Written by Peter Sulyok 1995 <sulyok@math.klte.hu>.
 *
 * This file is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#include <libc/dosio.h>
#include <errno.h>
#include <dos.h>
#include<menuet/os.h>

unsigned int _dos_open(const char *filename, unsigned int mode, int *handle)
{
 int i;
 i=dosemu_open(filename,mode);
 if(i==-1) return -1;
 if(handle) *handle=i;
 return 0;
}


text:
package me.dablakbandit.customentitiesapi.entities;

import ja.CtClass;

public abstract class CustomEntityInsentient extends CustomEntityLiving {

	public CustomEntityInsentient(String name) {
		super(name);
		if (ctClass == null)
			return;
		try {
			try {
				Class.forName("temp.CustomEntityInsentientHelper");
			} catch (Exception e) {
				CtClass ces = cp
						.getAndRename(
								"me.dablakbandit.customentitiesapi.entities.CustomEntityInsentientHelper",
								"temp.CustomEntityInsentientHelper");
				ces.setSuperclass(cp.get("temp.CustomEntityLivingHelper"));
				ces.toClass();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalAll() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalAll",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalFloatDefault() {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalFloat", Object.class)
					.invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalFloat() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalFloat",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalEatTileDefault() {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalEatTile",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalEatTile() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalEatTile",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalLookAtPlayer(float f, float f2) {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalLookAtPlayer",
					Object.class, float.class, float.class).invoke(null,
					entity, f, f2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Deprecated
	public void newGoalSelectorPathfinderGoalLookAtPlayer(String class0,
			float f, float f2) {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalLookAtPlayer",
					Object.class, String.class, float.class, float.class)
					.invoke(null, entity, class0, f, f2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalLookAtPlayer(EntityName en,
			float f, float f2) {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalLookAtPlayer",
					Object.class, String.class, float.class, float.class)
					.invoke(null, entity, en.getName(), f, f2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalLookAtPlayer(float f) {
		newGoalSelectorPathfinderGoalLookAtPlayer(f, 0.02F);
	}

	public void newGoalSelectorPathfinderGoalLookAtPlayer(EntityName en, float f) {
		newGoalSelectorPathfinderGoalLookAtPlayer(en, f, 0.02F);
	}

	public void removeGoalSelectorPathfinderGoalLookAtPlayer() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalLookAtPlayer",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalRandomLookaroundDefault() {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalRandomLookaround",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalRandomLookaround() {
		try {
			helper.getMethod(
					"removeGoalSelectorPathfinderGoalRandomLookaround",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalBreakDoorDefault() {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalBreakDoor",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalBreakDoor() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalBreakDoor",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalOpenDoor(boolean b) {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalOpenDoor",
					Object.class, boolean.class).invoke(null, entity, b);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalOpenDoor() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalOpenDoor",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Deprecated
	public void newGoalSelectorPathfinderGoalInteract(String class0, float f,
			float f2) {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalInteract",
					Object.class, String.class, float.class, float.class)
					.invoke(null, entity, class0, f, f2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalInteract(EntityName en, float f,
			float f2) {
		try {
			helper.getMethod("newGoalSelectorPathfinderGoalInteract",
					Object.class, String.class, float.class, float.class)
					.invoke(null, entity, en.getName(), f, f2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void newGoalSelectorPathfinderGoalInteract(float f, float f2) {
		newGoalSelectorPathfinderGoalInteract(EntityName.ENTITYPLAYER, f, f2);
	}

	public void newGoalSelectorPathfinderGoalInteract(float f) {
		newGoalSelectorPathfinderGoalInteract(f, 0.02F);
	}

	public void newGoalSelectorPathfinderGoalLeapAtTarget(float f){
		try{
			helper.getMethod("newGoalSelectorPathfinderGoalLeapAtTarget", Object.class, double.class).invoke(null, entity, f);
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalLeapAtTarget() {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalLeapAtTarget",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void removeGoalSelectorPathfinderGoalInteract(Object insentient) {
		try {
			helper.getMethod("removeGoalSelectorPathfinderGoalInteract",
					Object.class).invoke(null, entity);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public String getCustomName() {
		try {
			return (String) entity.getClass().getMethod("getCustomName")
					.invoke(entity);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	public boolean getCustomNameVisible() {
		try {
			return (Boolean) entity.getClass()
					.getMethod("getCustomNameVisible").invoke(entity);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	public String getName() {
		try {
			return (String) entity.getClass().getMethod("getName")
					.invoke(entity);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	public void setCustomName(String s) {
		try {
			entity.getClass().getMethod("setCustomName", String.class)
					.invoke(entity, s);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void setCustomNameVisible(boolean flag) {
		try {
			entity.getClass().getMethod("setCustomNameVisible", boolean.class)
					.invoke(entity, flag);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public boolean hasCustomName() {
		try {
			return (Boolean) entity.getClass().getMethod("hasCustomName")
					.invoke(entity);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
}


text:
package org.ikernits.lib.vaadin.builders;

import com.vaadin.ui.Grid;
import com.vaadin.data.Container.Indexed;
import com.vaadin.data.fieldgroup.FieldGroup;
import com.vaadin.data.fieldgroup.FieldGroupFieldFactory;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
import com.vaadin.event.SelectionEvent.SelectionListener;
import com.vaadin.event.SortEvent.SortListener;
import com.vaadin.server.Sizeable.Unit;
import com.vaadin.shared.ui.grid.ColumnResizeMode;
import com.vaadin.shared.ui.grid.HeightMode;
import com.vaadin.ui.Grid.CellDescriptionGenerator;
import com.vaadin.ui.Grid.CellStyleGenerator;
import com.vaadin.ui.Grid.ColumnReorderListener;
import com.vaadin.ui.Grid.ColumnResizeListener;
import com.vaadin.ui.Grid.ColumnVisibilityChangeListener;
import com.vaadin.ui.Grid.DetailsGenerator;
import com.vaadin.ui.Grid.EditorErrorHandler;
import com.vaadin.ui.Grid.HeaderRow;
import com.vaadin.ui.Grid.RowDescriptionGenerator;
import com.vaadin.ui.Grid.RowStyleGenerator;
import com.vaadin.ui.Grid.SelectionMode;
import com.vaadin.ui.Grid.SelectionModel;
import java.util.List;

@SuppressWarnings({"deprecation", "unused", "unchecked"})
public class GridBuilder<T extends Grid, B extends GridBuilder<T, B>> extends AbstractFocusableBuilder<T, B> {

    public GridBuilder(T delegate) {
        super(delegate);
    }

    /**
     * @see com.vaadin.ui.Grid#addColumn
     */
    public B addColumn(Object param1, Class param2) {
        delegate.addColumn(param1, param2);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addColumn
     */
    public B addColumn(Object column) {
        delegate.addColumn(column);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setColumnResizeMode
     */
    public B setColumnResizeMode(ColumnResizeMode columnResizeMode) {
        delegate.setColumnResizeMode(columnResizeMode);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setFrozenColumnCount
     */
    public B setFrozenColumnCount(int frozenColumnCount) {
        delegate.setFrozenColumnCount(frozenColumnCount);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setHeightByRows
     */
    public B setHeightByRows(double heightByRows) {
        delegate.setHeightByRows(heightByRows);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setHeightMode
     */
    public B setHeightMode(HeightMode heightMode) {
        delegate.setHeightMode(heightMode);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setSelectionModel
     */
    public B setSelectionModel(SelectionModel selectionModel) {
        delegate.setSelectionModel(selectionModel);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setSelectionMode
     */
    public B setSelectionMode(SelectionMode selectionMode) {
        delegate.setSelectionMode(selectionMode);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addSelectionListener
     */
    public B addSelectionListener(SelectionListener selectionListener) {
        delegate.addSelectionListener(selectionListener);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setSortOrder
     */
    public B setSortOrder(List sortOrder) {
        delegate.setSortOrder(sortOrder);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addSortListener
     */
    public B addSortListener(SortListener sortListener) {
        delegate.addSortListener(sortListener);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addHeaderRowAt
     */
    public B addHeaderRowAt(int headerRowAt) {
        delegate.addHeaderRowAt(headerRowAt);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setDefaultHeaderRow
     */
    public B setDefaultHeaderRow(HeaderRow defaultHeaderRow) {
        delegate.setDefaultHeaderRow(defaultHeaderRow);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setHeaderVisible
     */
    public B setHeaderVisible(boolean headerVisible) {
        delegate.setHeaderVisible(headerVisible);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addFooterRowAt
     */
    public B addFooterRowAt(int footerRowAt) {
        delegate.addFooterRowAt(footerRowAt);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setCellDescriptionGenerator
     */
    public B setCellDescriptionGenerator(CellDescriptionGenerator cellDescriptionGenerator) {
        delegate.setCellDescriptionGenerator(cellDescriptionGenerator);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setRowDescriptionGenerator
     */
    public B setRowDescriptionGenerator(RowDescriptionGenerator rowDescriptionGenerator) {
        delegate.setRowDescriptionGenerator(rowDescriptionGenerator);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setRowStyleGenerator
     */
    public B setRowStyleGenerator(RowStyleGenerator rowStyleGenerator) {
        delegate.setRowStyleGenerator(rowStyleGenerator);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorEnabled
     */
    public B setEditorEnabled(boolean editorEnabled) {
        delegate.setEditorEnabled(editorEnabled);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorFieldGroup
     */
    public B setEditorFieldGroup(FieldGroup editorFieldGroup) {
        delegate.setEditorFieldGroup(editorFieldGroup);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorFieldFactory
     */
    public B setEditorFieldFactory(FieldGroupFieldFactory editorFieldFactory) {
        delegate.setEditorFieldFactory(editorFieldFactory);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorErrorHandler
     */
    public B setEditorErrorHandler(EditorErrorHandler editorErrorHandler) {
        delegate.setEditorErrorHandler(editorErrorHandler);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorSaveCaption
     */
    public B setEditorSaveCaption(String editorSaveCaption) {
        delegate.setEditorSaveCaption(editorSaveCaption);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorCancelCaption
     */
    public B setEditorCancelCaption(String editorCancelCaption) {
        delegate.setEditorCancelCaption(editorCancelCaption);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setEditorBuffered
     */
    public B setEditorBuffered(boolean editorBuffered) {
        delegate.setEditorBuffered(editorBuffered);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addColumnVisibilityChangeListener
     */
    public B addColumnVisibilityChangeListener(ColumnVisibilityChangeListener columnVisibilityChangeListener) {
        delegate.addColumnVisibilityChangeListener(columnVisibilityChangeListener);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setDetailsGenerator
     */
    public B setDetailsGenerator(DetailsGenerator detailsGenerator) {
        delegate.setDetailsGenerator(detailsGenerator);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setDetailsVisible
     */
    public B setDetailsVisible(Object param1, boolean param2) {
        delegate.setDetailsVisible(param1, param2);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setHeight
     */
    public B setHeight(float height, Unit unit) {
        delegate.setHeight(height, unit);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setContainerDataSource
     */
    public B setContainerDataSource(Indexed containerDataSource) {
        delegate.setContainerDataSource(containerDataSource);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addListener
     */
    public B addListener(ItemClickListener listener) {
        delegate.addListener(listener);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setColumnReorderingAllowed
     */
    public B setColumnReorderingAllowed(boolean columnReorderingAllowed) {
        delegate.setColumnReorderingAllowed(columnReorderingAllowed);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setCellStyleGenerator
     */
    public B setCellStyleGenerator(CellStyleGenerator cellStyleGenerator) {
        delegate.setCellStyleGenerator(cellStyleGenerator);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addItemClickListener
     */
    public B addItemClickListener(ItemClickListener itemClickListener) {
        delegate.addItemClickListener(itemClickListener);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#setFooterVisible
     */
    public B setFooterVisible(boolean footerVisible) {
        delegate.setFooterVisible(footerVisible);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addColumnResizeListener
     */
    public B addColumnResizeListener(ColumnResizeListener columnResizeListener) {
        delegate.addColumnResizeListener(columnResizeListener);
        return self;
    }

    /**
     * @see com.vaadin.ui.Grid#addColumnReorderListener
     */
    public B addColumnReorderListener(ColumnReorderListener columnReorderListener) {
        delegate.addColumnReorderListener(columnReorderListener);
        return self;
    }

}