
This document, organized by header file, gives details about how much of the C++ library is
currently available and what parts remain to be implemented.

By default, assume all C++ 1998 library components are implemented unless otherwise stated.
However, also assume that *no* C++ 2011 library components are implemented unless otherwise
stated. In other words, the lists below contain C++ 1998 components that are missing and C++
2011 components that are available. These defaults reflect the fact that Open Watcom's C++ 2011
support is still in its early stages.

The Open Watcom documentation set also includes a document entitled *OWSTL Design Documentation*,
that described the design decisions made in the Open Watcom Standard Template Library (OWSTL).
It is a complement to this document.

All the header files of the C++ 2011 standard are listed here, and all of these header files
exist in the Open Watcom distribution. Most of the C++ 2011 headers are little more than
placeholders at this time. They allow programs that include those headers to compile, although
in most cases none of the C++ 2011 content is actually available.

### `<algorithm>`

The following algorithms are shown in the order in which they appear in the C++ 1998 standard.

#### Non-modifying Sequence Operations

All C++ 98 components are available.

#### Mutating Sequence Operations

```cpp
rotate( Forward, Forward, Forward )
rotate_copy( Forward, Forward, Forward, Output )
random_shuffle( RandomAccess, RandomAccess )
random_shuffle( RandomAccess, RandomAccess, RandomNumberGenerator)
partition( Forward, Forward, Predicate )
stable_partition( Bidirectional, Bidirectional, Predicate )
```

#### Sorting and Related Operations

```cpp
stable_sort( RandomAccess, RandomAccess )
stable_sort( RandomAccess, RandomAccess, Compare )
partial_sort( RandomAccess, RandomAccess, RandomAccess )
partial_sort( RandomAccess, RandomAccess, RandomAccess, Compare )
partial_sort_copy( Input, Input, RandomAccess, RandomAccess )
partial_sort_copy( Input, Input, RandomAccess, RandomAccess, Compare )
nth_element( RandomAccess, RandomAccess, RandomAccess )
nth_element( RandomAccess, RandomAccess, RandomAccess, Compare )
lower_bound( Forward, Forward, const T& )
lower_bound( Forward, Forward, const T&, Compare )
upper_bound( Forward, Forward, const T& )
upper_bound( Forward, Forward, const T& , Compare )
equal_range( Forward, Forward, const T& )
equal_range( Forward, Forward, const T&, Compare )
merge( Input1, Input1, Input2, Input2, Output result )
merge( Input1, Input1, Input2, Input2, Output result, Compare )
includes( Input1, Input1, Input2, Input )
includes( Input1, Input1, Input2, Input2, Compare )
set_union( Input1, Input1, Input2, Input2, Output )
set_union( Input1, Input1, Input2, Input2, Output, Compare )
set_intersection( Input1, Input1, Input2, Input2, Output )
set_intersection( Input1, Input1, Input2, Input2, Output, Compare )
set_difference( Input1, Input1, Input2, Input2, Output )
set_difference( Input1, Input1, Input2, Input2, Output, Compare )
set_symmetric_difference( Input1, Input1, Input2, Input2, Output )
set_symmetric_difference( Input1, Input1, Input2, Input2, Output, Compare )
```

The OWCPPLIB implementation of `unique` does not follow the precise letter of the 1998 standard.
This is common since the standard is defective in this regard. See ["Unique effects unclear when
predicate not an equivalence
relation"](http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202) in the WG21 library
defects list. The Open Watcom library follows the proposed resolution in the defect report. For
maximum portability avoid using unique with a non-equivalence relation.

The OWCPPLIB's implementation of `sort` uses a QuickSort with a median-of-three pivoting
scheme. It is recursive and thus uses O(log(N)) stack space (in the average case).

### `<array>`

Not implemented.

### `<atomic>`

Not implemented.

### `<bitset>`

Mostly complete.

### `<chrono>`

Not implemented.

### `<codecvt>`

Not implemented.

### `<complex>`

Mostly complete. No I/O operators for `std::complex` have been implemented but essentially all
the operations exist. This code needs to be reviewed by someone well versed in numerical
methods.

### `<condition_variable>`

Not implemented.

### `<deque>`

Partially complete. Enough functionality exists to be useful, but the following member functions
are missing:

```cpp
assign( size_type, const T& )
clear( )
deque( InputIterator, InputIterator, const Allocator& )
erase( iterator, iterator )
insert( iterator, const T& )
insert( iterator, size_type, const T& )
operator=( const deque& )
swap( deque& )
template assign( InputIterator, InputIterator )
template insert( iterator, InputIterator, InputIterator )
```

### `<exception>`

Mostly complete.

### `<forward_list>`

Mostly complete.

### `<fstream>`

The old-style IOStreams library is in namespace `std`.

### `<functional>`

Complete.

### `<future>`

Not implemented.

### `<initializer_list>`

Not implemented.

### `<iomanip>`

The old-style IOStreams library is in namespace `std`.

### `<ios>`

The old-style IOStreams library is in namespace `std`.

### `<iosfwd>`

The old-style IOStreams library is in namespace `std`.

### `<iostream>`

The old-style IOStreams library is in namespace `std`.

### `<istream>`

The old-style IOStreams library is in namespace `std`.

### `<iterator>`

Mostly complete. The only significant missing components are the stream iterators. These will be
added once the new IOStreams library is sufficiently mature.

### `<limits>`

Mostly complete. Support for `numeric_limits` on the floating point types is marginal and not
complete. The current implementation of limits is based on the macros in the C header limits.h.
Including limits will cause limits.h to also be included, bringing the macros it defines into
view. This may not be desirable. However, this approach also means that corrections to limits.h
are automatically applied to limits as well.

### `<list>`

Partially complete. Enough functionality exists to be useful. The following member functions are
missing:

```cpp
back( ) const;
front( ) const;
max_size( ) const
merge( list &, Compare )
remove_if( Predicate )
resize( size_type, T )
template <InputIterator> ctor
unique( BinaryPredicate )
unique( )
```

### `<locale>`

Not implemented.

### `<map>`

Partially complete. Enough functionality exists to be useful. The following member functions are
missing:

```cpp
const_reverse_iterator		
count( )		
equal_range( key_type ) and equal_range( key_type ) const		
erase( iterator first, iterator last )		
find( key_type ) const		
key_comp( )		
max_size( )		
rbegin( )
rbegin( ) const		
rend( )
rend( ) const		
reverse_iterator
swap		
template<InputIterator> ctor
value_comp( )
```

### `<memory>`

Mostly complete. Note that (among other things) `std::auto_ptr` is not 100% compliant with the
standard, although it should be close enough for some applications. The C++ 2011 smart pointer
templates are partially complete. In particular, `std::unique_ptr` is not yet implemented due to
missing move semantics in the compiler.

### `<mutex>`

Not implemented.

### `<new>`

Mostly complete.

### `<numeric>`

Complete.

### `<ostream>`

The old-style IOStreams library is in namespace `std`.

### `<queue>`

Complete.

### `<random>`

Partially complete.

### `<ratio>`

Not implemented.

### `<regex>`

Not implemented.

### `<set>`

Partially complete. Enough functionality exists to be useful.

### `<sstream>`

The old-style IOStreams library is in namespace `std`.

### `<stack>`

Complete.

### `<stdexcept>`

Mostly complete.

### `<streambuf>`

The old-style IOStreams library is in namespace `std`.

### `<string>`

Mostly complete, although there are no I/O operators.

[Issue 892](https://github.com/open-watcom/open-watcom-v2/issues/892) notes that the following
member functions are still missing:

```cpp
int compare( const string & ) const;
int compare( size_t, size_t, const string & ) const; 
int compare( size_t, size_t, const string &, size_t, size_t ) const;
int compare( const char * ) const;
int compare( size_t, size_t, const char * ) const;
int compare( size_t, size_t, const char *, size_t ) const;
```

In addition, the iterator interfaces are not implemented:

```cpp
template <class InputIterator>
string( InputIterator, InputIterator );

template <class InputIterator>
string &assign( InputIterator, InputIterator );
```

OWCPPLIB's `std::string` implementation is not a copy-on-write implementation. The OWSTL Design
Documentation discuss the reasons for this in more detail.

String objects always have a capacity that is a power of two in size. When the capacity is
increased (for example after a `push_back` that fills the current buffer) the size of the
internal buffer is doubled. The smallest capacity used is eight.

OWCPPLIB's `std::string` do not bother to null terminate their internal buffers. When `c_str` is
called, a null character is appended to the buffer at that time. At all times there will be
space for a null character. Thus, `c_str` never causes a reallocation and never throws an
exception.

### `<strstream>`

The old-style IOStreams library is in namespace `std`.

### `<system_error>`

Not implemented.

### `<thread>`

Not implemented.

### `<tuple>`

Not implemented.

### `<typeindex>`

Not implemented.

### `<typeinfo>`

Partially complete. Some features require compiler enhancements.

### `<type_traits>`

Partially complete. Some features require compiler enhancements.

### `<unordered_map>`

Not implemented.

### `<unordered_set>`

Not implemented.

### `<utility>`

Complete.

### `<valarray>`

Not implemented.

### `<vector>`

Partially complete. Enough functionality exists to be useful. Some member functions are known to
not yet be exception safe.
