template <
  typename BlockT = implementation_defined, 
  typename AllocT = implementation_defined >
class bit_vector 
{
public:
  ///-- Reversible Container Requirements --///
  typedef bool                                             value_type ;
  typedef implementation_defined                         reference ;
  typedef implementation_defined                         const_reference ; 
  typedef implementation_defined                         iterator ; 
  typedef implementation_defined                         reverse_iterator ; 
  typedef implementation_defined                         const_iterator ;
  typedef implementation_defined                         const_reverse_iterator ; 
  typedef implementation_defined                         difference_type ;
  typedef std::size_t                                      size_type ;
public:
  typedef bit_vector<>                                extract_type ;
public:
  //---- Constructors / Destructors ---//
  bit_vector ( ) ;
  explicit bit_vector ( size_type bit_length , value_type fill_bit = false ) ;
  template<typename CopyAllocT>
    bit_vector ( size_type bit_length , unsigned long init_val, CopyAllocT ) ; 
  template <typename CopyBlockT, typename CopyAllocT> 
    bit_vector ( const bit_vector<CopyBlockT,CopyAllocT> copy_bit_vec ) ;
  ~bit_vector ( ) ;
  //---- BitContainer Interface ----//
  bool any ( ) const ; 
  bool any ( size_type upper_idx , size_type lower_idx ) const ; 
  bool none ( ) const ; 
  bool none ( size_type upper_idx , size_type lower_idx ) const ; 
  void flip ( ) ; 
  void flip ( size_type upper_idx, size_type lower_idx ) ; 
  size_type count ( ) ; 
  reference select ( size_type bit_index ) 
  reference select ( size_type upper_bit_index , size_type lower_bit_index ) ;
  extract_type extract ( size_type upper_bit_index , size_type lower_bit_index ) ;
  template <typename PackageT>
    PackageT unpack (  size_type upper_bit_index , size_type lower_bit_index ) ;
  template <typename PackageT >
    void pack ( PackageT const & package ) 
  template <typename PackageT >
    void pack ( PackageT const & package , size_t upper_bit_index , size_type lower_bit_index ) ;
  //--- Operators ---//
  template <typename CmpBitT>
    bool operator== ( const CmpBitT & comp_value ) const ;
  template <typename CmpBitHandleT>
    bool operator== ( const CmpBitHandleT & comp_value ) const ;
  template <typename AssignT>
    bit_vector & operator= ( const AssignT & copy_value ) ; 
  template < typename HandleT>
    bit_vector & operator= ( const HandleT & copy_handle ) ; 
  bit_vector & operator= ( const char * string_of_bits ) ; 
  template <typename AndBitT>
    bit_vector & operator&= ( const AndBitT & and_value ) ; 
  template <typename OrBitT>
    bit_vector & operator|= ( const OrBitStorageT & or_value ) ; 
  template <typename XorBitT>
    bit_vector & operator^= ( const XorBitStorageT & xor_value ) ; 
  bit_vector & operator>>= ( std::size_t right_shift ) ; 
  bit_vector & operator<<= ( std::size_t left_shift ) ; 
  reference operator[] ( size_type bit_index ) ; return reference (  derived().storage() , bit_index ) ; }
  bool operator[] ( size_type bit_index ) const ; return extract_bit (  derived().storage() , bit_index ) ; }
  //--- Iterators ---//
  iterator begin ( ) ; 
  iterator end ( ) ; 
  const_iterator begin ( ) const ; 
  const_iterator end ( ) const ; 
  reverse_iterator rbegin ( ) ; 
  reverse_iterator rend ( ) ; 
  const_reverse_iterator rbegin ( ) const ; 
  const_reverse_iterator rend ( ) const ; 
  //---- Vector Interface ---//
  AllocT get_allocator() const ;
  void assign ( std::size_t num_elements , bool bit_val ) ;
  template <typename InputIteratorT>
    void assign ( InputIteratorT start_it, InputIteratorT end_it ) ; 
  reference at ( size_type idx ) ; 
  bool at ( size_type idx ) const ; 
  size_type size ( ) const ;
  size_type max_size ( ) const ;
  void resize ( std::size_t adj_size , bool value = false ) ;
  void push_back ( bool bit ) ; 
  void pop_back ( ) ;
  reference front ( ) ;
  reference back ( ) ;
  void reserve ( std::size_t res_size ) ; 
  size_type capacity ( ) const ; 
  void swap ( bit_vector & bit_container ) ; 
  iterator erase ( iterator erase_it ) ;
  iterator erase ( iterator start_erase_it , iterator end_erase_it ) ;
  template <typename BitStorageT>
    insert ( iterator insert_it , BitStorageT const & ins_bit_store ) ; 
  bool empty ( ) const ;
  void clear ( ) ; 

private:
  //  implementation_defined  

} ;