History.cs

/********************************************************************++
Copyright (c) Microsoft Corporation.  All rights reserved.
--********************************************************************/

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Management.Automation;
using System.Management.Automation.Host;
using System.Management.Automation.Internal;
using System.Management.Automation.Runspaces;
using Dbg = System.Management.Automation.Diagnostics;


namespace Microsoft.PowerShell.Commands
{
    /// <summary>
    /// Contains information about a single history entry
    /// </summary>
    public class HistoryInfo
    {
        #region constuctor

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="pipelineId">Id of pipeline in which command associated 
        /// with this history entry is executed</param>
        /// <param name="cmdline">command string</param>
        /// <param name="status">status of pipeline execution</param>
        /// <param name="startTime">startTime of execution</param>
        /// <param name="endTime">endTime of execution</param>
        internal HistoryInfo(long pipelineId, string cmdline, PipelineState status, DateTime startTime, DateTime endTime)
        {
            Dbg.Assert(cmdline != null, "caller should validate the parameter");
            _pipelineId = pipelineId;
            _cmdline = cmdline;
            _status = status;
            _startTime = startTime;
            _endTime = endTime;
            _cleared = false;
        }

        /// <summary>
        /// Copy constructor to support cloning
        /// </summary>
        /// <param name="history"></param>
        private HistoryInfo(HistoryInfo history)
        {
            _id = history._id;
            _pipelineId = history._pipelineId;
            _cmdline = history._cmdline;
            _status = history._status;
            _startTime = history._startTime;
            _endTime = history._endTime;
            _cleared = history._cleared;
        }

        #endregion constructor

        #region public
        /// <summary>
        /// Id of this history entry. 
        /// </summary>
        /// <value></value>
        public long Id
        {
            get
            {
                return _id;
            }
        }

        /// <summary>
        /// CommandLine string 
        /// </summary>
        /// <value></value>
        public string CommandLine
        {
            get
            {
                return _cmdline;
            }
        }

        /// <summary>
        /// Execution status of associated pipeline
        /// </summary>
        /// <value></value>
        public PipelineState ExecutionStatus
        {
            get
            {
                return _status;
            }
        }

        /// <summary>
        /// Start time of execution of associated pipeline
        /// </summary>
        /// <value></value>
        public DateTime StartExecutionTime
        {
            get
            {
                return _startTime;
            }
        }

        /// <summary>
        /// End time of execution of associated pipeline
        /// </summary>
        /// <value></value>
        public DateTime EndExecutionTime
        {
            get
            {
                return _endTime;
            }
        }

        /// <summary>
        /// Override for ToString() method
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            if (string.IsNullOrEmpty(_cmdline))
            {
                return base.ToString();
            }
            else
            {
                return _cmdline;
            }
        }


        #endregion public

        #region internal



        /// <summary>
        /// Cleared status of an entry
        /// </summary>

        internal bool Cleared
        {
            get
            {
                return _cleared;
            }
            set
            {
                _cleared = value;
            }
        }



        /// <summary>
        /// Sets Id
        /// </summary>
        /// <param name="id"></param>
        internal void SetId(long id)
        {
            _id = id;
        }

        /// <summary>
        /// Set status
        /// </summary>
        /// <param name="status"></param>
        internal void SetStatus(PipelineState status)
        {
            _status = status;
        }

        /// <summary>
        /// Set endtime
        /// </summary>
        /// <param name="endTime"></param>
        internal void SetEndTime(DateTime endTime)
        {
            _endTime = endTime;
        }

        /// <summary>
        /// Sets command
        /// </summary>
        /// <param name="command"></param>
        internal void SetCommand(string command)
        {
            _cmdline = command;
        }

        #endregion internal

        #region private

        /// <summary>
        /// Id of the pipeline corresponding to this history entry
        /// </summary>
        private long _pipelineId;

        /// <summary>
        /// Id of the history entry
        /// </summary>
        private long _id;

        /// <summary>
        /// CommandLine string
        /// </summary>
        private string _cmdline;

        /// <summary>
        /// ExecutionStatus of execution
        /// </summary>
        private PipelineState _status;

        /// <summary>
        /// Start time of execution
        /// </summary>
        private DateTime _startTime;

        ///
        ///End time of execution
        ///
        private DateTime _endTime;



        /// <summary>
        /// Flag indicating an entry is present/cleared
        /// </summary>

        private bool _cleared = false;

        #endregion private

        #region ICloneable Members

        /// <summary>
        /// Returns a clone of this object
        /// </summary>
        /// <returns></returns>
        public HistoryInfo Clone()
        {
            return new HistoryInfo(this);
        }

        #endregion
    }


    /// <summary>
    /// This class implements history and provides APIs for adding and fetching
    /// entries from history
    /// </summary>
    internal class History
    {
        /// <summary>
        /// Default history size
        /// </summary>
        internal const int DefaultHistorySize = 4096;

        #region constructors

        /// <summary>
        /// Constructs history store
        /// </summary>

        internal History(ExecutionContext context)
        {
            //Create history size variable. Add ValidateRangeAttribute to 
            //validate the range.
            Collection<Attribute> attrs = new Collection<Attribute>();
            attrs.Add(new ValidateRangeAttribute(1, (int)Int16.MaxValue));
            PSVariable historySizeVar = new PSVariable(SpecialVariables.HistorySize, DefaultHistorySize, ScopedItemOptions.None, attrs);
            historySizeVar.Description = SessionStateStrings.MaxHistoryCountDescription;

            context.EngineSessionState.SetVariable(historySizeVar, false, CommandOrigin.Internal);

            _capacity = DefaultHistorySize;
            _buffer = new HistoryInfo[_capacity];
        }

        #endregion constructors

        #region internal

        /// <summary>
        /// Create a new history entry
        /// </summary>
        /// <param name="pipelineId"></param>
        /// <param name="cmdline"></param>
        /// <param name="status"></param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="skipIfLocked">If true, the entry will not be added when the history is locked</param>
        /// <returns>id for the new created entry. Use this id to fetch the 
        /// entry. Returns -1 if the entry is not added</returns>
        /// <remarks>This function is thread safe</remarks>
        internal long AddEntry(long pipelineId, string cmdline, PipelineState status, DateTime startTime, DateTime endTime, bool skipIfLocked)
        {
            if (!System.Threading.Monitor.TryEnter(_syncRoot, skipIfLocked ? 0 : System.Threading.Timeout.Infinite))
            {
                return -1;
            }

            try
            {
                ReallocateBufferIfNeeded();

                HistoryInfo entry = new HistoryInfo(pipelineId, cmdline, status, startTime, endTime);
                return Add(entry);
            }
            finally
            {
                System.Threading.Monitor.Exit(_syncRoot);
            }
        }

        /// <summary>
        /// Update the history entry corresponding to id.
        /// </summary>
        /// <param name="id">id of history entry to be updated</param>
        /// <param name="status">status to be updated</param>
        /// <param name="endTime">endTime to be updated</param>
        /// <param name="skipIfLocked">If true, the entry will not be added when the history is locked</param>
        /// <returns></returns>
        internal void UpdateEntry(long id, PipelineState status, DateTime endTime, bool skipIfLocked)
        {
            if (!System.Threading.Monitor.TryEnter(_syncRoot, skipIfLocked ? 0 : System.Threading.Timeout.Infinite))
            {
                return;
            }

            try
            {
                HistoryInfo entry = CoreGetEntry(id);
                if (entry != null)
                {
                    entry.SetStatus(status);
                    entry.SetEndTime(endTime);
                }
            }
            finally
            {
                System.Threading.Monitor.Exit(_syncRoot);
            }
        }

        /// <summary>
        /// Gets entry from buffer for given id. This id should be the 
        /// id returned by Add method.
        /// </summary>
        /// <param name="id">Id of the entry to be fetched</param>
        /// <returns>entry corresponding to id if it is present else null
        /// </returns>
        internal HistoryInfo GetEntry(long id)
        {
            lock (_syncRoot)
            {
                ReallocateBufferIfNeeded();

                HistoryInfo entry = CoreGetEntry(id);
                if (entry != null)
                    if (entry.Cleared == false)
                        return entry.Clone();

                return null;
            }
        }



        /// <summary>
        /// Get count HistoryEntries 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="count"></param>
        /// <param name="newest"></param>        
        /// <returns>history entries</returns>
        internal HistoryInfo[] GetEntries(long id, long count, SwitchParameter newest)
        {
            ReallocateBufferIfNeeded();

            if (count < -1)
            {
                throw PSTraceSource.NewArgumentOutOfRangeException("count", count);
            }

            if (newest.ToString() == null)
            {
                throw PSTraceSource.NewArgumentNullException("newest");
            }


            if (count == -1 || count > _countEntriesAdded || count > _countEntriesInBuffer)
                count = _countEntriesInBuffer;

            if (count == 0 || _countEntriesInBuffer == 0)
            {
                return Utils.EmptyArray<HistoryInfo>();
            }

            lock (_syncRoot)
            {
                //Using list instead of an array to store the entries.With array we are getting null values
                //when the historybuffer size is changed
                List<HistoryInfo> entriesList = new List<HistoryInfo>();
                if (id > 0)
                {
                    long firstId, baseId;
                    baseId = id;

                    //get id,count,newest values
                    if (!newest.IsPresent)
                    {
                        //get older entries

                        //Calculate the first id (i.e lowest id to fetch)
                        firstId = baseId - count + 1;

                        //If first id is less than the lowest id in history store,
                        //assign lowest id as first ID
                        if (firstId < 1)
                        {
                            firstId = 1;
                        }

                        for (long i = baseId; i >= firstId; --i)
                        {
                            if (firstId <= 1) break;
                            // if entry is null , continue the loop with the next entry
                            if (_buffer[GetIndexFromId(i)] == null) continue;
                            if (_buffer[GetIndexFromId(i)].Cleared == true)
                            {
                                // we have to clear count entries before an id, so if an entry is null,decrement 
                                // first id as long as its is greater than the lowest entry in the buffer.
                                firstId--;
                                continue;
                            }
                        }

                        for (long i = firstId; i <= baseId; ++i)
                        {
                            //if an entry is null after being cleared by clear-history cmdlet,
                            //continue with the next entry
                            if (_buffer[GetIndexFromId(i)] == null || _buffer[GetIndexFromId(i)].Cleared == true)
                                continue;
                            entriesList.Add(_buffer[GetIndexFromId(i)].Clone());
                        }
                    }
                    else
                    { //get latest entries
                        // first id becomes the id +count no of entries from the end of the buffer
                        firstId = baseId + count - 1;
                        // if first id is more than the no of entries in the buffer, first id will be the last entry in the buffer
                        if (firstId >= _countEntriesAdded)
                        {
                            firstId = _countEntriesAdded;
                        }

                        for (long i = baseId; i <= firstId; i++)
                        {
                            if (firstId >= _countEntriesAdded) break;
                            // if entry is null , continue the loop with the next entry
                            if (_buffer[GetIndexFromId(i)] == null) continue;
                            if (_buffer[GetIndexFromId(i)].Cleared == true)
                            {
                                // we have to clear count entries before an id, so if an entry is null,increment  first id 
                                firstId++;
                                continue;
                            }
                        }

                        for (long i = firstId; i >= baseId; --i)
                        {
                            //if an entry is null after being cleared by clear-history cmdlet,
                            //continue with the next entry
                            if (_buffer[GetIndexFromId(i)] == null || _buffer[GetIndexFromId(i)].Cleared == true)
                                continue;
                            entriesList.Add(_buffer[GetIndexFromId(i)].Clone());
                        }
                    }
                }
                else
                {
                    //get entries for count,newest                                               

                    long index, SmallestID = 0;
                    //if we change the defaulthistory size and when no of entries exceed the size, then 
                    //we need to get the smallest entry in the buffer when we want to clear the oldest entry
                    //eg if size is 5 and then the entries can be 7,6,1,2,3
                    if (_capacity != DefaultHistorySize)
                        SmallestID = SmallestIDinBuffer();
                    if (!newest.IsPresent)
                    {
                        //get oldest count entries
                        index = 1;
                        if (_capacity != DefaultHistorySize)
                        {
                            if (_countEntriesAdded > _capacity)
                                index = SmallestID;
                        }
                        for (long i = count - 1; i >= 0;)
                        {
                            if (index > _countEntriesAdded) break;
                            if ((index <= 0 || GetIndexFromId(index) >= _buffer.Length) ||
                                (_buffer[GetIndexFromId(index)].Cleared == true))
                            {
                                index++; continue;
                            }
                            else
                            {
                                entriesList.Add(_buffer[GetIndexFromId(index)].Clone());
                                i--; index++;
                            }
                        }
                    }
                    else
                    {
                        index = _countEntriesAdded;//SmallestIDinBuffer

                        for (long i = count - 1; i >= 0;)
                        {
                            // if an entry is cleared continue to the next entry
                            if (_capacity != DefaultHistorySize)
                            {
                                if (_countEntriesAdded > _capacity)
                                {
                                    if (index < SmallestID)
                                        break;
                                }
                            }
                            if (index < 1) break;
                            if ((index <= 0 || GetIndexFromId(index) >= _buffer.Length) ||
                                (_buffer[GetIndexFromId(index)].Cleared == true))
                            { index--; continue; }
                            else
                            {
                                //clone the entry from the history buffer
                                entriesList.Add(_buffer[GetIndexFromId(index)].Clone());
                                i--; index--;
                            }
                        }
                    }
                }
                HistoryInfo[] entries = new HistoryInfo[entriesList.Count];
                entriesList.CopyTo(entries);
                return entries;
            }// end lock
        }// end function


        /// <summary>
        /// Get History Entries based on the WildCard Pattern value.
        /// If passed 0, returns all the values, else return on the basis of count.
        /// </summary>
        /// <param name="wildcardpattern"></param>
        /// <param name="count"></param>
        /// <param name="newest"></param>
        /// <returns></returns>
        internal HistoryInfo[] GetEntries(WildcardPattern wildcardpattern, long count, SwitchParameter newest)
        {
            lock (_syncRoot)
            {
                if (count < -1)
                {
                    throw PSTraceSource.NewArgumentOutOfRangeException("count", count);
                }
                if (newest.ToString() == null)
                {
                    throw PSTraceSource.NewArgumentNullException("newest");
                }
                if (count > _countEntriesAdded || count == -1)
                {
                    count = _countEntriesInBuffer;
                }
                List<HistoryInfo> cmdlist = new List<HistoryInfo>();
                long SmallestID = 1;
                //if buffersize is changes,Get the smallest entry that's not cleared in the buffer
                if (_capacity != DefaultHistorySize)
                    SmallestID = SmallestIDinBuffer();
                if (count != 0)
                {
                    if (!newest.IsPresent)
                    {
                        long id = 1;
                        if (_capacity != DefaultHistorySize)
                        {
                            if (_countEntriesAdded > _capacity)
                                id = SmallestID;
                        }
                        for (long i = 0; i <= count - 1;)
                        {
                            if (id > _countEntriesAdded) break;
                            if (_buffer[GetIndexFromId(id)].Cleared == false && wildcardpattern.IsMatch(_buffer[GetIndexFromId(id)].CommandLine.Trim()))
                            {
                                cmdlist.Add(_buffer[GetIndexFromId(id)].Clone()); i++;
                            }
                            id++;
                        }
                    }
                    else
                    {
                        long id = _countEntriesAdded;
                        for (long i = 0; i <= count - 1;)
                        {
                            //if buffersize is changed,we have to loop from max entry to min entry thats not cleared
                            if (_capacity != DefaultHistorySize)
                            {
                                if (_countEntriesAdded > _capacity)
                                {
                                    if (id < SmallestID)
                                        break;
                                }
                            }
                            if (id < 1) break;
                            if (_buffer[GetIndexFromId(id)].Cleared == false && wildcardpattern.IsMatch(_buffer[GetIndexFromId(id)].CommandLine.Trim()))
                            {
                                cmdlist.Add(_buffer[GetIndexFromId(id)].Clone()); i++;
                            }
                            id--;
                        }
                    }
                }
                else
                {
                    for (long i = 1; i <= _countEntriesAdded; i++)
                    {
                        if (_buffer[GetIndexFromId(i)].Cleared == false && wildcardpattern.IsMatch(_buffer[GetIndexFromId(i)].CommandLine.Trim()))
                        {
                            cmdlist.Add(_buffer[GetIndexFromId(i)].Clone());
                        }
                    }
                }
                HistoryInfo[] entries = new HistoryInfo[cmdlist.Count];
                cmdlist.CopyTo(entries);
                return entries;
            }
        }




        /// <summary>
        /// Clears the history entry from buffer for a given id. 
        /// </summary>
        /// <param name="id">Id of the entry to be Cleared</param>        
        /// <returns>nothing</returns>
        internal void ClearEntry(long id)
        {
            lock (_syncRoot)
            {
                if (id < 0)
                {
                    throw PSTraceSource.NewArgumentOutOfRangeException("id", id);
                }
                // no entries are present to clear
                if (_countEntriesInBuffer == 0)
                    return;

                // throw an exception if id is out of range
                if (id > _countEntriesAdded)
                {
                    return;
                }

                HistoryInfo entry = CoreGetEntry(id);
                if (entry != null)
                {
                    entry.Cleared = true;
                    _countEntriesInBuffer--;
                }
                return;
            }
        }


        ///<summary>
        /// gets the total number of entries added
        ///</summary>
        ///<returns>count of total entries added</returns>

        internal int Buffercapacity()
        {
            return _capacity;
        }


        #endregion internal

        #region private

        /// <summary>
        /// Adds an entry to the buffer. If buffer is full, overwrites
        /// oldest entry in the buffer
        /// </summary>
        /// <param name="entry"></param>
        /// <returns>Returns id for the entry. This id should be used to fetch
        /// the entry from the buffer</returns>
        /// <remarks>Id starts from 1 and is incremented by 1 for each new entry</remarks>

        private long Add(HistoryInfo entry)
        {
            if (entry == null)
            {
                throw PSTraceSource.NewArgumentNullException("entry");
            }

            _buffer[GetIndexForNewEntry()] = entry;

            //Increment count of entries added so far
            _countEntriesAdded++;

            //Id of an entry in history is same as its number in history store.
            entry.SetId(_countEntriesAdded);

            //Increment count of entries in buffer by 1
            IncrementCountOfEntriesInBuffer();

            return _countEntriesAdded;
        }

        /// <summary>
        /// Gets entry from buffer for given id. This id should be the 
        /// id returned by Add method.
        /// </summary>
        /// <param name="id">Id of the entry to be fetched</param>
        /// <returns>entry corresponding to id if it is present else null
        /// </returns>
        private HistoryInfo CoreGetEntry(long id)
        {
            if (id <= 0)
            {
                throw PSTraceSource.NewArgumentOutOfRangeException("id", id);
            }
            if (_countEntriesInBuffer == 0)
                return null;
            if (id > _countEntriesAdded)
            {
                return null;
            }
            // if (_buffer[GetIndexFromId(id)].Cleared == false )
            return _buffer[GetIndexFromId(id)];
            // else
            //    return null;
        }

        /// <summary>
        /// Gets the smallest id in the buffer
        /// </summary>
        /// <returns></returns>
        private long SmallestIDinBuffer()
        {
            long minID = 0;
            if (_buffer == null)
                return minID;
            for (int i = 0; i < _buffer.Length; i++)
            {
                //assign the first entry in the buffer as min.
                if (_buffer[i] != null && _buffer[i].Cleared == false)
                {
                    minID = _buffer[i].Id;
                    break;
                }
            }
            //check for the minimum id that is not cleared
            for (int i = 0; i < _buffer.Length; i++)
            {
                if (_buffer[i] != null && _buffer[i].Cleared == false)
                    if (minID > _buffer[i].Id)
                        minID = _buffer[i].Id;
            }
            return minID;
        }

        /// <summary>
        /// Reallocates the buffer if history size changed
        /// </summary>
        private void ReallocateBufferIfNeeded()
        {
            //Get current value of histoysize variable
            int historySize = GetHistorySize();

            if (historySize == _capacity)
                return;

            HistoryInfo[] tempBuffer = new HistoryInfo[historySize];

            //Calculate number of entries to copy in new buffer.                
            int numberOfEntries = _countEntriesInBuffer;

            //when buffer size is changed,we have to consider the totalnumber of entries added 
            if (numberOfEntries < _countEntriesAdded)
                numberOfEntries = (int)_countEntriesAdded;

            if (_countEntriesInBuffer > historySize)
                numberOfEntries = historySize;

            for (int i = numberOfEntries; i > 0; --i)
            {
                long nextId = _countEntriesAdded - i + 1;

                tempBuffer[GetIndexFromId(nextId, historySize)] = _buffer[GetIndexFromId(nextId)];
            }

            _countEntriesInBuffer = numberOfEntries;
            _capacity = historySize;
            _buffer = tempBuffer;
        }

        /// <summary>
        /// Get the index for new entry
        /// </summary>
        /// <returns>Index for new entry</returns>
        private int GetIndexForNewEntry()
        {
            return (int)(_countEntriesAdded % _capacity);
        }

        /// <summary>
        /// Gets index in buffer for an entry with given Id
        /// </summary>
        /// <returns></returns>
        private int GetIndexFromId(long id)
        {
            return (int)((id - 1) % _capacity);
        }

        /// <summary>
        /// Gets index in buffer for an entry with given Id using passed in 
        /// capacity
        /// </summary>
        /// <param name="id"></param>
        /// <param name="capacity"></param>
        /// <returns></returns>
        private static int GetIndexFromId(long id, int capacity)
        {
            return (int)((id - 1) % capacity);
        }

        /// <summary>
        /// Increment number of entries in buffer by 1
        /// </summary>
        private void IncrementCountOfEntriesInBuffer()
        {
            if (_countEntriesInBuffer < _capacity)
                _countEntriesInBuffer++;
        }


        /// <summary>
        /// Get the current history size
        /// </summary>
        /// <returns></returns>
        private int GetHistorySize()
        {
            int historySize = 0;
            var executionContext = LocalPipeline.GetExecutionContextFromTLS();
            object obj = (executionContext != null) ? executionContext.GetVariableValue(SpecialVariables.HistorySizeVarPath) : null;
            if (obj != null)
            {
                try
                {
                    historySize = (int)LanguagePrimitives.ConvertTo(obj, typeof(int), System.Globalization.CultureInfo.InvariantCulture);
                }
                catch (InvalidCastException)
                { }
            }

            if (historySize <= 0)
            {
                historySize = DefaultHistorySize;
            }

            return historySize;
        }

        /// <summary>
        /// buffer
        /// </summary>
        private HistoryInfo[] _buffer;

        /// <summary>
        /// Capacity of circular buffer
        /// </summary>
        private int _capacity;

        /// <summary>
        /// Number of entries in buffer currently
        /// </summary>
        private int _countEntriesInBuffer;

        /// <summary>
        /// total number of entries added till now including those which have 
        /// been overwritten after buffer got full. This is also number of 
        /// last entry added.
        /// </summary>
        private long _countEntriesAdded;


        /// <summary>
        /// Private object for synchronization
        /// </summary>
        private object _syncRoot = new object();

        #endregion private

        /// <summary>
        /// return the ID of the next history item to be added
        /// </summary>
        internal long GetNextHistoryId()
        {
            return _countEntriesAdded + 1;
        }
    }


    /// <summary>
    /// This class Implements the get-history command
    /// </summary>
    [Cmdlet(VerbsCommon.Get, "History", HelpUri = "http://go.microsoft.com/fwlink/?LinkID=113317")]
    [OutputType(typeof(HistoryInfo))]
    public class GetHistoryCommand : PSCmdlet
    {
        /// <summary>
        /// Ids of entries to display
        /// </summary>
        private long[] _id;

        /// <summary>
        /// Ids of entries to display
        /// </summary>
        /// <value></value>
        [Parameter(Position = 0, ValueFromPipeline = true)]
        [ValidateRangeAttribute((long)1, long.MaxValue)]
        public long[] Id
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }

        /// <summary>
        /// Is Count parameter specified
        /// </summary>
        private bool _countParameterSpecified;
        /// <summary>
        /// Count of entries to display. By default, count is the length of the history buffer.
        /// So "Get-History" returns all history entries.
        /// </summary>
        private int _count;

        /// <summary>
        /// No of History Entries (starting from last) that are to be displayed. 
        /// </summary>        
        [Parameter(Position = 1)]
        [ValidateRangeAttribute(0, (int)Int16.MaxValue)]
        public int Count
        {
            get
            {
                return _count;
            }
            set
            {
                _countParameterSpecified = true;
                _count = value;
            }
        }


        /// <summary>
        /// Implements the Processing() method for show/History command
        /// </summary>
        protected override void ProcessRecord()
        {
            History history = ((LocalRunspace)Context.CurrentRunspace).History;

            if (_id != null)
            {
                if (!_countParameterSpecified)
                {
                    //If Id parameter is specified and count is not specified, 
                    //get history
                    foreach (long id in _id)
                    {