001package org.unix4j.builder;
002
003import org.unix4j.builder.DefaultCommandBuilder;
004import org.unix4j.command.Command;
005import org.unix4j.command.NoOp;
006import org.unix4j.context.DefaultExecutionContext;
007import org.unix4j.context.ExecutionContextFactory;
008import org.unix4j.operation.LineOperation;
009
010import org.unix4j.unix.Cat;
011import org.unix4j.unix.cat.CatOptions;
012import org.unix4j.unix.Cd;
013import org.unix4j.unix.Cut;
014import org.unix4j.unix.cut.CutOptions;
015import org.unix4j.unix.Echo;
016import org.unix4j.unix.echo.EchoOptions;
017import org.unix4j.unix.Find;
018import org.unix4j.unix.find.FindOptions;
019import org.unix4j.unix.From;
020import org.unix4j.unix.Grep;
021import org.unix4j.unix.grep.GrepOptions;
022import org.unix4j.unix.Head;
023import org.unix4j.unix.head.HeadOptions;
024import org.unix4j.unix.Ls;
025import org.unix4j.unix.ls.LsOptions;
026import org.unix4j.unix.Sed;
027import org.unix4j.unix.sed.SedOptions;
028import org.unix4j.unix.Sort;
029import org.unix4j.unix.sort.SortOptions;
030import org.unix4j.unix.Tail;
031import org.unix4j.unix.tail.TailOptions;
032import org.unix4j.unix.Uniq;
033import org.unix4j.unix.uniq.UniqOptions;
034import org.unix4j.unix.Wc;
035import org.unix4j.unix.wc.WcOptions;
036import org.unix4j.unix.Xargs;
037import org.unix4j.unix.xargs.XargsOptions;
038
039/**
040 * Default implementation for {@link Unix4jCommandBuilder}. Application code 
041 * does usually not directly refer to this class but uses it indirectly through 
042 * the static methods in {@link org.unix4j.Unix4j Unix4j}.
043 */
044public class DefaultUnix4jCommandBuilder extends DefaultCommandBuilder implements Unix4jCommandBuilder {
045
046        /**
047         * Default constructor initialized with a {@link NoOp} command which will be 
048         * replaced by the first command joined to this builder's command chain. 
049         * Uses a {@link DefaultExecutionContext} to execute commands.
050         */
051        public DefaultUnix4jCommandBuilder() {
052                super();
053        }
054
055        /**
056         * Constructor using the specified factory to create contexts for command
057         * execution. The builder is initialized with a {@link NoOp} command which
058         * will be replaced by the first command joined to this builder's command 
059         * chain.
060         * 
061         * @param contextFactory
062         *            the factory used to create execution contexts that are passed
063         *            to the execute method when a command is executed
064         */
065        public DefaultUnix4jCommandBuilder(ExecutionContextFactory contextFactory) {
066                super(contextFactory);
067        }
068
069
070        /* ------------------ cat ------------------ */
071        @Override
072        public Unix4jCommandBuilder cat() {
073                join(Cat.Factory.cat());
074                return this;
075        }
076        @Override
077        public Unix4jCommandBuilder cat(String... args) {
078                join(Cat.Factory.cat(args));
079                return this;
080        }
081        @Override
082        public Unix4jCommandBuilder cat(java.io.File... files) {
083                join(Cat.Factory.cat(files));
084                return this;
085        }
086        @Override
087        public Unix4jCommandBuilder cat(CatOptions options) {
088                join(Cat.Factory.cat(options));
089                return this;
090        }
091        @Override
092        public Unix4jCommandBuilder cat(CatOptions options, java.io.File... files) {
093                join(Cat.Factory.cat(options, files));
094                return this;
095        }
096        @Override
097        public Unix4jCommandBuilder cat(CatOptions options, String... paths) {
098                join(Cat.Factory.cat(options, paths));
099                return this;
100        }
101
102        /* ------------------ cd ------------------ */
103        @Override
104        public Unix4jCommandBuilder cd() {
105                join(Cd.Factory.cd());
106                return this;
107        }
108        @Override
109        public Unix4jCommandBuilder cd(java.io.File file) {
110                join(Cd.Factory.cd(file));
111                return this;
112        }
113        @Override
114        public Unix4jCommandBuilder cd(String path) {
115                join(Cd.Factory.cd(path));
116                return this;
117        }
118
119        /* ------------------ cut ------------------ */
120        @Override
121        public Unix4jCommandBuilder cut(String... args) {
122                join(Cut.Factory.cut(args));
123                return this;
124        }
125        @Override
126        public Unix4jCommandBuilder cut(CutOptions options, org.unix4j.util.Range range) {
127                join(Cut.Factory.cut(options, range));
128                return this;
129        }
130        @Override
131        public Unix4jCommandBuilder cut(CutOptions options, int... indexes) {
132                join(Cut.Factory.cut(options, indexes));
133                return this;
134        }
135        @Override
136        public Unix4jCommandBuilder cut(CutOptions options, String delimiter, org.unix4j.util.Range range) {
137                join(Cut.Factory.cut(options, delimiter, range));
138                return this;
139        }
140        @Override
141        public Unix4jCommandBuilder cut(CutOptions options, String delimiter, int... indexes) {
142                join(Cut.Factory.cut(options, delimiter, indexes));
143                return this;
144        }
145        @Override
146        public Unix4jCommandBuilder cut(CutOptions options, String delimiter, char outputDelimiter, org.unix4j.util.Range range) {
147                join(Cut.Factory.cut(options, delimiter, outputDelimiter, range));
148                return this;
149        }
150        @Override
151        public Unix4jCommandBuilder cut(CutOptions options, String delimiter, char outputDelimiter, int... indexes) {
152                join(Cut.Factory.cut(options, delimiter, outputDelimiter, indexes));
153                return this;
154        }
155
156        /* ------------------ echo ------------------ */
157        @Override
158        public Unix4jCommandBuilder echo(String... args) {
159                join(Echo.Factory.echo(args));
160                return this;
161        }
162        @Override
163        public Unix4jCommandBuilder echo(EchoOptions options, String string) {
164                join(Echo.Factory.echo(options, string));
165                return this;
166        }
167        @Override
168        public Unix4jCommandBuilder echo(EchoOptions options, String... strings) {
169                join(Echo.Factory.echo(options, strings));
170                return this;
171        }
172
173        /* ------------------ find ------------------ */
174        @Override
175        public Unix4jCommandBuilder find(String... args) {
176                join(Find.Factory.find(args));
177                return this;
178        }
179        @Override
180        public Unix4jCommandBuilder find(String path) {
181                join(Find.Factory.find(path));
182                return this;
183        }
184        @Override
185        public Unix4jCommandBuilder find(String path, String name) {
186                join(Find.Factory.find(path, name));
187                return this;
188        }
189        @Override
190        public Unix4jCommandBuilder find(long size) {
191                join(Find.Factory.find(size));
192                return this;
193        }
194        @Override
195        public Unix4jCommandBuilder find(String path, long size) {
196                join(Find.Factory.find(path, size));
197                return this;
198        }
199        @Override
200        public Unix4jCommandBuilder find(long size, String name) {
201                join(Find.Factory.find(size, name));
202                return this;
203        }
204        @Override
205        public Unix4jCommandBuilder find(String path, long size, String name) {
206                join(Find.Factory.find(path, size, name));
207                return this;
208        }
209        @Override
210        public Unix4jCommandBuilder find(FindOptions options, String name) {
211                join(Find.Factory.find(options, name));
212                return this;
213        }
214        @Override
215        public Unix4jCommandBuilder find(FindOptions options, String path, String name) {
216                join(Find.Factory.find(options, path, name));
217                return this;
218        }
219        @Override
220        public Unix4jCommandBuilder find(FindOptions options, long size) {
221                join(Find.Factory.find(options, size));
222                return this;
223        }
224        @Override
225        public Unix4jCommandBuilder find(FindOptions options, String path, long size) {
226                join(Find.Factory.find(options, path, size));
227                return this;
228        }
229        @Override
230        public Unix4jCommandBuilder find(FindOptions options, java.util.Date time) {
231                join(Find.Factory.find(options, time));
232                return this;
233        }
234        @Override
235        public Unix4jCommandBuilder find(FindOptions options, String path, java.util.Date time) {
236                join(Find.Factory.find(options, path, time));
237                return this;
238        }
239        @Override
240        public Unix4jCommandBuilder find(FindOptions options, long size, String name) {
241                join(Find.Factory.find(options, size, name));
242                return this;
243        }
244        @Override
245        public Unix4jCommandBuilder find(FindOptions options, String path, long size, String name) {
246                join(Find.Factory.find(options, path, size, name));
247                return this;
248        }
249        @Override
250        public Unix4jCommandBuilder find(FindOptions options, java.util.Date time, String name) {
251                join(Find.Factory.find(options, time, name));
252                return this;
253        }
254        @Override
255        public Unix4jCommandBuilder find(FindOptions options, String path, java.util.Date time, String name) {
256                join(Find.Factory.find(options, path, time, name));
257                return this;
258        }
259        @Override
260        public Unix4jCommandBuilder find(FindOptions options, long size, java.util.Date time, String name) {
261                join(Find.Factory.find(options, size, time, name));
262                return this;
263        }
264        @Override
265        public Unix4jCommandBuilder find(FindOptions options, String path, long size, java.util.Date time, String name) {
266                join(Find.Factory.find(options, path, size, time, name));
267                return this;
268        }
269
270        /* ------------------ from ------------------ */
271        @Override
272        public Unix4jCommandBuilder fromString(String string) {
273                join(From.Factory.fromString(string));
274                return this;
275        }
276        @Override
277        public Unix4jCommandBuilder fromStrings(String... strings) {
278                join(From.Factory.fromStrings(strings));
279                return this;
280        }
281        @Override
282        public Unix4jCommandBuilder from(java.util.Collection<? extends String> lines) {
283                join(From.Factory.from(lines));
284                return this;
285        }
286        @Override
287        public Unix4jCommandBuilder fromFile(String path) {
288                join(From.Factory.fromFile(path));
289                return this;
290        }
291        @Override
292        public Unix4jCommandBuilder fromFile(java.io.File file) {
293                join(From.Factory.fromFile(file));
294                return this;
295        }
296        @Override
297        public Unix4jCommandBuilder fromResource(String resource) {
298                join(From.Factory.fromResource(resource));
299                return this;
300        }
301        @Override
302        public Unix4jCommandBuilder from(java.io.InputStream stream) {
303                join(From.Factory.from(stream));
304                return this;
305        }
306        @Override
307        public Unix4jCommandBuilder from(java.io.Reader reader) {
308                join(From.Factory.from(reader));
309                return this;
310        }
311        @Override
312        public Unix4jCommandBuilder from(java.net.URL url) {
313                join(From.Factory.from(url));
314                return this;
315        }
316        @Override
317        public Unix4jCommandBuilder from(org.unix4j.io.Input input) {
318                join(From.Factory.from(input));
319                return this;
320        }
321
322        /* ------------------ grep ------------------ */
323        @Override
324        public Unix4jCommandBuilder grep(String... args) {
325                join(Grep.Factory.grep(args));
326                return this;
327        }
328        @Override
329        public Unix4jCommandBuilder grep(String regexp) {
330                join(Grep.Factory.grep(regexp));
331                return this;
332        }
333        @Override
334        public Unix4jCommandBuilder grep(String regexp, java.io.File... files) {
335                join(Grep.Factory.grep(regexp, files));
336                return this;
337        }
338        @Override
339        public Unix4jCommandBuilder grep(java.util.regex.Pattern pattern) {
340                join(Grep.Factory.grep(pattern));
341                return this;
342        }
343        @Override
344        public Unix4jCommandBuilder grep(java.util.regex.Pattern pattern, java.io.File... files) {
345                join(Grep.Factory.grep(pattern, files));
346                return this;
347        }
348        @Override
349        public Unix4jCommandBuilder grep(java.util.regex.Pattern pattern, String... paths) {
350                join(Grep.Factory.grep(pattern, paths));
351                return this;
352        }
353        @Override
354        public Unix4jCommandBuilder grep(GrepOptions options, String regexp) {
355                join(Grep.Factory.grep(options, regexp));
356                return this;
357        }
358        @Override
359        public Unix4jCommandBuilder grep(GrepOptions options, java.util.regex.Pattern pattern) {
360                join(Grep.Factory.grep(options, pattern));
361                return this;
362        }
363        @Override
364        public Unix4jCommandBuilder grep(GrepOptions options, String regexp, java.io.File... files) {
365                join(Grep.Factory.grep(options, regexp, files));
366                return this;
367        }
368        @Override
369        public Unix4jCommandBuilder grep(GrepOptions options, String regexp, String... paths) {
370                join(Grep.Factory.grep(options, regexp, paths));
371                return this;
372        }
373        @Override
374        public Unix4jCommandBuilder grep(GrepOptions options, java.util.regex.Pattern pattern, java.io.File... files) {
375                join(Grep.Factory.grep(options, pattern, files));
376                return this;
377        }
378        @Override
379        public Unix4jCommandBuilder grep(GrepOptions options, java.util.regex.Pattern pattern, String... paths) {
380                join(Grep.Factory.grep(options, pattern, paths));
381                return this;
382        }
383
384        /* ------------------ head ------------------ */
385        @Override
386        public Unix4jCommandBuilder head() {
387                join(Head.Factory.head());
388                return this;
389        }
390        @Override
391        public Unix4jCommandBuilder head(String... args) {
392                join(Head.Factory.head(args));
393                return this;
394        }
395        @Override
396        public Unix4jCommandBuilder head(long count) {
397                join(Head.Factory.head(count));
398                return this;
399        }
400        @Override
401        public Unix4jCommandBuilder head(HeadOptions options, long count) {
402                join(Head.Factory.head(options, count));
403                return this;
404        }
405        @Override
406        public Unix4jCommandBuilder head(java.io.File... files) {
407                join(Head.Factory.head(files));
408                return this;
409        }
410        @Override
411        public Unix4jCommandBuilder head(long count, java.io.File... files) {
412                join(Head.Factory.head(count, files));
413                return this;
414        }
415        @Override
416        public Unix4jCommandBuilder head(long count, String... paths) {
417                join(Head.Factory.head(count, paths));
418                return this;
419        }
420        @Override
421        public Unix4jCommandBuilder head(HeadOptions options, long count, java.io.File... files) {
422                join(Head.Factory.head(options, count, files));
423                return this;
424        }
425        @Override
426        public Unix4jCommandBuilder head(HeadOptions options, long count, String... paths) {
427                join(Head.Factory.head(options, count, paths));
428                return this;
429        }
430
431        /* ------------------ ls ------------------ */
432        @Override
433        public Unix4jCommandBuilder ls() {
434                join(Ls.Factory.ls());
435                return this;
436        }
437        @Override
438        public Unix4jCommandBuilder ls(String... args) {
439                join(Ls.Factory.ls(args));
440                return this;
441        }
442        @Override
443        public Unix4jCommandBuilder ls(java.io.File... files) {
444                join(Ls.Factory.ls(files));
445                return this;
446        }
447        @Override
448        public Unix4jCommandBuilder ls(LsOptions options) {
449                join(Ls.Factory.ls(options));
450                return this;
451        }
452        @Override
453        public Unix4jCommandBuilder ls(LsOptions options, java.io.File... files) {
454                join(Ls.Factory.ls(options, files));
455                return this;
456        }
457        @Override
458        public Unix4jCommandBuilder ls(LsOptions options, String... paths) {
459                join(Ls.Factory.ls(options, paths));
460                return this;
461        }
462
463        /* ------------------ sed ------------------ */
464        @Override
465        public Unix4jCommandBuilder sed(String... args) {
466                join(Sed.Factory.sed(args));
467                return this;
468        }
469        @Override
470        public Unix4jCommandBuilder sed(String script) {
471                join(Sed.Factory.sed(script));
472                return this;
473        }
474        @Override
475        public Unix4jCommandBuilder sed(String regexp, String replacement) {
476                join(Sed.Factory.sed(regexp, replacement));
477                return this;
478        }
479        @Override
480        public Unix4jCommandBuilder sed(String regexp, String replacement, int... occurrence) {
481                join(Sed.Factory.sed(regexp, replacement, occurrence));
482                return this;
483        }
484        @Override
485        public Unix4jCommandBuilder sed(SedOptions options, String regexp) {
486                join(Sed.Factory.sed(options, regexp));
487                return this;
488        }
489        @Override
490        public Unix4jCommandBuilder sed(SedOptions options, String string1, String string2) {
491                join(Sed.Factory.sed(options, string1, string2));
492                return this;
493        }
494        @Override
495        public Unix4jCommandBuilder sed(SedOptions options, String string1, String string2, int... occurrence) {
496                join(Sed.Factory.sed(options, string1, string2, occurrence));
497                return this;
498        }
499
500        /* ------------------ sort ------------------ */
501        @Override
502        public Unix4jCommandBuilder sort() {
503                join(Sort.Factory.sort());
504                return this;
505        }
506        @Override
507        public Unix4jCommandBuilder sort(String... args) {
508                join(Sort.Factory.sort(args));
509                return this;
510        }
511        @Override
512        public Unix4jCommandBuilder sort(java.io.File... files) {
513                join(Sort.Factory.sort(files));
514                return this;
515        }
516        @Override
517        public Unix4jCommandBuilder sort(java.util.Comparator<? super org.unix4j.line.Line> comparator) {
518                join(Sort.Factory.sort(comparator));
519                return this;
520        }
521        @Override
522        public Unix4jCommandBuilder sort(java.util.Comparator<? super org.unix4j.line.Line> comparator, java.io.File... files) {
523                join(Sort.Factory.sort(comparator, files));
524                return this;
525        }
526        @Override
527        public Unix4jCommandBuilder sort(java.util.Comparator<? super org.unix4j.line.Line> comparator, String... paths) {
528                join(Sort.Factory.sort(comparator, paths));
529                return this;
530        }
531        @Override
532        public Unix4jCommandBuilder sort(SortOptions options) {
533                join(Sort.Factory.sort(options));
534                return this;
535        }
536        @Override
537        public Unix4jCommandBuilder sort(SortOptions options, java.io.File... files) {
538                join(Sort.Factory.sort(options, files));
539                return this;
540        }
541        @Override
542        public Unix4jCommandBuilder sort(SortOptions options, String... paths) {
543                join(Sort.Factory.sort(options, paths));
544                return this;
545        }
546        @Override
547        public Unix4jCommandBuilder sort(SortOptions options, java.util.Comparator<? super org.unix4j.line.Line> comparator) {
548                join(Sort.Factory.sort(options, comparator));
549                return this;
550        }
551        @Override
552        public Unix4jCommandBuilder sort(SortOptions options, java.util.Comparator<? super org.unix4j.line.Line> comparator, java.io.File... files) {
553                join(Sort.Factory.sort(options, comparator, files));
554                return this;
555        }
556        @Override
557        public Unix4jCommandBuilder sort(SortOptions options, java.util.Comparator<? super org.unix4j.line.Line> comparator, String... paths) {
558                join(Sort.Factory.sort(options, comparator, paths));
559                return this;
560        }
561
562        /* ------------------ tail ------------------ */
563        @Override
564        public Unix4jCommandBuilder tail() {
565                join(Tail.Factory.tail());
566                return this;
567        }
568        @Override
569        public Unix4jCommandBuilder tail(String... args) {
570                join(Tail.Factory.tail(args));
571                return this;
572        }
573        @Override
574        public Unix4jCommandBuilder tail(long count) {
575                join(Tail.Factory.tail(count));
576                return this;
577        }
578        @Override
579        public Unix4jCommandBuilder tail(TailOptions options, long count) {
580                join(Tail.Factory.tail(options, count));
581                return this;
582        }
583        @Override
584        public Unix4jCommandBuilder tail(java.io.File... files) {
585                join(Tail.Factory.tail(files));
586                return this;
587        }
588        @Override
589        public Unix4jCommandBuilder tail(long count, java.io.File... files) {
590                join(Tail.Factory.tail(count, files));
591                return this;
592        }
593        @Override
594        public Unix4jCommandBuilder tail(long count, String... paths) {
595                join(Tail.Factory.tail(count, paths));
596                return this;
597        }
598        @Override
599        public Unix4jCommandBuilder tail(TailOptions options, long count, java.io.File... files) {
600                join(Tail.Factory.tail(options, count, files));
601                return this;
602        }
603        @Override
604        public Unix4jCommandBuilder tail(TailOptions options, long count, String... paths) {
605                join(Tail.Factory.tail(options, count, paths));
606                return this;
607        }
608
609        /* ------------------ uniq ------------------ */
610        @Override
611        public Unix4jCommandBuilder uniq() {
612                join(Uniq.Factory.uniq());
613                return this;
614        }
615        @Override
616        public Unix4jCommandBuilder uniq(String... args) {
617                join(Uniq.Factory.uniq(args));
618                return this;
619        }
620        @Override
621        public Unix4jCommandBuilder uniq(java.io.File file) {
622                join(Uniq.Factory.uniq(file));
623                return this;
624        }
625        @Override
626        public Unix4jCommandBuilder uniq(String path) {
627                join(Uniq.Factory.uniq(path));
628                return this;
629        }
630        @Override
631        public Unix4jCommandBuilder uniq(UniqOptions options) {
632                join(Uniq.Factory.uniq(options));
633                return this;
634        }
635        @Override
636        public Unix4jCommandBuilder uniq(UniqOptions options, java.io.File file) {
637                join(Uniq.Factory.uniq(options, file));
638                return this;
639        }
640        @Override
641        public Unix4jCommandBuilder uniq(UniqOptions options, String path) {
642                join(Uniq.Factory.uniq(options, path));
643                return this;
644        }
645
646        /* ------------------ wc ------------------ */
647        @Override
648        public Unix4jCommandBuilder wc() {
649                join(Wc.Factory.wc());
650                return this;
651        }
652        @Override
653        public Unix4jCommandBuilder wc(String... args) {
654                join(Wc.Factory.wc(args));
655                return this;
656        }
657        @Override
658        public Unix4jCommandBuilder wc(java.io.File... files) {
659                join(Wc.Factory.wc(files));
660                return this;
661        }
662        @Override
663        public Unix4jCommandBuilder wc(WcOptions options) {
664                join(Wc.Factory.wc(options));
665                return this;
666        }
667        @Override
668        public Unix4jCommandBuilder wc(WcOptions options, java.io.File... files) {
669                join(Wc.Factory.wc(options, files));
670                return this;
671        }
672        @Override
673        public Unix4jCommandBuilder wc(WcOptions options, String[] paths) {
674                join(Wc.Factory.wc(options, paths));
675                return this;
676        }
677
678        /* ------------------ xargs ------------------ */
679        @Override
680        public Unix4jCommandBuilder xargs() {
681                join(Xargs.Factory.xargs());
682                return this;
683        }
684        @Override
685        public Unix4jCommandBuilder xargs(String... args) {
686                join(Xargs.Factory.xargs(args));
687                return this;
688        }
689        @Override
690        public Unix4jCommandBuilder xargs(String delimiter) {
691                join(Xargs.Factory.xargs(delimiter));
692                return this;
693        }
694        @Override
695        public Unix4jCommandBuilder xargs(long maxLines) {
696                join(Xargs.Factory.xargs(maxLines));
697                return this;
698        }
699        @Override
700        public Unix4jCommandBuilder xargs(int maxArgs) {
701                join(Xargs.Factory.xargs(maxArgs));
702                return this;
703        }
704        @Override
705        public Unix4jCommandBuilder xargs(long maxLines, int maxArgs) {
706                join(Xargs.Factory.xargs(maxLines, maxArgs));
707                return this;
708        }
709        @Override
710        public Unix4jCommandBuilder xargs(String delimiter, long maxLines) {
711                join(Xargs.Factory.xargs(delimiter, maxLines));
712                return this;
713        }
714        @Override
715        public Unix4jCommandBuilder xargs(String delimiter, int maxArgs) {
716                join(Xargs.Factory.xargs(delimiter, maxArgs));
717                return this;
718        }
719        @Override
720        public Unix4jCommandBuilder xargs(String delimiter, long maxLines, int maxArgs) {
721                join(Xargs.Factory.xargs(delimiter, maxLines, maxArgs));
722                return this;
723        }
724        @Override
725        public Unix4jCommandBuilder xargs(String delimiter, String eof, long maxLines, int maxArgs) {
726                join(Xargs.Factory.xargs(delimiter, eof, maxLines, maxArgs));
727                return this;
728        }
729        @Override
730        public Unix4jCommandBuilder xargs(XargsOptions options) {
731                join(Xargs.Factory.xargs(options));
732                return this;
733        }
734        @Override
735        public Unix4jCommandBuilder xargs(XargsOptions options, String delimiter) {
736                join(Xargs.Factory.xargs(options, delimiter));
737                return this;
738        }
739        @Override
740        public Unix4jCommandBuilder xargs(XargsOptions options, long maxLines) {
741                join(Xargs.Factory.xargs(options, maxLines));
742                return this;
743        }
744        @Override
745        public Unix4jCommandBuilder xargs(XargsOptions options, int maxArgs) {
746                join(Xargs.Factory.xargs(options, maxArgs));
747                return this;
748        }
749        @Override
750        public Unix4jCommandBuilder xargs(XargsOptions options, long maxLines, int maxArgs) {
751                join(Xargs.Factory.xargs(options, maxLines, maxArgs));
752                return this;
753        }
754        @Override
755        public Unix4jCommandBuilder xargs(XargsOptions options, String delimiter, long maxLines) {
756                join(Xargs.Factory.xargs(options, delimiter, maxLines));
757                return this;
758        }
759        @Override
760        public Unix4jCommandBuilder xargs(XargsOptions options, String delimiter, int maxArgs) {
761                join(Xargs.Factory.xargs(options, delimiter, maxArgs));
762                return this;
763        }
764        @Override
765        public Unix4jCommandBuilder xargs(XargsOptions options, String delimiter, long maxLines, int maxArgs) {
766                join(Xargs.Factory.xargs(options, delimiter, maxLines, maxArgs));
767                return this;
768        }
769        @Override
770        public Unix4jCommandBuilder xargs(XargsOptions options, String delimiter, String eof, long maxLines, int maxArgs) {
771                join(Xargs.Factory.xargs(options, delimiter, eof, maxLines, maxArgs));
772                return this;
773        }
774
775        @Override
776        public Unix4jCommandBuilder join(Command<?> command) {
777                super.join(command);
778                return this;
779        }
780        
781        @Override
782        public Unix4jCommandBuilder apply(LineOperation operation) {
783                super.apply(operation);
784                return this;
785        }
786
787        @Override
788        public Unix4jCommandBuilder reset() {
789                super.reset();
790                return this;
791        }
792
793}