[csdoc-patches] mcsdoc/src/MCSDoc.Core AttributeDoc.cs,NONE,1.1 ChangeLog,NONE,1.1 ClassDoc.cs,NONE,1.1 ClassDocList.cs,NONE,1.1 DocTreeGenerator.cs,NONE,1.1 NamespaceDoc.cs,NONE,1.1 RootDoc.cs,NONE,1.1

[<mas...@us...>]

Update of /cvsroot/csdoc/mcsdoc/src/MCSDoc.Core
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv14752

Added Files:
	AttributeDoc.cs ChangeLog ClassDoc.cs ClassDocList.cs 
	DocTreeGenerator.cs NamespaceDoc.cs RootDoc.cs 
Log Message:
2004-11-09  Gaurav Vaish <mastergaurav>

* AttributeDoc.cs,
* ClassDoc.cs,
* ClassDocList.cs,
* DocTreeGenerator.cs,
* NamespaceDoc.cs,
* RootDoc.cs                 : Core library that implements the framework.


--- NEW FILE: AttributeDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: $Author: mastergaurav $
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: AttributeDoc.cs,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $
 * Copyright: (C) 2003, 2004 Gaurav Vaish
 *
 */
#endregion

using System;

namespace MCSDoc.Framework
{
	internal class AttributeDoc : ClassDoc, IAttributeDoc
	{
		private AccessFlags      flags;
		private AttributeTargets targets;

		public AttributeDoc(Class klass) : base(klass)
		{
			if(!base.IsAttribute)
				throw new Exception("[AttributeDoc] Class is not an attribute");
		}

		public AccessFlags Flags
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public AttributeTargets Targets
		{
			get
			{
				throw new NotImplementedException();
			}
		}

	}
}

--- NEW FILE: ChangeLog ---
$Id: ChangeLog,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $

2004-11-09  Gaurav Vaish <mastergaurav>

	* AttributeDoc.cs,
	* ClassDoc.cs,
	* ClassDocList.cs,
	* DocTreeGenerator.cs,
	* NamespaceDoc.cs,
	* RootDoc.cs                 : Core library that implements the framework.

--- NEW FILE: ClassDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: $Author: mastergaurav $
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: ClassDoc.cs,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $
 * Copyright: (C) 2003, 2004 Gaurav Vaish
 *
 */
#endregion

using System;
using System.Collections;

namespace MCSDoc.Framework
{
	internal class ClassDoc : IClassDoc, IComparable
	{
		private Class  klass;
		private string name;
		private bool   isException = false;
		private bool   isAttribute = false;

		private IClassDoc       baseClass  = null;
		private IInterfaceDoc[] interfaces = null;
		private IContainerDoc   container  = null;

		public ClassDoc(Class klass)
		{
			this.klass = klass;
			// need to Set - BaseClass, Interfaces, Container
			throw new NotImplementedException();
		}

		private void Parse()
		{
			/*
			ArrayList bases = klass.Bases;
			if(bases != null || bases.Count > 0)
			{
				//
			}
			*/
			if(klass.BaseType != null)
			{
				isAttribute = IsSubtypeOf(TypeManager.attribute_type);
				isException = IsSubtypeOf(TypeManager.exception_type);
			}
		}

		private bool IsSubtypeOf(Type type)
		{
			Type baseType = klass.BaseType;
			while(baseType != null &&
			      baseType.ToString() != type.ToString())
			{
				if(baseType.IsSubclassOf(type))
					return true;
				baseType = baseType.BaseType;
			}
			return false;
		}

		protected Class Class
		{
			get
			{
				return this.klass;
			}
		}

		public string NamespaceName
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public string Comments
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public AccessFlags AccessFlags
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public string Name
		{
			get
			{
				return name;
			}
		}

		public bool IsContained
		{
			get
			{
				return this.container != null;
			}
		}

		public bool IsException
		{
			get
			{
				return isException;
			}
		}

		public bool IsAttribute
		{
			get
			{
				return isAttribute;
			}
		}

		public IClassDoc BaseClass
		{
			get
			{
				return baseClass;
			}
		}

		public IInterfaceDoc[] Interfaces
		{
			get
			{
				return interfaces;
			}
		}

		public IContainerDoc ContainerDoc
		{
			get
			{
				return this.container;
			}
		}

		public IAttributeDoc[] Attributes
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IMethodDoc[] Methods
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IPropertyDoc[] Properties
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IFieldDoc[] Fields
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IClassDoc[] InnerClasses
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IDelegateDoc[] InnerDelegates
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IEnumDoc[] InnerEnums
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IInterfaceDoc[] InnerInterfaces
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IStructDoc[] InnerStructs
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public int CompareTo(object obj)
		{
			if(obj is ClassDoc)
			{
				ClassDoc other = (ClassDoc) obj;
				string otherName = other.Name;
				if(other.NamespaceName == this.NamespaceName)
				{
					return (this.Name.CompareTo(other.Name));
				}
				// I know this is wrong.
				return NamespaceName.CompareTo(other.NamespaceName);
			}
			throw new ArgumentException("[CompareTo] obj is not of"
			                            + " type ClassDoc");
		}
	}
}

--- NEW FILE: ClassDocList.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: $Author: mastergaurav $
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: ClassDocList.cs,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $
 * Copyright: (C) 2003, 2004 Gaurav Vaish
 *
 */
#endregion

using System;
using System.Collections;

namespace MCSDoc.Framework
{
	public class ClassDocList : IEnumerable
	{
		private ArrayList classDocs = new ArrayList();

		public ClassDocList()
		{
		}

		public ClassDocList(ArrayList classDocs)
		{
			if(classDocs != null)
			{
				foreach(object c in classDocs)
				{
					if(c is IClassDoc)
						Add((IClassDoc)c);
				}
			}
		}

		public IClassDoc this[int index]
		{
			get
			{
				if(index >= 0 && index < classDocs.Count)
				{
					return (IClassDoc)classDocs[index];
				}
				throw new ArgumentException();//IndexOutOfRangeException();
			}
			set
			{
				classDocs[index] = value;
			}
		}

		public int Count
		{
			get
			{
				return classDocs.Count;
			}
		}

		public void Add(IClassDoc classDoc)
		{
			classDocs.Add(classDoc);
		}

		public bool Contains(IClassDoc classDoc)
		{
			return classDocs.Contains(classDoc);
		}

		public IEnumerator GetEnumerator()
		{
			return classDocs.GetEnumerator();
		}
	}
}

--- NEW FILE: DocTreeGenerator.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: $Author: mastergaurav $
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: DocTreeGenerator.cs,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $
 * Copyright: (C) 2003, 2004 Gaurav Vaish
 *
 */
#endregion

namespace MCSDoc.Framework
{
	internal class DocTreeGenerator
	{
		private TypeContainer root    = null;
		private RootDoc       rootDoc = null;

		private ArrayList allNamespaces = new ArrayList();
		private ArrayList allClasses    = new ArrayList();
		private ArrayList allStructs    = new ArrayList();
		private ArrayList allDelegates  = new ArrayList();
		private ArrayList allEnums      = new ArrayList();
		private ArrayList allInterfaces = new ArrayList();

		public DocTreeGenerator(TypeContainer root)
		{
			if(root == null)
			{
				throw new ArgumentException("[DocTreeGenerator] Null root");
			}

			this.root = root;
			//rootDoc = new RootDoc(root);
			ParseAndGenerate();
		}

		private void ParseAndGenerate()
		{
			//rootDoc.Parse(root);
			//ParseContainers(root.Types);
			//ParseDelegates(root.Delegates);
			//ParseEnums(root.Enums);
			//ParseInterfaces(root.Interfaces);
			ParseContainer(root);

			//First need to populate [allNamespaces]
			//or should I populate while generating tree?
			ParseNamespaces();
			GenerateTree();
		}

		private void GenerateTree()
		{
			rootDoc = new RootDoc();
			//Need to add ONLY namespaces and all types
			//that are not inside any namespace.
			//Namespaces will recursively contain all the
			//types that are within any namespace.
			//Now, I will go home today and work on the
			//exact logic for whole of this system!
			throw new NotImplementedException();
		}

		private void ParseNamespaces()
		{
			foreach(IClassDoc cd in this.allClasses)
			{
				if(cd.NamespaceName != null)
				{
					OptNamespaceAdd(cd.NamespaceName);
				}
			}

			foreach(IStructDoc sd in this.allStructs)
			{
				if(sd.NamespaceName != null)
				{
					OptNamespaceAdd(sd.NamespaceName);
				}
			}

			foreach(IEnumDoc ed in this.allEnums)
			{
				/**
				if(ed.NamespaceEntry.FullName != null)
				{
					OptNamespaceAdd(ed.NamespaceName);
				}
				*/
			}

			foreach(IInterfaceDoc id in this.allInterfaces)
			{
				/**
				if(id.NamespaceEntry.FullName != null)
				{
					OptNamespaceAdd(id.NamespaceName);
				}
				*/
			}

			foreach(IDelegateDoc dd in this.allDelegates)
			{
				/**
				if(dd.NamespaceEntry.FullName != null)
				{
					OptNamespaceAdd(dd.NamespaceName);
				}
				*/
			}
		}

		private void OptNamespaceAdd(string name)
		{
			foreach(NamespaceDoc current in allNamespaces)
			{
				if(current.Name == name)
				{
					return;
				}
			}

			NamespaceDoc nsd = new NamespaceDoc(name);
			allNamespaces.Add(nsd);
		}

		private void HandleNamespaceClass(Class klass, IClassDoc doc)
		{
			NamespaceDoc nsd = NamespaceLookup(klass.NamespaceEntry.FullName);
			nsd.AddClassDoc(doc);
		}

		private void HandleNamespaceStruct(Struct esstruct, IStructDoc doc)
		{
			NamespaceDoc nsd = NamespaceLookup(esstruct.NamespaceEntry.FullName);
			nsd.AddStructDoc(doc);
		}

		private void HandleNamespaceEnum(Mono.CSharp.Enum eenum,
		                                 IEnumDoc doc)
		{
			NamespaceDoc nsd = NamespaceLookup(eenum.NamespaceEntry.FullName);
			nsd.AddEnumDoc(doc);
		}

		private NamespaceDoc NamespaceLookup(string name)
		{
			throw new NotImplementedException();
		}

		private void ParseContainers(ArrayList containers)
		{
			if(containers != null && containers.Count > 0)
			{
				foreach(TypeContainer tc in containers)
				{
					ParseContainer(tc);
				}
			}
		}

		private void ParseContainer(TypeContainer container)
		{
			if(container != null)
			{
				if(container is Class)
				{
					Class c = (Class) container;
					IClassDoc cd = null;
					// Is there any better way, since
					// [c.BaseType != typeof(System.Attribute)]
					// c.BaseType.IsSubclassOf(typeof(System.Attribute))
					// || c.BaseType.IsSubclassOf(typeof(MCSAssembly.typeof(System.Attribute))
					if(c.BaseType.ToString() == "System.Attribute")
					{
						cd = new AttributeDoc(c);
					} else
					{
						cd = new ClassDoc(c);
					}
					allClasses.Add(cd);
				} else if(container is Struct)
				{
					Struct s = (Struct) container;
					IStructDoc sd = null;//new IStructDoc(s);
					allStructs.Add(sd);
				}
				//Handle all inner types recursively
				ParseContainers(container.Types);
				ParseDelegates(container.Delegates);
				ParseEnums(container.Enums);
				ParseInterfaces(container.Interfaces);
			}
		}

		private void ParseDelegates(ArrayList delegates)
		{
			if(delegates != null && delegates.Count > 0)
			{
				foreach(Mono.CSharp.Delegate deleg in delegates)
				{
					IDelegateDoc dd = null;//new DelegateDoc(deleg);
					allDelegates.Add(dd);
				}
			}
		}

		private void ParseEnums(ArrayList enums)
		{
			if(enums != null && enums.Count > 0)
			{
				foreach(Mono.CSharp.Enum eenum in enums)
				{
					IEnumDoc ed = null;//new EnumDoc(eenum);
					allDelegates.Add(ed);
				}
			}
		}

		private void ParseInterfaces(ArrayList interfaces)
		{
			if(interfaces != null && interfaces.Count > 0)
			{
				foreach(Interface interf in interfaces)
				{
					IInterfaceDoc id = null;//new InterfaceDoc(interf);
					allInterfaces.Add(id);
				}
			}
		}

		public IRootDoc RootDoc
		{
			get
			{
				return rootDoc;
			}
		}
	}
}

--- NEW FILE: NamespaceDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: $Author: mastergaurav $
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: NamespaceDoc.cs,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $
 * Copyright: (C) 2003, 2004 Gaurav Vaish
 *
 */
#endregion

using System;
using System.Collections;

namespace MCSDoc.Framework
{
	internal class NamespaceDoc : INamespaceDoc
	{
		private string comments;
		private string name;

		ArrayList classes    = new ArrayList();
		ArrayList structs    = new ArrayList();
		ArrayList delegates  = new ArrayList();
		ArrayList enums      = new ArrayList();
		ArrayList interfaces = new ArrayList();

		public NamespaceDoc(string name)
		{
			this.name = name;
		}

		public NamespaceDoc(string name, string filename) : this(name)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Will create a hierarchy of NamespaceDoc elements.
		/// </summary>
		/// <remarks>
		/// btw, do I really need this scrap funda of Parent namespace
		/// and sub-namespaces?
		/// </remarks>
		public static ArrayList CreateHierarchy(ArrayList namespaces)
		{
			ArrayList retVal = new ArrayList();
			string name;
			string[] subNames;
			if(namespaces != null && namespaces.Count > 0)
			{
				foreach(NamespaceDoc nd in namespaces)
				{
					name = nd.Name;
					bool isAdded = IsNamespaceAdded(name, retVal);
					/*
					if(!isAdded)
					{
						subNames = GetSubnames(name);
						if(subNames != null)
						{
							foreach(string subName in subNames)
							{
								isAdded &= IsNamespaceAdded(subName,
								                            retVal);
								if(isAdded)
									break;
							}
						}
					}
					*/
					AddNamespaceInHierarchy(nd, retVal);
					throw new NotImplementedException();

				}
				throw new NotImplementedException();
			}
			throw new NotImplementedException();
		}

		private static void AddNamespaceInHierarchy(NamespaceDoc doc,
		                                            ArrayList docList)
		{
			throw new NotImplementedException();
		}

		private static bool IsNamespaceAdded(string name, ArrayList namespaces)
		{
			foreach(NamespaceDoc nsd in namespaces)
			{
				if(IsNamespaceAdded(name, nsd))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsNamespaceAdded(string name, NamespaceDoc doc)
		{
			throw new NotImplementedException();
		}

		private static string[] GetSubnames(string name)
		{
			int dotCount = 0;
			foreach(char c in name)
			{
				if(c == '.')
					dotCount++;
			}

			if(dotCount == 0)
				return null;

			int[] dotIndices = new int[dotCount];
			int cIndex = 0;
			int cPos = 0;

			for(cPos = 0; cPos < name.Length; cPos++)
			{
				if(name[cPos] == '.')
				{
					dotIndices[cIndex] = cPos;
					cIndex++;
				}
			}

			string[] retVal = new string[dotCount];
			for(cIndex = 0; cIndex < dotCount; cIndex++)
			{
				retVal[cIndex] = name.Substring(0, dotIndices[cIndex] - 1);
			}
			return retVal;
		}

		public void AddClassDoc(IClassDoc doc)
		{
			classes.Add(doc);
		}

		public void AddStructDoc(IStructDoc doc)
		{
			structs.Add(doc);
		}

		public void AddDelegateDoc(IDelegateDoc doc)
		{
			delegates.Add(doc);
		}

		public void AddEnumDoc(IEnumDoc doc)
		{
			enums.Add(doc);
		}

		public void AddInterfaceDoc(IInterfaceDoc doc)
		{
			interfaces.Add(doc);
		}

		public string Name
		{
			get
			{
				return this.name;
			}
		}

		public string Comments
		{
			get
			{
				return comments;
			}
		}

		public INamespaceDoc[] Namespaces
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IClassDoc[] Classes
		{
			get
			{
				return (IClassDoc[]) classes.ToArray(typeof(IClassDoc));
			}
		}

		public IDelegateDoc[] Delegates
		{
			get
			{
				return (IDelegateDoc[]) delegates.ToArray(typeof(IDelegateDoc));
			}
		}

		public IEnumDoc[] Enums
		{
			get
			{
				return (IEnumDoc[]) enums.ToArray(typeof(IEnumDoc));
			}
		}

		public IInterfaceDoc[] Interfaces
		{
			get
			{
				return (IInterfaceDoc[]) interfaces.ToArray(typeof(IInterfaceDoc));
			}
		}

		public IStructDoc[] Structs
		{
			get
			{
				return (IStructDoc[]) interfaces.ToArray(typeof(IStructDoc));
			}
		}
	}
}

--- NEW FILE: RootDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: $Author: mastergaurav $
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: RootDoc.cs,v 1.1 2004/11/09 09:00:07 mastergaurav Exp $
 * Copyright: (C) 2003, 2004 Gaurav Vaish
 *
 */
#endregion

using System;
using System.Collections;

namespace MCSDoc.Framework
{
	internal class RootDoc : IRootDoc
	{
		INamespaceDoc[] namespaces = null;
		IClassDoc[]     classes    = null;
		IStructDoc[]    structs    = null;
		IDelegateDoc[]  delegates  = null;
		IEnumDoc[]      enums      = null;
		IInterfaceDoc[] interfaces = null;

		ArrayList namespaceList = new ArrayList();

		public RootDoc(TypeContainer root)
		{
			//Parse(root);
		}

		public RootDoc()
		{
			//Do nothing!
		}

		private void Parse(TypeContainer root)
		{
			PopulateContainers(root.Types);
			throw new NotImplementedException();
		}

		private void PopulateNamespaces()
		{
			if(namespaceList.Count > 0)
			{
				//namespaces = (INamespaceDoc[]) namespaceList.ToArray(typeof(INamespaceDoc));
			}
		}

		private void PopulateContainers(ArrayList containers)
		{
			if(containers != null || containers.Count > 0)
			{
				ArrayList classes = new ArrayList();
				ArrayList structs = new ArrayList();

				foreach(TypeContainer tc in containers)
				{
					if(tc is Class)
					{
						Class c = (Class)tc;
						ClassDoc cd = null;
						if(c.BaseType != null)
						{
							if(c.BaseType.ToString() == "System.Attribute")
							{
								cd = new AttributeDoc(c);
							}
						} else
						{
							cd = new ClassDoc(c);
						}
						if(c.NamespaceEntry != null && c.NamespaceEntry.FullName.Length > 0)
						{
							HandleNamespaceClass(c, cd);
						}
						// process ClassDoc
						classes.Add(cd);
					} else if(tc is Struct)
					{
						Struct s = (Struct)tc;
						IStructDoc sd = null;//new StructDoc(s);
						if(s.NamespaceEntry != null && s.NamespaceEntry.FullName.Length > 0)
						{
							HandleNamespaceStruct(s, sd);
						}
						// process StructDoc
						structs.Add(sd);
					}
					PopulateInners(tc.Types);
				}

				if(classes.Count > 0)
				{
					this.classes = (IClassDoc[]) classes.ToArray(typeof(IClassDoc));
				}

				if(structs.Count > 0)
				{
					this.structs = (IStructDoc[]) classes.ToArray(typeof(IStructDoc));
				}
			}
		}

		private NamespaceDoc NamespaceLookup(string name)
		{
			NamespaceDoc retVal =  null;
			foreach(NamespaceDoc current in namespaceList)
			{
				if(current.Name == name)
				{
					retVal = current;
					break;
				}
			}

			if(retVal == null)
			{
				retVal = new NamespaceDoc(name);
				namespaceList.Add(retVal);
			}
			return retVal;
		}

		private void HandleNamespaceClass(Class klass, ClassDoc doc)
		{
			NamespaceDoc nsd = NamespaceLookup(klass.NamespaceEntry.FullName);
			nsd.AddClassDoc(doc);
		}

		private void HandleNamespaceStruct(Struct esstruct, IStructDoc doc)
		{
			NamespaceDoc nsd = NamespaceLookup(esstruct.NamespaceEntry.FullName);
			nsd.AddStructDoc(doc);
		}

		private void PopulateInners(ArrayList types)
		{
			throw new NotImplementedException();
		}

		private void PopulateEnums(ArrayList enums)
		{
			if(enums != null && enums.Count > 0)
			{
				ArrayList enumDocs = new ArrayList();
				IEnumDoc doc = null;
				foreach(Mono.CSharp.Enum current in enums)
				{
					doc = null;//new EnumDoc(current);
					enumDocs.Add(doc);
				}

				if(enumDocs.Count > 0)
				{
					this.enums = (IEnumDoc[]) enumDocs.ToArray(typeof(IEnumDoc));
				}
			}
		}

		private void PopulateDelegates(ArrayList delegates)
		{
			if(delegates != null && delegates.Count > 0)
			{
				ArrayList delegateDocs = new ArrayList();
				IDelegateDoc doc = null;
				foreach(Mono.CSharp.Delegate current in delegates)
				{
					doc = null;//new DelegateDoc(current);
					delegateDocs.Add(doc);
				}

				if(delegateDocs.Count > 0)
				{
					this.delegates = (IDelegateDoc[]) delegateDocs.ToArray(typeof(IDelegateDoc));
				}
			}
		}

		private void PopulateInterfaces(ArrayList interfaces)
		{
			if(interfaces != null && interfaces.Count > 0)
			{
				ArrayList interfaceDocs = new ArrayList();
				IInterfaceDoc doc = null;
				foreach(Interface current in interfaces)
				{
					doc = null;//new InterfaceDoc(current);
					interfaceDocs.Add(doc);
				}

				if(interfaceDocs.Count > 0)
				{
					this.interfaces = (IInterfaceDoc[]) interfaceDocs.ToArray(typeof(IInterfaceDoc));
				}
			}
		}

		public INamespaceDoc[] Namespaces
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IClassDoc[] Classes
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IDelegateDoc[] Delegates
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IEnumDoc[] Enums
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IInterfaceDoc[] Interfaces
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public IStructDoc[] Structs
		{
			get
			{
				throw new NotImplementedException();
			}
		}
	}
}