source: branches/StackingProblems/HeuristicLab.Data.MoveVectorData/3.3/Stack.cs @ 14278

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using System;
using System.Collections.Generic;
using System.Drawing;

namespace HeuristicLab.Data.MoveVectorData
{
    [Item("Stack", "Represents a stack of containers.")]
    [StorableClass]
    public class Stack : IntArray
    {
        public static new Image StaticItemImage
        {
            get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
        }

        public int Id { get; set; }
        public int CurrentHeight
        {
            get
            {
                int ch = 0;
                for(int i = 0; i < Length; i++)
                {
                    if(array[i] > 0)
                    {
                        ch = i + 1;
                    } 
                }
                return ch;
            }
        }

        public virtual int Capacity
        {
            get
            {
                return array.Length;
            }
        }

        public Stack(int id) : base() { Id = id;  }
        public Stack(int id, int length) : base(length) { Id = id; }
        public Stack(int id, int[] elements) : base(elements) { Id = id; }
        public Stack(int id, IntArray elements) : this(elements.Length) {
            Id = id;
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = elements[i];
            }
                
        }

        [StorableConstructor]
        protected Stack(bool deserializing) : base(deserializing) { }
        protected Stack(Stack original, Cloner cloner) : base(original, cloner) { }
        public override IDeepCloneable Clone(Cloner cloner)
        {
            return new Stack(this, cloner);
        }

        protected override bool Validate(string value, out string errorMessage)
        {
            if (value == null) //TODO
            {
                errorMessage = "Invalid Value (string must not be null)";
                return false;
            }
            else {
                errorMessage = string.Empty;
                return true;
            }
        }

        protected override string GetValue(int index)
        {
            return this[index].ToString();
        }

        protected override bool SetValue(string value, int index)
        {
            int result;
            if (Int32.TryParse(value, out result))
            {
                this[index] = result;
                return true;
            }
            else
            {
                return false;
            }
        }

        public void Push(int value)
        {
            if (CurrentHeight < Length)
            {
                //currentHeight++;
                array[CurrentHeight] = value;
            }
        }

        public int Pop()
        {
            if (CurrentHeight > 0)
            {
                //currentHeight--;
                int val = array[CurrentHeight - 1];
                array[CurrentHeight - 1] = 0;
                return val;
            } else {
                return 0;
            }
        }

        public void Clear()
        {
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = 0;
            }
        }

        public void Randomize(double fillRate, int seed)
        {
            Random random = new Random(seed);
            Clear();
            int containerCount = Capacity;
            var range = new List<int>(containerCount + 1);
            for (int i = 0; i < containerCount; i++)
            {
                range.Add(i + 1);
            }
            range.Shuffle(random);

            for (int i = 0; i < containerCount; i++)
            {
                Push(range[i]);
            }
        }
    }
}