Resolves the lazy value cache.

@param string $oid
@param string $property

@return mixed|null
333847
private function resolveCache($oid, $property)
    {
        if (isset($this->lazyValueCache[$oid])) {
            if (isset($this->lazyValueCache[$oid][$property])) {
                return $this->lazyValueCache[$oid][$property];
            }

            return;
        }

        $this->lazyValueCache[$oid] = array();
    }
807478
protected static function getCache($id)
    {
        $type = static::getType();

        $id = (string)$id;

        static::initializeCache($type);

        $collection = self::$cache->{$type};

        if (!property_exists($collection, $id)) {
            return null;
        }

        $resource = $collection->{$id};

        return (clone $resource);
    }
1128104
public function getOPT($property)
    {
        if (isset($this->OPT[$property])) {
            return $this->OPT[$property];
        }
        return null;
    }
1170459
public function getDataProperty($property)
    {
        return isset($this->data[$property]) ? $this->data[$property] : null;
    }
809551
private function getValue(PropertyInterface $property)
    {
        $default = ['presentAs' => null, 'items' => []];
        if (!is_array($property->getValue())) {
            return $default;
        }

        return array_merge($default, $property->getValue());
    }
1308628
public function getValueForOid($oid)
    {
        if (isset($this->baseAsn1->oids[$oid])) {
            return $this->baseAsn1->oids[$oid];
        }

        throw new \RuntimeException(sprintf('Unknown oid "%s"', $oid));
    }
198489
public function get($property, $default = null)
    {
        $properties = $this->getValue('properties', []);
        if (array_key_exists($property, $properties)) {
            $value = $properties[$property];
            if (is_array($value)) {
                $value = reset($value);
            }

            return $value;
        }

        return $default;
    }
317299
public function getProperty(int $object, string $property)
    {
        $this->protocol->propertyAccessBegin($object, $property);
        $this->protocol->propertyAccessEnd();

        return $this->getResult();
    }
175801
public function decorate(Property $property)
	{
		if ( !$this->canDecorate($property) ) {
			return null;
		}

		$locator = $this->locatorFactory->createLocator($property);

		return $locator !== null ? $this->doDecorate($property, $locator) : null;
	}
360521
public function set($property, $value = null)
    {
        if (is_object($property)) {
            $property = get_object_vars($property);
        }

        if (is_array($property)) {
            foreach ($property as $k => $v) {
                $this->set($k, $v);
            }
        } elseif ('_' != substr($property, 0, 1)) {
            if (method_exists($this, 'set'.ucfirst($property))) {
                $this->{'set'.ucfirst($property)}($value);
            } else {
                $this->$property = $value;
            }
        }

        return $this;
    }
1029379
public function resolvePropertyTypeInfo(Property $property): ?VarTypeInfo
    {
        $types = [];

        $propertyDefault = $property->props[0]->default;
        if ($propertyDefault !== null) {
            $types[] = $this->nodeToStringTypeResolver->resolver($propertyDefault);
        }

        $classNode = $property->getAttribute(AttributeKey::CLASS_NODE);
        if (! $classNode instanceof Class_) {
            throw new ShouldNotHappenException();
        }

        $propertyName = $this->nameResolver->resolve($property);
        if ($propertyName === null) {
            return null;
        }

        /** @var Assign[] $propertyAssignNodes */
        $propertyAssignNodes = $this->betterNodeFinder->find([$classNode], function (Node $node) use (
            $propertyName
        ): bool {
            if ($node instanceof Assign && $node->var instanceof PropertyFetch) {
                // is property match
                return $this->nameResolver->isName($node->var, $propertyName);
            }

            return false;
        });

        foreach ($propertyAssignNodes as $propertyAssignNode) {
            $types = array_merge(
                $types,
                $this->nodeTypeResolver->resolveSingleTypeToStrings($propertyAssignNode->expr)
            );
        }

        $types = array_filter($types);

        return new VarTypeInfo($types, $this->typeAnalyzer, $types, true);
    }
615691
protected function invokeProperty($obj, $property = null)
    {
        if (null === $property) {
            return null;
        }

        if (!settype($property, 'string')) {
            return null;
        }

        $property = trim($property);
        if (0 === mb_strlen($property)) {
            return null;
        }

        if (!is_object($obj)) {
            return null;
        }

        $methods = [
            $this->createMethodName('get', $property),
            $this->createMethodName('is', $property),
            $property
        ];

        $r = new \ReflectionObject($obj);
        foreach ($methods as $method) {
            if ($r->hasMethod($method)) {
                $result = $r->getMethod($method)->invoke($obj);

                return $result;
            }
        }

        if ($r->hasProperty($property)) {
            $rProperty = $r->getProperty($property);
            if ($rProperty->isPublic()) {
                $result = $rProperty->getValue($obj);

                return $result;
            }
        }

        return null;
    }
638395
public void cache(Identity oid, Object obj)
    {
        if ((obj != null))
        {
            SoftReference ref = new SoftReference(obj);
            objectTable.put(oid, ref);
        }
    }
366316
public function get($property, $type = null, $default = null)
    {
        if (!isset($this->param[$property])) {
            return $default;
        }

        if (isset($type)) {
            $method = TypeCast::METHODPREFIX . $type;

            return TypeCast::$method($this->param[$property]);
        }

        return $this->param[$property];
    }
157887
public function property($propertyIdent = null)
    {
        if (isset($this->properties[$propertyIdent])) {
            return $this->properties[$propertyIdent];
        } else {
            return null;
        }
    }
821681
protected function getNodeTemplate($oid) {
    // load object if existing to get the original data
    $originalNode = $this->persistenceFacade->load($oid, BuildDepth::SINGLE);

    // create the request node and copy the orignal data
    $class = get_class($this->persistenceFacade->create($oid->getType(), BuildDepth::SINGLE));
    $node = new $class;
    if ($originalNode) {
      $originalNode->copyValues($node);
    }
    return $node;
  }
645045
public function getOPT($property)
	{
		if (isset($this->_OPT[$property])) {
			return $this->_OPT[$property];
		}
		return null;
	}