final protected function &_getProperty(
        $propName,
        $createMissingValue = false)
    {
        // Check if the property exists in class/data and get its definition.
        $propDef = $this->_getPropertyDefinition($propName); // Throws.

        // Assign the appropriate reference to the "$value" variable.
        if (array_key_exists($propName, $this->_objectData)) {
            // The value exists in the data, so refer directly to it.
            $value = &$this->_objectData[$propName]; // IMPORTANT: By reference!
        } elseif ($createMissingValue) {
            // No value exists in data yet, AND the caller wants us to create
            // a default NULL value for the data property in that situation.
            // NOTE: This is IMPORTANT so that the returned "default NULL"
            // by-reference value will refer to the correct internal data
            // array entry instead of to an unrelated, temporary variable.
            // NOTE: The downside to this is that we'll fill the object's
            // internal data storage with a bunch of default "NULL" values,
            // which increases memory needs and messes with the "to JSON"
            // output functions later. But it's unavoidable. We obviously
            // CANNOT return a real reference to an internal data entry
            // unless we CREATE the entry. So we MUST unfortunately do it!
            // NOTE: This "pollution" is only a problem if the caller intends
            // to use the property by reference, which isn't the case for
            // default __call() (the virtual functions), but IS necessary
            // in the default __get() (direct property access by reference).
            $this->_objectData[$propName] = null;

            // Now just link to the data array entry we just added.
            $value = &$this->_objectData[$propName]; // IMPORTANT: By reference!
            return $value; // OPTIMIZATION: Skip convert() for missing data.
        } else {
            // No value exists in data yet, but the caller didn't want us to set
            // the missing value. So we'll simply use a default NULL variable.
            // NOTE: If the caller tries to write to this one by reference,
            // they'll just modify this temporary variable instead of the
            // internal data. To link to real they MUST $createMissingValue.
            // NOTE: We MUST return a variable, since "return null" is illegal.
            $value = null; // Copy-on-write. Temporary variable to be returned.
            return $value; // OPTIMIZATION: Skip convert() for missing data.
        }

        // Map the value to the appropriate type and validate it.
        ValueConverter::convert( // Throws.
            ValueConverter::CONVERT_FROM_INTERNAL,
            $value, $propDef->arrayDepth, $propName, $propDef
        );

        // Whatever $value points at will now be returned by-reference.
        return $value; // By-reference due to &function signature.
    }