Get all the public properties' name.

@return array
439950
protected function getPublicPropertiesName(): array
    {
        $reflectionClass = new \ReflectionClass($this);
        $publicProperties = $reflectionClass->getProperties(\ReflectionProperty::IS_PUBLIC);

        return array_map(function (\ReflectionProperty $property) {
            return $property->name;
        }, $publicProperties);
    }
165527
public function names()
	{
		$names = array();

		foreach ($this->items as $item)
		{
			$names[] = $item->name;
		}

		return array_values($names);
	}
934160
public function getName()
    {
        $uri = $this->principalProperties['uri'];
        list(, $name) = Uri\split($uri);

        return $name;
    }
1075111
public function attributes()
    {
        $class = new \ReflectionClass($this);

        $names = [];
        foreach ($class->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
            if (!$property->isStatic()) {
                $names[] = $property->getName();
            }
        }

        return ArrayHelper::merge(parent::attributes(), $names);
    }
102499
public function getNames()
    {
        $names = array_keys($this->getServices());
        $len = strlen(self::METHOD_PREFIX);
        foreach (get_class_methods($this) as $method) {
            if (Text::startsWith($method, self::METHOD_PREFIX)) {
                $name = lcfirst(substr($method, $len));
                if ($name) {
                    $names[] = $name;
                }
            }
        }
        return $names;
    }
386897
public function fieldNames()
    {
        if ($this->hasProperty()) {
            $property = $this->property();
            if ($property instanceof StorablePropertyInterface) {
                return $property->fieldNames();
            } else {
                return [ $property ];
            }
        }

        return [];
    }
1149452
public function getAttributes(): array
    {
        $attributes = [];
        if ($this->confirm && $this->publicKey) {
            $attributes['confirm'] = $this->confirm;
            $attributes['public_key'] = $this->publicKey;
        }
        return $attributes;
    }
1182460
public function propertiesIdents()
    {
        $metadata = $this->proto()->metadata();
        if (isset($metadata['admin']['lists'])) {
            $adminMetadata   = $metadata['admin'];
            $collectionIdent = $this->collectionIdent();
            if (isset($adminMetadata['lists'][$collectionIdent]['properties'])) {
                return $adminMetadata['lists'][$collectionIdent]['properties'];
            }
        }

        return [];
    }
87422
public static function getAllServicesName() {
    return array(
      'CreateEmail' => TRUE,
      'CreatePaymentPage' => TRUE,
      'CreatePaymentURL' => TRUE,
      'VerifyPaymentNotification' => FALSE,
      'ReceiverStatus' => TRUE,
      'SetBillExpired' => TRUE,
      'SetPaidByReceiver' => TRUE,
      'SetRejectedByPayer' => TRUE,
      'PaymentStatus' => TRUE,
      'UpdatePaymentNotificationUrl' => TRUE,
      'ReceiverBanks' => TRUE,
      'GetPaymentNotification' => TRUE,
    );
  }
1092947
public function getAdminProperties() {

		if( !isset( $this->adminProperties ) ) {

			$this->adminProperties = AdminProperties::getInstance();
		}

		return $this->adminProperties;
	}
790929
public function
	GetPublicProperties() {
	/*//
	@return array
	fetch the properties i have decided are safe to write to disk without
	privacy issues. e.g. all publics on this class.
	//*/

		$output = [];
		foreach($this as $prop => $val) {
			$ref = new ReflectionProperty(static::class,$prop);
			if($ref->isPublic()) $output[$prop] = $val;
		}

		ksort($output);
		return $output;
	}
923561
public function actionDataProperties()
    {
        $data = [];
        foreach (Property::find()->all() as $item) {
            $object = Property::getObject($item->class_name);
            $data[] = [
                'id' => $item->id,
                'var_name' => $object->varName(),
                'option_json' => $object->options(),
                'label' => $object->label(),
                'type' => $object->type(),
                'default_value' => $object->defaultValue(),
                'i18n' => $object->i18n,
            ];
        }
        
        return $data;
    }
971249
public function getProperties($public = true)
	{
		$vars = get_object_vars($this);

		if ($public)
		{
			foreach ($vars as $key => $value)
			{
				if ('_' == substr($key, 0, 1))
				{
					unset($vars[$key]);
				}
			}
		}

		return $vars;
	}
94867
public function getPropertyNames()
    {
        if (is_object($this->contentObjectProxy)) {
            return ObjectAccess::getGettablePropertyNames($this->contentObjectProxy->getObject());
        }
        return array_keys($this->properties);
    }
1134863
protected function buildPropertyMap()
    {
        $map = [];
        $properties = (new ReflectionObject($this))->getProperties(ReflectionProperty::IS_PUBLIC);

        foreach ($properties as $property) {
            $map[$property->getName()] = $property;
        }

        return $map;
    }
69083
public function getSourcesNames()
    {
        static $result = [];

        if (empty($result)) {
            foreach ($this->sources() as $source) {
                $result[] = $source->getName();
            }
        }

        return $result;
    }
638447
public function fetchProperties()
    {
        $result = $this->_client->fetchProperties($this->_id);

        $this->_parentId = '' != $result->parent_id ?
            (string) $result->parent_id : null;

        $this->_name = $result->name;

        $this->_description = '' != $result->description ?
            (string) $result->description : null;

        $this->_size = (int) $result->size;

        /** @todo Handle volatile existence (eg. present only for files). */
        $this->_source = (string) $result->source;

        $this->_createdTime = strtotime($result->created_time);
        $this->_updatedTime = strtotime($result->updated_time);

        return $result;
    }