STL Definitions

gistfile1.cpp

#define general_methods(container)                                                                      \
    explicit container ({[size_type n, {const value_type& val = value_type()}, {charT c}]},             \
                        {const key_compare& comp = key_compare()},                                      \
                        const allocator_type& alloc = allocator_type());                                \
    template <class InputIterator>                                                                      \
    container (InputIterator first, InputIterator last, {const key_compare& comp = key_compare()},      \
               const allocator_type& alloc = allocator_type());                                         \
    container (const container& x);                                                                     \
    container& operator= (const container& x);                                                          \
                                                                                                        \
    // iterators                                                                                        \
    iterator begin();           // const;                                                               \
    iterator end();             // const;                                                               \
    reverse_iterator rbegin();  // const;                                                               \
    reverse_iterator rend();    // const;                                                               \
                                                                                                        \
    // capacity                                                                                         \
    bool empty() const;                                                                                 \
    size_type size() const;                                                                             \
    size_type max_size() const;                                                                         \
                                                                                                        \
    // modifiers                                                                                        \
    iterator insert (iterator position, const value_type& val);                                         \
    template <class InputIterator>                                                                      \
    void insert ({iterator position}, InputIterator first, InputIterator last);                         \
    iterator erase (iterator position);                                                                 \
    iterator erase (iterator first, iterator last);                                                     \
    void swap (container& x);                                                                           \
    void clear();

// <algorithm>
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);
template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type count (InputIterator first, InputIterator last, const T& val);

template <class ForwardIterator, class T>
void fill (ForwardIterator first, ForwardIterator last, const T& val);
template <class ForwardIterator, [class BinaryPredicate]>
ForwardIterator unique (ForwardIterator first, ForwardIterator last, [BinaryPredicate pred]);

template <class RandomAccessIterator, [class Compare]>
void sort (RandomAccessIterator first, RandomAccessIterator last, [Compare comp]);

template <class RandomAccessIterator, [class Compare]>
void nth_element (RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, [Compare comp]);

template <class ForwardIterator, class T, [class Compare]>
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val, [Compare comp]);
template <class ForwardIterator, class T, [class Compare]>
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& val, [Compare comp]);

template <class T, [class Compare]>
const T& min (const T& a, const T& b, [Compare comp]);
template <class T, [class Compare]>
const T& max (const T& a, const T& b, [Compare comp]);

// <bitset>
template <size_t N>
class bitset
{
    bitset ([unsigned long val]);
    template<class charT, class traits, class Alloc>
    explicit bitset (const basic_string<charT,traits,Alloc>& str,
                     typename basic_string<charT,traits,Alloc>::size_type pos = 0,
                     typename basic_string<charT,traits,Alloc>::size_type n = basic_string<charT,traits,Alloc>::npos);
    
    bitset& operator&= (const bitset& rhs);
    bitset& operator|= (const bitset& rhs);
    bitset& operator^= (const bitset& rhs);
    bitset& operator<<= (size_t pos);
    bitset& operator>>= (size_t pos);
    bitset operator~() const;
    bitset operator<<(size_t pos) const;
    bitset operator>>(size_t pos) const;
    bool operator== (const bitset& rhs) const;
    bool operator!= (const bitset& rhs) const;
    
    // bit access
    bool operator[] (size_t pos) const;
    reference operator[] (size_t pos);
    size_t count() const;
    size_t size() const;
    bool test (size_t pos) const;
    bool any() const;
    bool none() const;
    
    // bit operations
    bitset& set ([size_t pos, bool val = true]);
    bitset& reset ([size_t pos]);
    bitset& flip ([size_t pos]);
    
    // bitset operations
    template <class charT, class traits, class Alloc>
    basic_string<charT,traits,Alloc> to_string() const;
    unsigned long to_ulong() const;
};

template<size_t N>
bitset<N> operator& (const bitset<N>& lhs, const bitset<N>& rhs);
template<size_t N>
bitset<N> operator| (const bitset<N>& lhs, const bitset<N>& rhs);
template<size_t N>
bitset<N> operator^ (const bitset<N>& lhs, const bitset<N>& rhs);

template<class charT, class traits, size_t N>
basic_istream<charT, traits>& operator>> (basic_istream<charT,traits>& is, bitset<N>& rhs);
template<class charT, class traits, size_t N>
basic_ostream<charT, traits>& operator<< (basic_ostream<charT,traits>& os, const bitset<N>& rhs);

// <cmath>
double sqrt (double x);

// <cctype>
int isalpha ( int c );
int islower ( int c );
int ispunct ( int c );
int isspace ( int c );
int isupper ( int c );

// <cstring>
char * strcpy ( char * destination, const char * source );
int strcmp ( const char * str1, const char * str2 );
size_t strlen ( const char * str );

// <deque>
template < class T, class Alloc = allocator<T> >
class deque
{
    general_methods(deque);
    
    // capacity
    void resize (size_type n, value_type val = value_type());
    size_type capacity() const;

    // element access
    reference operator[] (size_type n); // const;
    reference at (size_type n);         // const;
    reference front();                  // const;
    reference back();                   // const;
    
    // modifiers
    void insert (iterator position, size_type n, const value_type& val);
    template <class InputIterator>
    void assign (InputIterator first, InputIterator last);
    void assign (size_type n, const value_type& val);
    void push_back (const value_type& val);
    void push_front (const value_type& val);
    void pop_back();
    void pop_front();
    
    // allocator
    allocator_type get_allocator() const;
};

// <map>
template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> > >  // map::allocator_type
class map
{
    typedef pair<const Key, T> value_type;
    
    general_methods(map);

    // element access
    mapped_type& operator[] (const key_type& k);
    
    // modifiers
    pair<iterator,bool> insert (const value_type& val);
    size_type erase (const key_type& k);
    
    // observers
    key_compare key_comp() const;
    value_compare value_comp() const;
    
    // operations
    iterator find (const key_type& k);                          // const;
    size_type count (const key_type& k) const;
    iterator lower_bound (const key_type& k);                   // const;
    iterator upper_bound (const key_type& k);                   // const;
    pair<iterator,iterator> equal_range (const key_type& k);    // const;
    
    // allocator
    allocator_type get_allocator() const;
};

template < class Key,                                     // multimap::key_type
           class T,                                       // multimap::mapped_type
           class Compare = less<Key>,                     // multimap::key_compare
           class Alloc = allocator<pair<const Key,T> > >  // multimap::allocator_type
class multimap
{
    typedef pair<const Key, T> value_type;

    general_methods(multimap);
    
    // modifiers
    iterator insert (const value_type& val);
    size_type erase (const key_type& k);
    
    // observers
    key_compare key_comp() const;
    value_compare value_comp() const;
    
    // operations
    iterator find (const key_type& k);                          // const;
    size_type count (const key_type& k) const;
    iterator lower_bound (const key_type& k);                   // const;
    iterator upper_bound (const key_type& k);                   // const;
    pair<iterator,iterator> equal_range (const key_type& k);    // const;
    
    // allocator
    allocator_type get_allocator() const;
};

// <queue>
template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type> >
class priority_queue
{
    explicit priority_queue (const Compare& comp = Compare(), const Container& ctnr = Container());
    template <class InputIterator>
    priority_queue (InputIterator first, InputIterator last, const Compare& comp = Compare(),
                    const Container& ctnr = Container());
    bool empty() const;
    size_type size() const;
    const value_type& top() const;
    void push (const value_type& val);
    void pop();
};

template <class T, class Container = deque<T> >
class queue
{
    explicit queue (const container_type& ctnr = container_type());
    bool empty() const;
    size_type size() const;
    value_type& front();    // const;
    value_type& back();     // const;
    void push (const value_type& val);
    void pop();
};

// relational operators: compare memberwise

// <set>
template < class T,                        // multiset::key_type/value_type
           class Compare = less<T>,        // multiset::key_compare/value_compare
           class Alloc = allocator<T> > >  // multiset::allocator_type
class multiset
{
    typedef pair<const Key, T> value_type;
    
    general_methods(multiset);
    
    iterator insert (const value_type& val);
    size_type erase (const value_type& val);
    
    key_compare key_comp() const;
    value_compare value_comp() const;
    
    iterator find (const value_type& val) const;
    size_type count (const value_type& val) const;
    iterator lower_bound (const value_type& val) const;
    iterator upper_bound (const value_type& val) const;
    pair<iterator,iterator> equal_range (const value_type& val) const;
    
    // allocator
    allocator_type get_allocator() const;
};

template < class T,                        // set::key_type/value_type
           class Compare = less<T>,        // set::key_compare/value_compare
           class Alloc = allocator<T> >    // set::allocator_type
class set
{
    general_methods(set);
    
    pair<iterator,bool> insert (const value_type& val);
    size_type erase (const value_type& val);
    
    key_compare key_comp() const;
    value_compare value_comp() const;
    
    iterator find (const value_type& val) const;
    size_type count (const value_type& val) const;
    iterator lower_bound (const value_type& val) const;
    iterator upper_bound (const value_type& val) const;
    pair<iterator,iterator> equal_range (const value_type& val) const;
    
    // allocator
    allocator_type get_allocator() const;
};

// <string>
template < class charT,
           class traits = char_traits<charT>,    // basic_string::traits_type
           class Alloc = allocator<charT> >      // basic_string::allocator_type
class basic_string
{
    static const size_type npos = -1;
    
    general_methods(basic_string);
    
    basic_string (const basic_string& str, size_type pos, size_type len = npos,
                  const allocator_type& alloc = allocator_type());
    basic_string (const charT* s, const allocator_type& alloc = allocator_type());
    basic_string (const charT* s, size_type n, const allocator_type& alloc = allocator_type());
    basic_string& operator= (const charT* s);
    basic_string& operator= (charT c);
    
    // capacity
    size_type length() const;
    void resize (size_type n, [charT c]);
    size_type capacity() const;
    void reserve (size_type n = 0);
    
    // element access
    reference operator[] (size_type pos);   // const;
    reference at (size_type pos);           // const;
    
    // modifiers
    basic_string& operator+= (const basic_string& str);
    basic_string& operator+= (const charT* s);
    basic_string& operator+= (charT c);
    basic_string& append (const basic_string& str, [size_type subpos, size_type sublen]);
    basic_string& append (const charT* s, [size_type n]);
    basic_string& append (size_type n, charT c);
    template <class InputIterator>
    basic_string& append (InputIterator first, InputIterator last);
    void push_back (charT c);
    basic_string& assign (const basic_string& str, [size_type subpos, size_type sublen]);
    basic_string& assign (const charT* s, [size_type n]);
    basic_string& assign (size_type n, charT c);
    template <class InputIterator>
    basic_string& assign (InputIterator first, InputIterator last);
    basic_string& insert (size_type pos, const basic_string& str, [size_type subpos, size_type sublen]);
    basic_string& insert (size_type pos, const charT* s, [size_type n]);
    basic_string& insert (size_type pos, size_type n, charT c);
    void insert (iterator p,     size_type n, charT c);
    basic_string& erase (size_type pos = 0, size_type len = npos);
    basic_string& replace (size_type pos, size_type len, const basic_string& str,
                           [size_type subpos, size_type sublen]);
    basic_string& replace (iterator i1,   iterator i2,   const basic_string& str);
    basic_string& replace (size_type pos, size_type len, const charT* s, [size_type n]);
    basic_string& replace (iterator i1,   iterator i2,   const charT* s, [size_type n]);
    basic_string& replace (size_type pos, size_type len, size_type n, charT c);
    basic_string& replace (iterator i1,   iterator i2,   size_type n, charT c);
    template <class InputIterator>
    basic_string& replace (iterator i1, iterator i2, InputIterator first, InputIterator last);
    
    // string operations
    const charT* c_str() const;
    const charT* data() const;
    allocator_type get_allocator() const;
    size_type copy (charT* s, size_type len, size_type pos = 0) const;
    size_type find (const basic_string& str, size_type pos = 0) const;
    size_type find (const charT* s, size_type pos = 0, [size_type n]) const;
    size_type find (charT c, size_type pos = 0) const;
    size_type rfind (const basic_string& str, size_type pos = npos) const;
    size_type rfind (const charT* s, size_type pos = npos, [size_type n]) const;
    size_type rfind (charT c, size_type pos = npos) const;
    size_type find_first_of (const basic_string& str, size_type pos = 0) const;
    size_type find_first_of (const charT* s, size_type pos = 0, [size_type n]) const;
    size_type find_first_of (charT c, size_type pos = 0) const;
    size_type find_last_of (const basic_string& str, size_type pos = npos) const;
    size_type find_last_of (const charT* s, size_type pos = npos, [size_type n]) const;
    size_type find_last_of (charT c, size_type pos = npos) const;
    size_type find_first_not_of (const basic_string& str, size_type pos = 0) const;
    size_type find_first_not_of (const charT* s, size_type pos = 0, [size_type n]) const;
    size_type find_first_not_of (charT c, size_type pos = 0) const;
    size_type find_last_not_of (const basic_string& str, size_type pos = npos) const;
    size_type find_last_not_of (const charT* s, size_type pos = npos, [size_type n]) const;
    size_type find_last_not_of (charT c, size_type pos = npos) const;
    basic_string substr (size_type pos = 0, size_type len = npos) const;
    int compare (const basic_string& str) const;
    int compare (size_type pos, size_type len, const basic_string& str, [size_type subpos, size_type sublen]) const;
    int compare (const charT* s) const;
    int compare (size_type pos, size_type len, const charT* s, [size_type n]) const;
};

template <class charT, class traits, class Alloc>
basic_string operator+ (const basic_string<charT,traits,Alloc>& lhs, const basic_string<charT,traits,Alloc>& rhs);
template <class charT, class traits, class Alloc>
basic_string operator+ (const basic_string<charT,traits,Alloc>& lhs, const charT* rhs);
template <class charT, class traits, class Alloc>
basic_string operator+ (const charT* lhs, const basic_string<charT,traits,Alloc>& rhs);
template <class charT, class traits, class Alloc>
basic_string operator+ (const basic_string<charT,traits,Alloc>& lhs, charT rhs);
template <class charT, class traits, class Alloc>
basic_string operator+ (charT lhs, const basic_string<charT,traits,Alloc>& rhs);

// relational operators: compare memberwise

template <class charT, class traits, class Alloc>
void swap (basic_string<charT,traits,Alloc>& x, basic_string<charT,traits,Alloc>& y);
template <class charT, class traits, class Alloc>
basic_istream<charT,traits>& operator>> (basic_istream<charT,traits>& is, basic_string<charT,traits,Alloc>& str);
template <class charT, class traits, class Alloc>
basic_ostream<charT,traits>& operator<< (basic_ostream<charT,traits>& os, const basic_string<charT,traits,Alloc>& str);
template <class charT, class traits, class Alloc>
basic_istream<charT,traits>& getline (basic_istream<charT,traits>& is,
                                      basic_string<charT,traits,Alloc>& str, charT delim);
template <class charT, class traits, class Alloc>
basic_istream<charT,traits>& getline (basic_istream<charT,traits>& is, basic_string<charT,traits,Alloc>& str);

typedef basic_string<char> string;

// <utility>
template <class T1, class T2>
struct pair
{
    pair([const first_type& a, const second_type& b]);
    template<class U, class V>
    pair (const pair<U,V>& pr);
    pair& operator= (const pair& pr);   // implicitly declared
};

// relational operators: compare memberwise

template <class T1, class T2>
pair<T1,T2> make_pair (T1 x, T2 y);

// <vector>
template < class T, class Alloc = allocator<T> >
class vector    // array
{
    general_methods(vector);
    
    // element access
    reference operator[] (size_type n); // const;
    reference at (size_type n);         // const;
    reference front();                  // const;
    reference back();                   // const;
    
    // capacity
    void resize (size_type n, value_type val = value_type());
    size_type capacity() const;
    void reserve (size_type n);

    // modifiers
    template <class InputIterator>
    void assign (InputIterator first, InputIterator last);
    void assign (size_type n, const value_type& val);
    void insert (iterator position, size_type n, const value_type& val);
    void push_back (const value_type& val);
    void pop_back();
    
    // allocator
    allocator_type get_allocator() const;
};

// relational operators: compare memberwise

template <class T, class Alloc>
void swap (vector<T,Alloc>& x, vector<T,Alloc>& y);

// bool specialization
template <class Alloc>
class vector<bool,Alloc>
{
    void flip();
    static void swap (reference ref1, reference ref2);
};