Store the DATAVALIDATIONS and DATAVALIDATION records.
339205
private function _writeDataValidity()
	{
		// Datavalidation collection
		$dataValidationCollection = $this->_phpSheet->getDataValidationCollection();

		// Write data validations?
		if (!empty($dataValidationCollection)) {

			// DATAVALIDATIONS record
			$record = 0x01B2;	  // Record identifier
			$length	  = 0x0012;	  // Bytes to follow

			$grbit  = 0x0000;	   // Prompt box at cell, no cached validity data at DV records
			$horPos	  = 0x00000000;  // Horizontal position of prompt box, if fixed position
			$verPos	  = 0x00000000;  // Vertical position of prompt box, if fixed position
			$objId  = 0xFFFFFFFF;  // Object identifier of drop down arrow object, or -1 if not visible

			$header	  = pack('vv', $record, $length);
			$data		= pack('vVVVV', $grbit, $horPos, $verPos, $objId,
										 count($dataValidationCollection));
			$this->_append($header.$data);

			// DATAVALIDATION records
			$record = 0x01BE;			  // Record identifier

			foreach ($dataValidationCollection as $cellCoordinate => $dataValidation) {
				// initialize record data
				$data = '';

				// options
				$options = 0x00000000;

				// data type
				$type = $dataValidation->getType();
				switch ($type) {
					case PHPExcel_Cell_DataValidation::TYPE_NONE:		$type = 0x00;	break;
					case PHPExcel_Cell_DataValidation::TYPE_WHOLE:		$type = 0x01;	break;
					case PHPExcel_Cell_DataValidation::TYPE_DECIMAL:	$type = 0x02;	break;
					case PHPExcel_Cell_DataValidation::TYPE_LIST:		$type = 0x03;	break;
					case PHPExcel_Cell_DataValidation::TYPE_DATE:		$type = 0x04;	break;
					case PHPExcel_Cell_DataValidation::TYPE_TIME:		$type = 0x05;	break;
					case PHPExcel_Cell_DataValidation::TYPE_TEXTLENGTH:	$type = 0x06;	break;
					case PHPExcel_Cell_DataValidation::TYPE_CUSTOM:		$type = 0x07;	break;
				}
				$options |= $type << 0;

				// error style
				$errorStyle = $dataValidation->getType();
				switch ($errorStyle) {
					case PHPExcel_Cell_DataValidation::STYLE_STOP:			$errorStyle = 0x00;		break;
					case PHPExcel_Cell_DataValidation::STYLE_WARNING:		$errorStyle = 0x01;		break;
					case PHPExcel_Cell_DataValidation::STYLE_INFORMATION:	$errorStyle = 0x02;		break;
				}
				$options |= $errorStyle << 4;

				// explicit formula?
				if ($type == 0x03 && preg_match('/^\".*\"$/', $dataValidation->getFormula1())) {
					$options |= 0x01				<< 7;
				}

				// empty cells allowed
				$options |= $dataValidation->getAllowBlank() << 8;

				// show drop down
				$options |= (!$dataValidation->getShowDropDown()) << 9;

				// show input message
				$options |= $dataValidation->getShowInputMessage() << 18;

				// show error message
				$options |= $dataValidation->getShowErrorMessage() << 19;

				// condition operator
				$operator = $dataValidation->getOperator();
				switch ($operator) {
					case PHPExcel_Cell_DataValidation::OPERATOR_BETWEEN: $operator = 0x00			;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_NOTBETWEEN: $operator = 0x01		;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_EQUAL: $operator = 0x02				;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_NOTEQUAL: $operator = 0x03			;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHAN: $operator = 0x04		;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_LESSTHAN: $operator = 0x05			;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHANOREQUAL: $operator = 0x06;	break;
					case PHPExcel_Cell_DataValidation::OPERATOR_LESSTHANOREQUAL: $operator = 0x07	;	break;
				}
				$options |= $operator << 20;

				$data		= pack('V', $options);

				// prompt title
				$promptTitle = $dataValidation->getPromptTitle() !== '' ?
					$dataValidation->getPromptTitle() : chr(0);
				$data .= PHPExcel_Shared_String::UTF8toBIFF8UnicodeLong($promptTitle);

				// error title
				$errorTitle = $dataValidation->getErrorTitle() !== '' ?
					$dataValidation->getErrorTitle() : chr(0);
				$data .= PHPExcel_Shared_String::UTF8toBIFF8UnicodeLong($errorTitle);

				// prompt text
				$prompt = $dataValidation->getPrompt() !== '' ?
					$dataValidation->getPrompt() : chr(0);
				$data .= PHPExcel_Shared_String::UTF8toBIFF8UnicodeLong($prompt);

				// error text
				$error = $dataValidation->getError() !== '' ?
					$dataValidation->getError() : chr(0);
				$data .= PHPExcel_Shared_String::UTF8toBIFF8UnicodeLong($error);

				// formula 1
				try {
					$formula1 = $dataValidation->getFormula1();
					if ($type == 0x03) { // list type
						$formula1 = str_replace(',', chr(0), $formula1);
					}
					$this->_parser->parse($formula1);
					$formula1 = $this->_parser->toReversePolish();
					$sz1 = strlen($formula1);

				} catch(PHPExcel_Exception $e) {
					$sz1 = 0;
					$formula1 = '';
				}
				$data .= pack('vv', $sz1, 0x0000);
				$data .= $formula1;

				// formula 2
				try {
					$formula2 = $dataValidation->getFormula2();
					if ($formula2 === '') {
						throw new PHPExcel_Writer_Exception('No formula2');
					}
					$this->_parser->parse($formula2);
					$formula2 = $this->_parser->toReversePolish();
					$sz2 = strlen($formula2);

				} catch(PHPExcel_Exception $e) {
					$sz2 = 0;
					$formula2 = '';
				}
				$data .= pack('vv', $sz2, 0x0000);
				$data .= $formula2;

				// cell range address list
				$data .= pack('v', 0x0001);
				$data .= $this->_writeBIFF8CellRangeAddressFixed($cellCoordinate);

				$length = strlen($data);
			$header = pack("vv", $record, $length);

				$this->_append($header . $data);
			}
		}
	}
925362
def _init_records(self, record_types):
        """"""
        for record_type in record_types:
            # This conditional was inserted on 7/11/14. It may prove problematic:
            if str(record_type) not in self._my_map['recordTypeIds']:
                record_initialized = self._init_record(str(record_type))
                if record_initialized:
                    self._my_map['recordTypeIds'].append(str(record_type))
525381
protected function prepareForValidation(): void
    {
        $data = $this->all();

        $data['base_cost'] = (int) $data['base_cost'];

        $this->replace($data);
    }
234849
public function validate() : void
    {
        $this->value = null;
        $value = $this->filter($this->raw_value);
        if (true === $this->checkValidity($value)) {
            $this->is_valid = true;
        } else {
            $this->is_valid = false;
            $this->reportError($this->error_message);
            $error_message = sprintf($this->error_message, $this->field_name);
            $this->the_message = $error_message;
        }
        // If no issues have been found, check the constraints.
        if ($this->is_valid) {
            foreach ($this->constraints as $constraint) {
                if (false === $constraint->check($value)) {
                    $this->is_valid = false;
                    $this->the_message = sprintf($constraint->getErrorMessage(), $this->field_name);
                }
            }
        }
        // Set the value for retrieval
        if ($this->is_valid) {
            $this->value = $value;
        }
    }
562221
def _populate_validated_data_with_sub_field_data(self, validated_data):
        
        for fieldname, field in self.get_fields().items():
            if isinstance(field, ModelSubSerializer):
                field_data = validated_data.pop(fieldname, None)
                if field_data:
                    validated_data.update(field_data)
1150346
def _validate(self, writing=False):
        """"""
        for box in self.DR:
            if box.box_id != 'url ':
                msg = ('Child boxes of a data reference box can only be data '
                       'entry URL boxes.')
                self._dispatch_validation_error(msg, writing=writing)
1287940
public void setValidationData(java.util.Collection<AttributeType> validationData) {
        if (validationData == null) {
            this.validationData = null;
            return;
        }

        this.validationData = new java.util.ArrayList<AttributeType>(validationData);
    }
538105
def save!(options={})
      if perform_validations(options)
        ret = super()
        process_response_errors
        raise_record_invalid if self.errors.any?
        ret
      else
        raise_record_invalid
      end
    end
1155485
def validate_integrity(self):
        
        self._validate_columns(self._columns)
        self._validate_index(self._index)
        self._validate_data()
6782
public void storeResults() {
		System.out.println("Processed " + countItems + " items and "
				+ countProperties + " properties in total.");
		System.out.println("Storing data ...");

		try (PrintStream out = new PrintStream(new FileOutputStream(
				"tutorial-results.csv"))) {
			// Two simple entries for demonstration purposes.
			// Use your own code when you have more interesting data.
			out.println("count of items," + countItems);
			out.println("count of properties," + countProperties);
		} catch (IOException e) {
			System.out.println("Oops, I could not write the file: "
					+ e.toString());
		}

		System.out.println("... data stored.");

	}
991568
def validate(self):
        """"""
        try:
            # update _resource to have default values from the schema
            self._resource = self.schema(self._resource)
        except MultipleInvalid as e:
            errors = [format_error(err, self.resource_type) for err in e.errors]
            raise exceptions.ValidationError({'errors': errors})

        yield self.check_unique()
1251845
public Set<ConstraintViolation> validate(int record) {
		Set<ConstraintViolation> errors = new LinkedHashSet<ConstraintViolation>();
		for (int ds = 0; ds < 250; ++ds) {
			try {
				DataSetInfo dataSetInfo = dsiFactory.create(IIM.DS(record, ds));
				errors.addAll(validate(dataSetInfo));
			} catch (InvalidDataSetException ignored) {
				// DataSetFactory doesn't know about this ds, so will skip it
			}
		}
		return errors;
	}
1239115
def validate(record, field_name, bindings = {})
      if validations
        validations.collect do |validation|
          unless valid_value?(validation, record, field_name, bindings)
            FieldValidationError.new(validation, record, field_name, pos, width)
          end
        end.compact
      elsif record && record[field_name]
        # when no validation rules exist for the field, just check if the field exists in the record
        []
      else
        raise "found field value nil in #{record} field #{field_name}, shouldn't be possible?"
      end
    end
376419
protected function _addValidators()
    {
        parent::_addValidators();

        //if hideIfNoValues and there are no values remove empty validator
        if ($this->getHideIfNoValues() && isset($this->_validators['notEmpty'])) {
            $store = $this->_getStoreData();
            if (!$store['data']) {
                unset($this->_validators['notEmpty']);
            }
        }
    }
206895
function store(err, resp, data) {
  if (err && (err.code == 'EADDRINFO' || err.code == 'ENOTFOUND'))
    failed.push(data);
}
1174074
def save_records(self, records):
        '''
        
        '''
        for record in records:
            if not isinstance(record, Record):
                record = Record(*record)
            self.save_record(*record)
223852
protected void store(SecurityEvent auditEvent) throws Exception {
		if (myDataStore == null)
			throw new InternalErrorException("No data store provided to persist audit events");
		myDataStore.store(auditEvent);
	}