Produce the static::$unsetablePropertiesArray
@return array
429538
private function getApiOptionsDeclaration()
    {

        // we got a max instances allowed in normality tags
        $apiOptions = json_encode( $this->apiOptions );
        $apiOptions = Php::varExport( $apiOptions, true );

        $this->class->classComponents[] = new VariableDeclaration(
            'apiOptions',
            new SFormatf( <<<'PHP'
                /**
                 * API options from relation
                 * @var array
                 */
                protected $apiOptions = %s;
PHP
                , $apiOptions
            )
        );

    }
79990
public function toArray()
    {
        $array = ['Enabled' => Utilities::booleanToString($this->_enabled)];
        if (isset($this->_days)) {
            $array['Days'] = strval($this->_days);
        }

        return $array;
    }
654732
public static function toArray()
  {
    $self   = new \ReflectionClass(get_called_class());
    $return = array();
    foreach ($self->getConstants() as $value)
    {
      array_push($return, $value);
    }

    return $return;
  }
924944
public function getQueryableProperties()
    {
        $classMetadata = $this->getObjectManager()
                              ->getClassMetadata($this->getEntityClass());

        $fields = $classMetadata->getFieldNames();
        $alias  = $this->getEntityClassAlias();

        foreach ($fields as $key => &$field) {
            $fieldType = $classMetadata->getTypeOfField($field);
            if (!in_array($fieldType, array('string', 'text'))) {
                unset($fields[$key]);
            } else {
                $field = $alias . '.' . $field;
            }
        }

        return $fields;
    }
602657
public function getModifiedProperties()
    {
        if ($this->read_only) {
            return array();
        }

        $modified_properties = array();
        foreach ($this->getProperties() as $name => $value) {
            $hashed_value = $this->getHashValue($value);
            if (
                array_key_exists($name, $this->property_hashes) &&
                $hashed_value !== $this->property_hashes[$name]
            ) {
                $modified_properties[$name] = $value;
            }
        }

        return $modified_properties;
    }
1369062
public static function toArray()
    {
        $reflectionClass = new \ReflectionClass(get_called_class());
        $parentRelectionClass = $reflectionClass->getParentClass();

        return array_diff(
            $reflectionClass->getConstants(),
            $parentRelectionClass->getConstants()
        );
    }
1169338
public function getOnlyFillable()
    {
        $list = [];

        foreach ($this->items as $item) {
            if ($item->fillable) {
                $list[] = $item;
            }
        }

        return new static($list);
    }
1110937
private function getMakeablePropertyDeclaration()
    {

        if( $this->entity->pgClass->isView() or $this->entity->pgClass->isMaterialisedView() ) {
            $makeable = 'MAKEABLE_EXCEPTION';
        }

        if( array_key_exists( 'makeable', $this->entity->normalityTags ) ) {
            $makeable = $this->entity->normalityTags['makeable'];
        }

        if( !isset( $makeable ) ) {
            return;
        }

        if( !defined( "\Bond\Repository::{$makeable}" ) ) {
            throw new \InvalidArgumentException("normality.makeable has bad value `{$makeable}`.");
        }

        $this->class->classComponents[] = new VariableDeclaration(
            'resolver',
            new SFormatf( <<<'PHP'
                /**
                 * Makeable
                 * @var string
                 */
                protected $makeable = self::%s;
PHP
                , $makeable
            )
        );

    }
807584
public function getArrayCopy() : array
    {
        $values = get_object_vars($this);
        foreach ($values as $property => $value) {
            // Skip relations
            if (is_object($value)) {
                unset($values[$property]);
            }
        }

        return $values;
    }
1137221
protected function getArray()
    {
        $key         = $this->getRangeKey()->getPropertyMetadata()->name;
        $array       = parent::getArray();
        $array[$key] = $this->getRangeValue();

        return $array;
    }
1051864
protected function getManagedProperties(): array
    {
        $properties = $this->entityMap->getProperties();

        $attributesName = $this->entityMap->getAttributesArrayName();

        return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
    }
1340824
public function toArray()
    {
        return [
            'field' => $this->getRawProperty('field'),
            'from-field' => $this->getRawProperty('fromField'),
            'to-field' => $this->getRawProperty('toField'),
            'is-deleted' => $this->isDeleted,
            'is-added' => $this->isAdded,
        ];
    }
1140515
public function toArray()
    {
        $out = [];

        foreach ($this->setFields as $key) {
            $property = $this->{$key};

            if ($property instanceof DateTime) {
                $out[$key] = $property->format(DateTime::ISO8601);
            } else {
                $out[$key] = $property;
            }
        }

        return $out;
    }
517586
public function getInjectablePropertiesBySetter() {
    	if ($this->injectablePropertiesBySetter === null) {
    		$this->injectablePropertiesBySetter = MoufReflectionClass::staticGetInjectablePropertiesBySetter($this);
    	}
    	return $this->injectablePropertiesBySetter;
    }
359546
public function toArray()
    {
        $result = [];
        foreach ($this->visibleProperties() as $property) {
            $value = $this->get($property);
            if (is_array($value)) {
                $result[$property] = [];
                foreach ($value as $k => $entity) {
                    if ($entity instanceof EntityInterface) {
                        $result[$property][$k] = $entity->toArray();
                    } else {
                        $result[$property][$k] = $entity;
                    }
                }
            } elseif ($value instanceof EntityInterface) {
                $result[$property] = $value->toArray();
            } else {
                $result[$property] = $value;
            }
        }

        return $result;
    }
645457
public function getPropertiesAsArray()
    {
        $array = array();

        foreach ($this->getProperties() as $property) {
            $array[$property->getName()] = [ 'value' => $property->getValue(), 'type' => $property->getType() ];
        }

        return $array;
    }
1149661
public static function getPossibleValues(): array
    {
        return [
            self::POST,
            self::PUT,
            self::PATCH,
            self::DELETE,
            self::GET,
        ];
    }