[[@doctodo method_description:isActuallyDirty]].

@return [[@doctodo return_type:isActuallyDirty]] [[@doctodo return_description:isActuallyDirty]]
168391
public function isActuallyDirty()
    {
        $values = $this->owner->getDirtyAttributes();
        if (isset($this->fields['modifiedField'])) {
            unset($values[$this->fields['modifiedField']]);
        }
        if (isset($this->fields['modifiedByField'])) {
            unset($values[$this->fields['modifiedByField']]);
        }
        if (isset($this->fields['createdField'])) {
            unset($values[$this->fields['createdField']]);
        }
        if (isset($this->fields['createdByField'])) {
            unset($values[$this->fields['createdByField']]);
        }

        return !empty($values);
    }
820151
public function getDirty()
    {
        $dirty = [];
        foreach ($this->getCurrent() as $key => $value) {

            // Value is a default value and `no_saving_default_values` option has been enabled
            if (array_key_exists('no_saving_default_values', $this->internal_options)
                && $this->internal_options['no_saving_default_values']
                && array_key_exists($key, $this->internal_defaults)
                && $this->internal_defaults[$key] === $value) {
                // Do nothing
            }

            // Existing value has changed
            elseif (array_key_exists($key, $this->internal_original_data)
                && $this->internal_original_data[$key] !== $value) {
                $dirty[$key] = $value;
            }

            // New value that has been assigned
            elseif (!array_key_exists($key, $this->internal_original_data)) {
                $dirty[$key] = $value;
            }
        }

        return $dirty;
    }
1367780
public function getDirty()
	{
		// Kinvey needs all of the model's attributes for update operations
		// see (http://devcenter.kinvey.com/rest/guides/datastore#Saving).

		$dirty = $this->attributes;

		if (array_key_exists(static::UPDATED_AT, $dirty)) unset($dirty[static::UPDATED_AT]);

		return $dirty;
	}
563014
private function getDirective()
    {
        switch (strtolower($this->type)) {
            case 'digest':
                return 'Digest ' . $this->buildDirectiveParameters(array(
                    'realm' => $this->realm,
                    'qop' => 'auth',
                    'nonce' => uniqid(),
                    'opaque' => md5($this->realm),
                ));

            default:
                return 'Basic ' . $this->buildDirectiveParameters(array(
                    'realm' => $this->realm
                ));
        }
    }
834286
public function listMissingMethod()
    {
        if (!is_null($this->listMissingMethod)) return $this->listMissingMethod;

        $required = $this->listRequiredMethod();
        $missing = array();

        foreach ($required as $methodName => $data) {
            if (!$this->reflection->hasMethod($methodName)) {
                $missing[$methodName] = $data;
            }
        }

        $this->listMissingMethod = $missing;

        return $missing;
    }
438329
public function getReverseDiff()
    {
        $diff = new self();
        $diff->setAddedTables($this->getRemovedTables());
        // idMethod is not set for tables build from reverse engineering
        // FIXME: this should be handled by reverse classes
        foreach ($diff->getAddedTables() as $name => $table) {
            if ($table->getIdMethod() == IDMethod::NO_ID_METHOD) {
                $table->setIdMethod(IDMethod::NATIVE);
            }
        }
        $diff->setRemovedTables($this->getAddedTables());
        $diff->setRenamedTables(array_flip($this->getRenamedTables()));
        $tableDiffs = array();
        foreach ($this->getModifiedTables() as $name => $tableDiff) {
            $tableDiffs[$name] = $tableDiff->getReverseDiff();
        }
        $diff->setModifiedTables($tableDiffs);

        return $diff;
    }
181395
final function isActive() {return /** @var int $y1 */ /** @var int $y2 */
		($y1 = df_year()) < ($y2 = $this->expYear()) || ($y1 === $y2 && df_month() <= $this->expMonth())
	;}
325900
public function getFullDescription()
    {
        if ($this->_description) {
            return $this->_description;
        }

        $descr        = $this->getRoundDescription();
        $hasDescr     = strlen(trim($descr));
        $order        = $this->getRoundOrder();
        $survey       = $this->getSurvey();
        $surveyExists = $survey ? $survey->exists : false;

        if ($order) {
            if ($hasDescr) {
                if ($surveyExists) {
                    $this->_description = sprintf($this->_('%d: %s - %s'), $order, $descr, $survey->getName());
                } else {
                    $this->_description = sprintf($this->_('%d: %s'), $order, $descr);
                }
            } elseif ($surveyExists) {
                $this->_description = sprintf($this->_('%d: %s'), $order, $survey->getName());
            } else {
                $this->_description = $order;
            }
        } elseif ($hasDescr) {
            if ($surveyExists) {
                $this->_description = sprintf($this->_('%s - %s'), $descr, $survey->getName());
            } else {
                $this->_description = $descr;
            }
        } else {
            if ($surveyExists) {
                $this->_description = $survey->getName();
            } else {
                $this->_description = '';
            }
        }

        return $this->_description;
    }
1047230
public function get_active_method() {
        global $DB;

        $this->ensure_isset(array('context', 'component', 'area'));

        // get the current grading area record if it exists
        if (is_null($this->areacache)) {
            $this->areacache = $DB->get_record('grading_areas', array(
                'contextid' => $this->context->id,
                'component' => $this->component,
                'areaname'  => $this->area),
            '*', IGNORE_MISSING);
        }

        if ($this->areacache === false) {
            // no area record yet
            return null;
        }

        return $this->areacache->activemethod;
    }
987935
public function isAlpha() {
        $this->check_role = 'alpha';
        $result = $this->checkRegex($this->value, '/^[A-Za-z]+$/');
        $this->checkResult($result);
        return $this;
    }
296240
public static function isArchive()
    {
        global $archive;
        global $post;

        if (defined('DOING_AJAX') && DOING_AJAX) {
            $archive = !is_numeric($_POST['id']) ? $_POST['id'] : '';
        }

        if (substr($archive, 0, 8) == 'archive-' || is_search()) {
            return $archive;
        }

        if (is_archive() && (is_object($post) && $post->post_type == 'post')) {
            return 'archive';
        } elseif (is_search() || (is_object($post) && is_post_type_archive($post->post_type))) {
            return 'archive-' . $post->post_type;
        } elseif (isset($_GET['id']) && $_GET['id'] == 'author') {
            return 'author';
        }

        return false;
    }
1218812
public function isDirty() : bool
    {
        foreach ($this->__state as $prop => $val) {
            if ($this->isModified($prop)) {
                return true;
            }
        }
        return false;
    }
1062871
public function getDirty()
    {
        $dirty    = [];
        $original = $this->getCastedOriginal();

        foreach ($this->attributes as $key => $value) {
            if ($this->hasCast($key, $value)) {
                $value = $this->castAttribute($key, $value);
            }

            if (
                ! array_key_exists($key, $original) ||
                ($value !== $original[$key] && ! $this->originalIsNumericallyEquivalent($key))
            ) {
                $dirty[$key] = $value;
            }
        }

        return $dirty;
    }
294806
private function ArchiveCategoryValue()
    {
        if (!$this->articleList->Exists()) {
            return '';
        }
        $archive = Archive::Schema()->ByPage($this->Page());
        if ($archive) {
            return $archive->GetID();
        }
        $category = Category::Schema()->ByPage($this->Page());
        if ($category) {
            return $category->GetArchive()->GetID() . '-' .
                    $category->GetID();
        }
    }
793774
public function getDefaultSorting()
    {
        $sorting = parent::getDefaultSorting();
        $activeCategory = $this->getActiveCategory();

        if ($this->getListType() != 'search' && $activeCategory && $activeCategory instanceof \OxidEsales\Eshop\Application\Model\Category) {
            if ($categorySorting = $activeCategory->getDefaultSorting()) {
                $sortingDirection = ($activeCategory->getDefaultSortingMode()) ? "desc" : "asc";
                $sorting = ['sortby' => $categorySorting, 'sortdir' => $sortingDirection];
            }
        }

        return $sorting;
    }
1096156
public function isDirty()
    {
        if (
            !empty($this->_dirtyAttr) ||
            (($this instanceof DeleteBySaving) && $this->isDeleted())
        ) {
            return true;
        }

        foreach (array_keys(get_object_vars($this)) as $key) {
            foreach ((array) $this->$key as $sub) {
                if (($sub instanceof DirtyAware) && $sub->isDirty()) {
                    return true;
                }
            }
        }
        return false;
    }
109387
protected function evalManageMode()
    {
        if ($mode = post(self::PARAM_MODE)) {
            return $mode;
        }

        if ($this->forceManageMode) {
            return $this->forceManageMode;
        }

        switch ($this->eventTarget) {
            case 'button-create':
            case 'button-update':
                return 'form';

            case 'button-link':
                return 'list';
        }

        switch ($this->relationType) {
            case 'belongsTo':
                return 'list';

            case 'morphToMany':
            case 'morphedByMany':
            case 'belongsToMany':
                if (isset($this->config->pivot)) {
                    return 'pivot';
                }
                elseif ($this->eventTarget == 'list') {
                    return 'form';
                }
                else {
                    return 'list';
                }

            case 'hasOne':
            case 'morphOne':
            case 'hasMany':
            case 'morphMany':
                if ($this->eventTarget == 'button-add') {
                    return 'list';
                }

                return 'form';
        }
    }