← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to waflib/ConfigSet.py

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler, Felipe Sateler, Jaromír Mikeš
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-9by89mlwhy6cpjxo
Tags: 3.4~dfsg-2
* Team upload.

[ Felipe Sateler ]
* Re-upload to unstable

[ Jaromír Mikeš ]
* Update copyright file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
waflib/ConfigSet.py
 
1
#! /usr/bin/env python
 
2
# encoding: utf-8
 
3
# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
 
4
 
 
5
import sys
 
6
if sys.hexversion < 0x020400f0: from sets import Set as set
 
7
import copy,re,os
 
8
from waflib import Logs,Utils
 
9
re_imp=re.compile('^(#)*?([^#=]*?)\ =\ (.*?)$',re.M)
 
10
class ConfigSet(object):
 
11
        __slots__=('table','parent')
 
12
        def __init__(self,filename=None):
 
13
                self.table={}
 
14
                if filename:
 
15
                        self.load(filename)
 
16
        def __contains__(self,key):
 
17
                if key in self.table:return True
 
18
                try:return self.parent.__contains__(key)
 
19
                except AttributeError:return False
 
20
        def keys(self):
 
21
                keys=set()
 
22
                cur=self
 
23
                while cur:
 
24
                        keys.update(cur.table.keys())
 
25
                        cur=getattr(cur,'parent',None)
 
26
                keys=list(keys)
 
27
                keys.sort()
 
28
                return keys
 
29
        def __str__(self):
 
30
                return"\n".join(["%r %r"%(x,self.__getitem__(x))for x in self.keys()])
 
31
        def __getitem__(self,key):
 
32
                try:
 
33
                        while 1:
 
34
                                x=self.table.get(key,None)
 
35
                                if not x is None:
 
36
                                        return x
 
37
                                self=self.parent
 
38
                except AttributeError:
 
39
                        return[]
 
40
        def __setitem__(self,key,value):
 
41
                self.table[key]=value
 
42
        def __delitem__(self,key):
 
43
                self[key]=[]
 
44
        def __getattr__(self,name):
 
45
                if name in self.__slots__:
 
46
                        return object.__getattr__(self,name)
 
47
                else:
 
48
                        return self[name]
 
49
        def __setattr__(self,name,value):
 
50
                if name in self.__slots__:
 
51
                        object.__setattr__(self,name,value)
 
52
                else:
 
53
                        self[name]=value
 
54
        def __delattr__(self,name):
 
55
                if name in self.__slots__:
 
56
                        object.__delattr__(self,name)
 
57
                else:
 
58
                        del self[name]
 
59
        def derive(self):
 
60
                newenv=ConfigSet()
 
61
                newenv.parent=self
 
62
                return newenv
 
63
        def detach(self):
 
64
                tbl=self.get_merged_dict()
 
65
                try:
 
66
                        delattr(self,'parent')
 
67
                except AttributeError:
 
68
                        pass
 
69
                else:
 
70
                        keys=tbl.keys()
 
71
                        for x in keys:
 
72
                                tbl[x]=copy.deepcopy(tbl[x])
 
73
                        self.table=tbl
 
74
        def get_flat(self,key):
 
75
                s=self[key]
 
76
                if isinstance(s,str):return s
 
77
                return' '.join(s)
 
78
        def _get_list_value_for_modification(self,key):
 
79
                try:
 
80
                        value=self.table[key]
 
81
                except KeyError:
 
82
                        try:value=self.parent[key]
 
83
                        except AttributeError:value=[]
 
84
                        if isinstance(value,list):
 
85
                                value=value[:]
 
86
                        else:
 
87
                                value=[value]
 
88
                else:
 
89
                        if not isinstance(value,list):
 
90
                                value=[value]
 
91
                self.table[key]=value
 
92
                return value
 
93
        def append_value(self,var,val):
 
94
                current_value=self._get_list_value_for_modification(var)
 
95
                if isinstance(val,str):
 
96
                        val=[val]
 
97
                current_value.extend(val)
 
98
        def prepend_value(self,var,val):
 
99
                if isinstance(val,str):
 
100
                        val=[val]
 
101
                self.table[var]=val+self._get_list_value_for_modification(var)
 
102
        def append_unique(self,var,val):
 
103
                if isinstance(val,str):
 
104
                        val=[val]
 
105
                current_value=self._get_list_value_for_modification(var)
 
106
                for x in val:
 
107
                        if x not in current_value:
 
108
                                current_value.append(x)
 
109
        def get_merged_dict(self):
 
110
                table_list=[]
 
111
                env=self
 
112
                while 1:
 
113
                        table_list.insert(0,env.table)
 
114
                        try:env=env.parent
 
115
                        except AttributeError:break
 
116
                merged_table={}
 
117
                for table in table_list:
 
118
                        merged_table.update(table)
 
119
                return merged_table
 
120
        def store(self,filename):
 
121
                try:
 
122
                        os.makedirs(os.path.split(filename)[0])
 
123
                except OSError:
 
124
                        pass
 
125
                f=None
 
126
                try:
 
127
                        f=open(filename,'w')
 
128
                        merged_table=self.get_merged_dict()
 
129
                        keys=list(merged_table.keys())
 
130
                        keys.sort()
 
131
                        for k in keys:
 
132
                                if k!='undo_stack':
 
133
                                        f.write('%s = %r\n'%(k,merged_table[k]))
 
134
                finally:
 
135
                        if f:
 
136
                                f.close()
 
137
        def load(self,filename):
 
138
                tbl=self.table
 
139
                code=Utils.readf(filename)
 
140
                for m in re_imp.finditer(code):
 
141
                        g=m.group
 
142
                        tbl[g(2)]=eval(g(3))
 
143
                Logs.debug('env: %s'%str(self.table))
 
144
        def update(self,d):
 
145
                for k,v in d.items():
 
146
                        self[k]=v
 
147
        def stash(self):
 
148
                self.undo_stack=self.undo_stack+[self.table]
 
149
                self.table=self.table.copy()
 
150
        def revert(self):
 
151
                self.table=self.undo_stack.pop(-1)