using System;
using System.Runtime.Serialization;

namespace Chernobyl
{
    /// <summary> 
    /// A generic version of the <see cref="WeakReference"/> class. This class 
    /// is used to refer to an object while still allowing that object to be 
    /// garbage collected.
    /// </summary>    
    /// <typeparam name="T">The type of the object being garbage collected. This 
    /// type must be a reference type.</typeparam>    
    [Serializable]
    public class WeakReference<T> : WeakReference where T : class
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="WeakReference{T}"/> class.
        /// </summary>
        /// <param name="target">The object to track or null.</param>
        public WeakReference(T target) : base(target) 
        { }

        /// <summary>        
        /// Initializes a new instance of the WeakReference{T} class, referencing 
        /// the specified object and using the specified resurrection tracking. 
        /// </summary>        
        /// <param name="target">An object to track.</param> 
        /// <param name="trackResurrection">Indicates when to stop tracking the 
        /// object. If true, the object is tracked after finalization; if false, 
        /// the object is only tracked until finalization.</param> 
        public WeakReference(T target, bool trackResurrection)
            : base(target, trackResurrection) 
        { }
        
        /// <summary>
        /// Initializes a new instance of the <see cref="WeakReference{T}"/> class
        /// using deserialized data from the specified serialization and stream 
        /// objects.
        /// </summary>
        /// <param name="info">An object that holds all the data needed to 
        /// serialize or deserialize this <see cref="WeakReference{T}"/> object.</param>
        /// <param name="context">Describes the source and destination of the 
        /// serialized stream specified by info.</param>
        protected WeakReference(SerializationInfo info, StreamingContext context)
            : base(info, context) 
        { }

        /// <summary> 
        /// The object being referenced or null if the object has been garbage 
        /// collected.
        /// 
        /// Performance Warning: Note that, the target will need to be casted 
        /// from the <see cref="WeakReference.Target"/> property to ensure it is 
        /// of the proper type. Therefore, call this method sparingly. If you 
        /// need to check if an object has been garbage collected, use the 
        /// <see cref="WeakReference.IsAlive"/> property instead.
        /// </summary> 
        public new T Target
        {
            get { return (T)base.Target; }
            set { base.Target = value; }
        }
    }
}