source: branches/eraser6/pluginsRewrite/Eraser.Plugins/ExtensionPoints/IErasureTarget.cs @ 2439

/* 
 * $Id: ErasureTarget.cs 2132 2010-05-15 13:50:31Z lowjoel $
 * Copyright 2008-2010 The Eraser Project
 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
 * Modified By:
 * 
 * This file is part of Eraser.
 * 
 * Eraser is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 * 
 * A copy of the GNU General Public License can be found at
 * <http://www.gnu.org/licenses/>.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Runtime.Serialization;
using System.Security.Permissions;

using Eraser.Util;
using Eraser.Plugins.Registrars;

namespace Eraser.Plugins.ExtensionPoints
{
    /// <summary>
    /// Represents a generic target of erasure
    /// </summary>
    [Serializable]
    public abstract class IErasureTarget : ISerializable, IRegisterable
    {
        #region Serialization code
        protected IErasureTarget(SerializationInfo info, StreamingContext context)
        {
            Guid methodGuid = (Guid)info.GetValue("Method", typeof(Guid));
            if (methodGuid == Guid.Empty)
                Method = ErasureMethodRegistrar.Default;
            else
                Method = Host.Instance.ErasureMethods[methodGuid];
        }

        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Method", Method.Guid);
        }
        #endregion

        #region IRegisterable Members

        public abstract Guid Guid
        {
            get;
        }

        #endregion

        /// <summary>
        /// Constructor.
        /// </summary>
        protected IErasureTarget()
        {
            Method = ErasureMethodRegistrar.Default;
        }

        /// <summary>
        /// The name of the type of the Erasure target.
        /// </summary>
        public abstract string Name
        {
            get;
        }

        /// <summary>
        /// The method used for erasing the file.
        /// </summary>
        public IErasureMethod Method
        {
            get
            {
                return method;
            }
            set
            {
                if (!SupportsMethod(value))
                    throw new ArgumentException(S._("The selected erasure method is not " +
                        "supported for this erasure target."));
                method = value;
            }
        }

        /// <summary>
        /// Gets the effective erasure method for the current target (i.e., returns
        /// the correct erasure method for cases where the <see cref="Method"/>
        /// property is <see cref="ErasureMethodRegistrar.Default"/>
        /// </summary>
        /// <returns>The Erasure method which the target should be erased with.
        /// This function will never return <see cref="ErasureMethodRegistrar.Default"/></returns>
        public virtual IErasureMethod EffectiveMethod
        {
            get
            {
                if (Method != ErasureMethodRegistrar.Default)
                    return Method;

                throw new InvalidOperationException("The effective method of the erasure " +
                    "target cannot be ErasureMethodRegistrar.Default");
            }
        }

        /// <summary>
        /// Checks whether the provided erasure method is supported by this current
        /// target.
        /// </summary>
        /// <param name="method">The erasure method to check.</param>
        /// <returns>True if the erasure method is supported, false otherwise.</returns>
        public virtual bool SupportsMethod(IErasureMethod method)
        {
            return true;
        }

        /// <summary>
        /// Retrieves the text to display representing this target.
        /// </summary>
        public abstract string UIText
        {
            get;
        }

        /// <summary>
        /// The Progress Changed event handler of the owning task.
        /// </summary>
        protected internal Action<IErasureTarget, ProgressChangedEventArgs> OnProgressChanged
        {
            get;
            internal set;
        }

        /// <summary>
        /// Gets an <see cref="IErasureTargetConfigurer"/> which contains settings for
        /// configuring this task, or null if this erasure target has no settings to be set.
        /// </summary>
        /// <remarks>The result should be able to be passed to the <see cref="Configure"/>
        /// function, and settings for this task will be according to the returned
        /// control.</remarks>
        public abstract IErasureTargetConfigurer Configurer
        {
            get;
        }

        /// <summary>
        /// Executes the given target.
        /// </summary>
        public abstract void Execute();

        /// <summary>
        /// The backing variable for the <see cref="Method"/> property.
        /// </summary>
        private IErasureMethod method;
    }

    /// <summary>
    /// Represents an interface for an abstract erasure target configuration
    /// object.
    /// </summary>
    public interface IErasureTargetConfigurer : ICliConfigurer<IErasureTarget>
    {
    }
}