Returns if the parsed UA was identified as desktop device
Desktop devices are all devices with an unknown type that are running a desktop os

@see self::$desktopOsArray

@return bool
547973
public function isDesktop()
    {
        $osShort = $this->getOs('short_name');
        if (empty($osShort) || self::UNKNOWN == $osShort) {
            return false;
        }

        // Check for browsers available for mobile devices only
        if ($this->usesMobileBrowser()) {
            return false;
        }

        $decodedFamily = OperatingSystem::getOsFamily($osShort);

        return in_array($decodedFamily, self::$desktopOsArray);
    }
399191
function DetectSymbianOS()
   {
       if (stripos($this->useragent, $this->deviceSymbian) > -1 || 
           stripos($this->useragent, $this->deviceS60) > -1 ||
           stripos($this->useragent, $this->deviceS70) > -1 || 
           stripos($this->useragent, $this->deviceS80) > -1 ||
           stripos($this->useragent, $this->deviceS90) > -1)
         return $this->true; 
      else
         return $this->false; 
   }
1262605
protected static function is_device($device)
    {
        $ua = $_SERVER['HTTP_USER_AGENT'];
        return (bool)preg_match("/" . self::$devices[$device] . "/i", $ua);
    }
410292
protected function checkBrowseriPad()
    {
        if (stripos($this->_agent, 'iPad') !== false) {
            $this->setVersion(self::VERSION_UNKNOWN);
            $this->setBrowser(self::BROWSER_IPAD);
            $this->getSafariVersionOnIos();
            $this->getChromeVersionOnIos();
            $this->checkForFacebookIos();
            $this->setTablet(true);
            return true;
        }
        return false;
    }
1002240
function DetectAndroidTablet()
   {
      //First, let's make sure we're on an Android device.
      if ($this->DetectAndroid() == $this->false)
         return $this->false; 

      //Special check for Android devices with Opera Mobile/Mini. They should NOT report here.
      if ($this->DetectOperaMobile() == $this->true)
         return $this->false; 
         
      //Otherwise, if it's Android and does NOT have 'mobile' in it, Google says it's a tablet.
      if (stripos($this->useragent, $this->mobile) > -1)
         return $this->false;
      else
         return $this->true; 
   }
1134380
private function detectFujitsuOasys($ua)
    {
        if (preg_match('/Fujitsu; OASYS/ui', $ua, $match)) {
            $this->data->device->manufacturer = 'Fujitsu';
            $this->data->device->model = 'OASYS';
            $this->data->device->type = Constants\DeviceType::PDA;
            $this->data->device->identified |= Constants\Id::MATCH_UA;
            $this->data->device->generic = false;

            if (preg_match('/eNavigator/ui', $ua, $match)) {
                $this->data->browser->name = 'eNavigator';
                $this->data->browser->version = null;
                $this->data->browser->type = Constants\BrowserType::BROWSER;
            }
        }
    }
1123001
public function isMobile(string $useragent): bool
    {
        if (preg_match('/xbox|googletv|eeepc|smart-?tv|sonydtv|hbbtv|gxt_dongle_3188|apple tv|mxl661l32|nettv|crkey|lenovog780|windows iot|netcast|raspbian|bravia|tablet pc [12]\.|automobile|netgem|wordpress/i', $useragent)) {
            return false;
        }

        if (preg_match('/iphone.*windows nt.*micromessenger/i', $useragent)) {
            return true;
        }

        if (preg_match('/windows nt.*arm;/i', $useragent)) {
            return true;
        }

        // ignore mobile safari token if windows nt token is available
        if (preg_match('/windows nt.*(mobile safari|opera mobi|iphone)/i', $useragent)) {
            return false;
        }

        if (preg_match('/Puffin\/[\d\.]+WD/', $useragent)) {
            return false;
        }

        if (preg_match('/UCWEB|Puffin\/[\d\.]+[AIWM][TP]?|TBD\d{4}|TBD[BCG]\d{3,4}/', $useragent)) {
            return true;
        }

        if (preg_match('/fbid\/desktop/i', $useragent)) {
            return false;
        }

        if (preg_match('/mobile;|mobileok|-mobile|office mobile|tablet|(?<!a)phone|wireless|wpdesktop|zunewp7|xblwp7|(?<!ninesky-)android|adr |iphone|ip[ao]d|samsung(?!browser|-agent)|j2me|micromax|htc|karbonn|hisense|docomo|siemens(?! ?(a\/s|testmanager|lms|ag))|ktouch|portalmmm|rim tablet|jolla|iball|windows mobile|windows ce|symbos|symbian|remixos|webos|velocitymicro|samsung-(gt|sph)|lenovo|lumia|surftab|padfone|xda_diamond_2|transformer tf|touchpad|toshiba_ac_and_az|hpwos|silk|wap-browser|sailfish|crowsnest|folio_and_a|steelcore|m2 note|spice qt-75|spark284|lemon b556|terra_101|dino762|wetab|dataaccessd|lenovotablet|qtcarbrowser|onebrowser|stitcher|rss_?radio|antennapod|antenna\/|podcruncher|captivenetworksupport|(?<!c)ios;|audioboom.com\/boos|beyondpod|st80208|\[fban|wap2|up\.link|up\.browser|series ?[46]0|pocket ?pc|playstation|palm(?!a)|opera mobi|opera mini|openwave|obigo|nokia|nintendo|netfront|mqqbrowser|midp|meego|maemo|look-alike|linux armv|like mac os x|kindle|juc ?\(linux; ?u;|j2me|iuc\(u;ios|iris|hp-tablet|hd_mini_t|gingerbread|folio100|foma|firefox or ie|embider|danger hiptop|cldc|blazer|dalvik|bolt|blackberry|\b(bb10|bada|brew|mtk)\b|\btcl\b(?! http client)|aspen simulator|arm; touch|wap browser|kyy21|ebrd1101|ebrd1201|huawei-u8651|tizen/i', $useragent)) {
            return true;
        }

        return false;
    }
627146
public function isRowsToRepeatAtTopSet() {
		if (is_array($this->_rowsToRepeatAtTop)) {
			if ($this->_rowsToRepeatAtTop[0] != 0 && $this->_rowsToRepeatAtTop[1] != 0) {
				return true;
			}
		}

		return false;
	}
1222836
function DetectDangerHiptop()
   {
      if (stripos($this->useragent, $this->deviceDanger) > -1 ||
          stripos($this->useragent, $this->deviceHiptop) > -1)
         return $this->true; 
      else
         return $this->false; 
   }
268539
public static function isMobileClient($ua = null)
	{
		// $this->debug->groupCollapsed(__CLASS__.'->'.__FUNCTION__);
		$return = false;
		$httpAccept = null;
		if (empty($ua)) {
			$ua = $_SERVER['HTTP_USER_AGENT'];
			if (isset($_SERVER['HTTP_ACCEPT'])) {
				$httpAccept = $_SERVER['HTTP_ACCEPT'];
			}
		}
		if (isset(self::$isMobileClient[$ua])) {
			// $this->debug->groupEnd();
			return self::$isMobileClient[$ua];
		}
		// check if the user agent gives away any tell tale signs it's a mobile browser
		if (preg_match('/Android(?:\s(\d+\.\d+))?/', $ua)) {
			// Android! - impossible to determine phone vs tablet with any reliability!
			if (preg_match('/\b(Nexus)\b/', $ua)) {
				$return = false;		// it's a tablet
			} elseif (preg_match('/\bMobile\b/i', $ua)) {
				$return = true;			// it's a phone
			}
		} elseif (preg_match('/up.browser|up.link|windows ce|iemobile|mini|mmp|symbian|midp|wap|phone|pocket|mobile|\bpda\b|psp/i', $ua)) {
			$return = true;
		} elseif (stristr($httpAccept, 'text/vnd.wap.wml') || stristr($httpAccept, 'application/vnd.wap.xhtml+xml')) {
			// check the http accept header to see if wap.wml or wap.xhtml support is claimed
			$return = true;
		} elseif (isset($_SERVER['HTTP_X_WAP_PROFILE']) || isset($_SERVER['HTTP_PROFILE']) || isset($_SERVER['X-OperaMini-Features']) || isset($_SERVER['UA-pixels'])) {
			// check if there are any tell tales signs it's a mobile device from the _server headers
			$return = true;
		} else {
			// the first four characters from the most common mobile user agents
			$agents = array('acs-','alav','alca','amoi','audi','aste','benq','bird','blac','blaz','brew','cell','cldc','cmd-','dang','doco','eric','hipt','inno','ipaq','java','jigs','kddi','keji','leno','lg-c','lg-d','lg-g','lge-','maui','maxo','midp','mits','mmef','mobi','mot-','moto','mwbp','nec-','newt','noki','opwv','palm','pana','pant','pdxg','phil','play','pluc','port','prox','qtek','qwap','sage','sams','sany','sch-','sec-','send','seri','sgh-','shar','sie-','siem','smal','smar','sony','sph-','symb','t-mo','teli','tim-','tosh','tsm-','upg1','upsi','vk-v','voda','w3c ','wap-','wapa','wapi','wapp','wapr','webc','winw','winw','xda','xda-');
			$a2 = array('avantgo');
			foreach ($a2 as $a2_str) {
				$agents[] = substr($a2_str, 0, 4);
			}
			$parts = explode('; ', strtolower($ua));
			foreach ($parts as $part) {
				if (in_array(substr($part, 0, 4), $agents)) {
					$return = true;
					foreach ($a2 as $a2_str) {
						if (( substr($part, 0, 4) == substr($a2_str, 0, 4) )
							&& ( strpos($part, $a2_str) === false )
						) {
							// matches 1st four of a2_str, but not whole
							$return = false;
						}
					}
					if ($return) {
						break;
					}
				}
			}
		}
		if ($return && preg_match('/\biPad\b/', $ua)) {
			$return = false;
		}
		self::$isMobileClient[$ua] = $return;
		// $this->debug->groupEnd();
		return $return;
	}
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;
    }
331844
protected function checkBrowserAndroid()
    {
        if (stripos($this->_agent, 'Android') !== false) {
            $aresult = explode(' ', stristr($this->_agent, 'Android'));
            if (isset($aresult[1])) {
                $aversion = explode(' ', $aresult[1]);
                $this->setVersion($aversion[0]);
            } else {
                $this->setVersion(self::VERSION_UNKNOWN);
            }
            if (stripos($this->_agent, 'Mobile') !== false) {
                $this->setMobile(true);
            } else {
                $this->setTablet(true);
            }
            $this->setBrowser(self::BROWSER_ANDROID);
            return true;
        }
        return false;
    }
1092367
private function detectArchos($ua)
    {
        /* Generation 4 */

        if (preg_match('/Archos A([67]04)WIFI\//u', $ua, $match)) {
            $this->data->os->reset();
            $this->data->device->setIdentification([
                'manufacturer'  =>  'Archos',
                'model'         =>  $match[1] . ' WiFi',
                'type'          =>  Constants\DeviceType::MEDIA
            ]);
        }

        /* Generation 5 */

        if (preg_match('/ARCHOS; GOGI; a([67]05f?);/u', $ua, $match)) {
            $this->data->os->reset();
            $this->data->device->setIdentification([
                'manufacturer'  =>  'Archos',
                'model'         =>  $match[1] . ' WiFi',
                'type'          =>  Constants\DeviceType::MEDIA
            ]);
        }

        /* Generation 6 without Android */

        if (preg_match('/ARCHOS; GOGI; G6-?(S|H|L|3GP);/u', $ua, $match)) {
            $this->data->os->reset();
            $this->data->device->setIdentification([
                'manufacturer'  =>  'Archos',
                'type'          =>  Constants\DeviceType::MEDIA
            ]);

            switch ($match[1]) {
                case '3GP':
                    $this->data->device->model = '5 3G+';
                    break;
                case 'S':
                case 'H':
                    $this->data->device->model = '5';
                    break;
                case 'L':
                    $this->data->device->model = '7';
                    break;
            }
        }

        /* Generation 6 with Android */

        if (preg_match('/ARCHOS; GOGI; A5[SH]; Version ([0-9]\.[0-9])/u', $ua, $match)) {
            $version = new Version([ 'value' => $match[1] ]);

            $this->data->os->reset([
                'name'          => 'Android',
                'version'       => new Version([ 'value' => $version->is('<', '1.7') ? '1.5' : '1.6' ])
            ]);

            $this->data->device->setIdentification([
                'manufacturer'  =>  'Archos',
                'model'         =>  '5',
                'type'          =>  Constants\DeviceType::MEDIA
            ]);
        }
    }
1234902
protected static function detectDevice()
  {
    $detect = new MobileDetect();
    self::$detectCode = array();
    self::$detectCode['tablet'] = $detect->isTablet();
    self::$detectCode['mobile'] = $detect->isMobile() && !$detect->isTablet();
    self::$detectCode['desktop'] = !self::$detectCode['tablet'] && !self::$detectCode['mobile'];
    self::$detectCode['device'] = 'desktop';
    foreach ($detect->getRules() as $name => $regex) {
      if ($detect->{'is' . $name}()) {
        self::$detectCode['device'] = $name;
        break;
      }
    }
  }
142753
public function isDisplayed(array $row)
    {
        if ($this->hasShowOnValues() === false) {
            return true;
        }

        $isDisplayed = false;
        foreach ($this->getShowOnValues() as $rule) {
            $value = '';
            if (isset($row[$rule['column']->getUniqueId()])) {
                $value = $row[$rule['column']->getUniqueId()];
            }

            if ($rule['value'] instanceof AbstractColumn) {
                if (isset($row[$rule['value']->getUniqueId()])) {
                    $ruleValue = $row[$rule['value']->getUniqueId()];
                } else {
                    $ruleValue = '';
                }
            } else {
                $ruleValue = $rule['value'];
            }

            $isDisplayedMatch = Filter::isApply($value, $ruleValue, $rule['comparison']);
            if ($this->getShowOnValueOperator() == 'OR' && true === $isDisplayedMatch) {
                // For OR one match is enough
                return true;
            } elseif ($this->getShowOnValueOperator() == 'AND' && false === $isDisplayedMatch) {
                return false;
            } else {
                $isDisplayed = $isDisplayedMatch;
            }
        }

        return $isDisplayed;
    }
78588
public function isMultiArray(): bool
    {
        return !(
            \count($this->getArray(), \COUNT_NORMAL)
            ===
            \count($this->getArray(), \COUNT_RECURSIVE)
        );
    }
28771
public function has($identifier)
    {
        $keys = $this->_parseIdentifier($identifier);

        foreach($keys as $key)
        {
            if(array_key_exists($key, $this->_data)) {
                return true;
            };
        }

        return false;
    }