import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static InputStream genericFileToInputStream(GenericFile<?> file, Exchange exchange) throws IOException, NoTypeConversionAvailableException {
    if (file.getFile() instanceof File) {
        // prefer to use a file input stream if its a java.io.File
        File f = (File) file.getFile();
        // the file must exists
        if (f.exists()) {
            // read the file using the specified charset
            String charset = file.getCharset();
            if (charset != null) {
                LOG.debug("Read file {} with charset {}", f, file.getCharset());
            } else {
                LOG.debug("Read file {} (no charset)", f);
            }
            return IOConverter.toInputStream(f, charset);
        }
    }
    if (exchange != null) {
        // otherwise ensure the body is loaded as we want the input stream of the body
        file.getBinding().loadContent(exchange, file);
        return exchange.getContext().getTypeConverter().convertTo(InputStream.class, exchange, file.getBody());
    } else {
        // should revert to fallback converter if we don't have an exchange
        return null;
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
/**
 * Returns the converted value, or null if the value is null
 */
@Converter
public static Class<?> toClass(Object value, Exchange exchange) {
    if (value instanceof Class) {
        return (Class<?>) value;
    } else if (value instanceof String) {
        // prefer to use class resolver API
        if (exchange != null) {
            return exchange.getContext().getClassResolver().resolveClass((String) value);
        } else {
            return ObjectHelper.loadClass((String) value);
        }
    } else {
        return null;
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static ByteBuffer toByteBuffer(File file) throws IOException {
    InputStream in = null;
    try {
        byte[] buf = new byte[(int)file.length()];
        in = IOHelper.buffered(new FileInputStream(file));
        int sizeLeft = (int)file.length();
        int offset = 0;
        while (sizeLeft > 0) {
            int readSize = in.read(buf, offset, sizeLeft);
            sizeLeft -= readSize;
            offset += readSize;
        }
        return ByteBuffer.wrap(buf);
    } finally {
        IOHelper.close(in, "Failed to close file stream: " + file.getPath(), LOG);
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static List<Map<String, Object>> toList(DataSet dataSet) {
    List<Map<String, Object>> answer = new ArrayList<Map<String, Object>>();
    dataSet.goTop();

    while (dataSet.next()) {
        Map<String, Object> map = new HashMap<String, Object>();
        putValues(map, dataSet);
        answer.add(map);
    }

    return answer;
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static byte[] toByteArray(ByteBuffer buffer) {
    buffer.mark();
    try {
        byte[] answer = new byte[buffer.remaining()];
        buffer.get(answer);
        return answer;
    } finally {
        buffer.reset();
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static <T> CxfPayload<T> sourceToCxfPayload(Source src, Exchange exchange) {
    List<T> headers = new ArrayList<T>();
    List<Source> body = new ArrayList<Source>();
    body.add(src);
    return new CxfPayload<T>(headers, body, null);
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
/**
 * Converts an {@link Iterator} to a {@link ArrayList}
 */
@Converter
public static <T> ArrayList<T> toArrayList(Iterator<T> it) {
    ArrayList<T> list = new ArrayList<T>();
    while (it.hasNext()) {
        list.add(it.next());
    }
    return list;
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
/**
 * Converts the given JavaMail multipart to a String body, where the content-type of the multipart
 * must be text based (ie start with text). Can return null.
 */
@Converter
public static String toString(Multipart multipart) throws MessagingException, IOException {
    int size = multipart.getCount();
    for (int i = 0; i < size; i++) {
        BodyPart part = multipart.getBodyPart(i);
        if (part.getContentType().toLowerCase().startsWith("text")) {
            return part.getContent().toString();
        }
    }
    return null;
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static Payload toPayload(final StreamSourceCache cache, Exchange exchange) throws IOException {
    long contentLength = ByteStreams.length(new InputSupplier<InputStream>() {
        @Override
        public InputStream getInput() throws IOException {
            return cache.getInputStream();
        }
    });
    cache.reset();
    InputStreamPayload payload = new InputStreamPayload(cache.getInputStream());
    payload.getContentMetadata().setContentLength(contentLength);
    setContentMetadata(payload, exchange);
    return payload;
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static OutgoingMessage toOutgoingMessage(String message, Exchange exchange) {
    if (message == null) {
        // fail fast
        return null;
    }

    Object typeObj = exchange.getIn().getHeader(TelegramConstants.TELEGRAM_MEDIA_TYPE);
    TelegramMediaType type;
    if (typeObj instanceof String) {
        type = TelegramMediaType.valueOf((String) typeObj);
    } else {
        type = (TelegramMediaType) typeObj;
    }

    // If the message is a string, it will be converted to a OutgoingTextMessage
    if (type == null) {
        type = TelegramMediaType.TEXT;
    }

    OutgoingMessage result;

    switch (type) {
    case TEXT: {
        OutgoingTextMessage txt = new OutgoingTextMessage();
        txt.setText(message);
        result = txt;
        break;
    }
    default: {
        throw new IllegalArgumentException("Unsupported conversion from String to media type " + type);
    }
    }


    return result;
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static DeleteRequest toDeleteRequest(String id, Exchange exchange) {
    return new DeleteRequest()
            .index(exchange.getIn().getHeader(
                    ElasticsearchConstants.PARAM_INDEX_NAME,
                    String.class))
            .type(exchange.getIn().getHeader(
                    ElasticsearchConstants.PARAM_INDEX_TYPE,
                    String.class)).id(id);
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
/**
 * Create a DOM document from the given Node.
 *
 * If the node is an document, just cast it, if the node is an root element, retrieve its
 * owner element or create a new document and import the node.
 */
@Converter
public Document toDOMDocument(final Node node) throws ParserConfigurationException, TransformerException {
    ObjectHelper.notNull(node, "node");

    // If the node is the document, just cast it
    if (node instanceof Document) {
        return (Document) node;
        // If the node is an element
    } else if (node instanceof Element) {
        Element elem = (Element) node;
        // If this is the root element, return its owner document
        if (elem.getOwnerDocument().getDocumentElement() == elem) {
            return elem.getOwnerDocument();
            // else, create a new doc and copy the element inside it
        } else {
            Document doc = createDocument();
            // import node must not occur concurrent on the same node (must be its owner)
            // so we need to synchronize on it
            synchronized (node.getOwnerDocument()) {
                doc.appendChild(doc.importNode(node, true));
            }
            return doc;
        }
        // other element types are not handled
    } else {
        throw new TransformerException("Unable to convert DOM node to a Document: " + node);
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static byte[] toByteArray(File file) throws IOException {
    InputStream is = toInputStream(file);
    try {
        return toBytes(is);
    } finally {
        IOHelper.close(is, "file", LOG);
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static <T> CxfPayload<T> elementToCxfPayload(Element element, Exchange exchange) {
    List<T> headers = new ArrayList<T>();
    List<Element> body = new ArrayList<Element>();
    body.add(element);
    return new CxfPayload<T>(headers, body);
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static String convertToString(ExecResult result, Exchange exchange) throws FileNotFoundException {
    // special for string, as we want an empty string if no output from stdin / stderr
    InputStream is = toInputStream(result);
    if (is != null) {
        return exchange.getContext().getTypeConverter().convertTo(String.class, exchange, is);
    } else {
        // no stdin/stdout, so return an empty string
        return "";
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static Method[] toMethods(String name) {
    String[] strings = name.split(",");
    List<Method> methods = new ArrayList<Method>();
    for (String string : strings) {
        methods.add(toMethod(string));
    }
    
    return methods.toArray(new Method[methods.size()]);
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static String toString(Status status) throws ParseException {
    return new StringBuilder()
        .append(status.getCreatedAt()).append(" (").append(status.getUser().getScreenName()).append(") ")
        .append(status.getText())
        .toString();
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static DBObject fromAnyObjectToDBObject(Object value) {
    BasicDBObject answer;
    try {
        Map<?, ?> m = OBJECT_MAPPER.convertValue(value, Map.class);
        answer = new BasicDBObject(m);
    } catch (Exception e) {
        LOG.warn("Conversion has fallen back to generic Object -> DBObject, but unable to convert type {}. Returning null.", 
                value.getClass().getCanonicalName());
        return null;
    }
    return answer;
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public static byte[] convertToByteArray(ExecResult result, Exchange exchange) throws FileNotFoundException, IOException {
    InputStream stream = toInputStream(result);
    try {
        return IOUtils.toByteArray(stream);
    } finally {
        IOUtils.closeQuietly(stream);
    }
}
 

import org.apache.camel.Converter; //导入依赖的package包/类
@Converter
public XMLStreamReader createXMLStreamReader(Reader reader) throws XMLStreamException {
    XMLInputFactory factory = getInputFactory();
    try {
        return factory.createXMLStreamReader(IOHelper.buffered(reader));
    } finally {
        returnXMLInputFactory(factory);
    }
}