Check for tx_styleguide_inline_usecombination and
tx_styleguide_inline_usecombinationbox table

@param array $data
@return bool
501691
public function match(array $data): bool
    {
        $match = parent::match($data);
        if ($match) {
            if ($data['fieldConfig']['config']['foreign_table'] !== 'tx_styleguide_inline_usecombination_mm'
                && $data['fieldConfig']['config']['foreign_table'] !== 'tx_styleguide_inline_usecombinationbox_mm'
            ) {
                $match = false;
            }
        }
        return $match;
    }
207491
public function selected( array $data )
    {
        if ( isset( $data['tags'] ) && is_string( $data['tags'] ) )
        {
            $data['tags'] = explode( static::TAG_SEPARATOR, $data['tags'] );
        }

        if ( isset( $data['tagIds'] ) && is_string( $data['tagIds'] ) )
        {
            $data['tagIds'] = explode( static::TAG_SEPARATOR, $data['tagIds'] );
        }

        if ( isset( $data['localeTags'] ) && is_string( $data['localeTags'] ) )
        {
            $data['localeTags'] = explode( static::TAG_SEPARATOR, $data['localeTags'] );
        }

        if ( isset( $data['proxyData'] ) && is_string( $data['proxyData'] ) )
        {
            $data['proxyData'] = $this->parseProxyData( $data['proxyData'] );
        }

        return parent::selected( $data );
    }
1086059
protected function invalidPayload($data)
    {
        return ! is_array($data) || ! isset($data['iv']) || ! isset($data['value']) || ! isset($data['mac']);
    }
623770
private function isMobile(array $data): ?bool
    {
        if (!isset($data['device']['type'])) {
            return null;
        }

        $mobileTypes = ['mobile', 'tablet', 'ereader', 'media', 'watch', 'camera'];

        if (in_array($data['device']['type'], $mobileTypes)) {
            return true;
        }

        if ('gaming' === $data['device']['type']) {
            if (isset($data['device']['subtype']) && 'portable' === $data['device']['subtype']) {
                return true;
            }
        }

        return false;
    }
54655
protected function parseArrayOfPrimaryData(array $data)
    {
        $isValid = true;
        $result  = null;
        foreach ($data as $primaryData) {
            $parsed = $this->parseSinglePrimaryData($primaryData);
            if ($parsed === null) {
                $isValid = false;
            } else {
                $result[] = $parsed;
            }
        }

        return $isValid === true ? $result : null;
    }
987901
private function isProbablySingleIdentity(array $data)
    {
        $isProbablySingle = array_key_exists(DocumentInterface::KEYWORD_TYPE, $data) ||
            array_key_exists(DocumentInterface::KEYWORD_ID, $data);

        return $isProbablySingle;
    }
493451
protected function checkMatchArray(array $data, array $matchArray): bool
    {
        $result = true;
        foreach ($matchArray as $name => $value) {
            if (isset($data[$name])) {
                if (is_array($value)) {
                    $result = $this->checkMatchArray($data[$name], $value);
                    if ($result === false) {
                        return false;
                    }
                } elseif ($data[$name] === $value) {
                    $result = (bool)($result & true);
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
        return $result;
    }
1036926
public static function arrayColumns(array $data)
    {
        // Count the amount of values from the source input
        $count = count($data);

        if ($count === 0) {
            return false;
        }

        if ($count === 1) {
            return array_keys($data[0]);
        }

        if (isset($data[0])) {
            return array_keys($data[0]);
        } else {
            return false;
        }
    }
1254236
private function isDataSetProperly(array $data): bool
    {
        return (isset($data["in"]) && isset($data["out"]) && isset($data["from"]) && isset($data["to"]));
    }
252237
public function validateCompatible(array $data)
    {
        if(!count($data)) {
            /**
             * Allow empty
             */
            return true;
        }
        $count = 0;
        foreach($data as $k=>$v) {
            foreach(array('name','channel','min','max') as $fld) {
                $$fld = trim($v[$fld]);
            }
            $count++;

            $res = $this->validateUrl($channel) && strlen($channel);
            if(!$res) {
                $this->addError("Invalid or empty channel in compat. #{$count}");
            }

            $res = $this->validatePackageName($name) && strlen($name);
            if(!$res) {
                $this->addError("Invalid or empty name in compat. #{$count}");
            }
            $res1 = $this->validateVersion($min);
            if(!$res1) {
                $this->addError("Invalid or empty minVersion in compat. #{$count}");
            }
            $res2 = $this->validateVersion($max);
            if(!$res2) {
                $this->addError("Invalid or empty maxVersion in compat. #{$count}");
            }
            if($res1 && $res2 && $this->versionLower($max, $min)) {
                $this->addError("Max version is lower than min in compat #{$count}");
            }

        }
        return ! $this->hasErrors();
    }
750598
protected function checkItems(array $data)
	{
		foreach ($data as &$item)
		{
			if( ! $item instanceof Model )
			{
				$item = new $this->defaultModel($item);
			}
		}

		return $data;
	}
505514
public static function replace(array $data)
    {
        if (empty($data)) {
            return false;
        }

        // Case where $data is not an array of arrays.
        if (!isset($data[0])) {
            $data = [$data];
        }

        $sql = static::buildReplaceSql($data);

        $data = static::inLineArray($data);

        return self::getModelConnectionName()->affectingStatement($sql, $data);
    }
416585
protected final function validateNewData(array $data = null) {
		if ($data === null && isset($this->_formData)) {
			$data = $this->_formData;
		}
		if ($this->rules) {
			return $this->validateData($this->rules, $data);
		}

		return true;
	}
604795
public function isSupported(array $data)
    {
        try {
            new DateTime($data[$this->getProperty()]);
        } catch (Exception $e) {
            return false;
        }

        return true;
    }
110593
public static function keysExist(array $data, array $keys): bool
    {
        if (count($keys) > 0) {
            foreach ($keys as $key) {
                if (!array_key_exists($key, $data)) {
                    return false;
                }
            }
        }
        return true;
    }
941528
public function getIsAllValuesValid(array $data)
    {
        foreach($data as $value)
        {
            if(!$this->getIsValidValue($value))
            {
                return false;
            }
        }
        return true;
    }
577049
private function _inlineScript($data = null) {
        // no data?
        if(is_null($data))
            return false;

        // compress
        $data = Algorithms::js($data, $this->_config['config']['js']);

        // keep a reference to avoid duplicates
        $hash = md5($data);
        if(in_array($hash, $this->inline['js']))
            return false;
        else $this->inline['js'][] = $hash;

        // output
        return "<script>{$data}</script>";
    }