public static function getInstance()
{
if (is_null(self::$instance)) {
self::$instance = new testBaseInitClass();
ezcBaseInit::fetchConfig('testBaseInit', self::$instance);
}
return self::$instance;
}
public static function getInstance()
{
if (self::$instance === null) {
self::$instance = new customSingleton();
ezcBaseInit::fetchConfig('customKey', self::$instance);
}
return self::$instance;
}
/**
* Returns the instance of the ezcSignalStaticConnections..
*
* @return ezcConfigurationManager
*/
public static function getInstance()
{
if (self::$instance === null) {
self::$instance = new ezcSignalStaticConnections();
ezcBaseInit::fetchConfig('ezcInitSignalStaticConnections', self::$instance);
}
return self::$instance;
}
/**
* Returns the persistent session instance named $identifier.
*
* If $identifier is ommited the default persistent session
* specified by chooseDefault() is returned.
*
* @throws ezcPersistentSessionNotFoundException if the specified instance is not found.
* @param string $identifier
* @return ezcPersistentSession
*/
public static function get($identifier = null)
{
if ($identifier === null && self::$defaultInstanceIdentifier) {
$identifier = self::$defaultInstanceIdentifier;
}
if (!isset(self::$instances[$identifier])) {
// The ezcInitPersistentSessionInstance callback should return an
// ezcPersistentSession object which will then be set as instance.
$ret = ezcBaseInit::fetchConfig('ymcJobQueueInstance', $identifier);
if ($ret === null) {
throw new Exception('Did not find queue instance ' . $identifier);
} else {
self::set($ret, $identifier);
}
}
return self::$instances[$identifier];
}
/**
* Returns the instance of this class.
*
* When the ezcDebug instance is created it is automatically added to the instance
* of ezcLog.
*
* @return ezcDebug
*/
public static function getInstance()
{
if (is_null(self::$instance)) {
self::$instance = new ezcDebug();
ezcBaseInit::fetchConfig('ezcInitDebug', self::$instance);
}
return self::$instance;
}
/**
* Returns the database instance $identifier.
*
* If $identifier is ommited the default database instance
* specified by chooseDefault() is returned.
*
* @throws ezcDbHandlerNotFoundException if the specified instance is not found.
* @param string $identifier
* @return ezcDbHandler
*/
public static function get($identifier = false)
{
if ($identifier === false && self::$DefaultInstanceIdentifier) {
$identifier = self::$DefaultInstanceIdentifier;
}
if (!isset(self::$Instances[$identifier])) {
// The DatabaseInstanceFetchConfig callback should return an
// ezcDbHandler object which will then be set as instance.
$ret = ezcBaseInit::fetchConfig('ezcInitDatabaseInstance', $identifier);
if ($ret === null) {
throw new ezcDbHandlerNotFoundException($identifier);
} else {
self::set($ret, $identifier);
}
}
return self::$Instances[$identifier];
}
/**
* Returns the value of the property $name.
*
* @throws ezcBasePropertyNotFoundException if the property does not exist.
* @param string $name
* @ignore
*/
public function __get($name)
{
switch ($name) {
case 'locale':
return $this->properties[$name];
case 'manager':
if ($this->properties[$name] === null) {
ezcBaseInit::fetchConfig('ezcInitTemplateTranslationManager', $this);
}
if ($this->properties[$name] === null) {
throw new ezcTemplateTranslationManagerNotConfiguredException();
}
return $this->properties[$name];
}
throw new ezcBasePropertyNotFoundException($name);
}
/**
* Returns the ezcCacheStorage object with the given ID.
* The cache ID has to be defined before using the
* {@link ezcCacheManager::createCache()} method. If no instance of this
* cache does exist yet, it's created on the fly. If one exists, it will
* be reused.
*
* @param string $id The ID of the cache to return.
* @return ezcCacheStorage The cache with the given ID.
*
* @throws ezcCacheInvalidIdException
* If the ID of a cache you try to access does not exist. To access
* a cache using this method, it first hast to be created using
* {@link ezcCacheManager::createCache()}.
* @throws ezcBaseFileNotFoundException
* If the storage location does not exist. This should usually not
* happen, since {@link ezcCacheManager::createCache()} already
* performs sanity checks for the cache location. In case this
* exception is thrown, your cache location has been corrupted
* after the cache was configured.
* @throws ezcBaseFileNotFoundException
* If the storage location is not a directory. This should usually
* not happen, since {@link ezcCacheManager::createCache()} already
* performs sanity checks for the cache location. In case this
* exception is thrown, your cache location has been corrupted
* after the cache was configured.
* @throws ezcBaseFilePermissionException
* If the storage location is not writeable. This should usually not
* happen, since {@link ezcCacheManager::createCache()} already
* performs sanity checks for the cache location. In case this
* exception is thrown, your cache location has been corrupted
* after the cache was configured.
* @throws ezcBasePropertyNotFoundException
* If you tried to set a non-existent option value. The accepted
* options depend on the ezcCacheStorage implementation and may
* vary.
*/
public static function getCache($id)
{
// Look for already existing cache object
if (!isset(self::$caches[$id])) {
// Failed, look for configuration, and if it does not exist, use
// delayed initialization.
if (!isset(self::$configurations[$id])) {
ezcBaseInit::fetchConfig('ezcInitCacheManager', $id);
}
// Check whether delayed initialization actually worked, if not,
// throw an exception
if (!isset(self::$configurations[$id])) {
throw new ezcCacheInvalidIdException($id);
}
$class = self::$configurations[$id]['class'];
self::$caches[$id] = new $class(self::$configurations[$id]['location'], self::$configurations[$id]['options']);
}
return self::$caches[$id];
}
/**
* Returns the instance of the class ezcConfigurationManager.
*
* @return ezcConfigurationManager
*/
public static function getInstance()
{
if (is_null(self::$instance)) {
self::$instance = new ezcConfigurationManager();
ezcBaseInit::fetchConfig('ezcInitConfigurationManager', self::$instance);
}
return self::$instance;
}
/**
* Returns the instance of the class
*
* @param boolean $isCliMode
* @return CjwNewsletterLog
*/
public static function getInstance($isCliMode = false)
{
try {
if (is_null(self::$instance)) {
self::$instance = new self($isCliMode);
ezcBaseInit::fetchConfig('cjwNewsletterInitLog', self::$instance);
}
return self::$instance;
} catch (ezcBaseFilePermissionException $e) {
eZDebug::writeError($e->getMessage(), 'CjwNewsletterLog::getInstance()');
if ($isCliMode) {
$output = new ezcConsoleOutput();
$output->formats->error->color = 'red';
$output->formats->error->style = array('bold');
$output->outputLine($e->getMessage(), 'error');
exit;
}
}
}
/**
* Returns the unique configuration instance named $name.
*
* Note: You only need to specify the name if you need multiple configuration
* objects.
*
* @param string $name Name of the configuration to use.
* @return ezcTemplateConfiguration
*/
public static function getInstance($name = "default")
{
if (!isset(self::$instanceList[$name])) {
self::$instanceList[$name] = new ezcTemplateConfiguration();
ezcBaseInit::fetchConfig('ezcInitTemplateConfiguration', self::$instanceList[$name]);
}
return self::$instanceList[$name];
}
/**
* Returns an instance of self for the given path.
*
* The lazy_initialization mechanism of eZ Components can be used to prepend the given path.
*
* @param string $path optional,
* @return ymcPipeDefinitionStorageXml
*/
public static function getInstance($path = '')
{
// ':' may not be a path, so we can use it to store the default instance
$key = $path ? $path : ':';
if (!array_key_exists($key, self::$instances)) {
$instance = ezcBaseInit::fetchConfig(__CLASS__, $path);
self::$instances[$key] = $instance ? $instance : new self($path);
}
return self::$instances[$key];
}
