Create getter & setter methods for properties

@param string $property
517928
protected function addGetterSetter($property) {
		$properyName = $this->parseMethodName($property, '');
		$getter = "get{$properyName}";
		$setter = "set{$properyName}";
		
		// Extract array to $type, $default, $primary
		$type = null;
		extract($this->getNames()->properties[$property]);
		
		// Type Cast
		$cast = '';
		if ($type == 'int')
			$cast = '(int)';
		
		//METHODS
		// METHOD:getPropperty
		$method = $this->buildMethod($getter);
		$body = <<<MBODY
return {$cast}\$this->{$property};
MBODY;
		$method->setBody($body);
		$method->setDocBlock(DocBlockGenerator::fromArray([
			'shortDescription' => "Get the {$property} property",
			'tags' => [
			new ReturnTag(['datatype' => $type])
			]]));
		$this->_class->addMethodFromGenerator($method);
		
		//===============================================
		
		// METHOD:setPropperty
		$parameterSetter = new ParameterGenerator();
		$parameterSetter->setName($property);
		$method = $this->buildMethod($setter);
		$method->setParameter($parameterSetter);
		$body = <<<MBODY
\$this->{$property} = \${$property};
return \$this;
MBODY;
		$method->setBody($body);
		$method->setDocBlock(DocBlockGenerator::fromArray([
			'shortDescription' => "Set the {$property} property",
			'tags' => [
				new ParamTag($property, ['datatype' => $type]),
				new ReturnTag(['datatype'  => $this->getNames()->entityName])
			]]));
		$this->_class->addMethodFromGenerator($method);
	}
61531
public function configure(array $properties)
    {
        foreach ($properties as $name => $value) {
            $methodName = 'set' . ucfirst(strtolower($name));
            if (method_exists($this, $methodName)) {
                $this->$methodName($value);
            }
        }
    }
1092127
public function __isset($property)
	{
		if(!empty($property))
		{
			# generic isset check
			$call = "isset_".$property;
			
			if(method_exists($this, $call))
				return $this->{$call}() && true;
			
			# now to see if the value is set?
			$call = "getter_".$property;
			
			if(method_exists($this, $call))
				return $this->{$call}() !== null;
			
			/*
				if($this instanceof ArrayAccess)
					return $this->offsetExists($property);
			*/
		}
		
		return false;
	}
1176206
public function setProperty($property, $value)
    {
        if (property_exists($this, $property) && $property !== 'form') {
            $this->$property = $value;
        }
        return $this;
    }
539818
public function makePropertyAccessible($property)
    {
        $reflectionProperty = $this->getReflectionClass()->getProperty($property);
        $this->setReflectionProperty($reflectionProperty);
        $reflectionProperty->setAccessible(true);

        return $reflectionProperty->getValue($this->getReflectionClass());
    }
360700
public function checkProperty(&$property)
    {
        if (is_string($property)) {
            $property = Placeholder::replaceStringsAndComments($property);
            $property = Placeholder::removeCommentPlaceholders($property, true);
            $property = Placeholder::replaceStringPlaceholders($property, true);

            return true;
        } else {
            throw new \InvalidArgumentException(
                "Invalid type '" . gettype($property). "' for argument 'property' given."
            );
        }
    }
1260758
protected function generatePropertyHash($property)
    {
        if ($this->read_only) {
            return;
        }

        $property_array = $this->getProperties();

        if (isset($property_array[$property])) {
            $hashed_value = $this->getHashValue($property_array[$property]);
            $this->property_hashes[$property] = $hashed_value;
        }
    }
976570
private function getMutatorMethod(string $class, string $property): ?array
    {
        $ucProperty = ucfirst($property);
        $ucSingulars = (array) Inflector::singularize($ucProperty);

        foreach ($this->mutatorPrefixes as $prefix) {
            $names = [$ucProperty];
            if (\in_array($prefix, $this->arrayMutatorPrefixes)) {
                $names = array_merge($names, $ucSingulars);
            }

            foreach ($names as $name) {
                try {
                    $reflectionMethod = new \ReflectionMethod($class, $prefix.$name);
                    if ($reflectionMethod->isStatic()) {
                        continue;
                    }

                    // Parameter can be optional to allow things like: method(array $foo = null)
                    if ($reflectionMethod->getNumberOfParameters() >= 1) {
                        return [$reflectionMethod, $prefix];
                    }
                } catch (\ReflectionException $e) {
                    // Try the next prefix if the method doesn't exist
                }
            }
        }

        return null;
    }
1114216
public function relation(string $property): RelationUsingDefiner
    {
        $this->verifyProperty(__METHOD__, $property);

        $accessor = new PropertyAccessor($this->class->getClassName(), $this->class->getProperty($property));

        return $this->defineRelationVia($accessor, function () use ($property) {
            $this->mappedProperties[$property] = true;
        });
    }
24055
protected function setProperty(ReflectionProperty $property)
    {
        if (mb_strpos($property->getDocComment(), Bean::ANNOTATION_PROPERTY, 0, 'UTF-8') !== false) {
            $this->property = $property;
        } else {
            $msg = "The property must be annotated with '@qtism-bean-property'.";
            throw new BeanException($msg, BeanException::NO_ANNOTATION);
        }
    }
173243
public function addProperty($property)
    {
        if ($this->hasProperty($property)) {
            throw new LogicException(sprintf('The property "%s" can not be set twice', $property));
        }

        $this->append(sprintf(' %s="%s"', $property, $property));
        array_push($this->properties, $property);

        return $this;
    }
983918
private function getEntitySetter($entity, $property)
    {
        $setter = 'set'.ucfirst($property);
        if (!method_exists($entity, $setter)) {
            throw new \LogicException("Entity has no setter for property `{$property}`.");
        }

        return $setter;
    }
577221
public function set($property, $value = null)
        {
            $this->One->set($property, $value);

            return $this;
        }
328599
public static function getProperty($object, string $property)
    {
        $getter = \Closure::bind(
            function ($object) use ($property) {
                return $object->{$property};
            },
            null,
            get_class($object)
        );

        return $getter($object);
    }
3717
protected function initializeProperties($properties = null)
    {
        $this->getPropertiesInfo();

        // Initialize the properties that were defined using the Initialize / InitializeObject annotations
        $initializeValueValidationEnabled = Configuration::isInitializeValuesValidationEnabled();
        foreach ($this->_initialPropertiesValues as $propertyName => $initialization) {
            $value = null;
            switch ($initialization['type']) {
                case 'initialize':
                    $value = $initialization['value'];
                    break;
                default:
                    $className = $initialization['value'];
                    $value = new $className();
                    break;
            }

            if ($initializeValueValidationEnabled) {
                $this->assertPropertyValue($propertyName, $value);
            }

            $this->$propertyName = $value;
            $this->updateInitializedPropertyValue($propertyName, $value);
        }

        // Initialize the propeties using given arguments
        if ($this->_initializationNeededArguments !== null && $properties !== null) {
            $numberOfNeededArguments = count($this->_initializationNeededArguments);

            MethodCallManager::assertArgsNumber($numberOfNeededArguments, $properties);

            for ($i = 0; $i < $numberOfNeededArguments; $i++) {
                $propertyName = $this->_initializationNeededArguments[$i];
                $argument = $properties[$i];

                $this->assertPropertyValue($propertyName, $argument);
                $this->$propertyName = $argument;
                $this->updateInitializedPropertyValue($propertyName, $argument);
            }
        }
    }
206969
public function &__get($property)
	{
		$value = null;
		
		if(!empty($property))
		{
			$call = "getter_".$property;
			
			if(method_exists($this, $call))
				$value = $this->{$call}();
			
			/*
				elseif($this instanceof ArrayAccess)
					$value = $this->offsetGet($property);
			*/
		}
		
		return $value;
	}
1332195
public function set($property, $value)
    {
        if ($this->_convert) {
            $property = str_replace( "_", "-", $property );
        } else {
            $property = str_replace( "-", "_", $property );
        }

        $this->_values[$property] = $value;
    }