@VirtualProperty
@SerializedName("addons")

@return ApiProductInterface[]
765191
public function getAddons()
    {
        $apiAddons = [];
        $addons = $this->entity->getAddons();
        /** @var AddonEntity $addon */
        foreach ($addons as $addon) {
            $apiAddon = $this->productFactory->createAddonProductApiEntity(
                $addon->getAddon(),
                $this->locale,
                iterator_to_array($addon->getAddonPrices())
            );

            $apiAddons[] = $apiAddon;
        }

        return $apiAddons;
    }
64705
public function export()
    {
        $result = array();

        foreach ($this->collection as $name => $property) {
            /* @var $property PropertyDefnitionInterface */
            $result[$name] = $property->getRawType();
        }

        return $result;
    }
845371
public function extend() 
    {
        return [
            "rentalFeeSink" => $this->rentalFeeSink()->address()->toClean(),
            "rentalFee" => empty($this->parent) ? Fee::ROOT_PROVISION_NAMESPACE : Fee::SUB_PROVISION_NAMESPACE,
            "parent" => $this->parent,
            "newPart" => $this->newPart,
            // transaction type specialization
            "type" => TransactionType::PROVISION_NAMESPACE,
        ];
    }
807736
public function getInstalledAddons()
    {
        if (!$this->controller_install_addon) {
            $this->controller_install_addon = $this->add('sandbox\\Controller_InstallAddon');
        }

        if ($this->controller_install_addon && $this->controller_install_addon->getSndBoxAddonReader()) {
            return $this->controller_install_addon->getSndBoxAddonReader()->getReflections();
        }

        return array();
    }
621020
public function getInitiatedAddons($addon_api_name = null)
    {
        if ($addon_api_name !== null) {
            return $this->addons[$addon_api_name];
        }

        return $this->addons;
    }
79313
public static function getVirtual(RepositoryInterface $table) : array
    {
        $moduleName = App::shortName(get_class($table), 'Model/Table', 'Table');

        $config = (new ModuleConfig(ConfigType::MODULE(), $moduleName))->parse();

        return property_exists($config, 'virtualFields') ? (array)$config->virtualFields : [];
    }
961195
public function getStaticProperties()
    {
        // In runtime static properties can be changed in any time
        if ($this->isInitialized()) {
            return parent::getStaticProperties();
        }

        $properties = [];

        $reflectionProperties = $this->getProperties(ReflectionProperty::IS_STATIC);
        foreach ($reflectionProperties as $reflectionProperty) {
            if (!$reflectionProperty instanceof ReflectionProperty) {
                if (!$reflectionProperty->isPublic()) {
                    $reflectionProperty->setAccessible(true);
                }
            }
            $properties[$reflectionProperty->getName()] = $reflectionProperty->getValue();
        }

        return $properties;
    }
78812
public function visibleProperties()
    {
        $properties = array_keys($this->_properties);
        $properties = array_merge($properties, $this->_virtual);

        return array_diff($properties, $this->_hidden);
    }
1291768
public function getProperties()
    {
        //build URI to merge Docs
        $strURI = Product::$baseProductUri . '/words/' . $this->getFileName() . '/documentProperties';

        //sign URI
        $signedURI = Utils::sign($strURI);

        $responseStream = Utils::processCommand($signedURI, 'GET', '', '');

        $json = json_decode($responseStream);


        if ($json->Code == 200) {
            return $json->DocumentProperties->List;
        }
        
        AsposeApp::getLogger()->warning('Error occured, http 200 code was not found.', array(
            'json-code' => $json->Code,
        ));
        return false;
    }
498536
public function handleInstall(): array
    {
        $result = [];

        $handlers = AbstractOperation::getOperationHandlers($this->composer);
        $handlersMap = [];

        foreach ($handlers as $handler) {
            $handler = new $handler($this->package, $this->projectType, $this->composer);
            if ($handler instanceof SupportedProjectTypesInterface) {
                if (in_array($this->projectType->getMachineName(), $handler->getSupportedProjectTypes())) {
                    $handlersMap[] = $handler;
                }
            }
        }

        foreach ($this->projectType->getTypes() as $type) {
            if (isset($handlers[$type])) {
                $class = $handlers[$type];
                /** @var AbstractOperation $handler */
                $handler = new $class($this->package, $this->projectType, $this->composer);
                $handlersMap[] = $handler;
            }
        }

        foreach ($handlersMap as $handler) {
            if ($handler instanceof AvailableOperationInterface) {
                if (!$handler->isAvailable()) {
                    continue;
                }
            }
            $result[] = $handler->install();
        }

        return $result;
    }
433810
public function getComputedProperties()
    {
        $result = array();

        if($entity = $this->getIterator()->current()) {
            $result = $entity->getComputedProperties();
        }

        return $result;
    }
399848
private Map<AddonId, AddonRepository> getInstalledAddons()
   {
      Map<AddonId, AddonRepository> addons = new HashMap<>();
      for (AddonRepository repository : getRepositories())
      {
         List<AddonId> listEnabled = repository.listAll();
         for (AddonId addonId : listEnabled)
         {
            addons.put(addonId, repository);
         }
      }
      return addons;
   }
65010
public function convertAll()
    {
        $apiObjects = $this->apiObjects;
        if (empty($apiObjects)) {
            return [];
        }

        return $this->getLegacyKernel()->runCallback(
            static function () use ($apiObjects) {
                $convertedObjects = [];
                foreach ($apiObjects as $alias => $apiObject) {
                    if ($apiObject instanceof Content) {
                        $convertedObjects[$alias] = eZContentObject::fetch($apiObject->getVersionInfo()->getContentInfo()->id);
                    } elseif ($apiObject instanceof Location) {
                        $convertedObjects[$alias] = eZContentObjectTreeNode::fetch($apiObject->id);
                    } elseif ($apiObject instanceof VersionInfo) {
                        $convertedObjects[$alias] = eZContentObjectVersion::fetchVersion($apiObject->versionNo, $apiObject->getContentInfo()->id);
                    }
                }

                return $convertedObjects;
            },
            false,
            false
        );
    }
228998
public static function getCommonDefinitions()
    {
        $customValues = (array) self::getCustom('common_definitions', []);

        $defaultValues = self::get('common_definitions', []);
        $final = [];
        $finalMatchingKeys = [];

        // Merge properties with existing patterns
        foreach ($defaultValues as $key => $defaultValue) {
            if (is_array($defaultValue)
                && array_key_exists('match', $defaultValue)
                && array_key_exists('set', $defaultValue)
            ) {
                $matches = (array) $defaultValue['match'];

                $finalMatchingKeys = array_merge($finalMatchingKeys, $matches);

                $final[] = [
                    'match' => $matches,
                    'set' => self::mergeDefinitions($matches, $customValues, (array) $defaultValue['set']),
                ];
            }
        }

        // Add new patterns
        foreach ($customValues as $key => $customValue) {
            if (is_array($customValue)
                && array_key_exists('match', $customValue)
                && array_key_exists('set', $customValue)
            ) {
                $newPatterns = array_diff((array) $customValue['match'], $finalMatchingKeys);

                if (empty($newPatterns)) {
                    // At this point there are no patters that we don't already have
                    continue;
                }

                $finalMatchingKeys = array_merge($finalMatchingKeys, $newPatterns);

                $final[] = [
                    'match' => $newPatterns,
                    'set' => $customValue['set'],
                ];
            }
        }

        return $final;
    }
1255850
function get_installed_addons() {
            $installed_addons = array();
            foreach ( self::$_instances as $instance ) {
                if ( $instance->is_addon() && is_object( $instance->_parent_plugin ) ) {
                    if ( $this->_plugin->id == $instance->_parent_plugin->id ) {
                        $installed_addons[] = $instance;
                    }
                }
            }

            return $installed_addons;
        }
94867
public function getPropertyNames()
    {
        if (is_object($this->contentObjectProxy)) {
            return ObjectAccess::getGettablePropertyNames($this->contentObjectProxy->getObject());
        }
        return array_keys($this->properties);
    }
269603
protected function getEmbeddedObjectAttributes() : array
    {
        $entityMap = $this->getRelatedMapper()->getEntityMap();

        $attributes = $entityMap->getAttributes();
        $properties = $entityMap->getProperties();

        return array_merge($attributes, $properties);
    }