{@inheritDoc}
@see \rocket\ei\manage\gui\EiEntryGuiListener::finalized()
541422
public function finalized(EiEntryGui $eiEntryGui) {
		if ($this->whenReadyClosure === null) return;
		
		$this->call($this->whenReadyClosure);
		
		if ($this->onSaveClosure === null || $this->savedClosure === null) {
			$eiEntryGui->unregisterEiEntryGuiListener($this);
		}
	}
110776
public function isFinalized($error = false)
    {
        if ($this->finalized && $error) {
            $this->triggerError($error, E_USER_ERROR);
        }
        return $this->finalized;
    }
53672
final public static function end()
    {
        $finalTime     = self::getTime();
        $execTime      = $finalTime - self::$time;
        $msgTranslated = new Internationalization("seconds");
        
        return number_format($execTime, 6) . " " . $msgTranslated;
    }
81449
public function completed()
    {
        $resource = $this->getActionExecution();
        if ($resource === null) {
            $requiredActionClass = new \core_kernel_classes_Class(self::CLASS_URI);
            $resource = $requiredActionClass->createInstanceWithProperties(array(
                self::PROPERTY_SUBJECT => $this->getUser()->getIdentifier(),
                self::PROPERTY_NAME => $this->requiredAction->getName(),
                self::PROPERTY_EXECUTION_TIME => time(),
            ));
        }
        $timeProperty = (new \core_kernel_classes_Property(self::PROPERTY_EXECUTION_TIME));
        $resource->editPropertyValues($timeProperty, time());
        return $resource;
    }
1333966
public function finalize()
	{
		$tag = $this->getTag();

		if (!isset($tag->template))
		{
			$tag->template = $this->getTemplate();
		}
	}
1121201
public function finalize() {
        if (!$this->isFinalized) {
            if (strlen($this->streamFilePath) > 0) {
                $this->closeStream();
            }
            $cd = implode("", $this->cdRec);

            $cdRecSize = pack("v", sizeof($this->cdRec));
            $cdRec = $cd . self::ZIP_END_OF_CENTRAL_DIRECTORY
                     . $cdRecSize . $cdRecSize
                     . pack("VV", strlen($cd), $this->offset);
            if (!empty($this->zipComment)) {
                $cdRec .= pack("v", strlen($this->zipComment)) . $this->zipComment;
            } else {
                $cdRec .= "\x00\x00";
            }

            $this->zipwrite($cdRec);

            $this->isFinalized = TRUE;
            $this->cdRec = NULL;

            return TRUE;
        }
        return FALSE;
    }
335040
public function finalize()
    {
        $gen = new UrlGenerator();
        if (!empty($this->redirect)) {
            $gen->redirect($this->redirect);
        }
    }
1065065
public function finalize()
    {
        foreach ($this->getGroups() as $group) {
            foreach ($group->getMiddleware() as $middleware) {
                array_unshift($this->middleware, $middleware);
            }
        }
        foreach ($this->getMiddleware() as $middleware) {
            $this->addMiddleware($middleware);
        }
    }
665347
public function complete()
    {
        $this->io->write('<info>Summary :</info>');
        foreach ($this->getConfigKey('Placeholders') as $placeholder) {
            $this->io->write(
                sprintf(
                    '%1$s: <info>%2$s</info>',
                    $placeholder['name'],
                    $placeholder['value']
                )
            );
        }
    }
11663
public function finalize()
    {
        list($usec, $sec) = explode(' ', microtime());
        $micro = sprintf("%06d", $usec * 1000000);
        $when = new \DateTime(date('Y-m-d H:i:s.' . $micro));
        $when->setTimezone(new \DateTimeZone('UTC'));
        $this->finalTime = $when->format('Y-m-d\TH:i:s.u\Z');
        $this->isFinalState = true;
    }
509659
public function finalize() : Values
    {
        /* @var input\Parameter $parameter */
        foreach ($this->definitions as $name => $parameter) {
            if (isset($this->items[$name])) {
                continue;
            }

            // In the case of Parameters which do not accept values (ie. optional flags), we explicitly default them
            // to a boolean false, opposed to a boolean true when they are actually set in input.
            $this->items[$name] = ($value = $parameter->getValue()) ? $value->getDefault() : false;
        }

        return $this;
    }
325904
public function finalize(string $tableName = null): FinalizedMapperDefinition
    {
        $this->verifyDefinedClass();

        $tableName = $tableName ?: $this->tableName;

        $allMappedProperties = $this->getAllMappedProperties();

        foreach ($this->class->getProperties() as $property) {
            $propertyName = $property->getName();

            if ($this->verifyAllPropertiesMapped && !isset($allMappedProperties[$propertyName])) {
                throw IncompleteMapperDefinitionException::format(
                    'Invalid mapper definition for %s: unmapped property \'%s\' of type %s, call $map->ignoreUnmappedProperties() to ignore this warning',
                    $this->class->getClassName(),
                    $propertyName,
                    $property->getType()->asTypeString()
                );
            }
        }

        $table = new Table(
            $this->orm->getNamespace() . $tableName,
            $this->columns,
            $this->indexes,
            $this->foreignKeys
        );

        $relationsFactory = function (Table $table, IObjectMapper $parentMapper) {
            $objectType = $parentMapper->getObjectType();
            $tableName  = $parentMapper->getDefinition()->getTable()->getName();

            $relations = [];
            foreach ($this->relationFactories as $factory) {
                $relationId  = implode(':', [$objectType, $tableName, $this->getRootDefinition()->relationCount++]);
                $relations[] = $factory($relationId, $table, $parentMapper);
            }

            return $relations;
        };

        $foreignKeysFactory = function (Table $table) {
            $foreignKeys = [];

            foreach ($this->foreignKeyFactories as $factory) {
                /** @var ForeignKey $foreignKey */
                $foreignKey    = $factory($table);
                $foreignKeys[] = $foreignKey->withNamePrefixedBy($this->orm->getNamespace());
            }

            return $foreignKeys;
        };

        $persistHooks = [];
        foreach ($this->persistHookFactories as $uniqueKey => $factory) {
            $persistHooks[] = $factory($table, $uniqueKey, $this->propertyColumnMap, $this->class->getClassName());
        }

        $subClassMappings = [];
        foreach ($this->subClassMappingFactories as $factory) {
            $subClassMappings[] = $factory($table);
        }

        return new FinalizedMapperDefinition(
            $this->orm,
            $this->class,
            $table,
            $this->propertyColumnMap,
            $this->columnGetterMap,
            $this->columnSetterMap,
            $this->phpToDbPropertyConverterMap,
            $this->dbToPhpPropertyConverterMap,
            $this->methodColumnMap,
            $this->customLoadMappingCallbacks,
            $this->lockingStrategies,
            $persistHooks,
            $subClassMappings,
            $relationsFactory,
            $foreignKeysFactory
        );
    }
97387
private function finalise()
    {
        // Send output to email
        $this->emailOutput();

        // Call any callback defined
        if (is_callable($this->after)) {
            call_user_func($this->after, $this->output, $this->returnCode);
        }
    }
1260437
function finalize($responses) {
        if(!empty($this->responses)) {
            $this->deleteRemainingResponses();
        }
        
        if(\is_array($responses)) {
            foreach($responses as $response) {
                /** @var \CharlotteDunois\Yasmin\Models\Message  $msg */
                $msg = (\is_array($response) ? $response[0] : $response);
                
                if(!($msg instanceof \CharlotteDunois\Yasmin\Models\Message)) {
                    continue;
                }
                
                $id = $this->getChannelIDOrDM($msg->channel);
                
                if(empty($this->responses[$id])) {
                    $this->responses[$id] = array();
                }
                
                $this->responses[$id][] = $response;
            }
        } elseif($responses !== null) {
            if(!($responses instanceof \CharlotteDunois\Yasmin\Models\Message)) {
                return;
            }
            
            $id = $this->getChannelIDOrDM($responses->channel);
            $this->responses[$id] = array($responses);
        }
    }
676209
private function complete()
    {
        if ($this->complete) {
            $message = "Iterator has already been completed";

            if (isset($this->resolutionTrace)) {
                $trace = formatStacktrace($this->resolutionTrace);
                $message .= ". Previous completion trace:\n\n{$trace}\n\n";
            } else {
                // @codeCoverageIgnoreStart
                $message .= ", define environment variable AMP_DEBUG or const AMP_DEBUG = true and enable assertions "
                    . "for a stacktrace of the previous resolution.";
                // @codeCoverageIgnoreEnd
            }

            throw new \Error($message);
        }

        \assert((function () {
            $env = \getenv("AMP_DEBUG") ?: "0";
            if (($env !== "0" && $env !== "false") || (\defined("AMP_DEBUG") && \AMP_DEBUG)) {
                $trace = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS);
                \array_shift($trace); // remove current closure
                $this->resolutionTrace = $trace;
            }

            return true;
        })());

        $this->complete = new Success(false);

        if ($this->waiting !== null) {
            $waiting = $this->waiting;
            $this->waiting = null;
            $waiting->resolve($this->complete);
        }
    }
897427
public function finalize($singular = false)
    {
        $this->finalized = true;

        if ($singular === true) {
            $text = ' />';
        } else {
            $text = '>';
        }

        $this->append($text);
        return $this;
    }
1240072
def finalize(self):
        
        self.pickButton.clicked.disconnect(self.execFontDialog)
        super(FontCtiEditor, self).finalize()