Get an activity object config.

@param string $object The object name.
@return KObjectConfig
11095
protected function _getConfig($object)
    {
        $config = new KObjectConfig();

        $method = '_' . strtolower($object) . 'Config';

        // Call config setter if any.
        if (method_exists($this, $method)) {
            $this->$method($config);
        }

        return $config;
    }
1131626
public function query($object) {
		$conditions = (array) $this->constraints();

		foreach ($this->key() as $from => $to) {
			if (!isset($object->{$from})) {
				return null;
			}
			$conditions[$to] = $object->{$from};

			if (is_object($conditions[$to]) && $conditions[$to] instanceof Countable) {
				$conditions[$to] = iterator_to_array($conditions[$to]);
			}
		}
		$fields = $this->fields();
		$fields = $fields === true ? null : $fields;
		return compact('conditions', 'fields');
	}
1088260
public function getObjectIdentity($object)
    {
        foreach ($this->configurations as $config) {
            if ($config->isRelevant($object)) {
                return $config->getObjectIdentity();
            }
        }

        return null;
    }
716585
public function getActivityData(KModelEntityInterface $object, KObjectIdentifierInterface $subject, $action = null)
    {
        $data = array(
            'application' => $subject->domain,
            'type'        => $subject->type,
            'package'     => $subject->package,
            'name'        => $subject->name,
        );

        if (is_array($this->_title_column))
        {
            foreach ($this->_title_column as $title)
            {
                if ($object->{$title})
                {
                    $data['title'] = $object->{$title};
                    break;
                }
            }
        }
        elseif ($object->{$this->_title_column}) {
            $data['title'] = $object->{$this->_title_column};
        }

        if (!isset($data['title'])) {
            $data['title'] = '#' . $object->id;
        }

        $data['row'] = $object->id;

        return $data;
    }
441715
public function getValue($object) {
		if(null === $this->reflectionClass) {
			$this->reflectionClass = new \ReflectionClass($this->class);
		}
		$method = $this->reflectionClass->getMethod($this->getter);
		return $method->invoke($object);
	}
741892
public static function functions($object)
    {
        return (is_array($object) || $object instanceOf \stdClass)
            ? static::keys(static::filter($object, function ($item) {
                return static::isFunction($item);
            }))
            : static::sortBy(get_class_methods($object), function($name) {
                return $name;
            });
    }
1372398
public function get($object)
	{
		if ($this->oauth != null)
		{
			if ($this->oauth->isAuthenticated())
			{
				$response = $this->oauth->query($this->fetchUrl($object));

				return json_decode($response->body);
			}
			else
			{
				return false;
			}
		}

		// Send the request.
		return $this->sendRequest($object);
	}
392987
protected function createObject($object)
    {
        $type = new ObjectType(['class'=>get_class($object)]);

        foreach (get_object_vars($object) as $property=>$value) {
            $type[$property] = $this->toType($value);
        }

        return $type;
    }
192849
private static function getPropertyMapping($object)
    {
        $mapping = array();
        $reflection = new \ReflectionClass($object);

        // Create a default property mapping by getting the properties
        foreach ($reflection->getProperties() as $property) {
            $name = $property->getName();
            $setterMethod = 'set' . ucfirst($name);

            if (method_exists($object, $setterMethod) || $property->isPublic()) {
                $mapping[$name] = $name;
            }
        }

        // If the getPropertyMapping method exists, merge it with the
        // existing mapping.
        //
        // This comes last because it has higher priority than the default
        // mapping.
        if (method_exists($object, 'getPropertyMapping')) {
            $mapping = array_merge($mapping, $object->getPropertyMapping());
        }

        // Filter any properties that are mapped to null
        foreach ($mapping as $destination => $source) {
            if (!$source) {
                unset($mapping[$destination]);
            }
        }

        return $mapping;
    }
1254601
public static function makeFromObject( $object )
    {
        // inistante object without going via constructer to allow us to
        $refl = new \ReflectionClass( __CLASS__ );
        $obj = $refl->newInstanceWithoutConstructor();
        $obj->isValid = true;
        $obj->decoded = $object;
        return $obj;
    }
653590
public function getMetadataForObject($object)
    {
        if (!$object instanceof StructureBehavior) {
            return;
        }

        $documentMetadata = $this->metadataFactory->getMetadataForClass(get_class($object));
        $structure = $this->structureFactory->getStructureMetadata(
            $documentMetadata->getAlias(),
            $object->getStructureType()
        );

        return $this->getMetadata($documentMetadata, $structure);
    }
772859
protected function getPaginationConfig($object, array $context = []): array
    {
        $currentPage = $lastPage = $itemsPerPage = $pageTotalItems = $totalItems = null;
        $paginated = $paginator = false;

        if ($object instanceof PartialPaginatorInterface) {
            $paginated = $paginator = true;
            if ($object instanceof PaginatorInterface) {
                $paginated = 1. !== $lastPage = $object->getLastPage();
                $totalItems = $object->getTotalItems();
            } else {
                $pageTotalItems = (float) \count($object);
            }

            $currentPage = $object->getCurrentPage();
            $itemsPerPage = $object->getItemsPerPage();
        } elseif (\is_array($object) || $object instanceof \Countable) {
            $totalItems = \count($object);
        }

        return [$paginator, $paginated, $currentPage, $itemsPerPage, $lastPage, $pageTotalItems, $totalItems];
    }
388685
protected function _getMethods($object)
    {
        if (is_string($object)) {
            $className = $object;
        } else {
            $className = get_class($object);
        }
        $methods = get_class_methods($className);

        if (self::$_config['sort']['methods']) {
            sort($methods);
        }
        return $methods;
    }
962055
public function getLabeledPropertiesToBeSet($object)
    {
        return array_filter($this->getLabeledProperties(), function (LabeledPropertyMetadata $labeledPropertyMetadata) use ($object) {
            return true === $labeledPropertyMetadata->getValue($object);
        });
    }
998106
public static function getTransformer($object)
	{
		$class = get_class($object);
		
		if (isset(static::$transformations[$class])) {
			return new static::$transformations[$class];
		}
		
		if (isset($object->transformer)) {
			return new $object->transformer;
		}
		
		return null;
	}
173886
public function methods($object)
    {
        $methods = (new ReflectionClass($object))->getMethods(ReflectionMethod::IS_PUBLIC);

        $iterator = function(ReflectionMethod $method)
        {
            return $method->getName();
        };

        return array_map($iterator, $methods);
    }
821948
protected function processInternal($object) {
		if (is_scalar($object)) {
			return $object;
		} elseif (is_array($object)) {
			return $this->processCollectionType($object, array_keys($object));
		} elseif ($object instanceof \DateTime) {
			return $object->format(DateTimeConverter::DEFAULT_DATE_FORMAT);
		} elseif (is_object($object) && ($object instanceof ArrayCollection)) {
			$arrayRepresentation = $object->toArray();
			return $this->processCollectionType($arrayRepresentation, array_keys($arrayRepresentation));
		} elseif ($object instanceof DataTransferInterface) {
			if (!$this->cacheTagService) {
				$content = $this->processCollectionType($object, $object->getPropertyNamesToBeApiExposed());
			} else {
				$this->cacheTagService->openEnvironment();
				$this->cacheTagService->addEnvironmentCacheTag($object);
				$identifier = md5($this->cacheTagService->createCacheIdentifier([$this->metaDataProcessorGroup, $object]));

				if (!$this->cache->has($identifier)) {
					$content = $this->processCollectionType($object, $object->getPropertyNamesToBeApiExposed());
					$this->cache->set($identifier, $content, $this->cacheTagService->getEnvironmentTags());
				} else {
					$content = $this->cache->get($identifier);
				}
				$this->cacheTagService->closeEnvironment();
			}
			return $content;
		} elseif ($object instanceof UriPointer) {
			return $this->processUriPointer($object);
		} elseif ($object instanceof Resource) {
			return $this->resourceManager->getPublicPersistentResourceUri($object);
		}
	}