map

将HTML转换为TXT文件的程序

    const rb_tree::node_type *y
  ) const {
    return *(const key_type *) x < ((const node_type *) y)->value.first;
  }
  /*virtual*/ bool node_less_than(
    const rb_tree::node_type *x,
    value_pointer            y
  ) const {
    return ((const node_type *) x)->value.first < *(const key_type *) y;
  }

  /*virtual*/ rb_tree::node_type *copy_node(const rb_tree::node_type *n) const {
    return new node_type(((const node_type *) n)->value);
  }
  /*virtual*/ void delete_node(rb_tree::node_type *n) const {
    delete (node_type *) n;
  }

  typedef void (*key_mapped_printer)(
    ostream           &,
    const key_type    &,
    const mapped_type &
  );
  /*virtual*/ void print_node_value(
    const rb_tree::node_type &n,
    ostream                  &os,
    void                     *closure
  ) const {
    (*(key_mapped_printer *) closure)(
      os,
      ((const node_type &) n).value.first,
      ((const node_type &) n).value.second
    );
  }
  void print(ostream &os, key_mapped_printer np) const {
    rb_tree::print(os, (void *) &np);
  }
  friend ostream &operator<<(
    ostream                          &,
    const map<key_type, mapped_type> &
  );

  // Needed by "map(iter, iter)".
  static rb_tree::node_type *copy_node2(const rb_tree::node_type *n) {
    return new node_type(((const node_type *) n)->value);
  }
  // Needed by "~map()".
  static void delete_node2(rb_tree::node_type *n) {
    delete (node_type *) n;
  }

  friend map__iterator<key_type, mapped_type>;
  friend map__const_iterator<key_type, mapped_type>;
};

/* ------------------------------------------------------------------------- */

template <class key_type, class mapped_type>
class multimap : public rb_tree {

  // Public types

public:
  typedef pair<const key_type, mapped_type>          value_type;
  typedef map__iterator<key_type, mapped_type>       iterator;
  typedef map__const_iterator<key_type, mapped_type> const_iterator;

  // Private types

private:
  typedef map__node<key_type, mapped_type> node_type;

  // Construct/Copy/Destroy

public:
  explicit multimap() : rb_tree() {
  }
  multimap(const_iterator i1, const_iterator i2) :
    rb_tree(i1.node, i2.node, copy_node2) {
  }
  multimap(const multimap<key_type, mapped_type> &x) : rb_tree(x) {
  }
  const multimap<key_type, mapped_type> &operator=(
    const multimap<key_type, mapped_type> &x
  ) {
    rb_tree::operator=(x); return *this;
  }
  ~multimap() {
    clear(delete_node2);
  }

  // Iterators

  iterator begin() {
    return iterator((node_type *) rb_tree::begin());
  }
  const_iterator begin() const {
    return const_iterator((const node_type *) rb_tree::begin());
  }
  iterator end() {
    return iterator((node_type *) rb_tree::end());
  }
  const_iterator end() const {
    return const_iterator((const node_type *) rb_tree::end());
  }
//reverse_iterator rbegin();
//const_reverse_iterator rbegin() const;
//reverse_iterator rend();
//const_reverse_iterator rend() const;

  // Capacity

//bool      empty()    const;  // Inherited from "rb_tree".
//size_type size()     const;  // Inherited from "rb_tree".
//size_type max_size() const;  // Inherited from "rb_tree".

  // Modifiers

  iterator insert(const value_type &x) {
    return iterator((node_type *) rb_tree::insert(new node_type(x)));
  }
//iterator insert(iterator, const value_type &);
  void insert(const_iterator from, const_iterator to) {
    rb_tree::insert(from.node, to.node);
  }
  size_type erase(const key_type &x) {
    return rb_tree::erase_all((value_pointer) &x);
  }
  iterator erase(iterator i) {
    return iterator(rb_tree::erase(i.node));
  }
  iterator erase(iterator i1, iterator i2) {
    return iterator(rb_tree::erase(i1.node, i2.node));
  }
  void swap(multimap<key_type, mapped_type> &x) {
    rb_tree::swap((rb_tree &) x);
  }
//void clear();                // Inherited from "rb_tree".

  // Multimap operations

  iterator find(const key_type &x) {
    return iterator(rb_tree::find_first((value_pointer) &x));
  }
  const_iterator find(const key_type &x) const {
    return const_iterator(rb_tree::find_first((value_pointer) &x));
  }
  size_type count(const key_type &x) const {
    return rb_tree::count((value_pointer) &x);
  }
  iterator lower_bound(const key_type &x) {
    return iterator(rb_tree::lower_bound((value_pointer) &x));
  }
  const_iterator lower_bound(const key_type &x) const {
    return const_iterator(rb_tree::lower_bound((value_pointer) &x));
  }
  iterator upper_bound(const key_type &x) {
    return iterator(rb_tree::upper_bound((value_pointer) &x));
  }
  const_iterator upper_bound(const key_type &x) const {
    return const_iterator(rb_tree::upper_bound((value_pointer) &x));
  }
  // Must not use "pair<iterator, iterator>", else CFRONT fails
  // G++ 2.7.2.1 cannot compile this ("field "first" has incomplete type")!?
//pair<
//  map__iterator<key_type, mapped_type>,
//  map__iterator<key_type, mapped_type>
//> equal_range(const key_type &x) {
//  return pair<iterator, iterator>(lower_bound(x), upper_bound(x));
//}
  // Must not use "pair<const_iterator, const_iterator>", else CFRONT fails
  pair<
    map__const_iterator<key_type, mapped_type>,
    map__const_iterator<key_type, mapped_type>
  > equal_range(const key_type &x) const {
    return pair<const_iterator, const_iterator>(lower_bound(x), upper_bound(x));
  }

  bool operator==(const multimap<key_type, mapped_type> &x) const {
    return rb_tree::operator==((const rb_tree &) x);
  }
  bool operator<(const multimap<key_type, mapped_type> &x) const {
    return rb_tree::operator<((const rb_tree &) x);
  }

  // Implementation of "rb_tree"'s virtual methods.

private:
  /*virtual*/ bool node_less_than(
    const rb_tree::node_type *x,
    const rb_tree::node_type *y
  ) const {
    return (
      ((const node_type *) x)->value.first <
      ((const node_type *) y)->value.first
    );
  }
  /*virtual*/ bool node_less_than(
    value_pointer            x,
    const rb_tree::node_type *y
  ) const {
    return *(const key_type *) x < ((const node_type *) y)->value.first;
  }
  /*virtual*/ bool node_less_than(
    const rb_tree::node_type *x,
    value_pointer            y
  ) const {
    return ((const node_type *) x)->value.first < *(const key_type *) y;
  }

  /*virtual*/ rb_tree::node_type *copy_node(const rb_tree::node_type *n) const {
    return new node_type(((const node_type *) n)->value);
  }
  /*virtual*/ void delete_node(rb_tree::node_type *n) const {
    delete (node_type *) n;
  }

  typedef void (*key_mapped_printer)(
    ostream           &,
    const key_type    &,
    const mapped_type &
  );
  /*virtual*/ void print_node_value(
    const rb_tree::node_type &n,
    ostream                  &os,
    void                     *closure
  ) const {
    (*(key_mapped_printer *) closure)(
      os,
      ((const node_type &) n).value.first,
      ((const node_type &) n).value.second
    );
  }
  void print(ostream &os, key_mapped_printer np) const {
    rb_tree::print(os, (void *) &np);
  }
  friend ostream &operator<<(
    ostream                               &,
    const multimap<key_type, mapped_type> &
  );

  // Needed by "multimap(iter, iter)".
  static rb_tree::node_type *copy_node2(const rb_tree::node_type *n) {
    return new node_type(((const node_type *) n)->value);
  }
  // Needed by "~multimap()".
  static void delete_node2(rb_tree::node_type *n) {
    delete (node_type *) n;
  }

  friend map__iterator<key_type, mapped_type>;
  friend map__const_iterator<key_type, mapped_type>;
};

/* ------------------------------------------------------------------------- */

/*
 * MUST DEFINE THESE HERE AT THE END OF THIS FILE; FOR ELSE STUPID CFRONT
 * INSTANTIATES IT OUT-OF-LINE!?
 */

template<class key_type, class mapped_type>
inline void map__print_key_mapped(
  ostream           &os,
  const key_type    &key,
  const mapped_type &mapped
)
{
  os << "(" << key << " => " << mapped << ")";
}

template<class key_type, class mapped_type>
inline ostream &
operator<<(ostream &os, const map<key_type, mapped_type> &x)
{
  x.print(os, map__print_key_mapped);
  return os;
}

template<class key_type, class mapped_type>
inline ostream &
operator<<(ostream &os, const multimap<key_type, mapped_type> &x)
{
  x.print(os, map__print_key_mapped);
  return os;
}

/* ------------------------------------------------------------------------- */

#endif /* } */

/* ------------------------------------------------------------------------- */