Exponential 6.0.13 Exponential Enterprise Open Source CMS - PHP Class Reference

ezintegertype.php
Go to the documentation of this file.
1 <?php
23 class eZIntegerType extends eZDataType
24 {
25 const DATA_TYPE_STRING = "ezinteger";
26 const MIN_VALUE_FIELD = "data_int1";
27 const MIN_VALUE_VARIABLE = "_ezinteger_min_integer_value_";
28 const MAX_VALUE_FIELD = "data_int2";
29 const MAX_VALUE_VARIABLE = "_ezinteger_max_integer_value_";
30 const DEFAULT_VALUE_FIELD = "data_int3";
31 const DEFAULT_VALUE_VARIABLE = "_ezinteger_default_value_";
32 const INPUT_STATE_FIELD = "data_int4";
33 const NO_MIN_MAX_VALUE = 0;
34 const HAS_MIN_VALUE = 1;
35 const HAS_MAX_VALUE = 2;
36 const HAS_MIN_MAX_VALUE = 3;
37
38 public function __construct()
39 {
40 parent::__construct( self::DATA_TYPE_STRING, ezpI18n::tr( 'kernel/classes/datatypes', "Integer", 'Datatype name' ),
41 array( 'serialize_supported' => true,
42 'object_serialize_map' => array( 'data_int' => 'value' ) ) );
43 $this->IntegerValidator = new eZIntegerValidator();
44 }
45
55 function validateIntegerHTTPInput( $data, $contentObjectAttribute, $classAttribute )
56 {
57 $min = $classAttribute->attribute( self::MIN_VALUE_FIELD );
58 $max = $classAttribute->attribute( self::MAX_VALUE_FIELD );
59 $input_state = $classAttribute->attribute( self::INPUT_STATE_FIELD );
60
61 switch( $input_state )
62 {
63 case self::NO_MIN_MAX_VALUE:
64 {
65 $this->IntegerValidator->setRange( false, false );
66 $state = $this->IntegerValidator->validate( $data );
67 if( $state === eZInputValidator::STATE_INVALID || $state === eZInputValidator::STATE_INTERMEDIATE )
68 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
69 'The input is not a valid integer.' ) );
70 else
71 return $state;
72 } break;
73 case self::HAS_MIN_VALUE:
74 {
75 $this->IntegerValidator->setRange( $min, false );
76 $state = $this->IntegerValidator->validate( $data );
77 if( $state === eZInputValidator::STATE_ACCEPTED )
78 return eZInputValidator::STATE_ACCEPTED;
79 else
80 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
81 'The number must be greater than %1' ),
82 $min );
83 } break;
84 case self::HAS_MAX_VALUE:
85 {
86 $this->IntegerValidator->setRange( false, $max );
87 $state = $this->IntegerValidator->validate( $data );
88 if( $state===1 )
89 return eZInputValidator::STATE_ACCEPTED;
90 else
91 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
92 'The number must be less than %1' ),
93 $max );
94 } break;
95 case self::HAS_MIN_MAX_VALUE:
96 {
97 $this->IntegerValidator->setRange( $min, $max );
98 $state = $this->IntegerValidator->validate( $data );
99 if( $state===1 )
100 return eZInputValidator::STATE_ACCEPTED;
101 else
102 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
103 'The number is not within the required range %1 - %2' ),
104 $min, $max );
105 } break;
106 }
107
108 return eZInputValidator::STATE_INVALID;
109
110 }
111
116 function validateObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
117 {
118 $classAttribute = $contentObjectAttribute->contentClassAttribute();
119
120 if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
121 {
122 $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
123 $data = str_replace(" ", "", $data );
124
125 if ( $data == "" )
126 {
127 if ( !$classAttribute->attribute( 'is_information_collector' ) and
128 $contentObjectAttribute->validateIsRequired() )
129 {
130 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
131 'Input required.' ) );
132 return eZInputValidator::STATE_INVALID;
133 }
134 else
135 return eZInputValidator::STATE_ACCEPTED;
136 }
137 else
138 {
139 return $this->validateIntegerHTTPInput( $data, $contentObjectAttribute, $classAttribute );
140 }
141 }
142 else if ( !$classAttribute->attribute( 'is_information_collector' ) and $contentObjectAttribute->validateIsRequired() )
143 {
144 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes', 'Input required.' ) );
145 return eZInputValidator::STATE_INVALID;
146 }
147 else
148 return eZInputValidator::STATE_ACCEPTED;
149 }
150
151 function fixupObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
152 {
153 }
154
158 function initializeObjectAttribute( $contentObjectAttribute, $currentVersion, $originalContentObjectAttribute )
159 {
160 if ( $currentVersion != false )
161 {
162 // $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
163 // $currentObjectAttribute = eZContentObjectAttribute::fetch( $contentObjectAttributeID,
164 // $currentVersion );
165 $dataInt = $originalContentObjectAttribute->attribute( "data_int" );
166 $contentObjectAttribute->setAttribute( "data_int", $dataInt );
167 }
168 else
169 {
170 $contentClassAttribute = $contentObjectAttribute->contentClassAttribute();
171 $default = $contentClassAttribute->attribute( "data_int3" );
172 if ( $default !== 0 )
173 {
174 $contentObjectAttribute->setAttribute( "data_int", $default );
175 }
176 }
177 }
178
182 function fetchObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
183 {
184 if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
185 {
186 $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
187 $data = trim( $data ) != '' ? $data : null;
188 $data = str_replace(" ", "", $data);
189 $contentObjectAttribute->setAttribute( "data_int", $data );
190 return true;
191 }
192 return false;
193 }
194
195 function validateCollectionAttributeHTTPInput( $http, $base, $contentObjectAttribute )
196 {
197 if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
198 {
199 $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
200 $data = str_replace(" ", "", $data );
201 $classAttribute = $contentObjectAttribute->contentClassAttribute();
202
203 if ( $data == "" )
204 {
205 if ( $contentObjectAttribute->validateIsRequired() )
206 {
207 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
208 'Input required.' ) );
209 return eZInputValidator::STATE_INVALID;
210 }
211 else
212 return eZInputValidator::STATE_ACCEPTED;
213 }
214 else
215 {
216 return $this->validateIntegerHTTPInput( $data, $contentObjectAttribute, $classAttribute );
217 }
218 }
219 else
220 return eZInputValidator::STATE_INVALID;
221 }
222
226 function fetchCollectionAttributeHTTPInput( $collection, $collectionAttribute, $http, $base, $contentObjectAttribute )
227 {
228 if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
229 {
230 $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
231 $data = trim( $data ) != '' ? $data : null;
232 $data = str_replace(" ", "", $data);
233 $collectionAttribute->setAttribute( "data_int", $data );
234 return true;
235 }
236 return false;
237 }
238
242 function storeObjectAttribute( $object_attribute )
243 {
244 }
245
246 function storeClassAttribute( $attribute, $version )
247 {
248 }
249
250 function validateClassAttributeHTTPInput( $http, $base, $classAttribute )
251 {
252 $minValueName = $base . self::MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
253 $maxValueName = $base . self::MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
254 $defaultValueName = $base . self::DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
255
256 if ( $http->hasPostVariable( $minValueName ) and
257 $http->hasPostVariable( $maxValueName ) and
258 $http->hasPostVariable( $defaultValueName ) )
259 {
260 $minValueValue = $http->postVariable( $minValueName );
261 $minValueValue = str_replace(" ", "", $minValueValue );
262 $maxValueValue = $http->postVariable( $maxValueName );
263 $maxValueValue = str_replace(" ", "", $maxValueValue );
264 $defaultValueValue = $http->postVariable( $defaultValueName );
265 $defaultValueValue = str_replace(" ", "", $defaultValueValue );
266
267 if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
268 return eZInputValidator::STATE_ACCEPTED;
269 }
270 else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
271 {
272 $max_state = $this->IntegerValidator->validate( $maxValueValue );
273 return $max_state;
274 }
275 else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
276 {
277 $min_state = $this->IntegerValidator->validate( $minValueValue );
278 return $min_state;
279 }
280 else
281 {
282 $min_state = $this->IntegerValidator->validate( $minValueValue );
283 $max_state = $this->IntegerValidator->validate( $maxValueValue );
284 if ( ( $min_state == eZInputValidator::STATE_ACCEPTED ) and
285 ( $max_state == eZInputValidator::STATE_ACCEPTED ) )
286 {
287 if ($minValueValue <= $maxValueValue)
288 return eZInputValidator::STATE_ACCEPTED;
289 else
290 {
291 $state = eZInputValidator::STATE_INTERMEDIATE;
292 eZDebug::writeNotice( "Integer minimum value great than maximum value." );
293 return $state;
294 }
295 }
296 }
297
298 if ($defaultValueValue == ""){
299 $default_state = eZInputValidator::STATE_ACCEPTED;
300 }
301 else
302 $default_state = $this->IntegerValidator->validate( $defaultValueValue );
303 }
304
305 return eZInputValidator::STATE_INVALID;
306 }
307
308 function fixupClassAttributeHTTPInput( $http, $base, $classAttribute )
309 {
310 $minValueName = $base . self::MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
311 $maxValueName = $base . self::MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
312 if ( $http->hasPostVariable( $minValueName ) and $http->hasPostVariable( $maxValueName ) )
313 {
314 $minValueValue = $http->postVariable( $minValueName );
315 $minValueValue = $this->IntegerValidator->fixup( $minValueValue );
316 $http->setPostVariable( $minValueName, $minValueValue );
317
318 $maxValueValue = $http->postVariable( $maxValueName );
319 $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
320 $http->setPostVariable( $maxValueName, $maxValueValue );
321
322 if ($minValueValue > $maxValueValue)
323 {
324 $this->IntegerValidator->setRange( $minValueValue, false );
325 $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
326 $http->setPostVariable( $maxValueName, $maxValueValue );
327 }
328 }
329 }
330
331 function fetchClassAttributeHTTPInput( $http, $base, $classAttribute )
332 {
333 $minValueName = $base . self::MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
334 $maxValueName = $base . self::MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
335 $defaultValueName = $base . self::DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
336
337 if ( $http->hasPostVariable( $minValueName ) and
338 $http->hasPostVariable( $maxValueName ) and
339 $http->hasPostVariable( $defaultValueName ) )
340 {
341 $minValueValue = $http->postVariable( $minValueName );
342 $minValueValue = str_replace(" ", "", $minValueValue );
343 $maxValueValue = $http->postVariable( $maxValueName );
344 $maxValueValue = str_replace(" ", "", $maxValueValue );
345 $defaultValueValue = $http->postVariable( $defaultValueName );
346 $defaultValueValue = str_replace(" ", "", $defaultValueValue );
347
348 $classAttribute->setAttribute( self::MIN_VALUE_FIELD, $minValueValue );
349 $classAttribute->setAttribute( self::MAX_VALUE_FIELD, $maxValueValue );
350 $classAttribute->setAttribute( self::DEFAULT_VALUE_FIELD, $defaultValueValue );
351
352 if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
353 $input_state = self::NO_MIN_MAX_VALUE;
354 $classAttribute->setAttribute( self::INPUT_STATE_FIELD, $input_state );
355 }
356 else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
357 {
358 $input_state = self::HAS_MAX_VALUE;
359 $classAttribute->setAttribute( self::INPUT_STATE_FIELD, $input_state );
360 }
361 else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
362 {
363 $input_state = self::HAS_MIN_VALUE;
364 $classAttribute->setAttribute( self::INPUT_STATE_FIELD, $input_state );
365 }
366 else
367 {
368 $input_state = self::HAS_MIN_MAX_VALUE;
369 $classAttribute->setAttribute( self::INPUT_STATE_FIELD, $input_state );
370 }
371 return true;
372 }
373 return false;
374 }
375
379 function objectAttributeContent( $contentObjectAttribute )
380 {
381 return $contentObjectAttribute->attribute( "data_int" );
382 }
383
384
388 function metaData( $contentObjectAttribute )
389 {
390 return (int)$contentObjectAttribute->attribute( "data_int" );
391 }
396 function toString( $contentObjectAttribute )
397 {
398 return $contentObjectAttribute->attribute( 'data_int' );
399 }
400
401 function fromString( $contentObjectAttribute, $string )
402 {
403 return $contentObjectAttribute->setAttribute( 'data_int', $string );
404 }
405
409 function title( $contentObjectAttribute, $name = null )
410 {
411 return $contentObjectAttribute->attribute( "data_int" );
412 }
413
414 function hasObjectAttributeContent( $contentObjectAttribute )
415 {
416 return $contentObjectAttribute->attribute( 'data_int' ) !== null;
417 }
418
419 function isInformationCollector()
420 {
421 return true;
422 }
423
427 function isIndexable()
428 {
429 return true;
430 }
431
432 function sortKey( $contentObjectAttribute )
433 {
434 return $contentObjectAttribute->attribute( 'data_int' );
435 }
436
437 function sortKeyType()
438 {
439 return 'int';
440 }
441
442 function serializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode )
443 {
444 $defaultValue = $classAttribute->attribute( self::DEFAULT_VALUE_FIELD );
445 $minValue = $classAttribute->attribute( self::MIN_VALUE_FIELD );
446 $maxValue = $classAttribute->attribute( self::MAX_VALUE_FIELD );
447 $minMaxState = $classAttribute->attribute( self::INPUT_STATE_FIELD );
448
449 $dom = $attributeParametersNode->ownerDocument;
450 $defaultValueNode = $dom->createElement( 'default-value' );
451 $defaultValueNode->appendChild( $dom->createTextNode( $defaultValue ) );
452 $attributeParametersNode->appendChild( $defaultValueNode );
453 if ( $minMaxState == self::HAS_MIN_VALUE or $minMaxState == self::HAS_MIN_MAX_VALUE )
454 {
455 $minValueNode = $dom->createElement( 'min-value' );
456 $minValueNode->appendChild( $dom->createTextNode( $minValue ) );
457 $attributeParametersNode->appendChild( $minValueNode );
458 }
459 if ( $minMaxState == self::HAS_MAX_VALUE or $minMaxState == self::HAS_MIN_MAX_VALUE )
460 {
461 $maxValueNode = $dom->createElement( 'max-value' );
462 $maxValueNode->appendChild( $dom->createTextNode( $maxValue ) );
463 $attributeParametersNode->appendChild( $maxValueNode );
464 }
465 }
466
467 function unserializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode )
468 {
469 $defaultValue = $attributeParametersNode->getElementsByTagName( 'default-value' )->item( 0 )->textContent;
470 $minValue = $attributeParametersNode->getElementsByTagName( 'min-value' )->item( 0 )->textContent;
471 $maxValue = $attributeParametersNode->getElementsByTagName( 'max-value' )->item( 0 )->textContent;
472
473 if ( strlen( $minValue ) > 0 and strlen( $maxValue ) > 0 )
474 $minMaxState = self::HAS_MIN_MAX_VALUE;
475 else if ( strlen( $minValue ) > 0 )
476 $minMaxState = self::HAS_MIN_VALUE;
477 else if ( strlen( $maxValue ) > 0 )
478 $minMaxState = self::HAS_MAX_VALUE;
479 else
480 $minMaxState = self::NO_MIN_MAX_VALUE;
481
482 $classAttribute->setAttribute( self::DEFAULT_VALUE_FIELD, $defaultValue );
483 $classAttribute->setAttribute( self::MIN_VALUE_FIELD, $minValue );
484 $classAttribute->setAttribute( self::MAX_VALUE_FIELD, $maxValue );
485 $classAttribute->setAttribute( self::INPUT_STATE_FIELD, $minMaxState );
486 }
487
488 function batchInitializeObjectAttributeData( $classAttribute )
489 {
490 $default = $classAttribute->attribute( "data_int3" );
491 if ( $default === 0 )
492 {
493 return array();
494 }
495 else
496 {
497 return array( 'data_int' => $default,
498 'sort_key_int' => $default );
499 }
500 }
501
502 function supportsBatchInitializeObjectAttribute()
503 {
504 return true;
505 }
506
509 public $IntegerValidator;
510 }
511
512 eZDataType::register( eZIntegerType::DATA_TYPE_STRING, "eZIntegerType" );
513
514 ?>
eZDataType
Base class for content datatypes.
Definition: ezdatatype.php:46
eZDataType\register
static register( $dataTypeString, $className)
Definition: ezdatatype.php:203
eZDebug\writeNotice
static writeNotice( $string, $label="", $backgroundClass="")
Definition: ezdebug.php:459
eZInputValidator\STATE_INTERMEDIATE
const STATE_INTERMEDIATE
Definition: ezinputvalidator.php:80
eZInputValidator\STATE_ACCEPTED
const STATE_ACCEPTED
Definition: ezinputvalidator.php:79
eZInputValidator\STATE_INVALID
const STATE_INVALID
Definition: ezinputvalidator.php:81
eZIntegerType
A content datatype which handles integers.
Definition: ezintegertype.php:24
eZIntegerType\DEFAULT_VALUE_FIELD
const DEFAULT_VALUE_FIELD
Definition: ezintegertype.php:30
eZIntegerType\storeClassAttribute
storeClassAttribute( $attribute, $version)
Definition: ezintegertype.php:246
eZIntegerType\validateObjectAttributeHTTPInput
validateObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute)
Definition: ezintegertype.php:116
eZIntegerType\MIN_VALUE_FIELD
const MIN_VALUE_FIELD
Definition: ezintegertype.php:26
eZIntegerType\unserializeContentClassAttribute
unserializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode)
Definition: ezintegertype.php:467
eZIntegerType\objectAttributeContent
objectAttributeContent( $contentObjectAttribute)
Definition: ezintegertype.php:379
eZIntegerType\title
title( $contentObjectAttribute, $name=null)
Definition: ezintegertype.php:409
eZIntegerType\$IntegerValidator
$IntegerValidator
Definition: ezintegertype.php:509
eZIntegerType\MAX_VALUE_VARIABLE
const MAX_VALUE_VARIABLE
Definition: ezintegertype.php:29
eZIntegerType\isInformationCollector
isInformationCollector()
Definition: ezintegertype.php:419
eZIntegerType\supportsBatchInitializeObjectAttribute
supportsBatchInitializeObjectAttribute()
Definition: ezintegertype.php:502
eZIntegerType\fromString
fromString( $contentObjectAttribute, $string)
Definition: ezintegertype.php:401
eZIntegerType\fixupClassAttributeHTTPInput
fixupClassAttributeHTTPInput( $http, $base, $classAttribute)
Definition: ezintegertype.php:308
eZIntegerType\DATA_TYPE_STRING
const DATA_TYPE_STRING
Definition: ezintegertype.php:25
eZIntegerType\DEFAULT_VALUE_VARIABLE
const DEFAULT_VALUE_VARIABLE
Definition: ezintegertype.php:31
eZIntegerType\validateIntegerHTTPInput
validateIntegerHTTPInput( $data, $contentObjectAttribute, $classAttribute)
Definition: ezintegertype.php:55
eZIntegerType\MAX_VALUE_FIELD
const MAX_VALUE_FIELD
Definition: ezintegertype.php:28
eZIntegerType\sortKey
sortKey( $contentObjectAttribute)
Definition: ezintegertype.php:432
eZIntegerType\serializeContentClassAttribute
serializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode)
Definition: ezintegertype.php:442
eZIntegerType\fetchClassAttributeHTTPInput
fetchClassAttributeHTTPInput( $http, $base, $classAttribute)
Definition: ezintegertype.php:331
eZIntegerType\initializeObjectAttribute
initializeObjectAttribute( $contentObjectAttribute, $currentVersion, $originalContentObjectAttribute)
Definition: ezintegertype.php:158
eZIntegerType\NO_MIN_MAX_VALUE
const NO_MIN_MAX_VALUE
Definition: ezintegertype.php:33
eZIntegerType\validateClassAttributeHTTPInput
validateClassAttributeHTTPInput( $http, $base, $classAttribute)
Definition: ezintegertype.php:250
eZIntegerType\HAS_MIN_VALUE
const HAS_MIN_VALUE
Definition: ezintegertype.php:34
eZIntegerType\INPUT_STATE_FIELD
const INPUT_STATE_FIELD
Definition: ezintegertype.php:32
eZIntegerType\MIN_VALUE_VARIABLE
const MIN_VALUE_VARIABLE
Definition: ezintegertype.php:27
eZIntegerType\isIndexable
isIndexable()
Definition: ezintegertype.php:427
eZIntegerType\hasObjectAttributeContent
hasObjectAttributeContent( $contentObjectAttribute)
Definition: ezintegertype.php:414
eZIntegerType\sortKeyType
sortKeyType()
Definition: ezintegertype.php:437
eZIntegerType\fetchObjectAttributeHTTPInput
fetchObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute)
Definition: ezintegertype.php:182
eZIntegerType\fixupObjectAttributeHTTPInput
fixupObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute)
Definition: ezintegertype.php:151
eZIntegerType\toString
toString( $contentObjectAttribute)
Definition: ezintegertype.php:396
eZIntegerType\HAS_MIN_MAX_VALUE
const HAS_MIN_MAX_VALUE
Definition: ezintegertype.php:36
eZIntegerType\batchInitializeObjectAttributeData
batchInitializeObjectAttributeData( $classAttribute)
Definition: ezintegertype.php:488
eZIntegerType\__construct
__construct()
Definition: ezintegertype.php:38
eZIntegerType\metaData
metaData( $contentObjectAttribute)
Definition: ezintegertype.php:388
eZIntegerType\fetchCollectionAttributeHTTPInput
fetchCollectionAttributeHTTPInput( $collection, $collectionAttribute, $http, $base, $contentObjectAttribute)
Definition: ezintegertype.php:226
eZIntegerType\HAS_MAX_VALUE
const HAS_MAX_VALUE
Definition: ezintegertype.php:35
eZIntegerType\validateCollectionAttributeHTTPInput
validateCollectionAttributeHTTPInput( $http, $base, $contentObjectAttribute)
Definition: ezintegertype.php:195
eZIntegerType\storeObjectAttribute
storeObjectAttribute( $object_attribute)
Definition: ezintegertype.php:242
eZIntegerValidator
The class eZIntegerValidator does.
Definition: ezintegervalidator.php:18
ezpI18n\tr
static tr( $context, $source, $comment=null, $arguments=null)
Definition: ezpi18n.php:86
Copyright © 1998 – 2026 7x. All rights reserved. Licensed under the GNU GPLv2+.