view api/Factories/AbstractNativeWarFoundryFactory.cs @ 312:3854c26073c4

Re #253: Allow multiple data files in a single zip * Rebuild file loading to start to allow multiple files in a native file
author IBBoard <dev@ibboard.co.uk>
date Sat, 26 Feb 2011 20:15:12 +0000
parents ca2905c9b225
children f00a57369aaa
line wrap: on
line source

// This file (AbstractNativeWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
//
// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.

using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.Collections.Generic;
using System.Text;
using IBBoard;
using IBBoard.IO;
using IBBoard.Lang;
using IBBoard.Logging;
using IBBoard.Xml;
using IBBoard.WarFoundry.API.Objects;
using ICSharpCode.SharpZipLib.Zip;

namespace IBBoard.WarFoundry.API.Factories
{
	/// <summary>
	/// Base abstract class for all factories that load native WarFoundry data.
	/// </summary>
	public abstract class AbstractNativeWarFoundryFactory : AbstractWarFoundryFactory<ZipFile>, INativeWarFoundryFactory
	{				
		protected AbstractNativeWarFoundryFactory()
		{
			//Do nothing - just make the constructor non-public
		}
				
		protected override ZipFile GetFileAsSupportedType (FileInfo file)
		{
			ZipFile zip = null;
			
			try
			{
				zip = new ZipFile(file.FullName);
			}
			catch(ZipException)
			{
				//Silently dispose as per spec for the method
			}
			catch (IOException)
			{
				//Silently dispose as per spec for the method
			}
			
			return zip;
		}
		
		protected override bool CheckCanHandleFileFormat (ZipFile file)
		{	
			return CheckCanHandleFileAsGameSystem(file) || CheckCanHandleFileAsRace(file) || CheckCanHandleFileAsArmy(file); 
		}
		
		protected override bool CheckCanHandleFileAsGameSystem(ZipFile file)
		{
			return CheckCanFindSystemFileContent(file);
		}
		
		protected abstract bool CheckCanFindSystemFileContent(ZipFile file);
		
		protected override bool CheckCanHandleFileAsRace(ZipFile file)
		{
			return CheckCanFindRaceFileContent(file);
		}
		
		protected abstract bool CheckCanFindRaceFileContent(ZipFile file);
		
		protected override bool CheckCanHandleFileAsArmy(ZipFile file)
		{
			return CheckCanFindArmyFileContent(file);
		}
		
		protected abstract bool CheckCanFindArmyFileContent(ZipFile file);
		
		protected override ICollection<IWarFoundryObject> DoCreateObjectsFromFile (ZipFile file)
		{
			ICollection<IWarFoundryObject> objects = new List<IWarFoundryObject>();

			try
			{
				if (CheckCanFindSystemFileContent(file))
				{
					AddAll(objects, CreateGameSystemsFromFile(file));
				}
				if (CheckCanFindRaceFileContent(file))
				{
					AddAll(objects, CreateRacesFromFile(file));
				}
				if (CheckCanFindArmyFileContent(file))
				{
					AddAll(objects, CreateArmiesFromFile(file));
				}
			}
			finally
			{
				file.Close();
			}
			
			return objects;
		}
		
		private void AddAll <NEW_ITEM_TYPE>(ICollection<IWarFoundryObject> collection, ICollection<NEW_ITEM_TYPE> newItems) where NEW_ITEM_TYPE : IWarFoundryObject
		{
			foreach (IWarFoundryObject obj in newItems)
			{
				collection.Add(obj);
			}
		}
		
		protected ICollection<Army> CreateArmiesFromFile(ZipFile file)
		{
			ICollection<ZipEntry> dataStreams = GetArmyZipEntries(file);
			ICollection<Army> armies = new List<Army>();

			foreach (ZipEntry entry in dataStreams)
			{
				using (Stream dataStream = file.GetInputStream(entry))
				{
				armies.Add(CreateArmyFromStream(file, dataStream));
				}
			}
			
			return armies;
		}
		
		protected abstract ICollection<ZipEntry> GetArmyZipEntries(ZipFile file);
		protected abstract Army CreateArmyFromStream(ZipFile file, Stream dataStream);
		
		protected ICollection<Race> CreateRacesFromFile(ZipFile file)
		{
			ICollection<ZipEntry> dataStreams = GetRaceZipEntries(file);
			ICollection<Race> races = new List<Race>();

			foreach (ZipEntry entry in dataStreams)
			{					
				using (Stream dataStream = file.GetInputStream(entry))
				{
					races.Add(CreateRaceFromStream(file, dataStream));
				}
			}
			
			return races;
		}
		
		protected abstract ICollection<ZipEntry> GetRaceZipEntries(ZipFile file);
		protected abstract Race CreateRaceFromStream(ZipFile file, Stream dataStream);
		
		protected ICollection<GameSystem> CreateGameSystemsFromFile(ZipFile file)
		{
			ICollection<ZipEntry> dataStreams = GetGameSystemZipEntries(file);
			ICollection<GameSystem> systems = new List<GameSystem>();

			foreach (ZipEntry entry in dataStreams)
			{
				using (Stream dataStream = file.GetInputStream(entry))
				{
					systems.Add(CreateGameSystemFromStream(file, dataStream));
				}
			}
			
			return systems;
		}
		
		protected abstract ICollection<ZipEntry> GetGameSystemZipEntries(ZipFile file);
		protected abstract GameSystem CreateGameSystemFromStream(ZipFile file, Stream dataStream);
		
		public override bool Equals (object o)
		{
			if (o == this)
			{
				return true;
			}
			else if (o == null || !(this.GetType().Equals(o.GetType())))
			{
				return false;
			}
			
			return true;
		}
		
		public override int GetHashCode ()
		{
			return GetType().FullName.GetHashCode();
		}
	}
}