Returns an extended filter with the starting date restriction.<p>

@param from the starting date to filter

@return an extended filter with the starting date restriction
190761
public CmsVisitEntryFilter filterFrom(long from) {

        CmsVisitEntryFilter filter = (CmsVisitEntryFilter)clone();
        filter.m_dateFrom = from;
        return filter;
    }
392158
public CmsLockFilter filterSharedExclusive() {

        CmsLockFilter filter = (CmsLockFilter)clone();
        filter.m_sharedExclusive = true;
        return filter;
    }
1248471
def subset(self, fromdate, todate):
        '''
        
        '''
#CONSIDER: raise an exception if a date is not in self
        i_from = self.index(fromdate)
        if fromdate != self[i_from]:
            # don't go back before fromdate
            i_from += 1
        i_to = self.index(todate)
        return self[i_from:i_to + 1]
1284619
public static CmsResourceFilter ignoreExpirationOffline(CmsObject cms) {

        return cms.getRequestContext().getCurrentProject().isOnlineProject() ? DEFAULT : IGNORE_EXPIRATION;
    }
1275428
function filterDay(arr, year, month, disabledDateObj) {
  const minDateTime = new Date(year, month, 1).getTime();
  const maxDateTime = new Date(year, month + 1, 0).getTime();
  const dayRangeArr = getDateRangeArr(disabledDateObj, minDateTime, maxDateTime);
  const dayArr = [];
  dayRangeArr.forEach((item) => {
    let { start, end } = item;
    start = new Date(start).getDate();
    end = new Date(end).getDate();
    for (let i = start; i <= end; i++) {
      dayArr.push(i);
    }
  });
  return arr.filter((item) => {
    const day = item.value;
    return dayArr.indexOf(day) === -1;
  });
}
1261766
String getFilterQuery() {

        String result = m_config.getFilterQuery();
        if (result == null) {
            result = "";
        }
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(result) && !result.startsWith("&")) {
            result = "&" + result;
        }
        if (!result.contains(CommonParams.FL + "=")) {
            result += "&" + CommonParams.FL + "=" + getDefaultReturnFields();
        }
        I_CmsListDateRestriction dateRestriction = m_config.getDateRestriction();
        if (dateRestriction != null) {
            result += "&fq="
                + CmsSearchField.FIELD_INSTANCEDATE_CURRENT_TILL
                + "_"
                + getSearchLocale().toString()
                + "_dt:"
                + dateRestriction.getRange();

        }
        return result;
    }
1142817
public Date getDate(final long min, final long max) {
		long millis = getLong(min, max);
		return DateUtils.truncate(new Date(millis), Calendar.DATE);
	}
162164
public static long between(Date beginDate, Date endDate, DateUnit unit, boolean isAbs) {
		return new DateBetween(beginDate, endDate, isAbs).between(unit);
	}
442870
public CmsRelationFilter filterNotDefinedInContent() {

        CmsRelationFilter filter = (CmsRelationFilter)clone();
        if (filter.m_types.isEmpty()) {
            filter.m_types.addAll(CmsRelationType.getAllNotDefinedInContent());
        } else {
            filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterNotDefinedInContent(filter.m_types));
        }
        return filter;
    }
1050985
public final void setStartDate(Date startDate) {
                if (this.startDate == null || !this.startDate.equals(startDate)) {
                        if (startDate != null && endDate != null && endDate.before(startDate)) {
                                throw new ParameterException("The start date must be before the end date of the filter.");
                        }
                        this.startDate = startDate;
                        setChanged();
                        notifyObservers();
                }
        }
1038667
public QueryChangesetsFilters byOpenSomeTimeBetween(Date createdBefore, Date closedAfter)
	{
		params.put("time", dateFormat.format(closedAfter) + "," + dateFormat.format(createdBefore));
		return this;
	}
1104272
public Comparer<Long> until(String targetDate) {
		return until(this.style.from().apply(targetDate));
	}
1007233
static Predicate<DateValue> byMonthDayFilter(final int[] monthDays) {
		return new Predicate<DateValue>() {
			private static final long serialVersionUID = -1618039447294490037L;

			public boolean apply(DateValue date) {
				int nDays = TimeUtils.monthLength(date.year(), date.month());
				for (int i = monthDays.length - 1; i >= 0; i--) {
					int day = monthDays[i];
					if (day < 0) {
						day += nDays + 1;
					}
					if (day == date.day()) {
						return true;
					}
				}
				return false;
			}
		};
	}
210461
private void getYearlyAbsoluteDates(Calendar calendar, List<Date> dates)
   {
      long startDate = calendar.getTimeInMillis();
      calendar.set(Calendar.DAY_OF_MONTH, 1);
      calendar.set(Calendar.MONTH, NumberHelper.getInt(m_monthNumber) - 1);
      int requiredDayNumber = NumberHelper.getInt(m_dayNumber);

      while (moreDates(calendar, dates))
      {
         int useDayNumber = requiredDayNumber;
         int maxDayNumber = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
         if (useDayNumber > maxDayNumber)
         {
            useDayNumber = maxDayNumber;
         }

         calendar.set(Calendar.DAY_OF_MONTH, useDayNumber);
         if (calendar.getTimeInMillis() < startDate)
         {
            calendar.add(Calendar.YEAR, 1);
         }

         dates.add(calendar.getTime());
         calendar.set(Calendar.DAY_OF_MONTH, 1);
         calendar.add(Calendar.YEAR, 1);
      }
   }
820873
public static long betweenMs(Date beginDate, Date endDate) {
		return new DateBetween(beginDate, endDate).between(DateUnit.MS);
	}
25266
public DateRangeParam setUpperBoundExclusive(Date theUpperBound) {
		validateAndSet(myLowerBound, new DateParam(ParamPrefixEnum.LESSTHAN, theUpperBound));
		return this;
	}
752081
public static FilterFragment[] from(Filter... filters) {
        FilterFragment[] ret = new FilterFragment[filters.length];
        Arrays.setAll(ret, (i) -> new FilterFragment(filters[i]));
        return ret;
    }