Sets the operator value for this AudienceSegmentCriteria.

@param operator   * The comparison operator. This attribute is required.
480870
public void setOperator(com.google.api.ads.admanager.axis.v201811.AudienceSegmentCriteriaComparisonOperator operator) {
        this.operator = operator;
    }
469824
public final void setElevation(StringBuilder contentBuffer) {
        ptValues[GpxMetadata.PTELE] = Double.parseDouble(contentBuffer.toString());
    }
4068
void acceptOperation(StreamSegmentTruncateOperation operation) {
        ensureSegmentId(operation);
        this.startOffset = operation.getStreamSegmentOffset();
        this.isChanged = true;
    }
1217661
public void setOperations(java.util.Collection<BatchReadOperation> operations) {
        if (operations == null) {
            this.operations = null;
            return;
        }

        this.operations = new java.util.ArrayList<BatchReadOperation>(operations);
    }
1029608
public function setOperator(\Sulu\Bundle\ResourceBundle\Entity\Operator $operator)
    {
        $this->operator = $operator;

        return $this;
    }
897986
def operatorLabel( self, operator ):
        
        for key, value in self._operatorMap.items():
            if ( value == operator ):
                return key
        return operator
1037625
def setOperatorType( self, operatorType ):
        
        op_name = Q.Op[operatorType]
        op_name = projex.text.joinWords(op_name, ' ').lower()
        self.setText(1, op_name)
1089107
function (operator) {
            var name = operator.operator,
                ret = {},
                field;
            if (name === "and" || name === "or" || name === "not") {
                ret["$" + name] = this.translateExpressions(operator.expressions);
            } else if (name === "eql") {
                field = operator.field;
                ret[field] = operator.value;
            } else if (QuerytoMongoMap.hasOwnProperty(name)) {
                field = operator.field;

                ret[field] = {};
                ret[field][QuerytoMongoMap[name]] = operator.value;
            } else if (name === "between") {
                field = operator.field;
                ret[field].$gt = operator.value[0];
                ret[field].$lt = operator.value[1];
            } else if (name === "like") {
                field = operator.field;
                ret[field] = {};
                ret[field].$regex = new RegExp(".*" + operator.value + ".*", "i");
            } else {
                throw new Error("Query Operator '" + name + "' is not supported!");
            }

            return ret;
        }
781717
private void processOperandValue(int index, FieldType type, GraphicalIndicatorCriteria criteria)
   {
      boolean valueFlag = (MPPUtility.getInt(m_data, m_dataOffset) == 1);
      m_dataOffset += 4;

      if (valueFlag == false)
      {
         int fieldID = MPPUtility.getInt(m_data, m_dataOffset);
         criteria.setRightValue(index, FieldTypeHelper.getInstance(fieldID));
         m_dataOffset += 4;
      }
      else
      {
         //int dataTypeValue = MPPUtility.getShort(m_data, m_dataOffset);
         m_dataOffset += 2;

         switch (type.getDataType())
         {
            case DURATION: // 0x03
            {
               Duration value = MPPUtility.getAdjustedDuration(m_properties, MPPUtility.getInt(m_data, m_dataOffset), MPPUtility.getDurationTimeUnits(MPPUtility.getShort(m_data, m_dataOffset + 4)));
               m_dataOffset += 6;
               criteria.setRightValue(index, value);
               break;
            }

            case NUMERIC: // 0x05
            {
               Double value = Double.valueOf(MPPUtility.getDouble(m_data, m_dataOffset));
               m_dataOffset += 8;
               criteria.setRightValue(index, value);
               break;
            }

            case CURRENCY: // 0x06
            {
               Double value = Double.valueOf(MPPUtility.getDouble(m_data, m_dataOffset) / 100);
               m_dataOffset += 8;
               criteria.setRightValue(index, value);
               break;
            }

            case STRING: // 0x08
            {
               String value = MPPUtility.getUnicodeString(m_data, m_dataOffset);
               m_dataOffset += ((value.length() + 1) * 2);
               criteria.setRightValue(index, value);
               break;
            }

            case BOOLEAN: // 0x0B
            {
               int value = MPPUtility.getShort(m_data, m_dataOffset);
               m_dataOffset += 2;
               criteria.setRightValue(index, value == 1 ? Boolean.TRUE : Boolean.FALSE);
               break;
            }

            case DATE: // 0x13
            {
               Date value = MPPUtility.getTimestamp(m_data, m_dataOffset);
               m_dataOffset += 4;
               criteria.setRightValue(index, value);
               break;
            }

            default:
            {
               break;
            }
         }
      }
   }
691421
public void setStreamSegmentId(long value) {
        Preconditions.checkState(this.streamSegmentId == ContainerMetadata.NO_STREAM_SEGMENT_ID, "StreamSegmentId has already been assigned for this operation.");
        Preconditions.checkArgument(value != ContainerMetadata.NO_STREAM_SEGMENT_ID, "Invalid StreamSegmentId");
        this.streamSegmentId = value;
    }
1343488
public static org.fcrepo.server.types.gen.Condition convertConditionToGenCondition(Condition condition) {
        String opAbbr = condition.getOperator().getAbbreviation();

        ComparisonOperator compOperator;
        try {
            compOperator = ComparisonOperator.fromValue(opAbbr);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("unrecognized comparison operator string: '"
                    + opAbbr + "'");
        }
        org.fcrepo.server.types.gen.Condition cond = new org.fcrepo.server.types.gen.Condition();
        cond.setProperty(condition.getProperty());
        cond.setOperator(compOperator);
        cond.setValue(condition.getValue());
        return cond;
    }
228723
def set_operator(self, operator):
        
        cairo.cairo_set_operator(self._pointer, operator)
        self._check_status()
669406
public function setFilterDefaultOperation($operator)
    {
        if (! in_array($operator, Filter::AVAILABLE_OPERATORS)) {
            throw new \InvalidArgumentException(sprintf('Invalid filter operator \'%s\'', strval($operator)));
        }

        $this->filterDefaultOperation = $operator;

        return $this;
    }
1049815
def _do_operator_comparison(operator_type, operator_name, comparison_value):
    
    def fallback(*args, **kwargs):
        raise AssertionError("Operator {0} does not exist for type {1}".format(
            operator_name, operator_type.__class__.__name__))
    method = getattr(operator_type, operator_name, fallback)
    if getattr(method, 'input_type', '') == FIELD_NO_INPUT:
        return method()
    return method(comparison_value)
1058343
private static String validateOperator(final String operator) {
        if (!OPERATORS.contains(operator) && !BOOLEAN_OPERATORS.contains(operator)) {
            throw new CitrusRuntimeException("Unknown operator '" + operator + "'");
        }
        return operator;
    }
408606
public Criteria addProperty(String name, String value, Operator operator) {
        properties.add(new PropertyCriteria(name, value, operator));
        return this;
    }
813877
public function addLogicalOperator($operator)
    {
        if ($this->_mode === self::GM_SIGNS) {
            include_once 'Zend/Search/Lucene/Search/QueryParserException.php';
            throw new Zend_Search_Lucene_Search_QueryParserException('It\'s not allowed to mix boolean and signs styles in the same subquery.');
        }

        $this->_mode = self::GM_BOOLEAN;

        $this->_entries[] = $operator;
    }