Validate taxonomies.

@param  mixed $value The taxonomies.
@return true|lang_string
767128
protected function validate_taxonomies($value) {
        $terms = explode(',', $value);

        foreach ($terms as $term) {
            if (!empty($term) && !array_key_exists($term, self::get_taxonomies_list())) {
                return new lang_string('invalidtaxonomy', 'core_competency', $term);
            }
        }

        return true;
    }
1257041
public function isValueValid($value) {
		return $value instanceof Type\CreativeWork || $value instanceof Type\HowToSection || $value instanceof Type\HowToStep || $value instanceof DataType\TextType;
	}
1006280
public function isValid($value)
    {
        if ($value instanceof LocaleCode) {
            $value = LocaleCode::canonicalize($value);
        }

        if (!is_string($value)) {
            $this->error(self::INVALID);
            return false;
        }

        $this->setValue($value);

        if (!in_array($value, $this->getLocaleList(), true)) {
            $this->error(self::NOT_FOUND);
        }

        return count($this->getMessages()) === 0;
    }
1229004
public function isValid($value)
    {
        try {
            if (null === \json_decode($value, true)) {
                return $this->_error(self::INVALID);
            }
        } catch (\Exception $e) {
            return $this->_error(self::INVALID);
        }
        return true;
    }
153355
public function isValid($value)
    {
        $result = (boolean) filter_var($value, FILTER_VALIDATE_URL);
        if (!$result) {
            $this->addMessage('url');
        }
        return $result;
    }
132956
public function validateValue( $value ) : bool
   {

      if ( false === $this->hasValidator() )
      {
         return true;
      }

      return (bool) ( $this->_validator )( $value );

   }
619596
public function isValid($value)
    {
        if (!is_string($value)) {
            $this->error(self::INVALID);
            return false;
        }

        $this->setValue($value);
        if (!preg_match(self::PATTERN, $value)) {
            $this->error(self::NOT_MATCH);
            return false;
        }

        if (!$this->getCurrencyList()->isAllowed($value)) {
            $this->error(self::NOT_FOUND);
        }

        return count($this->getMessages()) === 0;
    }
186143
public function isValueValid($value) {
		return $value instanceof Type\AlignmentObjectType || $value instanceof Type\CourseType || $value instanceof DataType\TextType;
	}
5120
private function isValidType($value): bool
    {
        if ($this->type instanceof DataType) {
            return $this->type->isTheTypeOf($value);
        }

        return true;
    }
1128505
public static function validate($value)
    {
        if (!is_array($value)) {
            return false;
        }
        if (isset($value['to']) && IdentityValidator::validate($value['to']) === false) {
            return false;
        }
        if (!isset($value['topics']) || !is_array($value['topics'])) {
            return false;
        }
        foreach ($value['topics'] as $topic) {
            if (is_array($topic)) {
                foreach ($topic as $subTopic) {
                    if (HexValidator::validate($subTopic) === false) {
                        return false;
                    }
                }
                continue;
            }
            if (HexValidator::validate($topic) === false) {
                if (!is_null($topic)) {
                    return false;
                }
            }
        }
        return true;
    }
464012
public function isValid($value)
    {
        if (!is_string($value) && !is_int($value) && !is_float($value)) {
            $this->_error(self::INVALID);
            return false;
        }

        if (is_int($value)) {
            return true;
        }

        $this->_setValue($value);
        if ($this->_locale === null) {
            $locale        = localeconv();
            $valueFiltered = str_replace($locale['decimal_point'], '.', $value);
            $valueFiltered = str_replace($locale['thousands_sep'], '', $valueFiltered);

            if (strval(intval($valueFiltered)) != $valueFiltered) {
                $this->_error(self::NOT_INT);
                return false;
            }

        } else {
            try {
                if (!Zend_Locale_Format::isInteger($value, array('locale' => $this->_locale))) {
                    $this->_error(self::NOT_INT);
                    return false;
                }
            } catch (Zend_Locale_Exception $e) {
                $this->_error(self::NOT_INT);
                return false;
            }
        }

        return true;
    }
378784
public function validate($value)
    {
        if ($value instanceof \O2System\Database\Sql\Abstracts\AbstractConnection || $value instanceof \O2System\Database\NoSql\Abstracts\AbstractConnection) {
            return true;
        }

        return false;
    }
292318
public function isValid($value)
    {
        if (false === Core::get()->classExists($value)) {
            $errorMessage = $this->translateErrorMessage('validator.class_exists.not_valid', 'configuration_object', [$value]);
            $this->addError($errorMessage, 1457610460);
        }
    }
107090
public function validate($value)
    {
        $messenger = $this->messenger->clear();
        return array_reduce(
            $this->func,
            function (&$result, $func) use ($value, $messenger) {
                return $result && $func($value, $messenger);
            },
            true
        );
    }
833363
public function isValueValid($value) {
		return $value instanceof Type\CreativeWork || $value instanceof Type\ItemList || $value instanceof DataType\TextType;
	}
450467
public function isValueValid($value) {
		return $value instanceof Type\QualitativeValueType || $value instanceof DataType\TextType || $value instanceof DataType\URLType;
	}
969813
public function isValid($value)
    {
        $nameOk = parent::isValid($value);

        if (!$nameOk) {
            return false;
        }

        $check = $this->pageRepo->findOneBy(
            [
                'name' => $value,
                'pageType' => $this->pageType,
                'site' => $this->siteId
            ]
        );

        if (!empty($check)) {
            $this->error(self::PAGE_EXISTS);

            return false;
        }

        return true;
    }