# File ValidForm.rb, line 409
        def validate
                @errors=[]
                rs = @validationRules

                val=self.value()

                dRE = '(?:1[012]|0?\d)/(?:[012]?\\d|3[01])/(?:\d{2}|\d{4})'
                tRE = '(?:(?:[01]?\d|2[0-3]):[0-5]\d(?::[0-5]\d)?|(?:0?\d|1[0-2])(?::[0-5]\d){1,2}\s*[ap]\.?m\.?)'
                dateRE = Regexp.new('^'+dRE+'$',true)
                timeRE = Regexp.new('^'+tRE+'$',true)
                datetimeRE = Regexp.new('^(?:'+dRE+'\\s+'+tRE+'|'+tRE+'\\s+'+dRE+')$',true)

                if val==nil || val==""
                        @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::REQUIRED_VALUE_EMPTY) if rs[:required]
                else
                        @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::LENGTH_TOO_SMALL) if rs[:minlength] && val.length<rs[:minlength]
                        @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::LENGTH_TOO_LARGE) if rs[:maxlength] && val.length>rs[:maxlength]
                        case rs[:type]
                                when :phone
                                        rs[:match]=/^\D*\d*\D*(\d{3})?\D*\d{3}\D*\d{4}\D*$/
                                        failType=ValidForm::ValidationError::MATCH_FAIL_PHONE
                                when :email
                                        rs[:match]=/^[^@]+@[^.]+\..+$/
                                        failType=ValidForm::ValidationError::MATCH_FAIL_EMAIL
                                when :zipcode
                                        rs[:match]=/^\d{5}(?:-\d{4})?$/
                                        failType=ValidForm::ValidationError::MATCH_FAIL_ZIPCODE
                                when :integer
                                        rs[:match]=/^-?\d+$/
                                        failType=ValidForm::ValidationError::MATCH_FAIL_INTEGER
                                when :float
                                        rs[:match]=/^-?(?:\d+|\d*\.\d+)$/
                                        failType=ValidForm::ValidationError::MATCH_FAIL_FLOAT
                                when :date
                                        rs[:match]=dateRE
                                        failType=ValidForm::ValidationError::MATCH_FAIL_DATE
                                when :time
                                        rs[:match]=timeRE
                                        failType=ValidForm::ValidationError::MATCH_FAIL_TIME
                                when :datetime
                                        rs[:match]=datetimeRE
                                        failType=ValidForm::ValidationError::MATCH_FAIL_DATETIME
                                else
                                        failType=ValidForm::ValidationError::MATCH_FAIL_CUSTOM
                        end
                        if (rs[:match] && !rs[:match].match(val)) || (rs[:nomatch] && rs[:nomatch].match(val))
                                @errors << ValidForm::ValidationError.new(self,failType)
                        else
                                case rs[:type]
                                        when :integer,:float
                                                @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::VALUE_TOO_SMALL) if rs[:minvalue] && val.to_f<rs[:minvalue]
                                                @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::VALUE_TOO_LARGE) if rs[:maxvalue] && val.to_f>rs[:maxvalue]
                                        when :date,:time,:datetime
                                                t = val.is_a?(Time) ? val : Time.parse(val)
                                                rs[:minvalue] = (rs[:minvalue].is_a?(Time) ? rs[:minvalue] : Time.parse(rs[:minvalue])) if rs[:minvalue]
                                                rs[:maxvalue] = (rs[:maxvalue].is_a?(Time) ? rs[:maxvalue] : Time.parse(rs[:maxvalue])) if rs[:maxvalue]
                                                @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::DATETIME_TOO_SMALL) if rs[:minvalue] && t < rs[:minvalue]
                                                @errors << ValidForm::ValidationError.new(self,ValidForm::ValidationError::DATETIME_TOO_LARGE) if rs[:maxvalue] && t > rs[:maxvalue]
                                end
                        end
                end

                @validated=true
                @errors=nil if @errors.empty?
                @errors || true
        end