{@inheritdoc}

@param mixed $id
@param mixed $default (optional)

@return \Ems\Contracts\Core\Identifiable|null
558774
public function get($id, $default = null)
    {
        $query = $this->model->newQuery();

        $this->callBeforeListeners('get', [$query]);

        if (!$model = $this->performGet($query, $id)) {
            return $default;
        }

        $this->callAfterListeners('get', [$model]);

        /** @var Identifiable $model */
        return $model;
    }
354900
public function param($name, $default = null)
    {
        return isset($this->parameters[$name]) ? $this->parameters[$name] : $default;
    }
1256122
public function rtcGet(string $id, string $group = '_default', $default = null)
    {
        if (!$this->rtcExists($id, $group)) {
            return $default;
        }

        return $this->runtimeCache[$group][$id];
    }
794186
public function get($identifier, $default = null)
    {
       $result = $this->offsetGet($identifier);

        // If the value is null return the default
        if(is_null($result)) {
            $result = $default;
        }

        return $result;
    }
936594
public static function get($id)
    {
        /** @var Entity $entity */
        $entity = new static();
        Manager::getInstance()->get($entity)->refreshRelations();
        $className = $entity->getClassName();
        $sql = Sql::createSql($entity->getAdapter())
            ->select($entity->getTableName())
            ->where(
                [
                    "{$entity->getTableName()}.{$entity->_primaryKey} = :id" =>
                        [
                            ':id' => $id
                        ]
                ]
            );
        $events = $entity->getEventManager();
        $event = new Select([
            'sqlQuery' => $sql,
            'params' => compact('id'),
            'action' => Select::GET,
            'singleItem' => true
        ]);
        $events->trigger(Select::BEFORE_SELECT, $entity, $event);
        $row = $event->sqlQuery->first();

        if ($row) {
            $event->data = $row;
            $events->trigger(Select::AFTER_SELECT, $entity, $event);
            $object = new $className($event->data);
            return $object;
        }
        return null;
    }
77686
public function get($identifier, $default = null)
    {
        $value = $this->internalGet($this->configsContainer, $identifier);

        if (is_null($value)) {
            return $default;
        }

        return $value;
    }
719482
public function getParameter($name, $default = NULL)
	{
		if (isset($this->params[$name])) {
			return $this->params[$name];

		} else {
			return $default;
		}
	}
1078864
private function get($key, $default = null)
    {
        if ( ! empty($this->shared[$key]))
            return $this->shared[$key];

        return $default;
    }
935045
public function find($id)
    {
        return Arr::first($this->items, function ($key, Contract $skill) use ($id) {
            return $skill->getId() === $id;
        }, null);
    }
1226765
public static function getCachedInfo($id, $key = null, $default = null)
    {
        $cacheKey = 'app:' . $id;
        try {
            $result = \Cache::remember($cacheKey, \Config::get('df.default_cache_ttl'), function () use ($id){
                $app = App::whereId($id)->first();

                if (empty($app)) {
                    throw new NotFoundException("App not found.");
                }

                if (!$app->is_active) {
                    throw new ForbiddenException("App is not active.");
                }

                return $app->toArray();
            });

            if (is_null($result)) {
                return $default;
            }
        } catch (ModelNotFoundException $ex) {
            return $default;
        }

        if (is_null($key)) {
            return $result;
        }

        return (isset($result[$key]) ? $result[$key] : $default);
    }
348162
public static function findIdentity($id) : ?Identity
    {
        $user = self::getRepository()->findActiveById($id);
        return $user ? new self($user) : null;
    }
800301
public function findById(int $id)
    {
        $entity = null;

        for ($i = 0; $i < count($this->registries); $i++) {
            /** @var RegistryInterface $registry */
            $registry = $this->registries[ $i ];
            $entity = $registry->findByKey($id);

            if ($entity instanceof AbstractEntity) {
                $this->updateRegistries([$entity], $i - 1);
                break;
            }
        }

        return $entity;
    }
726386
public function get($id, $default = null)
    {

        $cacheId = $this->cache->key([$this->prototype(), $id]);

        if ($this->cache->has($cacheId)) {
            return $this->cache->get($cacheId);
        }

        if ($model = $this->parent->get($id)) {
            $this->cache->put($cacheId, $model);
        }

        return $model ? $model : $default;
    }
876480
public function get($key, $default = null)
    {
        $data = DotArray::get($this->getStorage(), $key);

        return $data === null ? $default : $data;
    }
115975
public function byId($id, $fields = null)
    {
        if (is_null($fields)) {
            $fields = self::$defaultFields;
        }

        return $this->get("employees/{$id}/", ['fields' => implode(',', $fields)]);
    }
142333
public function get($key, $default = null)
    {
        if ($this->hasAccessibleMethod($key)) {
            return $this->$key();
        }

        if ($this->hasAccessibleProperty($key)) {
            return $this->$key;
        }

        return $default;
    }
266289
public function get($id, $defaultValue = null)
    {
        if ($this->contains($id)) {
            return $this->fetch($id);
        }

        return $defaultValue;
    }