Set up/do the local criteria.
This is only here to accomodate local file systems that can't handle
REMOTE criteria. All you have to do here to handle the remote criteria
locally is to call: return record.handleRemoteCriteria(xx, yy).
772180
public boolean doLocalCriteria(StringBuffer strFilter, boolean bIncludeFileName, Vector<BaseField> vParamList)
    {   // Default BaseListener
        return super.doLocalCriteria(strFilter, bIncludeFileName, vParamList);    // If can't handle remote
    }
83083
function() {

    if (!this._alreadyInitiallyExpandedCriteria) {
      this._wlQueryInfo.criteria = expandWhereShorthand(this._wlQueryInfo.criteria);
      this._alreadyInitiallyExpandedCriteria = true;
    }//>-

    this._wlQueryInfo.criteria.min = arguments[0];

    return this;
  }
1045942
private function doRs()
    {
        $this->criteria->setOffset($this->start);
        $this->criteria->setLimit($this->max);
        $this->rs = call_user_func(array($this->getPeerClass(), $this->getPeerSelectMethod()), $this->criteria);
    }
181066
public Criteria lt(Object o) {
        this.criteriaType = RelationalOperator.LT;
        this.right = ValueNode.toValueNode(o);
        return this;
    }
285236
private void addQueryParametersFromManager(IFilterCriteriaManager manager) {
        Map<FilterCriteriaType, IFilterCriteria> criterias = manager.getFilterCriterias();
        for (FilterCriteriaType type : criterias.keySet()) {
            IFilterCriteria criteria = criterias.get(type);
            if (criteria == null) continue;
            if (criteria.getModel().getObject() != null) {
                if (type.equals(FilterCriteriaType.RANGE)) {
                    List<?> list = (List<?>) criteria.getModel().getObject();
                    Object first = list.get(0);
                    Object second = list.get(1);
                    if (first != null && second != null) {
                        setParameter(criteria.getName() + 0, Model.of((Serializable) first));
                        setParameter(criteria.getName() + 1, Model.of((Serializable) second));
                    } else setParameter(criteria.getName(), Model.of(first != null ? (Serializable) first : (Serializable) second));
                } else setParameter(criteria.getName(), criteria.getModel());
            }
        }
    }
634707
def checkIfRemoteIsNewer(self, localfile):
        
        is_remote_newer = False
        if localfile.exists() and localfile.stat().st_size > 0:
            LOG.info("File exists locally, using cache")
        else:
            is_remote_newer = True
            LOG.info("No cache file, fetching entries")
        return is_remote_newer
118380
public Rule CriteriaOnlyFindQuery() {
		return Sequence( !peek().isCliQuery(), JsonParameter( JsonObject() ) , peek().setOperation( Operation.FIND ), peek().setCriteria( match() ) );
	}
2480
public void setCriteriaList(java.util.Collection<AbortCriteria> criteriaList) {
        if (criteriaList == null) {
            this.criteriaList = null;
            return;
        }

        this.criteriaList = new java.util.ArrayList<AbortCriteria>(criteriaList);
    }
1292645
def on_menu_criteria_file(self, event):
        
        if self.data_model == 3:
            default_file = "criteria.txt"
        else:
            default_file = "pmag_criteria.txt"
        read_sucsess = False
        dlg = wx.FileDialog(
            self, message="choose pmag criteria file",
            defaultDir=self.WD,
            defaultFile=default_file,
            style=wx.FD_OPEN | wx.FD_CHANGE_DIR
        )
        if self.show_dlg(dlg) == wx.ID_OK:
            criteria_file = dlg.GetPath()
            print(("-I- Read new criteria file: %s" % criteria_file))

            # check if this is a valid pmag_criteria file
            try:
                mag_meas_data, file_type = pmag.magic_read(criteria_file)
            except:
                dlg = wx.MessageDialog(
                    self, caption="Error", message="not a valid pmag_criteria file", style=wx.OK)
                result = self.show_dlg(dlg)
                if result == wx.ID_OK:
                    dlg.Destroy()
                dlg.Destroy()
                return

            # initialize criteria
            self.acceptance_criteria = self.read_criteria_file(criteria_file)
            read_sucsess = True

        dlg.Destroy()
        if read_sucsess:
            self.on_menu_change_criteria(None)
118714
function applicable(filepath, info, callback) {
  const q = queue();
  preprocessors.forEach((preprocessor) => {
    q.defer(preprocessor.criteria, filepath, info);
  });

  q.awaitAll((err, results) => {
    if (err) return callback(err);
    callback(null, preprocessors.filter((preprocessor, i) => {
      return !!results[i];
    }));
  });
}
1306575
def on_menu_criteria(self, event):
        

        dia = thellier_gui_dialogs.Criteria_Dialog(
            None, self.acceptance_criteria, self.preferences, title='Set Acceptance Criteria')
        dia.Center()
        result = self.show_dlg(dia)

        if result == wx.ID_OK:  # Until the user clicks OK, show the message
            self.On_close_criteria_box(dia)
1002918
def _get_with_criteria(self, criteria, offset=None, limit=None):
        ''' 
        '''
        SQL = SQLBuilder(self._table, criteria).select(offset=offset, limit=limit)
        self._cursor.execute(SQL)
        for item in self._cursor.fetchall():
            yield self._make_item(item)
53382
public static boolean exampleHasAtLeastOneCriteriaCheck(Object parameter) {
        if (parameter != null) {
            try {
                if (parameter instanceof Example) {
                    List<Example.Criteria> criteriaList = ((Example) parameter).getOredCriteria();
                    if (criteriaList != null && criteriaList.size() > 0) {
                        return true;
                    }
                } else {
                    Method getter = parameter.getClass().getDeclaredMethod("getOredCriteria");
                    Object list = getter.invoke(parameter);
                    if(list != null && list instanceof List && ((List) list).size() > 0){
                        return true;
                    }
                }
            } catch (Exception e) {
                throw new MapperException(SAFE_DELETE_ERROR, e);
            }
        }
        throw new MapperException(SAFE_DELETE_EXCEPTION);
    }
863546
def parse_criteria
      @criteria = (JSS::Criteriable::Criteria.new @init_data[:criteria].map { |c| JSS::Criteriable::Criterion.new c } if @init_data[:criteria])
      @criteria.container = self if @criteria
    end
97591
def post(method, hmc, uri, uri_parms, body, logon_required,
             wait_for_completion):
        """"""
        assert wait_for_completion is True  # async not supported yet
        lpar_oid = uri_parms[0]
        lpar_uri = '/api/logical-partitions/' + lpar_oid
        try:
            lpar = hmc.lookup_by_uri(lpar_uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        cpc = lpar.manager.parent
        assert not cpc.dpm_enabled

        status = lpar.properties.get('status', None)
        force = body.get('force', False) if body else False
        clear_indicator = body.get('clear-indicator', True) if body else True
        store_status_indicator = body.get('store-status-indicator',
                                          False) if body else False
        if status == 'not-activated':
            raise ConflictError(method, uri, reason=0,
                                message="LPAR {!r} could not be loaded "
                                "because the LPAR is in status {}.".
                                format(lpar.name, status))
        elif status == 'operating' and not force:
            raise ServerError(method, uri, reason=263,
                              message="LPAR {!r} could not be loaded "
                              "because the LPAR is already loaded "
                              "(and force was not specified).".
                              format(lpar.name))

        load_address = body.get('load-address', None) if body else None
        if not load_address:
            # Starting with z14, this parameter is optional and a last-used
            # property is available.
            load_address = lpar.properties.get('last-used-load-address', None)
        if load_address is None:
            # TODO: Verify actual error for this case on a z14.
            raise BadRequestError(method, uri, reason=5,
                                  message="LPAR {!r} could not be loaded "
                                  "because a load address is not specified "
                                  "in the request or in the Lpar last-used "
                                  "property".
                                  format(lpar.name))

        load_parameter = body.get('load-parameter', None) if body else None
        if not load_parameter:
            # Starting with z14, a last-used property is available.
            load_parameter = lpar.properties.get(
                'last-used-load-parameter', None)
        if load_parameter is None:
            load_parameter = ''

        # Reflect the load in the resource
        if clear_indicator:
            lpar.properties['memory'] = ''

        if store_status_indicator:
            lpar.properties['stored-status'] = status
        else:
            lpar.properties['stored-status'] = None
        lpar.properties['status'] = LparLoadHandler.get_status()
        lpar.properties['last-used-load-address'] = load_address
        lpar.properties['last-used-load-parameter'] = load_parameter
953320
function(criteria, cb){
      var self = this;
      waterlock.Auth.findOne(criteria).populate('user')
      .exec(function(err, auth){
        cb(err, self._invertAuth(auth));
      });
    }
434582
function LocalFilesystemHandler(req, res, next, local = false) {
            if (!self.settings.localFilesystem) {
                return next();
            }
            return FilesystemHandler(req, res, next, self.localFilesystemUrl, undefined, local);
        }