001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.camel.component.file;
018
019 import java.util.Comparator;
020
021 import org.apache.camel.Expression;
022 import org.apache.camel.language.simple.FileLanguage;
023 import org.apache.camel.util.ObjectHelper;
024
025 /**
026 * Default file sorter.
027 */
028 public final class GenericFileDefaultSorter {
029
030 private GenericFileDefaultSorter() {
031 }
032
033 /**
034 * Returns a new sort by name
035 */
036 public static Comparator<GenericFile> sortByName(final boolean reverse) {
037 return new Comparator<GenericFile>() {
038 public int compare(GenericFile o1, GenericFile o2) {
039 int answer = o1.getFileName().compareTo(o2.getFileName());
040 return reverse ? -1 * answer : answer;
041 }
042 };
043 }
044
045 /**
046 * Returns a new sort by path name
047 */
048 public static Comparator<GenericFile> sortByPathName(final boolean reverse) {
049 return new Comparator<GenericFile>() {
050 public int compare(GenericFile o1, GenericFile o2) {
051 int answer = o1.getParent().compareTo(o2.getParent());
052 return reverse ? -1 * answer : answer;
053 }
054 };
055 }
056
057 /**
058 * Returns a new sort by last modified (newest first)
059 */
060 public static Comparator<GenericFile> sortByLastModified(
061 final boolean reverse) {
062 return new Comparator<GenericFile>() {
063 public int compare(GenericFile o1, GenericFile o2) {
064 long delta = o1.getLastModified() - o2.getLastModified();
065 if (delta == 0) {
066 return 0;
067 }
068 int answer = delta > 0 ? 1 : -1;
069 return reverse ? -1 * answer : answer;
070 }
071 };
072 }
073
074 /**
075 * Returns a new sort by file size (smallest first)
076 */
077 public static Comparator<GenericFile> sortBySize(final boolean reverse) {
078 return new Comparator<GenericFile>() {
079 public int compare(GenericFile o1, GenericFile o2) {
080 long delta = o1.getFileLength() - o2.getFileLength();
081 if (delta == 0) {
082 return 0;
083 }
084 int answer = delta > 0 ? 1 : -1;
085 return reverse ? -1 * answer : answer;
086 }
087 };
088 }
089
090 /**
091 * Returns a new sory by file language expression
092 *
093 * @param expression the file language expression
094 * @param reverse true to reverse order
095 * @return the comparator
096 */
097 public static Comparator<GenericFileExchange> sortByFileLanguage(
098 final String expression, final boolean reverse) {
099 return sortByFileLanguage(expression, reverse, false, null);
100 }
101
102 /**
103 * Returns a new sory by file language expression
104 *
105 * @param expression the file language expression
106 * @param reverse true to reverse order
107 * @param ignoreCase ignore case if comparing strings
108 * @return the comparator
109 */
110 public static Comparator<GenericFileExchange> sortByFileLanguage(
111 final String expression, final boolean reverse, final boolean ignoreCase) {
112 return sortByFileLanguage(expression, reverse, ignoreCase, null);
113 }
114
115 /**
116 * Returns a new sort by file language expression
117 *
118 * @param expression the file language expression
119 * @param reverse true to reverse order
120 * @param ignoreCase ignore case if comparing strings
121 * @param nested nested comparator for sub group sorting, can be null
122 * @return the comparator
123 */
124 public static Comparator<GenericFileExchange> sortByFileLanguage(
125 final String expression, final boolean reverse,
126 final boolean ignoreCase, final Comparator<GenericFileExchange> nested) {
127 return new Comparator<GenericFileExchange>() {
128 public int compare(GenericFileExchange o1, GenericFileExchange o2) {
129 final Expression exp = FileLanguage.file(expression);
130 Object result1 = exp.evaluate(o1);
131 Object result2 = exp.evaluate(o2);
132 int answer = ObjectHelper.compare(result1, result2, ignoreCase);
133 // if equal then sub sort by nested comparator
134 if (answer == 0 && nested != null) {
135 answer = nested.compare(o1, o2);
136 }
137 return reverse ? -1 * answer : answer;
138 }
139
140 public String toString() {
141 return expression + (nested != null ? ";" + nested.toString() : "");
142 }
143 };
144 }
145
146 }