initial commit
[namibia] / data / DoctrineORMModule2 / __CG__LocationEntityTown.php
1 <?php
2
3 namespace DoctrineProxies\__CG__\Location\Entity;
4
5 /**
6  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE'S PROXY GENERATOR
7  */
8 class Town extends \Location\Entity\Town implements \Doctrine\ORM\Proxy\Proxy
9 {
10     /**
11      * @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with
12      *      three parameters, being respectively the proxy object to be initialized, the method that triggered the
13      *      initialization process and an array of ordered parameters that were passed to that method.
14      *
15      * @see \Doctrine\Common\Persistence\Proxy::__setInitializer
16      */
17     public $__initializer__;
18
19     /**
20      * @var \Closure the callback responsible of loading properties that need to be copied in the cloned object
21      *
22      * @see \Doctrine\Common\Persistence\Proxy::__setCloner
23      */
24     public $__cloner__;
25
26     /**
27      * @var boolean flag indicating if this object was already initialized
28      *
29      * @see \Doctrine\Common\Persistence\Proxy::__isInitialized
30      */
31     public $__isInitialized__ = false;
32
33     /**
34      * @var array properties to be lazy loaded, with keys being the property
35      *            names and values being their default values
36      *
37      * @see \Doctrine\Common\Persistence\Proxy::__getLazyProperties
38      */
39     public static $lazyPropertiesDefaults = array();
40
41
42
43     /**
44      * @param \Closure $initializer
45      * @param \Closure $cloner
46      */
47     public function __construct($initializer = null, $cloner = null)
48     {
49
50         $this->__initializer__ = $initializer;
51         $this->__cloner__      = $cloner;
52     }
53
54     /**
55      * {@inheritDoc}
56      * @param string $name
57      */
58     public function __get($name)
59     {
60         $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', array($name));
61
62         return parent::__get($name);
63     }
64
65     /**
66      * {@inheritDoc}
67      * @param string $name
68      * @param mixed  $value
69      */
70     public function __set($name, $value)
71     {
72         $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', array($name, $value));
73
74         return parent::__set($name, $value);
75     }
76
77
78
79     /**
80      * 
81      * @return array
82      */
83     public function __sleep()
84     {
85         if ($this->__isInitialized__) {
86             return array('__isInitialized__', 'id', 'region', 'name', 'created', 'updated', 'archived');
87         }
88
89         return array('__isInitialized__', 'id', 'region', 'name', 'created', 'updated', 'archived');
90     }
91
92     /**
93      * 
94      */
95     public function __wakeup()
96     {
97         if ( ! $this->__isInitialized__) {
98             $this->__initializer__ = function (Town $proxy) {
99                 $proxy->__setInitializer(null);
100                 $proxy->__setCloner(null);
101
102                 $existingProperties = get_object_vars($proxy);
103
104                 foreach ($proxy->__getLazyProperties() as $property => $defaultValue) {
105                     if ( ! array_key_exists($property, $existingProperties)) {
106                         $proxy->$property = $defaultValue;
107                     }
108                 }
109             };
110
111         }
112     }
113
114     /**
115      * 
116      */
117     public function __clone()
118     {
119         $this->__cloner__ && $this->__cloner__->__invoke($this, '__clone', array());
120     }
121
122     /**
123      * Forces initialization of the proxy
124      */
125     public function __load()
126     {
127         $this->__initializer__ && $this->__initializer__->__invoke($this, '__load', array());
128     }
129
130     /**
131      * {@inheritDoc}
132      * @internal generated method: use only when explicitly handling proxy specific loading logic
133      */
134     public function __isInitialized()
135     {
136         return $this->__isInitialized__;
137     }
138
139     /**
140      * {@inheritDoc}
141      * @internal generated method: use only when explicitly handling proxy specific loading logic
142      */
143     public function __setInitialized($initialized)
144     {
145         $this->__isInitialized__ = $initialized;
146     }
147
148     /**
149      * {@inheritDoc}
150      * @internal generated method: use only when explicitly handling proxy specific loading logic
151      */
152     public function __setInitializer(\Closure $initializer = null)
153     {
154         $this->__initializer__ = $initializer;
155     }
156
157     /**
158      * {@inheritDoc}
159      * @internal generated method: use only when explicitly handling proxy specific loading logic
160      */
161     public function __getInitializer()
162     {
163         return $this->__initializer__;
164     }
165
166     /**
167      * {@inheritDoc}
168      * @internal generated method: use only when explicitly handling proxy specific loading logic
169      */
170     public function __setCloner(\Closure $cloner = null)
171     {
172         $this->__cloner__ = $cloner;
173     }
174
175     /**
176      * {@inheritDoc}
177      * @internal generated method: use only when explicitly handling proxy specific cloning logic
178      */
179     public function __getCloner()
180     {
181         return $this->__cloner__;
182     }
183
184     /**
185      * {@inheritDoc}
186      * @internal generated method: use only when explicitly handling proxy specific loading logic
187      * @static
188      */
189     public function __getLazyProperties()
190     {
191         return self::$lazyPropertiesDefaults;
192     }
193
194     
195     /**
196      * {@inheritDoc}
197      */
198     public function setCreateTime()
199     {
200
201         $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCreateTime', array());
202
203         return parent::setCreateTime();
204     }
205
206     /**
207      * {@inheritDoc}
208      */
209     public function setUpdateTime()
210     {
211
212         $this->__initializer__ && $this->__initializer__->__invoke($this, 'setUpdateTime', array());
213
214         return parent::setUpdateTime();
215     }
216
217     /**
218      * {@inheritDoc}
219      */
220     public function toArray(array $expand = array (
221 ), array $intersect = array (
222 ))
223     {
224
225         $this->__initializer__ && $this->__initializer__->__invoke($this, 'toArray', array($expand, $intersect));
226
227         return parent::toArray($expand, $intersect);
228     }
229
230     /**
231      * {@inheritDoc}
232      */
233     public function toSynchArray()
234     {
235
236         $this->__initializer__ && $this->__initializer__->__invoke($this, 'toSynchArray', array());
237
238         return parent::toSynchArray();
239     }
240
241     /**
242      * {@inheritDoc}
243      */
244     public function fromArray($data = array (
245 ))
246     {
247
248         $this->__initializer__ && $this->__initializer__->__invoke($this, 'fromArray', array($data));
249
250         return parent::fromArray($data);
251     }
252
253 }