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.CamelContext;
022 import org.apache.camel.Expression;
023 import org.apache.camel.spi.Language;
024 import org.apache.camel.util.ObjectHelper;
025
026 /**
027 * Default file sorter.
028 */
029 public final class GenericFileDefaultSorter {
030
031 private GenericFileDefaultSorter() {
032 }
033
034 /**
035 * Returns a new sort by name
036 */
037 public static Comparator<GenericFile> sortByName(final boolean reverse) {
038 return new Comparator<GenericFile>() {
039 public int compare(GenericFile o1, GenericFile o2) {
040 int answer = o1.getFileName().compareTo(o2.getFileName());
041 return reverse ? -1 * answer : answer;
042 }
043 };
044 }
045
046 /**
047 * Returns a new sort by path name
048 */
049 public static Comparator<GenericFile> sortByPathName(final boolean reverse) {
050 return new Comparator<GenericFile>() {
051 public int compare(GenericFile o1, GenericFile o2) {
052 int answer = o1.getParent().compareTo(o2.getParent());
053 return reverse ? -1 * answer : answer;
054 }
055 };
056 }
057
058 /**
059 * Returns a new sort by last modified (newest first)
060 */
061 public static Comparator<GenericFile> sortByLastModified(
062 final boolean reverse) {
063 return new Comparator<GenericFile>() {
064 public int compare(GenericFile o1, GenericFile o2) {
065 long delta = o1.getLastModified() - o2.getLastModified();
066 if (delta == 0) {
067 return 0;
068 }
069 int answer = delta > 0 ? 1 : -1;
070 return reverse ? -1 * answer : answer;
071 }
072 };
073 }
074
075 /**
076 * Returns a new sort by file size (smallest first)
077 */
078 public static Comparator<GenericFile> sortBySize(final boolean reverse) {
079 return new Comparator<GenericFile>() {
080 public int compare(GenericFile o1, GenericFile o2) {
081 long delta = o1.getFileLength() - o2.getFileLength();
082 if (delta == 0) {
083 return 0;
084 }
085 int answer = delta > 0 ? 1 : -1;
086 return reverse ? -1 * answer : answer;
087 }
088 };
089 }
090
091 /**
092 * Returns a new sory by file language expression
093 *
094 * @param context the camel context
095 * @param expression the file language expression
096 * @param reverse true to reverse order
097 * @return the comparator
098 */
099 public static Comparator<GenericFileExchange> sortByFileLanguage(
100 CamelContext context, String expression, boolean reverse) {
101 return sortByFileLanguage(context, expression, reverse, false, null);
102 }
103
104 /**
105 * Returns a new sory by file language expression
106 *
107 * @param context the camel context
108 * @param expression the file language expression
109 * @param reverse true to reverse order
110 * @param ignoreCase ignore case if comparing strings
111 * @return the comparator
112 */
113 public static Comparator<GenericFileExchange> sortByFileLanguage(
114 CamelContext context, String expression, boolean reverse, boolean ignoreCase) {
115 return sortByFileLanguage(context, expression, reverse, ignoreCase, null);
116 }
117
118 /**
119 * Returns a new sort by file language expression
120 *
121 * @param context the camel context
122 * @param expression the file language expression
123 * @param reverse true to reverse order
124 * @param ignoreCase ignore case if comparing strings
125 * @param nested nested comparator for sub group sorting, can be null
126 * @return the comparator
127 */
128 public static Comparator<GenericFileExchange> sortByFileLanguage(
129 final CamelContext context, final String expression, final boolean reverse,
130 final boolean ignoreCase, final Comparator<GenericFileExchange> nested) {
131 return new Comparator<GenericFileExchange>() {
132 public int compare(GenericFileExchange o1, GenericFileExchange o2) {
133 Language language = context.resolveLanguage("file");
134 final Expression exp = language.createExpression(expression);
135 Object result1 = exp.evaluate(o1, Object.class);
136 Object result2 = exp.evaluate(o2, Object.class);
137 int answer = ObjectHelper.compare(result1, result2, ignoreCase);
138 // if equal then sub sort by nested comparator
139 if (answer == 0 && nested != null) {
140 answer = nested.compare(o1, o2);
141 }
142 return reverse ? -1 * answer : answer;
143 }
144
145 public String toString() {
146 return expression + (nested != null ? ";" + nested.toString() : "");
147 }
148 };
149 }
150
151 }