static string MakeTopicName(LocalTopicName name)
		{
			if (name.Version == null || name.Version.Length == 0)
				return name.Name;
			else
				return name.Name + "(" + name.Version + ")";
		}

		/// <summary>
		/// Answer whether a topic exists and is writable
		/// </summary>
		/// <param name="topic">The topic (must directly be in this content base)</param>
		/// <returns>true if the topic exists AND is writable by the current user; else false</returns>
		public abstract bool IsExistingTopicWritable(LocalTopicName topic);

		/// <summary>
		/// Write a new version of the topic (doesn't write a new version).  Generate all needed federation update changes via the supplied generator.
		/// </summary>
		/// <param name="topic">Topic to write</param>
		/// <param name="content">New content</param>
		/// <param name="sink">Object to recieve change info about the topic</param>
		override protected void WriteTopic(LocalTopicName topic, string content, FederationUpdateGenerator gen)
		{
			string root = Root;
			string fullpath = MakePath(root, topic);
			bool isNew = !(File.Exists(fullpath));

			// Get old topic so we can analyze it for properties to compare with the new one
			string oldText = null;
			Hashtable oldProperties = null;
			if (!isNew)
			{
				using (StreamReader sr = new StreamReader(new FileStream(fullpath, FileMode.Open, FileAccess.Read, FileShare.Read)))
				{
					oldText = sr.ReadToEnd();
				}
				oldProperties = ExtractExplicitFieldsFromTopicBody(oldText);	
			}

			// Change it
			using (StreamWriter sw = new StreamWriter(fullpath))
			{
				sw.Write(content);
			}

			// Quick check to see if we're about to let somebody write the DefinitionTopic for this ContentBase.  
			// If so, we reset our Info object to reread
			string pathToDefinitionTopic = MakePath(Root, DefinitionTopicName.LocalName);
			if (fullpath == pathToDefinitionTopic)
				this.Federation.InvalidateNamespace(Namespace);

			// Record changes
			try
			{
				AbsoluteTopicName absTopic = topic.AsAbsoluteTopicName(Namespace);

				gen.Push();

				// Record the topic-level change
				if (isNew)
					gen.RecordCreatedTopic(absTopic);
				else
					gen.RecordUpdatedTopic(absTopic);

				//	Now process the properties
				Hashtable newProperties = ExtractExplicitFieldsFromTopicBody(content);
				if (isNew)
				{
					foreach (string pName in newProperties.Keys)
						gen.RecordPropertyChange(absTopic, pName, FederationUpdate.PropertyChangeType.PropertyAdd);
					gen.RecordPropertyChange(absTopic, "_Body", FederationUpdate.PropertyChangeType.PropertyAdd);
					gen.RecordPropertyChange(absTopic, "_TopicName", FederationUpdate.PropertyChangeType.PropertyAdd);
					gen.RecordPropertyChange(absTopic, "_TopicFullName", FederationUpdate.PropertyChangeType.PropertyAdd);
					gen.RecordPropertyChange(absTopic, "_LastModifiedBy", FederationUpdate.PropertyChangeType.PropertyAdd);
					gen.RecordPropertyChange(absTopic, "_CreationTime", FederationUpdate.PropertyChangeType.PropertyAdd);
					gen.RecordPropertyChange(absTopic, "_ModificationTime", FederationUpdate.PropertyChangeType.PropertyAdd);
				}
				else
				{
					if (content != oldText)
					{
						FillFederationUpdateByComparingPropertyHashes(gen, absTopic, oldProperties, newProperties);
						gen.RecordPropertyChange(absTopic, "_Body", FederationUpdate.PropertyChangeType.PropertyUpdate);
					}
					gen.RecordPropertyChange(absTopic, "_ModificationTime", FederationUpdate.PropertyChangeType.PropertyUpdate);				
				}
			}
			finally
			{
				gen.Pop();
			}
		}

		/// <summary>
		/// All of the FileInfos for the historical versions of a given topic
		/// </summary>
		/// <param name="topic"></param>
		/// <returns>FileInfos</returns>
		FileInfo[] FileInfosForTopic(LocalTopicName topic)
		{
			FileInfo [] answer = {};

			// If the topic does not exist, we ignore any historical versions (the result of a delete)
			if (!TipFileExists(topic.Name))
				return answer;

			try
			{
				answer = new DirectoryInfo(Root).GetFiles(topic.Name + "(*).awiki");
			}
			catch (DirectoryNotFoundException e)
			{
				System.Diagnostics.Debug.WriteLine(e.ToString()); 
			}
			return answer;
		}

		/// <summary>
		/// Answer all of the versions for a given topic
		/// </summary>
		/// <remarks>
		/// TODO: Change this to return TopicChanges instead of the TopicNames
		/// </remarks>
		/// <param name="topic">A topic</param>
		/// <returns>Enumeration of the topic names (with non-null versions in them) </returns>
		override public IEnumerable AllVersionsForTopic(LocalTopicName topic)
		{
			ArrayList answer = new ArrayList();
			FileInfo[] infos = FileInfosForTopic(topic);
			ArrayList sortable = new ArrayList();
			foreach (FileInfo each in infos)
				sortable.Add(new FileInfoTopicData(each, Namespace));
			BackingTopic back = GetBackingTopicNamed(topic);
			if (back != null)
				sortable.Add(new BackingTopicTopicData(back));
			sortable.Sort(new TimeSort());
			foreach (TopicData each in sortable)
			{
				AbsoluteTopicName name = topic.AsAbsoluteTopicName(Namespace);
				name.Version = each.Version;
				answer.Add(name);
			}
			return answer;
		}

		/// <summary>
		/// Answer a TextReader for the given topic
		/// </summary>
		/// <param name="topic"></param>
		/// <exception cref="TopicNotFoundException">Thrown when the topic doesn't exist</exception>
		/// <returns>TextReader</returns>
		override public TextReader TextReaderForTopic(LocalTopicName topic)
		{
			string topicFile = TopicPath(topic);
			if (topicFile == null || !File.Exists(topicFile))
			{
				BackingTopic back = GetBackingTopicNamed(topic);
				if (back != null)
					return new StringReader(back.Body);
				throw TopicNotFoundException.ForTopic(topic, Namespace);
			}
			return new StreamReader(new FileStream(topicFile, FileMode.Open, FileAccess.Read, FileShare.Read));
		}

		/// <summary>
		/// Answer when a topic was created
		/// </summary>
		/// <param name="topic">The topic</param>
		/// <returns></returns>
		override public DateTime GetTopicCreationTime(LocalTopicName topic)
		{
			string path = TopicPath(topic);
			if (File.Exists(path))
				return File.GetCreationTime(path);
			BackingTopic back = GetBackingTopicNamed(topic);
			if (back != null)
				return back.CreationTime;
			throw TopicNotFoundException.ForTopic(topic, Namespace);			
		}

		/// <summary>
		/// Answer true if a topic exists in this ContentBase
		/// </summary>
		/// <param name="name">Name of the topic</param>
		/// <returns>true if it exists</returns>
		override public bool TopicExistsLocally(LocalTopicName name)
		{
			if (BackingTopics.ContainsKey(name.Name))
				return true;
			return File.Exists(MakePath(Root, name));
		}

		/// <summary>
		/// Delete a topic
		/// </summary>
		/// <param name="topic"></param>
		public abstract void DeleteTopic(LocalTopicName topic);

		/// <summary>
		/// Answer a TextReader for the given topic
		/// </summary>
		/// <param name="topic"></param>
		/// <exception cref="TopicNotFoundException">Thrown when the topic doesn't exist</exception>
		/// <returns>TextReader</returns>
		public abstract TextReader TextReaderForTopic(LocalTopicName topic);

		/// <summary>
		/// Change the value of a property (aka field) in a a topic.  If the topic doesn't exist, it will be created.
		/// </summary>
		/// <param name="topic">The topic whose property is to be changed</param>
		/// <param name="field">The name of the property to change</param>
		/// <param name="rep">The new value for the field</param>
		public void SetFieldValue(LocalTopicName topic, string field, string rep, bool writeNewVersion)
		{
			if (!TopicExistsLocally(topic))
			{
				WriteTopic(topic, "");
			}

			string original = Read(topic);

			// Multiline values need to end a complete line
			string repWithLineEnd = rep;
			if (!repWithLineEnd.EndsWith("\n"))
				repWithLineEnd = repWithLineEnd + "\n";
			bool newValueIsMultiline = rep.IndexOf("\n") > 0;

			string simpleField = "(?<name>(" + field + ")):(?<val>[^\\[].*)";
			string multiLineField = "(?<name>(" + field + ")):\\[(?<val>[^\\[]*\\])";

			string update = original;
			if (new Regex(simpleField).IsMatch(original))
			{
				if (newValueIsMultiline)
					update = Regex.Replace (original, simpleField, "${name}:[ " + repWithLineEnd + "]");
				else
					update = Regex.Replace (original, simpleField, "${name}: " + rep);
			}
			else if (new Regex(multiLineField).IsMatch(original))
			{
				if (newValueIsMultiline)
					update = Regex.Replace (original, multiLineField, "${name}:[ " + repWithLineEnd + "]");
				else
					update = Regex.Replace (original, multiLineField, "${name}: " + rep);
			}
			else
			{
				if (!update.EndsWith("\n"))
					update = update + "\n";
				if (rep.IndexOf("\n") == -1)
					update += field + ": " + repWithLineEnd;
				else
					update += field + ":[ " + repWithLineEnd + "]\n";
			}
			if (writeNewVersion)
				WriteTopicAndNewVersion(topic, update);
			else
				WriteTopic(topic, update);
		}

		/// <summary>
		/// Reach and answer all the properties (aka fields) for the given topic.  This includes both the 
		/// properties defined in the topic plus the extra properties that every topic has (e.g., _TopicName, _TopicFullName, _LastModifiedBy, etc.)
		/// </summary>
		/// <param name="topic"></param>
		/// <returns>Hashtable (keys = string property names, values = values [as strings]);  or null if the topic doesn't exist</returns>
		public Hashtable GetFieldsForTopic(LocalTopicName topic)
		{
			if (!TopicExistsLocally(topic))
				return null;

			string allLines = Read(topic);
			Hashtable answer = ExtractExplicitFieldsFromTopicBody(allLines);	
			Federation.AddImplicitPropertiesToHash(answer, topic.AsAbsoluteTopicName(Namespace), GetTopicLastAuthor(topic), GetTopicCreationTime(topic), GetTopicLastWriteTime(topic), allLines);
			return answer;
		}

		/// <summary>
		/// Answer the contents of a given topic
		/// </summary>
		/// <param name="topic">The topic</param>
		/// <returns>The contents of the topic or null if it can't be read (e.g., doesn't exist)</returns>
		public string Read(LocalTopicName topic)
		{
			using (TextReader st = TextReaderForTopic(topic))
			{
				if (st == null)
					return null;
				return st.ReadToEnd();
			}
		}

		/// <summary>
		/// Answer the identify of the author who last modified a given topic
		/// </summary>
		/// <param name="topic"></param>
		/// <returns>a user name</returns>
		public abstract string GetTopicLastAuthor(LocalTopicName topic);

		/// <summary>
		/// Answer when a topic was created
		/// </summary>
		/// <param name="topic">The topic</param>
		/// <returns></returns>
		public abstract DateTime GetTopicCreationTime(LocalTopicName topic);

		string TopicPath(LocalTopicName localTopicName)
		{
			return MakePath(Root, localTopicName);
		}

		/// <summary>
		/// Answer the full file system path for a given topic in a given folder.  
		/// </summary>
		/// <param name="root">File system path to the root directory for the containing content base</param>
		/// <param name="name">The name of the topic</param>
		/// <returns>Full path to the file containing the content for the most recent version of the topic</returns>
		static string MakePath(string root, LocalTopicName name)
		{
			if (name.Version == null || name.Version.Length == 0)
				return root + "\\" + name.Name + ".wiki";
			else
				return root + "\\" + name.Name + "(" + name.Version + ").awiki";
		}

		/// <summary>
		/// Answer all of the versions for a given topic
		/// </summary>
		/// <remarks>
		/// TODO: Change this to return TopicChanges instead of the TopicNames
		/// </remarks>
		/// <param name="topic">A topic</param>
		/// <returns>Enumeration of the topic names (with non-null versions in them) </returns>
		public abstract IEnumerable AllVersionsForTopic(LocalTopicName topic);

		/// <summary>
		/// Answer whether a topic exists and is writable
		/// </summary>
		/// <param name="topic">The topic (must directly be in this content base)</param>
		/// <returns>true if the topic exists AND is writable by the current user; else false</returns>
		override public bool IsExistingTopicWritable(LocalTopicName topic)
		{

			string path = TopicPath(topic);
			if (!File.Exists(path))
			{
				BackingTopic back = GetBackingTopicNamed(topic);
				if (back == null)
					return false;
				return back.CanOverride;
			}
			DateTime old = File.GetLastWriteTimeUtc(path);
			try
			{
				// Hacky implementation, but there's no better with the framework to do this that just to try and see what happens!!!
				FileStream stream = File.OpenWrite(path);
				stream.Close();
			}
			catch (UnauthorizedAccessException unauth)
			{
				unauth.ToString();
				return false;
			}
			File.SetLastWriteTimeUtc(path, old);
			return true;
		}

		/// <summary>
		/// Returns the most recent version for the given topic
		/// </summary>
		/// <param name="topic">The topic</param>
		/// <returns>The most recent version string for the topic</returns>
		public abstract string LatestVersionForTopic(LocalTopicName topic);