//-----------------------------------------------------------------------
// <copyright file="IDtoAssembler.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>9-2-2009</date>
// <summary>Defines a contract for the data transfer object assembler</summary>
//-----------------------------------------------------------------------
using System.Collections.Generic;
using System.Xml.Linq;

namespace Deltares.Standard
{
    /// <summary>
    /// Defines the contract of a data transfer object (dto) assembler
    /// The interface should be used in scenario's where an domain object needs 
    /// to be created from a dto and vice versa.
    /// The dto in this case can be any class.
    /// </summary>
    /// <typeparam name="TDomainObject">The domain object type</typeparam>
    /// <typeparam name="TDataTransferObject">The dto object type</typeparam>
    public interface IDtoAssembler<TDomainObject, TDataTransferObject>
    {
        /// <summary>
        /// Creates a domain object from dto 
        /// </summary>
        /// <param name="dtoObj">The dto to create a domain object from</param>
        /// <returns>The domain object</returns>
        TDomainObject CreateDomainObject(TDataTransferObject dtoObj);

        /// <summary>
        /// Creates a dto from a domain object
        /// </summary>
        /// <param name="domainObj">The domain object to create the dto from</param>
        /// <returns>The dto object</returns>
        TDataTransferObject CreateDataTransferObject(TDomainObject domainObj);
    }

    /// <summary>
    /// Defines the contract of a data transfer object (dto) assembler
    /// The interface should be used in scenario's where an domain object needs 
    /// to be created from a dto and vice versa.
    /// The dto in this case can be any class.
    /// </summary>
    /// <typeparam name="TDomainObject">The domain object type</typeparam>
    /// <typeparam name="TDataTransferObject">The dto object type</typeparam>
    public interface IDtoAssembler<TDomainInputObject, TDomainOutputObject, TDataTransferObject>
    {
        /// <summary>
        /// Creates a domain object from output dto 
        /// </summary>
        /// <param name="dtoObj">The dto to create a domain object from</param>
        /// <returns>The domain object</returns>
        TDomainOutputObject CreateOutputObject(TDataTransferObject dto);

        /// <summary>
        /// Creates a domain object from output dto 
        /// </summary>
        /// <param name="dtoObj">The dto to create a domain object from</param>
        /// <returns>The domain object</returns>
        TDomainInputObject CreateInputObject(TDataTransferObject dto);

        /// <summary>
        /// Creates a dto from a domain input object
        /// </summary>
        /// <param name="domainObj">The domain object to create the dto from</param>
        /// <returns>The dto object</returns>
        TDataTransferObject CreateDataTransferObject(TDomainInputObject input);
    }


    /// <summary>
    /// Defines the contract of a data transfer object (dto) assembler
    /// The interface should be used in scenario's where an domain object needs 
    /// to be created from a dto and vice versa.
    /// The dto in this case is a <see cref="XElement"/> object.
    /// </summary>
    /// <typeparam name="TDomainObject">The domain object type</typeparam>
    public interface IDtoAssembler<TDomainObject> : IDtoAssembler<TDomainObject, XElement>
    {
        string ElementName { get; }
    }

    /// <summary>
    /// Defines the contract of a data transfer object (dto) collection assembler
    /// The interface should be used in scenario's where an domain object collections needs 
    /// to be created from a dto collection and vice versa.
    /// The dto in this case is a <see cref="XElement"/> object.
    /// </summary>
    /// <typeparam name="TDomainObject">The domain object type in the collection</typeparam>
    /// <typeparam name="TDataTransferObject">The data transfer object type in the collection</typeparam>
    public interface IDtoCollectionAssembler<TDomainObject, TDataTransferObject>
    {
        /// <summary>
        /// Gets the entity assembler
        /// </summary>
        IDtoAssembler<TDomainObject> EntityAssembler { get; }

        /// <summary>
        /// Create the domain object collection
        /// </summary>
        /// <param name="dtoCollObj">The dto collection object from which to create domain collection</param>
        /// <returns>The (typed) domain object collection</returns>
        IEnumerable<TDomainObject> CreateDomainObjectCollection(TDataTransferObject dtoCollObj);

        /// <summary>
        /// Created the data transfer collection object
        /// </summary>
        /// <param name="domainCollObj">The domain collection from which to create the dto collection</param>
        /// <returns>The dto collection object</returns>
        TDataTransferObject CreateDataTransferObject(IEnumerable<TDomainObject> domainCollObj);
    }

    /// <summary>
    /// Defines the contract of a data transfer object (dto) collection assembler
    /// The interface should be used in scenario's where an domain object collections needs 
    /// to be created from a dto collection and vice versa.
    /// The dto in this case is a <see cref="XElement"/> object.
    /// </summary>
    /// <typeparam name="TDomainObject">The domain object type in the collection</typeparam>
    public interface IDtoCollectionAssembler<TDomainObject> : IDtoCollectionAssembler<TDomainObject, XElement>
    {
        string ElementName { get; }
    }
}