@param mixed $param

@throws Exception
@return string
325471
protected function convertParam($platform, $param, $type = null)
    {
        if (is_object($param)) {
            if (!method_exists($param, '__toString')) {
                if ($param instanceof DateTimeInterface) {
                    $param = $param->format('Y-m-d H:i:s');
                } elseif (Type::hasType($type)) {
                    $type  = Type::getType($type);
                    $param = $type->convertToDatabaseValue($param, $platform);
                } else {
                    throw new Exception('Given query param is an instance of ' . get_class($param) . ' and could not be converted to a string');
                }
            }
        } elseif (is_array($param)) {
            if ($this->isNestedArray($param)) {
                $param = json_encode($param, JSON_UNESCAPED_UNICODE);
            } else {
                $param = implode(
                    ', ',
                    array_map(
                        function ($part) {
                            return '"' . (string) $part . '"';
                        },
                        $param
                    )
                );

                return '(' . $param . ')';
            }
        } else {
            $param = e($param);
        }

        return '"' . (string) $param . '"';
    }
983318
protected function _buildDataAttrs(array $param = array())
    {
        $return = '';
        foreach ($param as $data => $val) {
            $dKey = 'data-' . trim($data);

            if (is_object($val)) {
                $val = (array) $val;
            }

            if (is_array($val)) {
                $val = str_replace('"', '\'', json_encode($val));
                $return .= $this->_buildAttr($dKey, $val);
                continue;
            }

            $return .= $this->_buildAttr($dKey, $val);
        }

        return $return;
    }
337309
public function getParam($param = null)
    {
        if (null === $param) {
            return $this->_params;
        }

        return isset($this->_params[$param]) ? $this->_params[$param] : null;
    }
430667
protected function getQueryParam(string $param) : ?string
    {
        if ($this->queryParams === null) {
            $this->parseQueryParams();
        }
        return $this->queryParams[$param] ?? null;
    }
1055138
public function getEnv(string $param): string
    {
        if (preg_match_all('#\{ENV\(([A-Za-z0-9_]+)(?:(,?)([^}]*))\)\}#', $param, $matches)) {
            if (4 !== count($matches)) {
                return $param;
            }

            for ($i = 0; $i < count($matches[0]); ++$i) {
                $param = $this->parseEnv($param, $matches, $i);
            }

            return $param;
        }

        return $param;
    }
1193401
public function load($param = null)
    {

        $configSet = $this->_getConfigSet();

        if (0 === count($configSet)) {
            // set default config set for the default execution
            $configSet = [
                realpath(
                    "{$this->config_path}/{$this->get(self::HIERARCHY_PLACEHOLDER_INDEX)}"
                    . (string) self::CONFIG_DELIMITER
                    . (string) self::FILE_EXTENSION
                )
            ];
            $this->set('config_set', $configSet);
        }

        return $this->populateEngine(
            $this->checkConfigForDefaultConfig($configSet)
        );
    }
322382
protected static function getPath($param)
    {
        $path = (is_null(Application::$root) ? "config/$param.php" : Application::$root."config/$param.php");
        //
        return Bus::need((is_null(Application::$root) ? "config/$param.php" : Application::$root."config/$param.php"));
    }
55829
private static Object getParam(final Object param) {
		final StringBuilder sb = new StringBuilder();
		if(param instanceof String){
			sb.append("'");
			sb.append((String)param);
			sb.append("'");
		}
		else if(param instanceof Boolean){
			sb.append(String.valueOf((Boolean)param));			
		}
        else if(param instanceof Integer){
            sb.append(String.valueOf((Integer)param));
        }
        else if(param instanceof DBRegExp){
            sb.append('/');
            sb.append(((DBRegExp) param).toString());
            sb.append('/');
        }
		
		return sb.toString();
	}
709010
public function get($param)
    {
        return array_key_exists($param, $this->data) ? $this->data[$param] : null;
    }
1051436
public static function title($param = null)
    {

        if (is_integer($param)) {
            $param = array(
                'amount' => $param
            );
        }

        if (!is_array($param)) {
            $param = array();
        }

        $defParam = array(
            'amount' => 30,
            'what' => 'bytes',
            'start' => 'yes',
            'lang' => 'en'
        );

        $param = array_merge($defParam, $param);

        $json = Utils::getJSON('http://json-lipsum.appspot.com/?' . http_build_query($param));

        if (isset($json->lipsum)) {
            return $json->lipsum;
        } else {
            return 'Error Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
        }

    }
1166595
public function exec($param)
    {
        $flowInterrupt = $this->interrupt($param);
        if ($flowInterrupt === null) {
            // do nothing, let the flow proceed
            return;
        }

        if ($flowInterrupt instanceof  InterrupterInterface) {
            $flowInterruptType = $flowInterrupt->getType();
        } elseif ($flowInterrupt) {
            $flowInterruptType = InterrupterInterface::TYPE_CONTINUE;
            $flowInterrupt     = null;
        } else {
            $flowInterruptType = InterrupterInterface::TYPE_BREAK;
            $flowInterrupt     = null;
        }

        /* @var null|InterrupterInterface $flowInterrupt */
        $this->carrier->interruptFlow($flowInterruptType, $flowInterrupt);
    }
315214
public static function getQueryString( &$param ){
        
        // Geocoding components parameter
        if( isset($param['components']) && is_array($param['components'])){
           $param['components'] = self::joinParam( $param['components'], ':', '|');
        }   
        ///
        
        // Direction parameters
        if( isset($param['origin']) && is_array($param['origin'])){
           $param['origin'] = self::joinParam( $param['origin'], '', ':', false );
        }   
        
        if( isset($param['destination']) && is_array($param['destination'])){
           $param['destination'] = self::joinParam( $param['destination'], '', ':', false );
        }      
        
        if( isset($param['waypoints']) && is_array($param['waypoints'])){
           $param['waypoints'] = self::joinParam( $param['waypoints'], '', '|', false );
        } 
        
        if( isset($param['avoid']) && is_array($param['avoid'])){
           $param['avoid'] = self::joinParam( $param['avoid'], '', '|', false );
        }     
        ///
        
        // Distance Matrix parameters
        if( isset($param['origins']) && is_array($param['origins'])){
           $param['origins'] = self::joinParam( $param['origins'], '', '|', false );
        }   
        
        if( isset($param['destinations']) && is_array($param['destinations'])){
           $param['destinations'] = self::joinParam( $param['destinations'], '', '|', false );
        }   
        
        if( isset($param['transit_mode']) && is_array($param['transit_mode'])){
           $param['transit_mode'] = self::joinParam( $param['transit_mode'], '', '|', false );
        } 
        ///
        
        // Elevation & Road parameters
        if( isset($param['locations']) && is_array($param['locations'])){
           $param['locations'] = self::joinParam( $param['locations'], '', '|', false );
        }   
        if( isset($param['path']) && is_array($param['path'])){
           $param['path'] = self::joinParam( $param['path'], '', '|', false );
        } 
        ///
        
        // Places & Time Zone parameters
        if( isset($param['location']) && is_array($param['location'])){
           $param['location'] = self::joinParam( $param['location'], '', ',', false );
        } 
        
        /**
        * Place Search
        * Deprecation notices: Premium data (Zagat), types parameter, id and reference fields
        * Restricts the results to places matching the specified type. 
        * Only one type may be specified (if more than one type is provided, all types following the first entry are ignored).
        */
        if( isset($param['types']) && is_array($param['types'])){
           #$param['types'] = self::joinParam( $param['types'], '', '|', false );
           $param['type'] = !empty( $param['types'][0] ) ? $param['types'][0] : "";
        }     
                     
        ///
                
        // reset to empty array 
        self::$urlParam = [];
        
        return  self::joinParam( $param );

    }
427841
protected function parseParam($param)
    {
        $method = 'parse'.ucfirst($param);

        if (method_exists($this, $method)) {
            if ($params = $this->input($param)) {
                return $this->$method($params);
            }
        }
    }
1171564
public function getParam($param, $default = null) 
    {
        if(array_key_exists($param, $this->params)) {
            return $this->params[$param];
        }
        
        return $default;
    }
781177
public function hasParam($param)
	{
		$param = (string)$this->params[$param];
		
		return strlen($param) > 0 ? true : false;
	}
342698
final protected function getValueFromConfig(string $param)
  {
    $value = null;
    $config = self::$suiteConfig;

    preg_match_all(self::$regEx['config'], $param, $args, PREG_PATTERN_ORDER);
    foreach ($args[1] as $arg) {
      if (array_key_exists($arg, $config)) {
        $value = $config[$arg];
        if (is_array($value)) {
          $config = $value;
        } else {
          break;
        }
      }
    }
    return $value;
  }
81707
public function exec($param = null)
    {
        try {
            $result = $this->rewind()
                ->flowStart()
                ->recurse($param);

            // set flowStatus to make sure that we have the proper
            // value in flowEnd even when overridden without (or when
            // improperly) calling parent
            if ($this->flowStatus->isRunning()) {
                $this->flowStatus = new FlowStatus(FlowStatus::FLOW_CLEAN);
            }

            $this->flowEnd();

            return $result;
        } catch (\Exception $e) {
            $this->flowStatus = new FlowStatus(FlowStatus::FLOW_EXCEPTION, $e);
            $this->flowEnd();
            if ($e instanceof NodalFlowException) {
                throw $e;
            }

            throw new NodalFlowException('Flow execution failed', 0, $e, [
                'nodeMap' => $this->getNodeMap(),
            ]);
        }
    }