Gets the criterionUse value for this AdGroupCriterion.

@return criterionUse   * <span class="constraint ReadOnly">This field is read only and
will be ignored when sent to the API.</span>
186358
public com.google.api.ads.adwords.axis.v201809.cm.CriterionUse getCriterionUse() {
        return criterionUse;
    }
92044
public function getUsabilityScore()
    {
        $ruleGroups = $this->getRuleGroups();

        if (!array_key_exists(RuleGroup::GROUP_USABILITY, $ruleGroups)) {
            throw new UsabilityScoreNotAvailableException('Usability score is only available with mobile strategy API call.');
        }

        return $ruleGroups[RuleGroup::GROUP_USABILITY]->getScore();
    }
1030517
public synchronized SelectionCriteria getSelectionCriteria()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getSelectionCriteria"); //469395

      checkReleased();

      SelectorDomain selectorDomain = SelectorDomain.getSelectorDomain(getShort());
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selector domain", selectorDomain);

      /**************************************************************/
      /* Destination                                                */
      /**************************************************************/
      String discriminator = getString();
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Discriminator:", discriminator);

      /**************************************************************/
      /* Destination                                                */
      /**************************************************************/
      String selector = getString();
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selector:", selector);

      SelectionCriteria selectionCriteria =
    		  CommsClientServiceFacade.getSelectionCriteriaFactory().createSelectionCriteria(discriminator,
                                                                        selector,
                                                                        selectorDomain);



      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getSelectionCriteria"); //469395
      return selectionCriteria;
   }
154524
public com.google.api.ads.admanager.axis.v201808.CustomCriteria[] getCustomTargetingSegment() {
        return customTargetingSegment;
    }
54491
public SelectionCriteria[] getCriterias()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getCriterias");
      
    SelectionCriteria[] criterias = aiRequestedTick.getCriterias();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getCriterias", criterias);
    return criterias;
  }
530852
public static Usage getUsage(String cobolUsage) {
        if (cobolUsage == null) {
            return null;
        }
        if (cobolUsage.equals(BINARY)) {
            return Usage.BINARY;
        } else if (cobolUsage.equals("COMP")) {
            return Usage.BINARY;
        } else if (cobolUsage.equals("COMPUTATIONAL")) {
            return Usage.BINARY;
        } else if (cobolUsage.equals("COMP-4")) {
            return Usage.BINARY;
        } else if (cobolUsage.equals("COMPUTATIONAL-4")) {
            return Usage.BINARY;
        } else if (cobolUsage.equals(COMP_1)) {
            return Usage.SINGLEFLOAT;
        } else if (cobolUsage.equals(COMP_2)) {
            return Usage.DOUBLEFLOAT;
        } else if (cobolUsage.equals(PACKED_DECIMAL)) {
            return Usage.PACKEDDECIMAL;
        } else if (cobolUsage.equals("PACKED-DECIMAL")) {
            return Usage.PACKEDDECIMAL;
        } else if (cobolUsage.equals("COMPUTATIONAL-3")) {
            return Usage.PACKEDDECIMAL;
        } else if (cobolUsage.equals(COMP_5)) {
            return Usage.NATIVEBINARY;
        } else if (cobolUsage.equals("COMPUTATIONAL-5")) {
            return Usage.NATIVEBINARY;
        } else if (cobolUsage.equals(DISPLAY)) {
            return Usage.DISPLAY;
        } else if (cobolUsage.equals(DISPLAY_1)) {
            return Usage.DISPLAY1;
        } else if (cobolUsage.equals(INDEX)) {
            return Usage.INDEX;
        } else if (cobolUsage.equals(NATIONAL)) {
            return Usage.NATIONAL;
        } else if (cobolUsage.equals(POINTER)) {
            return Usage.POINTER;
        } else if (cobolUsage.equals(PROCEDURE_POINTER)) {
            return Usage.PROCEDUREPOINTER;
        } else if (cobolUsage.equals(FUNCTION_POINTER)) {
            return Usage.FUNCTIONPOINTER;
        } else {
            throw new IllegalArgumentException("Unknown COBOL usage: "
                    + cobolUsage);
        }

    }
101032
public function applyCriteria()
    {
        // if we're ignoring criteria, the model must be remade without criteria
        if ($this->ignoreCriteria === true) {

            // and make sure that they are re-applied when we stop ignoring
            if ( ! $this->activeCriteria->isEmpty()) {
                $this->makeModel();
                $this->activeCriteria = new Collection();
            }
            return $this;
        }

        if ($this->areActiveCriteriaUnchanged()) return $this;

        // if the new Criteria are different, clear the model and apply the new Criteria
        $this->makeModel();

        $this->markAppliedCriteriaAsActive();


        // apply the collected criteria to the query
        foreach ($this->getCriteriaToApply() as $criteria) {

            if ($criteria instanceof CriteriaInterface) {

                $this->model = $criteria->apply($this->model, $this);
            }
        }

        $this->clearOnceCriteria();

        return $this;
    }
371415
List getOrderby()
    {
        List result = _getOrderby();
        Iterator iter = getCriteria().iterator();
        Object crit;

        while (iter.hasNext())
        {
            crit = iter.next();
            if (crit instanceof Criteria)
            {
                result.addAll(((Criteria) crit).getOrderby());
            }
        }

        return result;
    }
363532
@Override
	public void visit(LogicalCriterion criterion, Object context) {
		LogicalCriterionDto clone = new LogicalCriterionDto(criterion.getOperator());
		List<Criterion> clonedChildren = new ArrayList<Criterion>(criterion.getChildren().size());
		for (Criterion criterionDto : criterion.getChildren()) {
			clonedChildren.add(clone((CriterionDto) criterionDto));
		}
		clone.setChildren(clonedChildren);
		((CriterionContext) context).setCriterion(clone);
	}
1060577
public String getUsage()
    {
        Set<Option> set = new HashSet<>();
        StringBuilder sb = new StringBuilder();
        sb.append("usage: ");
        boolean n1 = false;
        for (Entry<String,List<Option>> e : groups.entrySet())
        {
            if (n1)
            {
                sb.append("|");
            }
            n1 = true;
            sb.append("[");
            boolean n2 = false;
            for (Option opt : e.getValue())
            {
                if (n2)
                {
                    sb.append(" ");
                }
                n2 = true;
                append(sb, opt);
                set.add(opt);
            }
            sb.append("]");
        }
        for (Option opt : map.values())
        {
            if (!set.contains(opt))
            {
                sb.append(" ");
                append(sb, opt);
            }
        }
        for (int ii=0;ii<names.size();ii++)
        {
            sb.append(" <").append(names.get(ii)).append(">");
            if (types.get(ii).isArray())
            {
                sb.append("...");
            }
        }
        return sb.toString();
    }
454665
public String getSelector()
  {
    if (tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getSelector");
      SibTr.exit(tc, "getSelector", selector);
    }

    return selector;
  }
148001
public com.google.api.ads.adwords.axis.v201809.mcm.ManagedCustomer[] getValue() {
        return value;
    }
15843
public void setCriterionTypeGroup(com.google.api.ads.adwords.axis.v201809.cm.CriterionTypeGroup criterionTypeGroup) {
        this.criterionTypeGroup = criterionTypeGroup;
    }
1324755
public com.google.api.ads.adwords.axis.v201809.cm.AdGroupCriterionLimitExceededCriteriaLimitType getLimitType() {
        return limitType;
    }
1112185
@Override
	public List<Criterion> getCriteria() {
		if (criteria == null) {
			criteria = new ArrayList<Criterion>();
		}
		return criteria;
	}
898099
def CreateDefaultPartition(client, ad_group_id):
  
  ad_group_criterion_service = client.GetService('AdGroupCriterionService',
                                                 version='v201809')

  operations = [{
      'operator': 'ADD',
      'operand': {
          'xsi_type': 'BiddableAdGroupCriterion',
          'adGroupId': ad_group_id,
          # Make sure that caseValue and parentCriterionId are left unspecified.
          # This makes this partition as generic as possible to use as a
          # fallback when others don't match.
          'criterion': {
              'xsi_type': 'ProductPartition',
              'partitionType': 'UNIT'
          },
          'biddingStrategyConfiguration': {
              'bids': [{
                  'xsi_type': 'CpcBid',
                  'bid': {
                      'microAmount': 500000
                  }
              }]
          }
      }
  }]

  ad_group_criterion = ad_group_criterion_service.mutate(operations)['value'][0]

  print ('Ad group criterion with ID "%d" in ad group with ID "%d" was added.'
         % (ad_group_criterion['criterion']['id'],
            ad_group_criterion['adGroupId']))
326263
protected function applyCriteria()
    {

        if ($this->skipCriteria === true) {
            return $this;
        }

        $criteria = $this->getCriteria();

        if ($criteria) {
            foreach ($criteria as $c) {
                if ($c instanceof CriteriaInterface) {
                    $this->model = $c->apply($this->model, $this);
                }
            }
        }

        return $this;
    }