/// <summary>
        /// Loads the data for the specified identifier using the specified serializable data inteface object.
        /// </summary>
        /// <param name="serializableData">The serializable data.</param>
        /// <param name="id">The identifier.</param>
        private static byte[] Load(ISerializableData serializableData, string id)
        {
            byte[] data = serializableData.LoadData(id);

            if (data == null)
            {
                Log.Debug(typeof(BinaryData), "Load", id, "-");
                return(null);
            }

            Log.Debug(typeof(BinaryData), "Load", id, data.Length);

            if (data.Length > 0)
            {
                if (data.Length < 2)
                {
                    throw new InvalidOperationException("Serialized data corruption");
                }

                if (!FletcherChecksum.Validate(data, 0, data.Length))
                {
                    throw new InvalidOperationException("Serialized data corruption");
                }

                Array.Resize(ref data, data.Length - 2);
            }

            return(data);
        }
        /// <summary>
        /// Checks a local checksum using error-correction check-bytes.
        /// </summary>
        /// <returns>True if the checksum is valid.</returns>
        public void CheckLocalCheckSum()
        {
            this.AssureLeft(2);
            this.index += 2;

            if (!FletcherChecksum.Validate(this.serializedData, this.localCheckSumIndex, this.index))
            {
                this.DeserializationError = true;
                throw new InvalidOperationException("Serialized data corruption!");
            }
        }
        /// <summary>
        /// Adds a local checksum to the data.
        /// </summary>
        public void AddLocalCheckSum()
        {
            this.AssureSize(this.index + 2);

            FletcherChecksum.ControlBytes control = FletcherChecksum.GetControlBytes(this.serializedData, this.localCheckSumIndex, this.index);

            this.serializedData[this.index]     = control.First;
            this.serializedData[this.index + 1] = control.Second;
            this.index += 2;

            this.localCheckSumIndex = this.index;
        }
        /// <summary>
        /// Saves the serialized data.
        /// </summary>
        /// <param name="serializableData">The serializable data inteface object.</param>
        /// <param name="id">The identifier.</param>
        public void Save(ISerializableData serializableData, string id)
        {
            if (!this.isWriteable)
            {
                throw new InvalidOperationException("Container is readonly");
            }

            if (this.serializedData != null)
            {
                FletcherChecksum.ControlBytes control = FletcherChecksum.GetControlBytes(this.serializedData, 0, this.index);

                byte[] data = new byte[this.index + 2];
                if (this.index > 0)
                {
                    Buffer.BlockCopy(this.serializedData, 0, data, 0, this.index);
                }

                data[this.index]     = control.First;
                data[this.index + 1] = control.Second;

                Log.Debug(this, "Save", id, data.Length);
                serializableData.SaveData(id, data);
            }
        }