The Paging Feature
Some ACF Tables do not show all data on a single page. These tables have features that allow a user to navigate to different parts of the table by page. Each table with this feature will have a box that looks like this towards the bottom:

This box tells the user which page is being viewed (ie: Page 11 of 40) and contains buttons to the right and/or the left of the box that allow the user to navigate to different parts of the table.

Clicking on      will display the next page in the table.

Clicking on      will display the previous page in the table.

Clicking on      will display the last page in the table.

Clicking on      will display the first page in the table.

  The Search Feature
Tables with a search feature will have a search form at the bottom that looks like this:

The search feature allows a user to search for a particular element in a table column. This element is entered into the box next to the word "use," and the column to be searched is entered by using the dropdown box next to the words "on column." Clicking the button will begin a search. To clear a search and return the table to its original state, click on the button.

Note: Word phrases in ACF Tables must be searched in all lowercase form.

There are three ways to search ACF Tables, each chosen through the dropdown box next to the word "as."

1. Search by Substring: Returns elements in a column containing the entered phrase in whole or in part.

   Example: A search for hal will find hallett, marshall, michalowski, and hall.
   Similarly, a search for 440 will find 1440, 24403, and 4407.

2. Search by Match: Returns elements in a column that exactly match the entered phrase.

   Example: A search for ben will return ben but not ben p. or benjamin.

3. Search by Regular Expression: Allows a user to conduct an advanced search using regular expressions. The following examples illustrate regular expressions that will generate data in an ACF Table:

• All characters except special characters: Match a single instance of themselves.
  Special Characters: [\^$.|?*+()
  Example: a matches a.

• A backslash: Escapes special characters to suppress their special meaning.
  Example: \+ matches +.

• \xFF, where FF are 2 hexadecimal digits: Matches the character with the specified ASCII/ANSI value, which depends on the code page used. Can be used in character classes.
  Example: \xA9 matches ©.

• \n, \r and \t: Match an LF character, CR character and a tab character respectively. Can be used in character classes. Example: \r\n matches a DOS/Windows CRLF line break.

• [ (opening square bracket): Starts a character class. A character class matches a single character out of all the possibilities offered by the character class. Inside a character class, different rules apply.
  Character Class Special Characters: ^-]\

• Any character (except ^-]\): Adds that character to the possible matches for the character class.
  Example: [abc] matches a, b, or c.

• \ (backslash) followed by any of ^-]\: Escapes special characters to suppress their special meaning.
  Example: [\^\]] matches ^ or ].

• - (hyphen) except immediately after the opening [: Specifies a range of characters. (Specifies a hyphen if placed immediately after the opening [).
  Example: [a-zA-Z0-9] matches any letter or digit.

• ^ (caret) immediately after the opening [: Negates the character class, causing it to match a single character not listed in the character class. (Specifies a caret if placed anywhere except after the opening [).
  Example: [^a-d] matches x (any character except a, b, c or d).

• \d, \w and \s: Shorthand character classes matching digits 0-9, word characters (letters and digits) and whitespace respectively. Can be used inside and outside character classes.
  Example: [\d\s] matches a character that is a digit or whitespace.

• \D, \W and \S: Negated versions of the above. Should be used only outside character classes.
  Example: \D matches a character that is not a digit.

• . (dot): Matches any single character except line break characters \r and \n. Example: . matches x or (almost) any other character.

• ^ (caret): Matches at the start of the string the regex pattern is applied to. Matches a position rather than a character.
  Example: ^. matches a in abc.

• $ (dollar): Matches at the end of the string the regex pattern is applied to. Matches a position rather than a character. Example: .$ matches c in abc.

• /b: Matches at the position between a word character and a non-word character as well as at the start and/or end of the string if the first and/or last characters in the string are word characters. Example: .\b matches c in abc.

• | (pipe): Causes the regex engine to match either the part on the left side, or the part on the right side. Can be strung together into a series of options. Example: abc|def|xyz matches abc, def or xyz.

  Note: The pipe has the lowest precedence of all operators. Use grouping to alternate only part of the regular expression.
  Example: abc(def|xyz) matches abcdef or abcxyz.

• ? (question mark): Makes the preceding item optional. Greedy, so the optional item is included in the match if possible.
  Example: abc? matches ab or abc.

• ??: Makes the preceding item optional. Lazy, so the optional item is excluded in the match if possible.
  Example: abc?? matches ab or abc.

• * (star): Repeats the previous item zero or more times. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is not matched at all.
  Example: ".*" matches "def" "ghi" in abc "def" "ghi" jkl.

• *? (lazy star): Repeats the previous item zero or more times. Lazy, so the engine first attempts to skip the previous item, before trying permutations with ever increasing matches of the preceding item.
  Example: ".*?" matches "def" in abc "def" "ghi" jkl.

• + (plus): Repeats the previous item once or more. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is matched only once.
  Example: ".+" matches "def" "ghi" in abc "def" "ghi" jkl.

• +? (lazy plus): Repeats the previous item once or more. Lazy, so the engine first matches the previous item only once, before trying permutations with ever increasing matches of the preceding item.
  Example: ".+?" matches "def" in abc "def" "ghi" jkl.

• {n} where n is an integer >= 1: Repeats the previous item exactly n times.
  Example: a{3} matches aaa.

• {n,m} where n >= 1 and m >= n: Repeats the previous item between n and m times. Greedy, so repeating m times is tried before reducing the repetition to n times.
  Example: a{2,4} matches aa, aaa or aaaa.

• {n,m}? where n >= 1 and m >= n: Repeats the previous item between n and m times. Lazy, so repeating n times is tried before increasing the repetition to m times.
  Example: a{2,4}? matches aaaa, aaa or aa.

• {n,} where n >= 1: Repeats the previous item at least n times. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is matched only n times.
  Example: a{2,} matches aaaaa in aaaaa.

• {n,}? where n >= 1: Repeats the previous item between n and m times. Lazy, so the engine first matches the previous item n times, before trying permutations with ever increasing matches of the preceding item.
  Example: a{2,}? matches aa in aaaaa.

    

    

    

© American Checker Federation 2007 This website was created by the ACF Website Team. Original site design by Clint Olsen. Official ACF Logo design by John Acker and Lisle Cormier. All checker board images courtesy of Vinco Online Games. .