/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.camel.converter.dozer;

import java.util.List;
import java.util.Map;

import org.dozer.CustomConverter;
import org.dozer.CustomFieldMapper;
import org.dozer.DozerEventListener;

public class DozerBeanMapperConfiguration {

    private List<String> mappingFiles;
    private List<CustomConverter> customConverters;
    private List<DozerEventListener> eventListeners;
    private Map<String, CustomConverter> customConvertersWithId;
    private CustomFieldMapper customFieldMapper;

    public List<String> getMappingFiles() {
        return mappingFiles;
    }

    public void setMappingFiles(List<String> mappingFiles) {
        this.mappingFiles = mappingFiles;
    }

    public List<CustomConverter> getCustomConverters() {
        return customConverters;
    }

    public void setCustomConverters(List<CustomConverter> customConverters) {
        this.customConverters = customConverters;
    }

    public List<DozerEventListener> getEventListeners() {
        return eventListeners;
    }

    public void setEventListeners(List<DozerEventListener> eventListeners) {
        this.eventListeners = eventListeners;
    }

    public Map<String, CustomConverter> getCustomConvertersWithId() {
        return customConvertersWithId;
    }

    public void setCustomConvertersWithId(Map<String, CustomConverter> customConvertersWithId) {
        this.customConvertersWithId = customConvertersWithId;
    }

    public CustomFieldMapper getCustomFieldMapper() {
        return customFieldMapper;
    }

    public void setCustomFieldMapper(CustomFieldMapper customFieldMapper) {
        this.customFieldMapper = customFieldMapper;
    }
}
