Returns the real object.

@return object
425571
public function getObject()
    {
        if ($this->thawedObject === null) {
            $this->thawedObject = $this->storage->fetch($this->id);
        }

        return $this->thawedObject;
    }
1205317
public function toObject()
    {
        $obj = new stdClass();

        if (! empty($this->attributes)) {
            foreach ($this->attributes as $key => $value) {
                $obj->$key = $value;
            }
        }

        return $obj;
    }
882668
public static function getInstance()
    {
        if (empty(static::$instance)) {
            $className = get_called_class();

            static::$instance = new $className();

            if (method_exists(static::$instance, '__reconstruct')) {
                call_user_func_array([&static::$instance, '__reconstruct'], func_get_args());
            }
        }

        return static::$instance;
    }
1285358
public function getAuthObject()
    {
        if (!$this->_resultRow) {
            return false;
        }

        if (null === $this->_tableName || null === $this->_identityColumn || null === $this->_identity) {
            return false;
        }

        $dbSelect = \Doctrine_Query::create()
                ->from("$this->_tableName table")
                ->where("table.$this->_identityColumn = ?", $this->_identity);

        foreach ($this->_conditions as $condition => $value) {
            $dbSelect->addWhere($condition, $value);
        }

        $returnObject = $dbSelect->fetchOne();

        if ($returnObject) {
            return $returnObject;
        } else {
            return false;
        }
    }
936104
public function current()
    {
        $data = $this->dataSource->current();
        $object = null;

        if (is_array($data)) {
            $object = $this->getPrototypeStrategy()->createObject($this->getObjectPrototype(), $data);
            $this->getHydrator()->hydrate($data, $object);
        }

        return $object;
    }
1346517
public function toObject()
    {
        $output = array('cols' => array(), 'rows' => array());

        // Column Definitions
        foreach ($this->columns as $inputColumn) {
            $output['cols'][] = $inputColumn->toDefinitionObject();
        }

        // Rows
        foreach ($this->rows as $inputRow) {
            $row = array('c' => array());
            foreach ($inputRow->getCells() as $i => $cell) {
                if (null === $cell) {
                    $row['c'][] = null;
                } else {
                    $colType = $this->columns[$i]->getType();
                    $outputCell = array('v' => $colType->convertToCellValue($cell));
                    $stringVal = $colType->convertToStringVersion($cell);
                    if ($stringVal != null) {
                        $outputCell['f'] = trim($stringVal);
                    }
                    $row['c'][] = (object) $outputCell;
                }
            }

            $output['rows'][] = (object) $row;
        }

        return (object) $output;
    }
526282
public function &GetSpotObject()
    {
        $oObject = &$this->GetFromInternalCache('oObjectAssignedToSpot');
        if (is_null($oObject)) {
            $oObject = $this->GetFieldLinkedRecord();
            $this->SetInternalCache('oObjectAssignedToSpot', $oObject);
        }

        return $oObject;
    }
321153
public function top()
    {
        $objects = array_values($this->_data);

        $object = null;
        if (isset($objects[0])) {
            $object = $objects[0];
        }

        return $object;
    }
864796
public static function getInstance() {
        if( is_null(self::$_oInstance) ) {
            $c = __CLASS__;
            self::$_oInstance = new $c;
        }
        return self::$_oInstance;
    }
336602
public function getRegisteredObject()
    {
        if($this->registeredObject == null)
        {
            $di = jaxon()->di();
            // Use the Reflection class to get the parameters of the constructor
            if(($constructor = $this->reflectionClass->getConstructor()) != null)
            {
                $parameters = $constructor->getParameters();
                $parameterInstances = [];
                foreach($parameters as $parameter)
                {
                    // Get the parameter instance from the DI
                    $parameterInstances[] = $di->get($parameter->getClass()->getName());
                }
                $this->registeredObject = $this->reflectionClass->newInstanceArgs($parameterInstances);
            }
            else
            {
                $this->registeredObject = $this->reflectionClass->newInstance();
            }
        }
        return $this->registeredObject;
    }
205671
public function obj()
    {
        if ($this->obj === null) {
            $objId   = filter_input(INPUT_GET, 'obj_id', FILTER_SANITIZE_STRING);
            $objType = filter_input(INPUT_GET, 'obj_type', FILTER_SANITIZE_STRING);
            if ($objId && $objType) {
                $obj = $this->modelFactory()->create($objType);
                $obj->load($objId);

                $this->obj = $obj;
            } else {
                throw new InvalidArgumentException('Missing Object Type or ID');
            }
        }

        return $this->obj;
    }
587542
public function getResultObject()
    {
        if (!isset($this->_dataObject) && !empty($this->result)) {
            $this->_dataObject = unserialize($this->result);
        } elseif (!isset($this->_dataObject)) {
            $this->_dataObject = new Result;
        }
        $this->_dataObject->model = $this;

        return $this->_dataObject;
    }
546333
public static function getInstance()
    {
        $self = get_called_class();
        if (!isset(self::$instances[$self])) {
            self::$instances[$self] = new $self;
        }
        return self::$instances[$self];
    }
993580
public function get() {
		if ($this->active) $this->stop();

		foreach (array_keys($this->data) as $key) {
			$row =& $this->data[$key];
			$row['realtime_ms'] = $row['realtime']*1000;
			if (is_numeric($row['proctime'])) {
				$row['proctime_ms'] = $row['proctime']*1000;
			} else {
				$row['proctime_ms'] = 'n/a';
			}
		}

		$returner = $this->data;
		unset($this->data);
		
		return $returner;
	}
694709
public function build(): object
    {
        $object = $this->instanciator->build($this->class, $this->properties);
        $parameters = $this->instanciator->parameters($this->class);

        //avoid injecting the properties already used in the constructor
        $properties = $this
            ->properties
            ->filter(function(string $property) use ($parameters) {
                return !$parameters->contains($property);
            });
        $refl = new ReflectionObject(
            $object,
            $properties,
            $this->injectionStrategy
        );

        return $refl->build();
    }
1184047
public static function instance()
    {
        if (self::$instance) {
            return self::$instance;
        }

        //set up a proper instance
        self::$instance = new self;

        return self::$instance;
    }
728062
public function getDescriptor()
    {
        if (is_null($this->_descriptor) && isset($this->object)) {
            $this->_descriptor = $this->object->descriptor;
        }

        return $this->_descriptor;
    }