PHP static::base方法代码示例

 /**
  * Get the base URL of the application.
  *
  * @return string
  */
 public static function base()
 {
     if (isset(static::$base)) {
         return static::$base;
     }
     $base = 'http://localhost';
     // If the application URL configuration is set, we will just use that
     // instead of trying to guess the URL from the $_SERVER array's host
     // and script variables as this is more reliable.
     if (($url = Config::get('application.url')) !== '') {
         $base = $url;
     } elseif (isset($_SERVER['HTTP_HOST'])) {
         $protocol = Request::secure() ? 'https://' : 'http://';
         // Basically, by removing the basename, we are removing everything after the
         // and including the front controller from the request URI. Leaving us with
         // the path in which the framework is installed.
         $script = $_SERVER['SCRIPT_NAME'];
         $path = str_replace(basename($script), '', $script);
         // Now that we have the base URL, all we need to do is attach the protocol
         // and the HTTP_HOST to build the full URL for the application. We also
         // trim off trailing slashes to clean the URL.
         $base = rtrim($protocol . $_SERVER['HTTP_HOST'] . $path, '/');
     }
     return static::$base = $base;
 }

 /**
  * Create a new instance of the MailboxStoreSelector class
  *
  * @param		Link				The Link to a directory server to operate on
  */
 public function __construct(Link $link)
 {
     parent::__construct($link);
     // Make sure we are searching for the mailbox databases in the Configuration Naming Context, otherwise
     // we might not find anything...
     static::$base = $this->link->rootDSE->configurationNamingContext(0);
 }

 /**
  * Clears all stored routes definitions to pristine conditions.
  * @return void
  */
 public static function reset()
 {
     static::$routes = [];
     static::$base = '';
     static::$prefix = [];
     static::$group = [];
     static::$optimized_tree = [];
 }

 public static function load($config_file = null, $config_data = null)
 {
     if (!empty($config_file) && Helper::checkFile($config_file) && !($yaml = file_get_contents($config_file))) {
         throw new \Exception("Failed to read config file {$config_file}");
     }
     if (empty($config_data) && !($data = Yaml::parse($yaml))) {
         throw new \Exception("Failed to parse config file {$config_file}");
     }
     static::$data = static::$base = array_merge(static::$data, $data);
     self::$cache = array();
 }

 /**
  * Get the base URL of the application.
  *
  * @return string
  */
 public static function base()
 {
     if (isset(static::$base)) {
         return static::$base;
     }
     $conf = Registry::get('conf');
     $url = $conf['app']['url'];
     if ($url !== '') {
         $base = $url;
     } else {
         $base = Registry::get('env')->getUrl();
     }
     return static::$base = $base;
 }

    public function __construct()
    {
        // Because some hosts are complete
        // idiotic pieces of shit, let's
        // strip slashes from input.
        if (get_magic_quotes_gpc()) {
            $php_is_the_worst_language_ever_because_of_this = function (&$value) {
                $value = stripslashes($value);
            };
            array_walk_recursive($_GET, $php_is_the_worst_language_ever_because_of_this);
            array_walk_recursive($_POST, $php_is_the_worst_language_ever_because_of_this);
            array_walk_recursive($_COOKIE, $php_is_the_worst_language_ever_because_of_this);
            array_walk_recursive($_REQUEST, $php_is_the_worst_language_ever_because_of_this);
        }

        // Set query string
        static::$query = (isset($_SERVER['QUERY_STRING']) ? $_SERVER['QUERY_STRING'] : null);

        // Set request scheme
        static::$scheme = static::isSecure() ? 'https' : 'http';

        // Set host
        static::$host = strtolower(preg_replace('/:\d+$/', '', trim($_SERVER['SERVER_NAME'])));

        // Set base url
        static::$base = static::baseUrl();

        // Set the request path
        static::$request_uri = static::requestPath();

        // Set relative uri without query string
        $uri = explode('?', str_replace(static::$base, '', static::$request_uri));
        static::$uri = $uri[0];

        // Request segments
        static::$segments = explode('/', trim(static::$uri, '/'));

        // Set the request method
        static::$method = strtolower($_SERVER['REQUEST_METHOD']);

        // Requested with
        static::$requested_with = @$_SERVER['HTTP_X_REQUESTED_WITH'];

        // _REQUEST
        static::$request = $_REQUEST;

        // _POST
        static::$post = $_POST;
    }

 /**
  * Get the base URL of the application.
  *
  * @return string
  */
 public static function base()
 {
     if (isset(static::$base)) {
         return static::$base;
     }
     $base = 'http://localhost';
     // If the application's URL configuration is set, we will just use that
     // instead of trying to guess the URL from the $_SERVER array's host
     // and script variables as this is a more reliable method.
     if (($url = Config::get('application.url')) !== '') {
         $base = $url;
     } else {
         $base = Request::foundation()->getRootUrl();
     }
     return static::$base = $base;
 }

 /**
  * Get the base URL of the application.
  *
  * @return string
  */
 public static function base()
 {
     if (isset(static::$base)) {
         return static::$base;
     }
     $base = 'http://localhost';
     // If the application URL configuration is set, we will just use that
     // instead of trying to guess the URL from the $_SERVER array's host
     // and script variables as this is more reliable.
     if (($url = Config::get('application.url')) !== '') {
         $base = $url;
     } elseif (isset($_SERVER['HTTP_HOST'])) {
         $base = static::guess();
     }
     return static::$base = $base;
 }

 function __construct()
 {
     // TODO: simplified
     if (!isset(static::$base)) {
         static::$base = new SplFixedArray(32);
         $const = SplFixedArray::fromArray(include "base.php", false);
         for ($i = 0; $i < 32; ++$i) {
             static::$base[$i] = new SplFixedArray(8);
             for ($j = 0; $j < 8; ++$j) {
                 static::$base[$i][$j] = new GePrecomp($const[$i][$j][0], $const[$i][$j][1], $const[$i][$j][2]);
             }
         }
     }
     if (!isset(static::$Bi)) {
         static::$Bi = new SplFixedArray(8);
         $const = SplFixedArray::fromArray(include "base2.php", false);
         for ($i = 0; $i < 8; ++$i) {
             static::$Bi[$i] = new GePrecomp($const[$i][0], $const[$i][1], $const[$i][2]);
         }
     }
 }

 /**
  * Initialize the URI class.
  *
  * @return void
  */
 public static function initialize()
 {
     // We need to get the different sections from the URI to process the
     // correct route.
     // Standard request in the browser?
     if (isset($_SERVER['REQUEST_URI'])) {
         // Get the active URI.
         $request = $_SERVER['REQUEST_URI'];
         $host = $_SERVER['HTTP_HOST'];
         $protocol = 'http' . (Request::https() ? 's' : '');
         $base = $protocol . '//' . $host;
         $uri = $base . $request;
         // Build the URI segments.
         $length = strlen($base);
         $str = (string) substr($uri, $length);
         $arr = (array) explode('/', trim($str, '/'));
         $segments = [];
         foreach ($arr as $segment) {
             if ($segment !== '') {
                 array_push($segments, $segment);
             }
         }
         // Assign properties.
         static::$base = $base;
         static::$uri = $uri;
         static::$segments = $segments;
     } else {
         if (isset($_SERVER['argv'])) {
             $segments = [];
             foreach ($_SERVER['argv'] as $arg) {
                 if ($arg !== $_SERVER['SCRIPT_NAME']) {
                     array_push($segments, $arg);
                 }
             }
             static::$segments = $segments;
         }
     }
 }

 /**
  * Method to reset class static members for testing and other various issues.
  *
  * @return  void
  *
  * @since   11.1
  */
 public static function reset()
 {
     static::$instances = array();
     static::$base = array();
     static::$root = array();
     static::$current = '';
 }

 /**
  * Set base API url
  * @param string $base
  */
 public static function setBase($base)
 {
     static::$base = $base;
 }

 /**
  * Execute the command.
  *
  * @param Application $app The application instance
  *
  * @return mixed
  */
 public static function execute(Application $app)
 {
     static::$base = dirname(__DIR__) . '/templates/help/';
     $help = new static($app->command ?: 'help');
     $help->render();
 }

 private static function generateBaseUri()
 {
     $config = Registry::getInstance()->config['uri'];
     $base = $config['scheme'] != null ? $config['scheme'] : 'http';
     $base .= '://';
     $base .= $config['host'] != null ? $config['host'] : $_SERVER['HTTP_HOST'];
     if ($config['port'] != null) {
         $base .= ':' . $config['port'];
     }
     $base .= rtrim('/' . ltrim($config['path'], '/'), '/') . '/';
     static::$base = $base;
 }

 public static function activateModule($module)
 {
     static::$base = \Uri::create('/admin/' . $module);
     static::$current_module = $module;
     static::$sidebar_config_path = "cmf.admin.modules.{$module}.sidebar";
 }