getCPUArchitecture.

@return string the arch and bits
491196
public function getCPUArchitecture()
    {

        // Time?
        if (!empty($this->settings['timer'])) {
            $t = new Timer('CPU architecture');
        }

        foreach ($this->wmi->ExecQuery('SELECT Architecture FROM Win32_Processor') as $cpu) {
            switch ($cpu->Architecture) {
                case 0:
                    return 'x86';
                case 1:
                    return 'MIPS';
                case 2:
                    return 'Alpha';
                case 3:
                    return 'PowerPC';
                case 6:
                    return 'Itanium-based systems';
                case 9:
                    return 'x64';
            }
        }

        return 'Unknown';
    }
1065264
protected function getAppropriateMode() {
		$builder = $this->builder;
		$stack = $builder->stack;
		$last = false;
		$node = $stack->current;
		for ( $idx = $stack->length() - 1; $idx >= 0; $idx-- ) {
			$node = $stack->item( $idx );
			if ( $idx === 0 ) {
				$last = true;
				if ( $builder->isFragment ) {
					$node = $builder->fragmentContext;
				}
			}

			switch ( $node->htmlName ) {
			case 'select':
				if ( $last ) {
					return self::IN_SELECT;
				}
				for ( $ancestorIdx = $idx - 1; $ancestorIdx >= 1; $ancestorIdx-- ) {
					$ancestor = $stack->item( $ancestorIdx );
					if ( $ancestor->htmlName === 'template' ) {
						return self::IN_SELECT;
					} elseif ( $ancestor->htmlName === 'table' ) {
						return self::IN_SELECT_IN_TABLE;
					}
				}
				return self::IN_SELECT;

			case 'td':
			case 'th':
				if ( !$last ) {
					return self::IN_CELL;
				}
				break;

			case 'tr':
				return self::IN_ROW;

			case 'tbody':
			case 'thead':
			case 'tfoot':
				return self::IN_TABLE_BODY;

			case 'caption':
				return self::IN_CAPTION;

			case 'colgroup':
				return self::IN_COLUMN_GROUP;

			case 'table':
				return self::IN_TABLE;

			case 'template':
				return $this->templateModeStack->current;

			case 'head':
				if ( $last ) {
					return self::IN_BODY;
				} else {
					return self::IN_HEAD;
				}

			case 'body':
				return self::IN_BODY;

			case 'frameset':
				return self::IN_FRAMESET;

			case 'html':
				if ( $builder->headElement === null ) {
					return self::BEFORE_HEAD;
				} else {
					return self::AFTER_HEAD;
				}
			}
		}

		return self::IN_BODY;
	}
1108995
private function isHierarchical()
    {
        $dataDefinition  = $this->environment->getDataDefinition();
        $basicDefinition = $dataDefinition->getBasicDefinition();

        return $basicDefinition::MODE_HIERARCHICAL === $basicDefinition->getMode();
    }
419922
public function toBinary()
    {
        $bytes = '';

        foreach (str_split($this->value, 8) as $piece) {
            $bytes .= chr(bindec($piece));
        }

        return $bytes;
    }
1219776
private function listOfKnownCpuArchitectures()
    {
        $arc = array_merge($this->listOfCpuArchitecturesX86(), $this->listOfCpuArchitecturesX64());
        ksort($arc);
        return $arc;
    }
1241075
public function getCssBundlePath()
    {
        $cacheDir = $this->getCssCachePath();

        if ($this->isRelativePath($cacheDir)) {
            $cacheDir = $this->getDocRoot() . DIRECTORY_SEPARATOR . $cacheDir;
        }

        $name = $this->getName();

        if (null === $name) {
            $name = sprintf('bundle_%s', $this->getCssFileList()->getHash());
        } elseif (strpos($name, '%s') !== false) {
            $name = sprintf($name, $this->getCssFileList()->getHash());
        }

        return sprintf(
            "%s%s%s.css",
            $cacheDir,
            DIRECTORY_SEPARATOR,
            $name
        );
    }
37941
public function getSystemPropertiesAsArray()
    {
        $systemProperties = array();
        if (is_array($this->getSystemProperties())) {
            foreach ($this->getSystemProperties() as $systemProperty) {
                $systemProperties[$systemProperty->getName()] = $systemProperty->castToType();
            }
        }
        return $systemProperties;
    }
665820
public static function readStructure()
    {
        if(count(self::$structure) == 0 ){
            if(self::USE_CACHE == false){
                //rebuild structure each time
                self::$structure = self::buildStructures();

            } else {
                //cache management
                try {
                    self::$structure = \common_cache_FileCache::singleton()->get(self::CACHE_KEY);
                } catch (\common_cache_NotFoundException $e) {
                    self::$structure = self::buildStructures();
                    \common_cache_FileCache::singleton()->put(self::$structure, self::CACHE_KEY);
                }

            }
        }
        return self::$structure;
    }
1169286
public function getRootTotalSize()
	{
		$path = rtrim($this->rootWrapperPath, '/') . '/';
		$result = $this->getDirSummary($path);
		return $result['size'];
	}
158299
private function getSystem()
    {
        $uname = strtolower(php_uname());
        if (str_contains($uname, 'darwin')) {
            return 'macosx';
        } elseif (str_contains($uname, 'win')) {
            return 'windows';
        } elseif (str_contains($uname, 'linux')) {
            return PHP_INT_SIZE === 4 ? 'linux-i686' : 'linux-x86_64';
        } else {
            throw new RuntimeException('Unknown operating system.');
        }
    }
213914
public function getBuildPath()
    {
        if (!$this->getId()) {
            return null;
        }

        if (empty($this->currentBuildPath)) {
            $buildDirectory = $this->getId() . '_' . substr(md5(microtime(true)), 0, 5);
            $this->currentBuildPath = PHPCI_BUILD_ROOT_DIR . $buildDirectory . DIRECTORY_SEPARATOR;
        }

        return $this->currentBuildPath;
    }
48543
public function getBaseTmpDir()
    {
        $folders = explode(DIRECTORY_SEPARATOR, $this->getRootDir());
        $foldersCount = count($folders);

        /**
         * Base Path
         */
        $projectDir = '';
        if (true === isset($folders[$foldersCount - 2])) {
            $projectDir = $folders[$foldersCount - 2];
        }

        $tempDirPath = FileUtility::getUserBasedCachedDir(sprintf('%s-%s', $projectDir, $this->getEnvironment()));
        FileUtility::mkdir($tempDirPath);

        return $tempDirPath;
    }
832973
public function toBinary()
    {
        $data = '';

        $guid = str_replace('-', '', $this->guid);
        foreach ($this->octetSections as $section) {
            $data .= $this->parseSection($guid, $section, true);
        }

        return hex2bin($data);
    }
1305343
public function getTopology() {
		$descriptor      = new Descriptor('APC', self::TOPOLOGY_BACKEND);
		$memoryFormatter = new Memory();
				
		$info = apc_sma_info(true);
		
		$limit  = $info['seg_size'] * $info['num_seg'];
		$used   = $limit - $info['avail_mem'];
		$filled = $used / $limit * 100;
		
		$descriptor->id     = $this->getTopologyId();
		$descriptor->used   = $memoryFormatter->format($used);
		$descriptor->limit  = $memoryFormatter->format($limit);
		$descriptor->filled = round($filled, 2) . '%';
		
		return $descriptor;
	}
777550
public function getBuild()
    {
        if (
            $this->git->isVersionComingFromGit() &&
            ($value = $this->git->version('build'))
        ) {
            return $value;
        }

        if ($this->config->get('build.mode') === Constants::BUILD_MODE_NUMBER) {
            return $this->config->get('build.number');
        }

        return $this->git->getCommit();
    }
475377
public function getProcessorId()
    {
        if (-1 === $this->index || !$this->valid()) {
            return null;
        }

        return $this->processors[$this->index][0];
    }
131621
protected function getOperatingSystem()
    {
        $osRaw = strtolower(PHP_OS);
        
        if (strpos($osRaw, 'linux') !== false) {
            return RequestAbstract::OS_LINUX;
        } else if (strpos($osRaw, 'windows') !== false) {
            return RequestAbstract::OS_WINDOWS;
        } else {
            return RequestAbstract::OS_UNKNOWN;
        }
    }