Gets the operation value for this ChangeHistoryValue.

@return operation
501072
public com.google.api.ads.admanager.axis.v201808.ChangeHistoryOperation getOperation() {
        return operation;
    }
619660
public function process()
    {
        $operands = $this->getOperands();

        if (count($operands) === 0) {
            return null;
        }

        if ($operands->exclusivelySingleOrMultiple() === false) {
            $msg = "The Multiple operator only accepts operands with single or omultiple cardinality.";
            throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_CARDINALITY);
        }

        $refType = null;
        $returnValue = null;

        foreach ($operands as $operand) {

            if (is_null($operand) || ($operand instanceof MultipleContainer && $operand->isNull())) {
                // As per specs, ignore.
                continue;
            } else {
                if ($refType !== null) {
                    // A reference type as already been identified.
                    if (CommonUtils::inferBaseType($operand) === $refType) {
                        // $operand can be added to $returnValue.
                        static::appendValue($returnValue, $operand);
                    } else {
                        // baseType mismatch.
                        $msg = "The Multiple operator only accepts values with a similar baseType.";
                        throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_BASETYPE);
                    }
                } elseif (($discoveryType = CommonUtils::inferBaseType($operand)) !== false) {
                    // First value being identified as non-null.
                    $refType = $discoveryType;
                    $returnValue = new MultipleContainer($refType);
                    static::appendValue($returnValue, $operand);
                }
            }
        }

        return $returnValue;
    }
44589
public function getFirstOperation()
    {
        $returnValue = null;

        
        if(empty($this->firstOperation)){
        	$property = new core_kernel_classes_Property(RulesRdf::PROPERTY_OPERATION_FIRST_OP);
        	$resource = $this->getUniquePropertyValue($property);
        	$this->firstOperation = new core_kernel_rules_Term($resource->getUri());
        }
        $returnValue = $this->firstOperation;
        

        return $returnValue;
    }
452150
protected function getPrev()
    {
        if (!$this->current)
        {
            return null;
        }
        if ($this->prev !== -1)
        {
            return $this->prev;
        }
        $this->load();
        for ($i = 0; $i < count($this->items); $i++)
        {
            if ($this->items[$i]->id == $this->current->id)
            {
                if ($i > 0)
                {
                    $this->prev = $this->items[$i - 1];
                    return $this->prev;
                }
                break;
            }
        }
        return null;
    }
1270762
public final function getOrgValue() {
		if ($this->orgValueLoaded) {
			return $this->orgValue;
		}

		$this->orgValue = $this->readValue();
		$this->orgValueLoaded = true;
		return $this->orgValue;
	}
1202838
public function getOperator()
    {
        $returnValue = null;

        
        if(empty($this->arithmeticOperator)){
        	$property = new core_kernel_classes_Property(RulesRdf::PROPERTY_OPERATION_OPERATOR);
        	$this->arithmeticOperator = $this->getUniquePropertyValue($property);
        }
        $returnValue = $this->arithmeticOperator;
        

        return $returnValue;
    }
1292306
public ListenableFuture<ChangeRequestsSnapshot<DataSegmentChangeRequest>> getSegmentChangesSince(ChangeRequestHistory.Counter counter)
  {
    if (counter.getCounter() < 0) {
      synchronized (lock) {
        Iterable<DataSegmentChangeRequest> segments = Iterables.transform(
            segmentLookup.keySet(),
            new Function<DataSegment, DataSegmentChangeRequest>()
            {
              @Nullable
              @Override
              public SegmentChangeRequestLoad apply(DataSegment input)
              {
                return new SegmentChangeRequestLoad(input);
              }
            }
        );

        SettableFuture<ChangeRequestsSnapshot<DataSegmentChangeRequest>> future = SettableFuture.create();
        future.set(ChangeRequestsSnapshot.success(changes.getLastCounter(), Lists.newArrayList(segments)));
        return future;
      }
    } else {
      return changes.getRequestsSince(counter);
    }
  }
726183
public function getTime()
    {
        // Time should only be used with the history state.
        if (!$this->isHistory()) {
            return new DateTime('now');
        }

        $timestamp = $this->session->get($this->timePersistenceKey, time());

        return (new DateTime())->setTimestamp($timestamp);
    }
103128
@Override
	public Long getValue() {
		final JobStatus status = eg.getState();

		if (status == JobStatus.RUNNING) {
			// running right now - report the uptime
			final long runningTimestamp = eg.getStatusTimestamp(JobStatus.RUNNING);
			// we use 'Math.max' here to avoid negative timestamps when clocks change
			return Math.max(System.currentTimeMillis() - runningTimestamp, 0);
		}
		else if (status.isTerminalState()) {
			// not running any more -> finished or not on leader
			return NO_LONGER_RUNNING;
		}
		else {
			// not yet running or not up at the moment
			return 0L;
		}
	}
1005678
public function getConvertedFromValue()
    {
        if ($this->valueHasBeenConverted === false) {
            $value = $this->executeValueConversion();

            $this->convertedFromValue = $value[0];
            $this->convertedToValue = $value[1];

            $this->valueHasBeenConverted = true;
        }

        return $this->convertedFromValue;
    }
1071958
public function _mergeWithPrevious($previous)
    {
        if (!$previous)
        {
            return $this;
        }
        if ($previous instanceof DeleteOperation)
        {
            return new SetOperation($this->value);
        }
        if ($previous instanceof SetOperation)
        {
            return new SetOperation($previous->getValue() + $this->value);
        }
        if ($previous instanceof IncrementOperation)
        {
            return new IncrementOperation($previous->getValue() + $this->value);
        }
        throw new AVException('Operation is invalid after previous operation.');
    }
1019503
public BaseField getHistorySourceDate()
    {
        if (m_fldSourceHistoryDate == null)
        {
            if (m_iSourceDateSeq != null)
                m_fldSourceHistoryDate = this.getOwner().getField(m_iSourceDateSeq);
            else if (this.getHistoryRecord() instanceof VirtualRecord)
                m_fldSourceHistoryDate = this.getOwner().getField(VirtualRecord.LAST_CHANGED);
        }
        return m_fldSourceHistoryDate;
    }
1189323
protected function evaluateOperations()
    {
        while ($op = array_shift($this->operations)) {
            $operation = $this->operationResolver->resolveOperation($op['name'], $this->context);
            $lastOperationResult = $operation->evaluate($this, $op['arguments']);
        }
        return $lastOperationResult;
    }
4831
public function getCurrent()
	{
		if ( ! $this->iterationStarted || is_null( $this->current ) )
			throw new InvalidOperationException();
		return $this->current->Current;
	}
802325
public function getLogicalOperator()
    {
        $returnValue = null;

        
         if(empty($this->logicalOperator)){
         	$property = new core_kernel_classes_Property(RulesRdf::PROPERTY_HASLOGICALOPERATOR);
			$this->logicalOperator = $this->getUniquePropertyValue($property);
         }
         $returnValue = $this->logicalOperator;
        

        return $returnValue;
    }
244524
public function getLastMoveIndex()
    {
        $move_history = $this->getMoveHistory();

        // get last value
        $last_move = end($move_history);

        // reset pointer
        reset($this->moves);

        return $last_move;
    }
1067928
public function getChangedFields() {
        if($this->isAfterSave() && method_exists($this->getEntity(), 'getUpdatedFields')) {
            if($this->getEntity()->hasSnapshotData()) {
                $actualChangedFields = $this->getEntity()->getUpdatedFields();
            } else {
                $actualChangedFields = $this->getSnapshotData();
            }
        } else { //Legacy
            $actualChangedFields = $this->getEntity()->getChangedFields();
        }
        $model = $this->getEntity();
        foreach($actualChangedFields as $index => $changedField) {
            $newValue = $model->readAttribute($changedField);
            if(is_array($newValue)) {
                $newValue = json_encode($newValue);
            }
            $oldValue = $this->getSnapshotData()[$changedField] ?? null ?? null;
            if(is_object($oldValue)) {
                $oldValue = (string)$oldValue;
            }
            if(is_object($newValue)) {
                $newValue = (string)$newValue;
            }
            if(is_bool($oldValue) || is_bool($newValue)){
                $oldValue = (bool) $oldValue;
                $newValue = (bool) $newValue;
            }
            if($oldValue === $newValue) {
                unset($actualChangedFields[$index]);
            }

        }
        return array_values($actualChangedFields);
    }