solenv/gdb/boost/lib/unordered.py

   1 # -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
   2 # Helper classes for working with Boost.Unordered.
   3 #
   4 # Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
   5 #
   6 # This file is part of boost-gdb-printers.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 import gdb
  22
  23 class Unordered(object):
  24     '''Common representation of Boost.Unordered types'''
  25
  26     def __init__(self, value, extractor):
  27         self.value = value
  28         self.extractor = extractor
  29         self.node_type = self._node_type()
  30
  31     def __len__(self):
  32         table = self.value['table_']
  33         if table['buckets_']:
  34             return int(table['size_'])
  35         else:
  36             return 0
  37
  38     def __iter__(self):
  39         table = self.value['table_']
  40         buckets = table['buckets_']
  41         if buckets:
  42             first = table['cached_begin_bucket_']
  43             last = buckets + table['bucket_count_']
  44         else:
  45             first = last = None
  46         return self._iterator(first, last, self.node_type, self.extractor)
  47
  48     def empty(self):
  49         return not self.value['table_']['buckets_']
  50
  51     def _node_type(self):
  52         hash_table = self.value['table_'].type.fields()[0]
  53         assert hash_table.is_base_class
  54         hash_buckets = hash_table.type.fields()[0]
  55         assert hash_buckets.is_base_class
  56         node_type = gdb.lookup_type("%s::node" % hash_buckets.type)
  57         assert node_type != None
  58         return node_type
  59
  60     class _iterator(object):
  61         '''Iterator for Boost.Unordered types'''
  62
  63         def __init__(self, first_bucket, last_bucket, node_type, extractor):
  64             self.bucket = first_bucket
  65             self.last_bucket = last_bucket
  66             self.node = self.bucket
  67             self.node_type = node_type
  68             self.value_type = self._value_type()
  69             self.extractor = extractor
  70
  71         def __iter__(self):
  72             return self
  73
  74         def next(self):
  75             if self.node:
  76                 self.node = self.node.dereference()['next_']
  77
  78             # we finished the current bucket: go on to the next non-empty one
  79             if not self.node:
  80                 while not self.node and self.bucket != self.last_bucket:
  81                     self.bucket += 1
  82                     self.node = self.bucket.dereference()['next_']
  83
  84             # sorry, no node available
  85             if not self.node or self.node == self.bucket:
  86                 raise StopIteration()
  87
  88             mapped = self._value()
  89             return (self.extractor.key(mapped), self.extractor.value(mapped))
  90
  91         def _value(self):
  92             assert self.node != self.bucket # bucket node has no value
  93             assert self.node != None
  94             node = self.node.dereference().cast(self.node_type)
  95             return node['data_'].cast(self.value_type)
  96
  97         def _value_type(self):
  98             value_base = self.node_type.fields()[1]
  99             assert value_base.is_base_class
 100             return value_base.type.template_argument(0)
 101
 102 class Map(Unordered):
 103
 104     def __init__(self, value):
 105         super(Map, self).__init__(value, self._extractor())
 106
 107     class _extractor(object):
 108
 109         def key(self, node):
 110             return node['first']
 111
 112         def value(self, node):
 113             return node['second']
 114
 115 class Set(Unordered):
 116
 117     def __init__(self, value):
 118         super(Set, self).__init__(value, self._extractor())
 119
 120     class _extractor(object):
 121
 122         def key(self, node):
 123             return None
 124
 125         def value(self, node):
 126             return node
 127
 128 # vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab: