Verifies if lists from given tab is empty.

@param string $tabName
340070
public function verifyListIsEmpty(string $tabName): void
    {
        if ($this->adminList->table->getItemCount() > 0) {
            throw new \Exception(sprintf('%s list is not empty.', $tabName));
        }
    }
798782
public function hasInstalledPackage($packageName)
    {
        foreach ($this->contents['packages'] as $packageDetails) {
            if ($packageName === $packageDetails['name']) {
                return true;
            }
        }
        
        return false;
    }
586713
public static function existsTable($tableName)
    {
        if ($tableName === '') {
            throw new \InvalidArgumentException('The table name must not be empty.', 1331315636);
        }

        self::retrieveTableNames();

        return isset(self::$tableNameCache[$tableName]);
    }
303467
function hasLoaded($moduleName)
    {
        if (!is_string($moduleName))
            throw new \InvalidArgumentException(sprintf(
                'Invalid module name, "%s".'
                , \Poirot\Std\flatten($moduleName)
            ));

        return in_array($moduleName, $this->listLoadedModules());
    }
419954
public function tableExists($tableName)
    {
        if (is_null($this->dbh)) {
            throw new NoConnectionException();
        }

        $mrSql  = "SHOW TABLES LIKE :table_name";
        $mrStmt = $this->dbh->prepare($mrSql);

        // protect from injection attacks
        $mrStmt->bindParam(":table_name", $tableName, \PDO::PARAM_STR);

        $sqlResult = $mrStmt->execute();

        if ($sqlResult) {
            $row = $mrStmt->fetch(\PDO::FETCH_NUM);

            if ($row[0]) {
                return true;
            }
        }

        return false;
    }
578218
private function validateTabs($tabs)
    {
        if ($tabs === false)
            return $tabs;

        foreach($tabs as $q=>$tab){
            $resolver = new OptionsResolver();
            $resolver->setRequired([
                'name',
                'container',
            ]);
            $resolver->setDefaults([
                'label' => false,
                'label_params' => [],
                'display' => true,
            ]);

            if (!empty($tab['display']) && is_string($tab['display'])) {
                $method = $tab['display'];
                $tab['display'] = $this->$method();
            }
            $resolver->setAllowedTypes('label', ['boolean','string']);
            $resolver->setAllowedTypes('display', ['boolean']);
            $resolver->setAllowedTypes('name', ['string']);
            $resolver->setAllowedTypes('container', ['array']);
            $resolver->setAllowedTypes('label_params', ['array']);
            
            $tabs[$q] = $resolver->resolve($tab);
            $this->setCurrentTab($tab['name']);
            $tabs[$q]['container'] = $this->validateContainer($tab['container']);

        }


        $x = 0;
        foreach($tabs as $tab)
            if ($tab['name'] === $this->getRequestedTab())
                break;
            else
                $x++;
        $tabs['selectedTab'] = $x;
        return $tabs;
    }
276432
public function setFileName($fileName = null) {
		if (empty($fileName)) {
			return false;
		}

		$this->_fileName = (string)$fileName;

		return true;
	}
892513
public static function tableExists($tableName)
    {
        $query = "SELECT 1 FROM $tableName LIMIT 1";

        try {
            $result = Connection::db()->query($query);
        } catch (Exception $e) {
            return false;
        }

        return $result !== false;
    }
813746
public function isEmpty(): bool
    {
        return $this->isNull()
            || (is_array($this->value) && count($this->value) === 0)
            || (is_string($this->value) && strlen($this->value) === 0);
    }
350938
public boolean isNullOrEmpty(String attributeName) {
        String attr = attributes.get(attributeName);
        if (attr == null || attr.isEmpty()) {
            return true;
        }
        return false;
    }
552172
public function has($itemName)
        {
            return Arrays::exists($itemName, $this->_store) && isset($this->_store[$itemName]['lookupType']);
        }
36348
private function isEmpty($value)
    {
        // Assume that the value is empty
        $empty = true;

        // If the value is an array
        if (is_array($value)) {
            foreach ($value as $element) {
                // The value is empty if all elements of the array are empty
                $empty = $empty && $this->isEmpty($element);
            }
        } else {
            // We can't use the empty function here because it treats "0" as empty
            $empty = strlen($value) == 0;
        }

        return $empty;
    }
762050
public function isEmpty($value)
    {
        return empty($value) && (is_array($value) || is_object($value) || strlen(trim($value)) === 0);
    }
1255941
final public static function isEmptiable($fieldName) {
		
		$column = static::getColumnType($fieldName);
		
		if (is_null($column)) {
			return NULL;
		}
		
		$emptiables = ['CHAR','VARCHAR','TINYTEXT','TEXT','MEDIUMTEXT','BIGTEXT'];
		
		if (in_array($column->type, $emptiables) or ('ENUM' == $column->type and in_array('', $column->length))) {
			return TRUE;
		} else {
			return FALSE;
		}
		
		
	}
790067
public function isEmpty($keys = null)
    {
        if (is_null($keys)) {
            return empty($this->elements);
        }
        $keys = (array) $keys;
        foreach ($keys as $key) {
            if (!empty($this->get($key))) {
                return false;
            }
        }
        return true;
    }
1128889
public function isEmpty($key = null) {
        if (is_null($key)) {
            return count($this->__attributes) == 0;
        }
        return !$this->has($key) || empty($this->__attributes[$key]);
    }
839546
static function tab($tabName, $tabProperty) {
		/** @var Structure $s */
		$s = df_config_structure();
		if (!isset($s->_data['tabs'])) {
			$s->getTabs();
		}
		return dfa(dfa($s->_data['tabs'], $tabName, []), $tabProperty);
	}