@VirtualProperty
@SerializedName("items")

@return array
774710
public function getItems()
    {
        if (!$this->shippingItems) {
            $this->shippingItems = array();
            foreach ($this->entity->getShippingItems() as $shippingItem) {
                $this->shippingItems[] = new ShippingItem(
                    $shippingItem,
                    $this->locale,
                    $this->itemFactory,
                    $this->priceFormatter
                );
            }
        }

        return $this->shippingItems;
    }
789457
public function properties()
    {
        if ($this->properties === null) {
            $model = $this->proto();
            $props = $model->metadata()->properties();

            $collectionIdent = $this->collectionIdent();
            if ($collectionIdent) {
                $metadata      = $model->metadata();
                $adminMetadata = isset($metadata['admin']) ? $metadata['admin'] : null;

                if (isset($adminMetadata['lists'][$collectionIdent]['properties'])) {
                    // Flipping to have property ident as key
                    $listProperties = array_flip($adminMetadata['lists'][$collectionIdent]['properties']);
                    // Replacing values of listProperties from index to actual property values
                    $props = array_replace($listProperties, $props);
                    // Get only the keys that are in listProperties from props
                    $props = array_intersect_key($props, $listProperties);
                }
            }

            $this->properties = $props;
        }

        return $this->properties;
    }
645457
public function getPropertiesAsArray()
    {
        $array = array();

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

        return $array;
    }
947949
public function jsonSerialize()
    {
        $output = [];
        foreach ($this::getReflection()->getProperties() as $propertyName => $property) {

            $value = $this->{$propertyName};
            if ($value instanceof Entity\Collection || $value instanceof Entity) {
                $output[$propertyName] = $value->jsonSerialize();
            } elseif ($value instanceof \DateTime
                && $property->getType() === Entity\Reflection\Property::TYPE_DATE
            ) {
                $output[$propertyName] = (array) $value;
                $output[$propertyName]["date"] = $value->format(self::$dateFormat);
            } else {
                $output[$propertyName] = $value;
            }
        }

        return $output;
    }
833403
public function toArray()
    {
        $newItem = [];

        foreach ($this->items as $key => $val) {
            if ($val instanceof ArrayInterface) {
                $newItem[$key] = $val->items;
            } else {
                $newItem[$key] = $val;
            }
        }

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

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

        return $result;
    }
542183
private function getItems()
    {
        $items = [];

        $layer = $this->layerResolver->get();
        $filterList = $this->getFilterList();

        foreach ($filterList->getFilters($layer) as $filter) {
            if ($filter->getRequestVar() == $this->getFilterName()) {
                foreach ($filter->getItems() as $item) {
                    $item->setBaseUrl($this->_redirect->getRedirectUrl());
                    $items[] = $item->toArray(['url', 'count', 'is_selected', 'label']);
                }
            }
        }

        return $items;
    }
1169343
public function serialize()
    {
        $data = array();

        // unset subdataobjects that are not to be serialized
        $serializable_sub_data_objects = $this->getSerializableSubDataObjects();
        $unset_objects = array();
        foreach ($this->sub_data_objects as $name => $object) {
            if (!in_array($name, $serializable_sub_data_objects)) {
                $unset_objects[$name] = $this->getSubDataObject($name);
                $this->unsetSubDataObject($name);
            }
        }

        foreach ($this->getSerializablePrivateProperties() as $property) {
            $data[$property] = $this->$property;
        }

        $reflector = new ReflectionObject($this);
        foreach ($reflector->getProperties() as $property) {
            if ($property->isPublic() && !$property->isStatic()) {
                $name = $property->getName();
                $data[$name] = $this->$name;
            }
        }

        foreach ($this->getProtectedPropertyList() as $property => $accessor) {
            // We want to maintain what is internally stored in this object so
            // we don't want to use the getter. What the getter returns
            // publicly may be different than what we have internally.
            $data[$property] = $this->$property;
        }

        $serialized_data = serialize($data);

        // restore unset sub-dataobjects on this object
        foreach ($unset_objects as $name => $object) {
            $this->setSubDataObject($name, $object);
        }

        return $serialized_data;
    }
614618
public function toArray()
    {
        return [
            'name' => $this->name,
            'class-name' => $this->className,
            'path' => $this->path,
            'is-create' => $this->isCreate,
            'is-virtual' => $this->isVirtual,
            'is-organized' => $this->isOrganized,
            'with-soft-delete' => $this->withSoftDelete,
            'without-timestamps' => $this->withoutTimestamps,
            'resource' => ($this->resource ?: new Resource())->toArray(),
        ];
    }
429561
public function toArray($properties = null)
    {
        $array = [];

        if (!empty($this->getMeta())) {
            $array['meta'] = $this->getMeta();
        }

        if (!empty($this->getPropertyContainer())) {
            $array['properties'] = [];

            foreach ($this->getPropertyContainer()->getProperties() as $item) {
                if (method_exists(
                    $item,
                    'toArray'
                )) {
                    $array['properties'][] = $item->toArray();
                }
            }
        }
        if (!empty($this->getDatabaseContainer())) {
            $array['database'] = $this->getDatabaseContainer()->getDatabase()->toArray();
        }

        return $array;
    }
536122
public function serialize()
    {
        $data = array();

        foreach (get_object_vars($this) as $propertyName => $propertyValue) {
            $data[$propertyName] = $propertyValue;
        }

        return serialize($data);
    }
198064
public function getItems()
  {
    $namespaces = $this->xml->getDocNamespaces();
    foreach($namespaces as $namespace => $url)
    {
      $this->xml->registerXPathNamespace($namespace, $url);
    }

    foreach ($this->xml->xpath($this->itemXpath) as $item)
    {
      $this->items[] = new Item
      (
        $this->itemtitleXpath ? (string) $item->xpath($this->itemtitleXpath)[0] : NULL,
        $this->itemtorrenturlXpath ? (string) $item->xpath($this->itemtorrenturlXpath)[0] : NULL,
        $this->itemmagnetXpath ? (string) $item->xpath($this->itemmagnetXpath)[0] : NULL
      );
    }

    return $this->items;
  }
795923
public function getItemUrlArray()
    {
        return array(
            \MUtil_Model::REQUEST_ID1 => $this->_getParam(\MUtil_Model::REQUEST_ID1),
            \MUtil_Model::REQUEST_ID2 => $this->_getParam(\MUtil_Model::REQUEST_ID2),
            );
    }
121756
public function toArray()
    {
        if ($this->gettersVariable) {
            $var = $this->gettersVariable;

            return $this->{$var};
        }

        $properties = (array)$this;
        $list = [];
        foreach ($properties as $property => $value) {
            if ($property[0] !== "\0") {
                $list[$property] = $value;
            }
        }

        return $list;
    }
1083692
public function jsonSerialize()
    {
        $result = array();
        foreach (get_class_methods($this) as $method) {
            if (strncmp('get', $method, 3) === 0) {
                if ($method === 'getUnknownProperties') {
                    continue;
                }
                if ($method === 'getIterator') {
                    continue;
                }
                $property = strtolower(preg_replace('/[A-Z]/', '_\0', lcfirst(substr($method, 3))));
                $value = $this->serializeValueToJson($this->{$method} ());
                if ($value !== null) {
                    $result[$property] = $value;
                }
            }
        }
        if (!empty($this->unknownProperties)) {
            foreach ($this->unknownProperties as $property => $value) {
                if (!array_key_exists($property, $result)) {
                    $result[$property] = $this->serializeValueToJson($value);
                }
            }
        }
        return $result;
    }
203825
public function toArray()
    {
        $data = parent::toArray();

        foreach ($this->getComputedProperties() as $property)
        {
            if ($this->{$property} instanceof ModelEntityInterface) {
                $data[$property] = array_values($this->{$property}->toArray());
            } else {
                $data[$property] = $this->{$property};
            }
        }

        foreach(array_keys($data) as $key)
        {
            if (substr($key, 0, 1) === '_') {
                unset($data[$key]);
            }
        }

        return $data;
    }
1284152
public function __getSerialisablePropertyMap()
    {

        $serialisableProperties = parent::__getSerialisablePropertyMap();
        $dynamicProperties = $this->__dynamicPropertyMap;

        $map = array();
        foreach ($dynamicProperties as $key => $value) {
            $map[$key] = $value;
        }
        foreach ($serialisableProperties as $key => $value) {
            $map[$key] = $value;
        }

        // Merge our dynamic properties in and return.
        return $map;

    }