NAME

       setop - make set of strings from input

SYNOPSIS

       setop  [-h]  [--quiet  |  --verbose]  [-C]  [--include-empty] [-n insepar | -l elregex] [-o outsepar] [-t
       trimchars] [-u|i|s] [inputfilename]* [-d filename]* [-# | --is-empty | -c element  |  -e  filename  |  -b
       filename | -p filename]

DESCRIPTION

       Apply  set  operations like union, intersection, or set difference to input files and print resulting set
       (sorted and with unique string elements) to standard output or give answer to special queries like number
       of elements.

OPTIONS

       --help produce this help message and exit

       --version
              output name and version

       --quiet
              suppress  all output messages in case of special queries (e. g. when check if element is contained
              in set)

       --verbose
              always use output messages in case of special queries (i. e. also output message on success)

       -C [ --ignore-case ]
              handle input elements case-insensitive

       --include-empty
              don’t ignore empty elements (these can come from empty lines, trimming, etc.)

       -n [ --input-separator ] arg
              describe the form of an input separator as regular expression in ECMAScript syntax; default is new
              line (if --input-element is not given); don’t forget to include the new line character \n when you
              set the input separator manually, when desired!

       -l [ --input-element ] arg
              describe the form of input elements as regular expression in ECMAScript syntax

       -o [ --output-separator ] arg (=\n) string for separating output elements;
              escape sequences are allowed

       -t [ --trim ] arg
              trim all given characters at beginning and end of elements (escape sequences allowed)

       -u [ --union ]
              unite all given input sets (default)

       -i [ --intersection ]
              unite all given input sets

       -s [ --symmetric-difference ]
              build symmetric difference for all given input sets

       -d [ --difference ] arg
              subtract all elements in given file from output set

       -# [ --count ]
              just output number of (different) elements, don’t list them

       --is-empty
              check if resulting set is empty

       -c [ --contains ] arg
              check if given element is contained in set

       -e [ --equal ] arg
              check set equality, i. e. check if output corresponds with content of file

       -b [ --subset ] arg
              check if content of file is subset of output set

       -p [ --superset ] arg
              check if content of file is superset of output set

       No input filename or "-" is equal to reading from standard input.

       The sequence of events of setop is as follows:  At  first,  all  input  files  are  parsed  and  combined
       according  to  one  of  the  options  -u, -i, or -s. After that, all inputs from option -d are parsed and
       removed from result of first step. Finally, the desired output is printed to screen: the set  itself,  or
       its number of elements, or a comparison to another set (option -e), etc.

       By  default  each line of an input stream is considered to be an element, you can change this by defining
       regular expressions within the options --input-separator or --input-element. When using both,  the  input
       stream  is  first  split  according to the separator and after that filtered by the desired input element
       form. After finding the elements they are finally trimmed according to the argument  given  with  --trim.
       The  option  -C  lets  you  treat  Word and WORD equal, only the first occurrence of all input streams is
       considered. Note that  -C  does  not  affect  the  regular  expressions  used  in  --input-separator  and
       --input-element.

       When  describing  strings  and  characters  for the output separator or for the option --trim you can use
       escape sequences like \t, \n, \" and \'. But be aware that some of these sequences (especially \\ and \")
       might  be interpreted by your shell before passing the string to setop. In that case you have to use \\\\
       respectively \\\" just for describing a \ or a ". You can check your shell’s behavior with echo  "\\  and
       \""

       Special  boolean  queries  (e.  g. check if element is contained in set) don’t return anything in case of
       success except their exit code EXIT_SUCCESS (0). In case the query is unsuccessful  (e.  g.  element  not
       contained  in  set)  the  exit  code is guaranteed to be unequal to EXIT_SUCCESS and to EXIT_FAILURE (1).
       (Here it is 3.) This way, setop can be used in the shell.

EXAMPLES

       setop -c ":fooBAR-:" --trim ":-\t" -C -d B.txt A.txt

              case-insensitive check if element "foobar" is contained in A minus B

       setop A.txt - -i B.txt --input-element "\d+"

              output intersection of console, A, and B, where elements are recognized as strings of digits  with
              at least one character; i. e. elements are non-negative integers

       setop -s A.txt B.txt --input-separator [[:space:]-]

              find  all  elements  contained  in A *or* B, not both, where a whitespace (i. e. \v \t \n \r \f or
              space) or a minus is interpreted as a separator between elements