folly::StringKeyedSetBase< Compare, Alloc > Class Template Reference

#include <StringKeyedSet.h>

Inheritance diagram for folly::StringKeyedSetBase< Compare, Alloc >:

Public Types
typedef Base::key_type	key_type
typedef Base::value_type	value_type
typedef Base::key_compare	key_compare
typedef Base::allocator_type	allocator_type
typedef Base::reference	reference
typedef Base::const_reference	const_reference
typedef Base::pointer	pointer
typedef Base::const_pointer	const_pointer
typedef Base::iterator	iterator
typedef Base::const_iterator	const_iterator
typedef Base::reverse_iterator	reverse_iterator
typedef Base::const_reverse_iterator	const_reverse_iterator
typedef Base::size_type	size_type
typedef Base::difference_type	difference_type

Public Member Functions
	StringKeyedSetBase (const key_compare &comp=key_compare(), const allocator_type &alloc=allocator_type())
	StringKeyedSetBase (const allocator_type &alloc)
template<class InputIterator >
	StringKeyedSetBase (InputIterator b, InputIterator e, const key_compare &comp=key_compare(), const allocator_type &alloc=allocator_type())
	StringKeyedSetBase (const StringKeyedSetBase &rhs)
	StringKeyedSetBase (const StringKeyedSetBase &rhs, const allocator_type &a)
	StringKeyedSetBase (StringKeyedSetBase &&other) noexcept
	StringKeyedSetBase (StringKeyedSetBase &&other, const allocator_type &alloc) noexcept
	StringKeyedSetBase (std::initializer_list< value_type > il, const key_compare &comp=key_compare(), const allocator_type &alloc=allocator_type())
StringKeyedSetBase &	operator= (const StringKeyedSetBase &other)
StringKeyedSetBase &	operator= (StringKeyedSetBase &&other) noexcept
bool	operator== (StringKeyedSetBase const &other) const
template<class... Args>
std::pair< iterator, bool >	emplace (Args &&...args)
std::pair< iterator, bool >	insert (value_type val)
iterator	erase (const_iterator position)
size_type	erase (StringPiece key)
void	clear () noexcept
void	swap (StringKeyedSetBase &other)&
	~StringKeyedSetBase ()

Private Types
using	Base = std::set< StringPiece, Compare, Alloc >

Detailed Description

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>
class folly::StringKeyedSetBase< Compare, Alloc >

Wrapper class for set<string> that can perform lookup operations with StringPiece, not only string.

It uses kind of hack: string pointed by StringPiece is copied when StringPiece is inserted into set

Definition at line 40 of file StringKeyedSet.h.

Member Typedef Documentation

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::allocator_type folly::StringKeyedSetBase< Compare, Alloc >::allocator_type

Definition at line 48 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

using folly::StringKeyedSetBase< Compare, Alloc >::Base = std::set<StringPiece, Compare, Alloc>

private

Definition at line 42 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::const_iterator folly::StringKeyedSetBase< Compare, Alloc >::const_iterator

Definition at line 54 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::const_pointer folly::StringKeyedSetBase< Compare, Alloc >::const_pointer

Definition at line 52 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::const_reference folly::StringKeyedSetBase< Compare, Alloc >::const_reference

Definition at line 50 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::const_reverse_iterator folly::StringKeyedSetBase< Compare, Alloc >::const_reverse_iterator

Definition at line 56 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::difference_type folly::StringKeyedSetBase< Compare, Alloc >::difference_type

Definition at line 58 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::iterator folly::StringKeyedSetBase< Compare, Alloc >::iterator

Definition at line 53 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::key_compare folly::StringKeyedSetBase< Compare, Alloc >::key_compare

Definition at line 47 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::key_type folly::StringKeyedSetBase< Compare, Alloc >::key_type

Definition at line 45 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::pointer folly::StringKeyedSetBase< Compare, Alloc >::pointer

Definition at line 51 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::reference folly::StringKeyedSetBase< Compare, Alloc >::reference

Definition at line 49 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::reverse_iterator folly::StringKeyedSetBase< Compare, Alloc >::reverse_iterator

Definition at line 55 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::size_type folly::StringKeyedSetBase< Compare, Alloc >::size_type

Definition at line 57 of file StringKeyedSet.h.

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

typedef Base::value_type folly::StringKeyedSetBase< Compare, Alloc >::value_type

Definition at line 46 of file StringKeyedSet.h.

Constructor & Destructor Documentation

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( const key_compare &  comp = key_compare(), const allocator_type &  alloc = allocator_type()  )

inlineexplicit

Definition at line 60 of file StringKeyedSet.h.

Referenced by folly::StringKeyedSetBase< Compare, Alloc >::operator=().

      : Base(comp, alloc) {}

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( const allocator_type &  alloc )

inlineexplicit

Definition at line 65 of file StringKeyedSet.h.

: Base(alloc) {}

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

template<class InputIterator >

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( InputIterator  b, InputIterator  e, const key_compare &  comp = key_compare(), const allocator_type &  alloc = allocator_type()  )

inline

Definition at line 68 of file StringKeyedSet.h.

References b, and folly::StringKeyedSetBase< Compare, Alloc >::emplace().

      : Base(comp, alloc) {
    for (; b != e; ++b) {
      emplace(*b);
    }
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( const StringKeyedSetBase< Compare, Alloc > &  rhs )

inline

Definition at line 79 of file StringKeyedSet.h.

      : StringKeyedSetBase(rhs, rhs.get_allocator()) {}

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( const StringKeyedSetBase< Compare, Alloc > &  rhs, const allocator_type &  a  )

inline

Definition at line 82 of file StringKeyedSet.h.

      : StringKeyedSetBase(rhs.begin(), rhs.end(), rhs.key_comp(), a) {}

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( StringKeyedSetBase< Compare, Alloc > &&  other )

inlinenoexcept

Definition at line 85 of file StringKeyedSet.h.

      : Base(std::move(other)) {
    assert(other.empty());
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( StringKeyedSetBase< Compare, Alloc > &&  other, const allocator_type &  alloc  )

inlinenoexcept

Definition at line 90 of file StringKeyedSet.h.

      : Base(std::move(other), alloc) {
    assert(other.empty());
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase ( std::initializer_list< value_type >  il, const key_compare &  comp = key_compare(), const allocator_type &  alloc = allocator_type()  )

inline

Definition at line 97 of file StringKeyedSet.h.

      : StringKeyedSetBase(il.begin(), il.end(), comp, alloc) {}

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

folly::StringKeyedSetBase< Compare, Alloc >::~StringKeyedSetBase ( )

inline

Definition at line 183 of file StringKeyedSet.h.

References folly::stringPieceDel().

                        {
    // Here we assume that set doesn't use keys in destructor
    for (auto it : *this) {
      stringPieceDel(it, get_allocator());
    }
  }

Member Function Documentation

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

void folly::StringKeyedSetBase< Compare, Alloc >::clear ( )

inlinenoexcept

Definition at line 170 of file StringKeyedSet.h.

References folly::stringPieceDel().

Referenced by folly::StringKeyedSetBase< Compare, Alloc >::operator=().

                        {
    for (auto it : *this) {
      stringPieceDel(it, get_allocator());
    }
    Base::clear();
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

template<class... Args>

std::pair<iterator, bool> folly::StringKeyedSetBase< Compare, Alloc >::emplace ( Args &&...  args )

inline

Definition at line 137 of file StringKeyedSet.h.

References folly::test::end(), and folly::stringPieceDup().

Referenced by folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase(), and TEST().

                                                  {
    auto key = StringPiece(std::forward<Args>(args)...);
    auto it = find(key);
    if (it != end()) {
      return {it, false};
    }
    return Base::emplace(stringPieceDup(key, get_allocator()));
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

iterator folly::StringKeyedSetBase< Compare, Alloc >::erase ( const_iterator  position )

inline

Definition at line 154 of file StringKeyedSet.h.

References folly::stringPieceDel().

Referenced by folly::StringKeyedSetBase< Compare, Alloc >::erase(), and TEST().

                                          {
    auto key = *position;
    auto result = Base::erase(position);
    stringPieceDel(key, get_allocator());
    return result;
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

size_type folly::StringKeyedSetBase< Compare, Alloc >::erase ( StringPiece  key )

inline

Definition at line 161 of file StringKeyedSet.h.

References folly::test::end(), and folly::StringKeyedSetBase< Compare, Alloc >::erase().

                                   {
    auto it = find(key);
    if (it == end()) {
      return 0;
    }
    erase(it);
    return 1;
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

std::pair<iterator, bool> folly::StringKeyedSetBase< Compare, Alloc >::insert ( value_type  val )

inline

Definition at line 146 of file StringKeyedSet.h.

References folly::test::end(), and folly::stringPieceDup().

Referenced by TEST().

                                                 {
    auto it = find(val);
    if (it != end()) {
      return {it, false};
    }
    return Base::insert(stringPieceDup(val, get_allocator()));
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

StringKeyedSetBase& folly::StringKeyedSetBase< Compare, Alloc >::operator= ( const StringKeyedSetBase< Compare, Alloc > &  other )

inline

Definition at line 103 of file StringKeyedSet.h.

References folly::StringKeyedSetBase< Compare, Alloc >::StringKeyedSetBase().

                                                                 {
    if (this == &other) {
      return *this;
    }
    return *this = StringKeyedSetBase(other);
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

StringKeyedSetBase& folly::StringKeyedSetBase< Compare, Alloc >::operator= ( StringKeyedSetBase< Compare, Alloc > &&  other )

inlinenoexcept

Definition at line 110 of file StringKeyedSet.h.

References folly::test::begin(), folly::padded::cbegin(), folly::padded::cend(), folly::StringKeyedSetBase< Compare, Alloc >::clear(), count, folly::empty(), folly::test::end(), folly::gen::move, and folly::size().

                                                                     {
    assert(this != &other);
    clear();
    Base::operator=(std::move(other));
    assert(other.empty());
    return *this;
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

bool folly::StringKeyedSetBase< Compare, Alloc >::operator== ( StringKeyedSetBase< Compare, Alloc > const &  other ) const

inline

Definition at line 130 of file StringKeyedSet.h.

References testing::Args(), upload::const, and folly::detail::rhs.

                                                         {
    Base const& lhs = *this;
    Base const& rhs = static_cast<Base const&>(other);
    return lhs == rhs;
  }

template<class Compare = std::less<StringPiece>, class Alloc = std::allocator<StringPiece>>

void folly::StringKeyedSetBase< Compare, Alloc >::swap ( StringKeyedSetBase< Compare, Alloc > &  other )

inline

Definition at line 179 of file StringKeyedSet.h.

References folly::f14::swap().

                                         {
    return Base::swap(other);
  }

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/experimental/StringKeyedSet.h