← Back to branch summary

~gdesklets-desklet-team/gdesklets/0.36

« back to all changes in this revision

Viewing changes to utils/Element.py

  • Committer: Robert Pastierovic
  • Date: 2007-10-07 10:08:42 UTC
  • Revision ID: pastierovic@gmail.com-20071007100842-fdvp2vzmqgh1j87k
merged 0.3x branch and basic documentation and some other changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/Element.py
 
1
from utils.datatypes import *
 
2
 
 
3
 
 
4
class Element(object):
 
5
    """
 
6
      Base class for elements with typed properties.
 
7
      Classes deriving from this base class have to call
 
8
 
 
9
        _register_property(name, datatype, setter, getter, default, doc)
 
10
 
 
11
      in the constructor. Properties can then be set with
 
12
 
 
13
        set_prop(key, value)
 
14
 
 
15
      and can be read with
 
16
 
 
17
        get_prop(key, value)
 
18
 
 
19
 
 
20
      If you don't need any special setter or getter methods, then you can use
 
21
      the predefined _setp(key, value) and _getp(key) methods.
 
22
    """
 
23
 
 
24
    __slots__ = ('__name', '__properties', '__property_handlers',
 
25
                 '__ident_counter')
 
26
 
 
27
    AUTHORIZED_METHODS = ()
 
28
 
 
29
    # counter for unique IDs
 
30
    __ident_counter = 0
 
31
 
 
32
 
 
33
    def __init__(self, name):
 
34
 
 
35
        # name of the element
 
36
        self.__name = name
 
37
 
 
38
        # values of the properties
 
39
        self.__properties = {}
 
40
 
 
41
        # table: property name -> (setter, getter, datatype, doc)
 
42
        self.__property_handlers = {}
 
43
 
 
44
 
 
45
        new_id = "id%d" % self.__ident_counter
 
46
        self.__ident_counter += 1
 
47
        self._register_property("id", TYPE_STRING, self._setp, self._getp,
 
48
                                new_id, doc = "Unique identifier")
 
49
 
 
50
 
 
51
 
 
52
    #
 
53
    # Registers the given property with the given setter and getter methods.
 
54
    #
 
55
    def _register_property(self, name, datatype, setter, getter,
 
56
                           default = None, doc = ""):
 
57
 
 
58
        self.__property_handlers[name] = (setter, getter, datatype, doc)
 
59
        self._setp(name, default)
 
60
 
 
61
 
 
62
 
 
63
    #
 
64
    # Sets the given property as a string.
 
65
    #
 
66
    def set_prop_from_string(self, key, value):
 
67
 
 
68
        value = str(value)  # to stay compatible with sensors :(
 
69
        key = key.replace("_", "-")
 
70
        try:
 
71
            datatype = self.get_datatype_of_property(key)
 
72
        except KeyError:
 
73
            datatype = TYPE_ANY
 
74
 
 
75
        from utils import typeconverter
 
76
        self.set_prop(key, typeconverter.str2type(datatype, value))
 
77
 
 
78
 
 
79
 
 
80
    #
 
81
    # Sets the given property.
 
82
    #
 
83
    def set_prop(self, key, value):
 
84
 
 
85
        key = key.replace("_", "-")
 
86
        try:
 
87
            setter = self.__property_handlers[key][0]
 
88
            datatype = self.__property_handlers[key][2]
 
89
 
 
90
        except KeyError:
 
91
            raise UserError(_("No such property: %s") % key,
 
92
                            _("The element <b>%s</b> does not have the "
 
93
                              "<b>%s</b> property.") % (self.__name, key))
 
94
        
 
95
        if (not setter):
 
96
            raise UserError(_("Permission Error"),
 
97
                           _("The property <b>%s</b> of element <b>%s</b> "
 
98
                             "is not writable.") % (key, self.__name))
 
99
        
 
100
        elif (dtype_check(datatype, value)):
 
101
            setter(key, value)
 
102
 
 
103
        else:
 
104
            actual_type = dtype_guess(value)
 
105
            raise UserError(_("Type Error"),
 
106
                           _("The property <b>%s</b> of element <b>%s</b> "
 
107
                             "got a value of wrong type.\n"
 
108
                             "Expected <b>%s</b>, but got <b>%s</b>."
 
109
                             % (key, self.__name, datatype[0],
 
110
                                actual_type[0])))
 
111
 
 
112
 
 
113
 
 
114
    #
 
115
    # Returns the value of the given property.
 
116
    #
 
117
    def get_prop(self, key):
 
118
 
 
119
        key = key.replace("_", "-")
 
120
        try:
 
121
            getter = self.__property_handlers[key] [1]
 
122
        except KeyError:
 
123
            raise KeyError("Error: No such property: %s" % key)
 
124
 
 
125
        if (not getter):
 
126
            raise UserError(_("Permission Error"),
 
127
                           _("The property <b>%s</b> of element <b>%s</b> "
 
128
                             "is not readable.") % (key, self.__name))
 
129
        
 
130
        else:
 
131
            return getter(key)
 
132
 
 
133
 
 
134
 
 
135
    #
 
136
    # Returns the datatype of the given property.
 
137
    #
 
138
    def get_datatype_of_property(self, prop):
 
139
 
 
140
        # we intentionally don't catch the KeyError here
 
141
        return self.__property_handlers[prop][2]
 
142
 
 
143
 
 
144
 
 
145
    #
 
146
    # Returns the documentation string of the given property.
 
147
    #
 
148
    def get_doc_of_property(self, prop):
 
149
 
 
150
        try:
 
151
            doc = self.__property_handlers[prop][3]
 
152
        except:
 
153
            return ""
 
154
 
 
155
        return doc
 
156
 
 
157
 
 
158
 
 
159
    #
 
160
    # Returns a list of the names of all available properties.
 
161
    #
 
162
    def get_props(self): return self.__property_handlers.keys()
 
163
 
 
164
 
 
165
 
 
166
    #
 
167
    # Generic setter and getter methods for properties.
 
168
    #
 
169
    def _setp(self, key, value): self.__properties[key] = value
 
170
    def _getp(self, key): return self.__properties[key]
 
171
 
 
172
 
 
173
    #
 
174
    # Returns the element's name
 
175
    #
 
176
    def get_name(self): return self.__name