Getter for the platform property

@return PropelPlatformInterface
766509
public function getPlatform()
    {
        if (null === $this->platform) {
            require_once dirname(__FILE__) . '/../platform/SqlitePlatform.php';
            $this->platform = new SqlitePlatform();
        }

        return $this->platform;
    }
1096656
public function getAvailablePlatforms()
	{
	    $select = $this->tableGateway->getSql()->select();
	    $select->columns(array('*'));
	    $select->join('melis_core_platform', 'melis_core_platform.plf_id = melis_cms_platform_ids.pids_id', array('*'), $select::JOIN_RIGHT);
	    $select->where('melis_cms_platform_ids.pids_id IS NULL');
	    $resultSet = $this->tableGateway->selectWith($select);
	    
	    return $resultSet;
	}
400454
public function getBuildFlavor()
    {
        $appConfig = $this->getConfig();
        if (!isset($appConfig['type'])) {
            throw new InvalidConfigException('Application configuration key not found: `type`');
        }

        $key = isset($appConfig['build']['flavor']) ? $appConfig['build']['flavor'] : 'default';
        list($stack, ) = explode(':', $appConfig['type'], 2);
        foreach (self::getBuildFlavors() as $candidate) {
            if (in_array($key, $candidate->getKeys())
                && ($candidate->getStacks() === [] || in_array($stack, $candidate->getStacks()))) {
                return $candidate;
            }
        }
        throw new InvalidConfigException('Build flavor not found: ' . $key);
    }
781557
private function getDeliveryEndDateProperty() {
        $this->propertyDeliveryEndDate = $this->propertyDeliveryEndDate ?: $this->getProperty(DeliveryAssemblyService::PROPERTY_END);
        return $this->propertyDeliveryEndDate;
    }
388662
public function getPlatformById($id)
    {
        $id = (int) $id;
        $id = max(0, $id);

        return $this->request('platforms/'.$id);
    }
573318
public function get()
    {
        $keys = $this->registry
            ->setRoot(Registry::HKEY_LOCAL_MACHINE)
            ->setPath($this->path)
            ->get();

        $software = [];

        foreach ($keys as $key) {
            // Set a new temporary path for the software key
            $path = $this->path.$key;

            // Retrieve the name of the software
            $name = $this->registry->setPath($path)->getValue('DisplayName');

            // If the name exists, we'll retrieve the rest of the software information
            if ($name) {
                $software[] = new Application([
                    'name' => $name,
                    'version' => $this->registry->getValue('DisplayVersion'),
                    'publisher' => $this->registry->getValue('Publisher'),
                    'install_date' => $this->registry->getValue('InstallDate'),
                ]);
            }
        }

        return $software;
    }
789457
public function properties()
    {
        if ($this->properties === null) {
            $model = $this->proto();
            $props = $model->metadata()->properties();

            $collectionIdent = $this->collectionIdent();
            if ($collectionIdent) {
                $metadata      = $model->metadata();
                $adminMetadata = isset($metadata['admin']) ? $metadata['admin'] : null;

                if (isset($adminMetadata['lists'][$collectionIdent]['properties'])) {
                    // Flipping to have property ident as key
                    $listProperties = array_flip($adminMetadata['lists'][$collectionIdent]['properties']);
                    // Replacing values of listProperties from index to actual property values
                    $props = array_replace($listProperties, $props);
                    // Get only the keys that are in listProperties from props
                    $props = array_intersect_key($props, $listProperties);
                }
            }

            $this->properties = $props;
        }

        return $this->properties;
    }
735806
private function getPlatformProvider($platform=[], EventManager $eventManager)
	{	
		if (is_null($platform)) {
			return false;
		}

		$platformId = key($platform);
		$platform = current($platform);
		if (!isset($platform['provider'])) {
			$this->connectionFailed = ':noPlatform';
			return false;
		}

		$provider = $platform['provider'];
		if (!class_exists($provider)) {
			$this->connectionFailed = ':noConnectorProvider';
			return false;
		}

		$this->preparedConnection = $platform;
		$platformProvider = new $provider($this, new EventManager());
		if (!$platformProvider instanceof PlatformProvider) {
			return false;
		}

		if (isset($platform['domain']) && !Domain::matches($platform['domain'])) {
			$eventManager->dispatchEvent('domain.notallowed', [$platformId => $platform]);
			return false;
		}

		$this->platformProvider = $platformProvider;
		$providerConnector = $this->platformProvider;
		return $providerConnector;
	}
146209
public function get_props() {
		$props = array(
			'id'         => $this->id,
			'name'       => $this->name,
			'controller' => $this->controller,
			'templateId' => $this->template_id,
			'data'       => $this->get_props_data(),
		);

		/**
		 * Filter icon type properties
		 *
		 * @since 0.1.0
		 * @param array            $props Icon type properties.
		 * @param string           $id    Icon type ID.
		 * @param Icon_Picker_Type $type  Icon_Picker_Type object.
		 */
		$props = apply_filters( 'icon_picker_type_props', $props, $this->id, $this );

		/**
		 * Filter icon type properties
		 *
		 * @since 0.1.0
		 * @param array            $props Icon type properties.
		 * @param Icon_Picker_Type $type  Icon_Picker_Type object.
		 */
		$props = apply_filters( "icon_picker_type_props_{$this->id}", $props, $this );

		return $props;
	}
279023
public PlatformTransactionManager getPlatformTransactionManager() {
        if (transactionManager != null) {
            return transactionManager;
        }
        transactionManager = (PlatformTransactionManager) ContainerManager.getComponent("transactionManager");
        return transactionManager;
    }
629016
public function getPlatform()
    {
        if (null === $this->platform) {
            $this->platform = new SqlitePlatform();
        }

        $this->platform->setIdentifierQuoting($this->identifierQuoting);

        return $this->platform;
    }
663761
protected function getPlatformInfo()
    {
        $db = $this->get('database_connection');

        $data = [];
        $data[] = [
            'title' => 'Smart Core CMS version',
            'value' => CMSAppKernel::VERSION,
            'required' => '',
            'recomended' => '',
            'hint' => '',
            'warning' => 0,
        ];
        $isDebug = $this->get('kernel')->isDebug() ? 'true' : 'false';
        $data[] = [
            'title' => 'Symfony Framework version',
            'value' => Kernel::VERSION.' (debug = '.$isDebug.')',
            'required' => '',
            'recomended' => '',
            'hint' => '',
            'warning' => 0,
        ];
        $data[] = [
            'title' => 'Database server',
            'value' => $db->query('SHOW VARIABLES LIKE "%version_comment%"')->fetchObject()->Value.' version '.$db->query('SELECT version() AS version')->fetchObject()->version,
            'required' => 'MySQL 5.1',
            'recomended' => 'MySQL 5.5+ or PostgreSQL 9.3+',
            'hint' => '',
            'warning' => 0,
        ];
        $data[] = [
            'title' => 'Web Server',
            'value' => $_SERVER['SERVER_SOFTWARE'].' ('.php_sapi_name().')',
            'required' => '',
            'recomended' => '',
            'hint' => '',
            'warning' => 0,
        ];

        return $data;
    }
747425
public function getPlatformDataAction(){
        $melisEngineTablePlatformIds = $this->getServiceLocator()->get('MelisEngineTablePlatformIds');
        $translator = $this->getServiceLocator()->get('translator');
        $platformTable = $this->getServiceLocator()->get('MelisCoreTablePlatform');
        $melisTool = $this->getServiceLocator()->get('MelisCoreTool');
        $melisTool->setMelisToolKey(self::TOOL_INDEX, self::TOOL_KEY);
        
        $colId = array();
        $dataCount = 0;
        $draw = 0;
        $tableData = array();
        
        if($this->getRequest()->isPost()) {
        
            $colId = array_keys($melisTool->getColumns());
        
            $sortOrder = $this->getRequest()->getPost('order');
            $sortOrder = $sortOrder[0]['dir'];
        
            $selCol = $this->getRequest()->getPost('order');
            $selCol = $colId[$selCol[0]['column']];
        
            $draw = $this->getRequest()->getPost('draw');
        
            $start = $this->getRequest()->getPost('start');
            $length =  $this->getRequest()->getPost('length');
        
            $dataCount = $melisEngineTablePlatformIds->getTotalData();
        
            $getData = $melisEngineTablePlatformIds->getPagedData(array(
                'order' => array(
                    'key' => $selCol,
                    'dir' => $sortOrder,
                ),
                'start' => $start,
                'limit' => $length,
                'columns' => $melisTool->getSearchableColumns(),
                'date_filter' => array()
            ));
        
            $tableData = $getData->toArray();
            for($ctr = 0; $ctr < count($tableData); $ctr++)
            {
                // apply text limits
                foreach($tableData[$ctr] as $vKey => $vValue)
                {
                    $tableData[$ctr][$vKey] = $melisTool->limitedText($melisTool->escapeHtml($vValue));
                    
                    $tableData[$ctr]['pids_name'] = $translator->translate('Deleted ('.$tableData[$ctr]['pids_id'].')');
                    
                    $platformName = $platformTable->getEntryById($tableData[$ctr]['pids_id']);
                    
                    if (!empty($platformName)){
                        $platformName = $platformName->current();
                        if (!empty($platformName)){
                            
                            if (getenv('MELIS_PLATFORM')==$platformName->plf_name){
                                $tableData[$ctr]['DT_RowClass'] = 'noPlatformIdDeleteBtn';
                            }
                            
                            $tableData[$ctr]['pids_name'] = $melisTool->limitedText($platformName->plf_name,25);
                        }
                    }
                    
                    
                }
                
                // manually modify value of the desired row
                // no specific row to be modified
        
                // add DataTable RowID, this will be added in the <tr> tags in each rows
                $tableData[$ctr]['DT_RowId'] = $tableData[$ctr]['pids_id'];
            }
        }
        
        return new JsonModel(array(
            'draw' => (int) $draw,
            'recordsTotal' => $dataCount,
            'recordsFiltered' =>  $melisEngineTablePlatformIds->getTotalFiltered(),
            'data' => $tableData,
        ));
    }
79493
public function getProperties()
    {
        $properties = new BeanPropertyCollection();

        // Properties already taken into account accross the hierarchy.
        $registeredProperties = array();
        $target = $this->getClass();

        while ($target) {

            foreach ($target->getProperties() as $prop) {

                $propName = $prop->getName();

                if ($this->isPropertyAnnotated($propName) === true && in_array($propName, $registeredProperties) === false) {
                    $properties[] = new BeanProperty($target->getName(), $propName);
                    $registeredProperties[] = $propName;
                }
            }

            $target = $target->getParentClass();
        }

        return $properties;
    }
1313242
public function getSiteProperties() {

		if( !isset( $this->adminProperties ) ) {

			$this->adminProperties = AdminProperties::getInstance();
		}

		return $this->adminProperties;
	}
1066910
public function getPlatformIdsByPlatformName($platformName)
	{
		$select = $this->tableGateway->getSql()->select();
		$select->columns(array('*'));
		$select->join('melis_core_platform', 'melis_core_platform.plf_id = melis_cms_platform_ids.pids_id',
				array('*'));
		$select->where("plf_name = '$platformName'");
		$resultSet = $this->tableGateway->selectWith($select);
		return $resultSet;
	}
96510
public function convertToPHPValue($value, AbstractPlatform $platform)
    {
        return ($this->constructor)($value, $this->name, $platform);
    }