/// <summary>
        /// Write the news rows to the database as specified in <param name="rows">.
        /// </summary>
        /// <param name="rows">
        /// The new rows to write to the database.
        /// </param>
        public void WriteNewRows(List <Row> rows)
        {
            // A dictionary for the new values that need to be written to the index file.
            Dictionary <int, int> toAddToIndex = new Dictionary <int, int> ();

            DataBaseStream.Position = (RowCount * ROW_BYTE_SIZE) + HEADER_BYTE_SIZE;
            foreach (Row r in rows)
            {
                // Write the row with the next primary key.
                WriteRow(r, NextPrimaryKey, WriteType.NewRowWrite);
                // Bump up the row count.
                RowCount++;
                // Add the new index file data to dictionary.
                toAddToIndex.Add(NextPrimaryKey, RowCount);
                // Add the new index data to the dictionary that references the index file.
                Index.Add(NextPrimaryKey, RowCount);
                // Bump up the primary key.
                NextPrimaryKey++;
            }
            // Set the database stream position to the header and update the header with the next primary key and the new row count.
            DataBaseStream.Position = HEADER_INFO_NEXT_PRIMARY_KEY;
            DataBaseWriter.Write(NextPrimaryKey);
            DataBaseWriter.Write(RowCount);

            //Set the index stream to the end of the file and write the new index values to tthe index file.
            IndexStream.Position = (RowCount - toAddToIndex.Count) * INDEX_ROW_BYTE_SIZE;
            foreach (KeyValuePair <int, int> primaryKeyRowLocation in toAddToIndex)
            {
                WriteIndexRow(primaryKeyRowLocation.Key, primaryKeyRowLocation.Value, WriteType.IndexNewRowWrite);
            }
        }
 /// <summary>
 /// Write the header details for the database file if it has just been created.
 /// </summary>
 private void WriteNewFileHeader()
 {
     DataBaseStream.Position = 0;
     DataBaseWriter.Write("rubbishtable________".ToCharArray());
     DataBaseWriter.Write(0);
     DataBaseWriter.Write(0);
     DataBaseWriter.Write(0);
 }
 /// <summary>
 /// Write the rows as specified in <param name="rows"> as deleted.
 /// </summary>
 /// <param name="rows">
 /// The rows that are to be marked as deleted.
 /// </param>
 public void MarkRowsDeleted(List <Row> rows)
 {
     foreach (Row row in rows)
     {
         // Write the row's status to false (deleted) and bump up the number of rows deleted.
         WriteRow(row, row.PrimaryKey, WriteType.RowDelete);
         DeletedRowCount++;
     }
     // Update the header information with the new number of rows deleted.
     DataBaseStream.Position = HEADER_INFO_NUM_ROWS_DELETED;
     DataBaseWriter.Write(DeletedRowCount);
 }
        public void UploadData(string name, string author, string creationYear, string style, string epoch, string medium, int width,
                               int height, string plot, string cost)
        {
            Picture addedPic = new Picture()
            {
                Name         = name,
                CreationYear = int.Parse(creationYear),
                Style        = style,
                Epoch        = epoch,
                Medium       = medium,
                Width        = width,
                Height       = height,
                Plot         = plot,
                Cost         = long.Parse(cost)
            };

            DataBaseWriter.Write(addedPic);
        }
 /// <summary>
 /// Reorder the database and index rows with the dictionary of row - location in <param name="rowsToMove">.
 /// </summary>
 /// <param name="rowsToMove">
 /// Dictionary of row - location.
 /// </param>
 private void RearrangeRowsAndIndex(Dictionary <Row, int> rowsToMove)
 {
     // Set the new sizes of both the index and database file.
     DataBaseStream.SetLength(((RowCount - DeletedRowCount) * ROW_BYTE_SIZE) + HEADER_BYTE_SIZE);
     IndexStream.SetLength((RowCount - DeletedRowCount) * INDEX_ROW_BYTE_SIZE);
     // Write each row to it's new location. Write each index keyvalue pair of primary key location to the index file.
     // Update the object index.
     foreach (KeyValuePair <Row, int> data in rowsToMove)
     {
         Index [data.Key.PrimaryKey] = data.Value;
         WriteRow(data.Key, data.Key.PrimaryKey, WriteType.RowMove);
         WriteIndexRow(data.Key.PrimaryKey, data.Value, WriteType.IndexRowMove);
     }
     // Update the row count accordingly and reassign deleted rows the value of 0. We've just compacted!
     RowCount               -= DeletedRowCount;
     DeletedRowCount         = 0;
     DataBaseStream.Position = HEADER_INFO_NUM_ROWS;
     // Write that to the database header.
     DataBaseWriter.Write(RowCount);
     DataBaseWriter.Write(DeletedRowCount);
 }
 /// <summary>
 /// Write the row <param name="row"> with primary key <param name="primaryKey"> using the WriteType <param name="type">.
 /// </summary>
 /// <param name="row">
 /// Row to write.
 /// </param>
 /// <param name="primaryKey">
 /// Primary key of row to write.
 /// </param>
 /// <param name="type">
 /// The kind of row write to perform.
 /// </param>
 private void WriteRow(Row row, int primaryKey, WriteType type)
 {
     // If we're not udating an existing row. I.e. moving a row, writing a new row or deleting a row.
     if (type != WriteType.RowUpdate)
     {
         if (type != WriteType.NewRowWrite)
         {
             // Set the database stream to the location of the row
             DataBaseStream.Position = (Index [row.PrimaryKey] - 1) * ROW_BYTE_SIZE + HEADER_BYTE_SIZE;
         }
         // If the row is deleted, only write to it's status and leave the method.
         if (type == WriteType.RowDelete)
         {
             DataBaseWriter.Write(row.Status);
             return;
         }
         // Write the row's status and primary key.
         DataBaseWriter.Write(row.Status);
         DataBaseWriter.Write(primaryKey);
         // If it's a new row, write the new row's data and return from the method.
         if (type == WriteType.NewRowWrite)
         {
             DataBaseWriter.Write(row.NewTextData.PadRight(20, (char)0).ToCharArray());
             DataBaseWriter.Write(row.NewNumberData);
             return;
         }
     }
     // If the row is being updated, set the database stream to the rows data locaton
     if (type == WriteType.RowUpdate)
     {
         DataBaseStream.Position = (Index [row.PrimaryKey] - 1) * ROW_BYTE_SIZE + HEADER_BYTE_SIZE + ROW_DATA_LOCATION;
     }
     // Write the row data. This will happen for rows being moved or updated.
     DataBaseWriter.Write(row.TextData.PadRight(20, (char)0).ToCharArray());
     DataBaseWriter.Write(row.NumberData);
 }