EntityObject::__call

public function __call($name, $arguments)
{
	$first3 = substr($name, 0, 3);

	// regular getter
	if ($first3 == 'get')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 3));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check runtime
			if (array_key_exists($fieldName, $this->_runtimeValues))
			{
				return $this->sysGetRuntime($fieldName);
			}

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		// check if field exists
		if ($this->entity->hasField($fieldName))
		{
			return $this->sysGetValue($fieldName);
		}
	}

	// regular setter
	if ($first3 == 'set')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 3));
		$value = $arguments[0];

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);
			$value = $arguments[1];

			// check for runtime field
			if (array_key_exists($fieldName, $this->_runtimeValues))
			{
				throw new SystemException(sprintf(
					'Setting value for runtime field `%s` in `%s` is not allowed, it is read-only field',
					$fieldName, get_called_class()
				));
			}

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		// check if field exists
		if ($this->entity->hasField($fieldName))
		{
			$field = $this->entity->getField($fieldName);

			if ($field instanceof IReadable && !($value instanceof SqlExpression))
			{
				$value = $field->cast($value);
			}

			return $this->sysSetValue($fieldName, $value);
		}
	}

	if ($first3 == 'has')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 3));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// runtime fields
			if (array_key_exists($fieldName, $this->_runtimeValues))
			{
				return true;
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			return $this->sysHasValue($fieldName);
		}
	}

	$first4 = substr($name, 0, 4);

	// filler
	if ($first4 == 'fill')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 4));

		// no custom/personal method for fill

		// check if field exists
		if ($this->entity->hasField($fieldName))
		{
			return $this->fill([$fieldName]);
		}
	}

	$first5 = substr($name, 0, 5);

	// relation adder
	if ($first5 == 'addTo')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 5));
		$value = $arguments[0];

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);
			$value = $arguments[1];

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			return $this->sysAddToCollection($fieldName, $value);
		}
	}

	// unsetter
	if ($first5 == 'unset')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 5));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			return $this->sysUnset($fieldName);
		}
	}

	// resetter
	if ($first5 == 'reset')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 5));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			$field = $this->entity->getField($fieldName);

			if ($field instanceof OneToMany || $field instanceof ManyToMany)
			{
				return $this->sysResetRelation($fieldName);
			}
			else
			{
				return $this->sysReset($fieldName);
			}
		}
	}

	$first9 = substr($name, 0, 9);

	// relation mass remover
	if ($first9 == 'removeAll')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 9));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			return $this->sysRemoveAllFromCollection($fieldName);
		}
	}

	$first10 = substr($name, 0, 10);

	// relation remover
	if ($first10 == 'removeFrom')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 10));
		$value = $arguments[0];

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);
			$value = $arguments[1];

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			return $this->sysRemoveFromCollection($fieldName, $value);
		}
	}

	$first12 = substr($name, 0, 12);

	// actual value getter
	if ($first12 == 'remindActual')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 12));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		// check if field exists
		if ($this->entity->hasField($fieldName))
		{
			return $this->_actualValues[$fieldName] ?? null;
		}
	}

	$first7 = substr($name, 0, 7);

	// strict getter
	if ($first7 == 'require')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 7));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $name.static::sysFieldToMethodCase($fieldName);

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		// check if field exists
		if ($this->entity->hasField($fieldName))
		{
			return $this->sysGetValue($fieldName, true);
		}
	}

	$first2 = substr($name, 0, 2);
	$last6 = substr($name, -6);

	// actual value checker
	if ($first2 == 'is' && $last6 =='Filled')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 2, -6));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $first2.static::sysFieldToMethodCase($fieldName).$last6;

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			$field = $this->entity->getField($fieldName);

			if ($field instanceof OneToMany || $field instanceof ManyToMany)
			{
				return array_key_exists($fieldName, $this->_actualValues) && $this->_actualValues[$fieldName]->sysIsFilled();
			}
			else
			{
				return $this->sysIsFilled($fieldName);
			}
		}
	}

	$last7 = substr($name, -7);

	// runtime value checker
	if ($first2 == 'is' && $last7 == 'Changed')
	{
		$fieldName = self::sysMethodToFieldCase(substr($name, 2, -7));

		if ($fieldName == '')
		{
			$fieldName = StringHelper::strtoupper($arguments[0]);

			// check if custom method exists
			$personalMethodName = $first2.static::sysFieldToMethodCase($fieldName).$last7;

			if (method_exists($this, $personalMethodName))
			{
				return $this->$personalMethodName(...array_slice($arguments, 1));
			}

			// hard field check
			$this->entity->getField($fieldName);
		}

		if ($this->entity->hasField($fieldName))
		{
			$field = $this->entity->getField($fieldName);

			if ($field instanceof OneToMany || $field instanceof ManyToMany)
			{
				return array_key_exists($fieldName, $this->_actualValues) && $this->_actualValues[$fieldName]->sysIsChanged();
			}
			else
			{
				return $this->sysIsChanged($fieldName);
			}
		}
	}

	throw new SystemException(sprintf(
		'Unknown method `%s` for object `%s`', $name, get_called_class()
	));
}