[csdoc-patches] mcsdoc/src/MCSDoc.Framework AccessFlags.cs,NONE,1.1 AttributeDoc.cs,NONE,1.1 ChangeL

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

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

Added Files:
	AccessFlags.cs AttributeDoc.cs ChangeLog ClassDoc.cs 
	ClassDocList.cs DocTreeGenerator.cs IAttributeDoc.cs 
	IClassDoc.cs IContainerDoc.cs IDelegateDoc.cs IEnumDoc.cs 
	IFieldDoc.cs IInterfaceDoc.cs IMethodDoc.cs INamespaceDoc.cs 
	IPropertyDoc.cs IRootDoc.cs IStructDoc.cs NamespaceDoc.cs 
	RootDoc.cs 
Log Message:
2004-11-09  Gaurav Vaish <mastergaurav>

* *.cs                       : Import from old mcsdoc


--- NEW FILE: AccessFlags.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: AccessFlags.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */
#endregion

using Mono.CSharp;
using System;

namespace MCSDoc
{
	public enum AccessFlags
	{
		Public,
		Private,
		Protected,
		Internal,
		ProtectedInternal
	}
}
--- NEW FILE: AttributeDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: AttributeDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;
using System;

namespace MCSDoc
{
	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 08:47:21 mastergaurav Exp $

2004-11-09  Gaurav Vaish <mastergaurav>

	* *.cs                       : Import from old mcsdoc

2004-10-30  Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* AccessFlags.cs             : Added enumeration.
	* AttributeDoc.cs            : Missing ';'.
	* ClassDocList.cs            : Typo fixed.
	                               It should implement IEnumerable
	* DocTreeGenerator.cs        : ParseNamespaces()   - Refer to interfaces.
	                               StructDoc/ClassDoc to IStructDoc/IClassDoc
	* IContainer.cs              : IMemberDoc renamed to IFieldDoc 
	* IEnumDoc.cs                : Added interface for enum-doc.
	* IFieldDoc.cs               : Added interface for class/struct fields-doc
	* IMethodDoc.cs              : Added itnerface for method-doc.

2004-10-30  Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* RootDoc.cs                 : NamespaceLookup(string)    - Don't return
	                                        evaluating the value.

2004-10-30  Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* **.cs                      : Moving from ../../mcs/MCSDoc directory
	                               to here.

2003-04-06	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* ClassDoc.cs                : Checking for exception and attribute.
	                   Ummm! Looks clumsy. Will rectify it later.

2003-04-02	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* DocTreeGenerator.cs        : ParseAndGenerate() - No need for
	                               multiple calls here itself.
	                             : GenerateTree()     - Lot of work.
	* NamespaceDoc.cs            : No need for subnamespaces.
	* ClassDoc.cs                : Implements IComparable. Need while
	                               sorting the array.

2003-04-01	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* NamespaceDoc.cs            : Name { get; }        - Added,
	                               CreateHierarchy(ArrayList) - Init impl,
	                               IsNamespaceAdded(string, ArrayList),
	                               IsNamespaceAdded(string, NamespaceDoc),
	                               GetSubnames(string)  - Added.

2003-04-01	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* INamespaceDoc.cs            : Namespaces { get; } - Sub-namespaces.
	* DocTreeGenerator.cs         : Parsing done. Generation to start.
	* NamespaceDoc.cs             : CreateHierarchy(ArrayList) - Stubbed.

2003-04-01	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* AttributeDoc.cs             : Oops! Forgot to add last time.
	* RootDoc.cs                  : Don't parse here.
	* DocTreeGenerator.cs         : Making it come to use.

2003-03-28	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* RootDoc.cs                  : Populated all. Will take a second
	            look sometime later, especially for PopulateInners.
	            Have to take of if class is an attribute.
	* AttributeDoc.cs             : Initial implementation
	* ClassDoc.cs                 : Class { get; }         - Added.
	                              : Accessibility          - internal.

2003-03-28	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* ClassDoc.cs                 : Parse()                - Some impl.
	* RootDoc.cs                  : PopulateTypeContainers - Init Impl.
	* NamespaceDoc.cs             : Initial implementation.
	* INamespaceDoc.cs            : No Attributes to a namespace. Ok!
	* IAttributeDoc.cs,
	* IInterfaceDoc.cs,
	* IContainerDoc.cs            : Name { get; }      - Added.
	* IAttributeDoc.cs            : Now derives from IContainerDoc

2003-03-28	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* RootDoc.cs                  : Stubbed PopulateXXXX methods
	* DocTreeGenerator.cs         : Looks like won't need it in future

2003-03-27	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* RootDoc.cs                  : Initial implementation.
	* ClassDoc.cs                 : Initial implementation.
	* DocTreeGenerator.cs         : Going ahead and back and ahead.
	* IContainerDoc.cs            : IContainerDoc made property.
	* IRootDoc.cs                 : Namespaces is INamespace[]

2003-03-22	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* DocTreeGenerator.cs         : Stubbed RootDoc { get; }

2003-03-22	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* IAttributeDoc.cs,
	* IInterfaceDoc.cs            : Added interfaces
	* ClassDoc.cs                 : Initial implementation
	* DocTreeGenerator.cs         : Initial implementation

2003-03-09	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* IRootDoc.cs,
	* IClassDoc.cs,
	* INamespaceDoc.cs            : Don't use *List classes.
	* ClassDocList.cs             : Will remove it later.
	* IContainerDoc.cs            : Superinterfaces for
	                       IClassDoc, IStructDoc since both of them
	                       can hold all other types inside them.
	* IStructDoc.cs               : Added interface.

2003-03-08	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* IRootDoc.cs,
	* IClassDoc.cs,
	* INamespaceDoc.cs,
	* ClassDocList.cs                       : Trying to see what
	                     works best. Still not sure of what classes
	                     to have and what properties will they have.

2003-02-25	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* RootDoc.cs                            : Removed
	* IRootDoc.cs                           : Added interface
	* ClassDocList.cs                       : List of IClassDoc

2003-02-25	Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

	* RootDoc.cs                            : Initial implementaion.

--- NEW FILE: ClassDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: ClassDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using System;
using System.Collections;
using Mono.CSharp;

namespace MCSDoc
{
	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 ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: ClassDocList.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using System;
using Mono.CSharp;
using System.Collections;

namespace MCSDoc
{
	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 ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: DocTreeGenerator.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;
using System;
using System.Collections;

namespace MCSDoc
{
	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: IAttributeDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IAttributeDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;
using System;

namespace MCSDoc
{
	public interface IAttributeDoc : IClassDoc
	{
		AccessFlags Flags        { get; }
		AttributeTargets Targets { get; }
	}
}

--- NEW FILE: IClassDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IClassDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;

namespace MCSDoc
{
	public interface IClassDoc : IContainerDoc
	{
		bool IsException  { get; }
		bool IsAttribute  { get; }

		/// <summary>
		/// Returns document element for the
		/// base class, if any.
		/// </summary>
		IClassDoc       BaseClass  { get; }
		
		/// <summary>
		/// Returns document elements for the
		/// implemented interfaces, if any.
		/// </summary>
		IInterfaceDoc[] Interfaces { get; }
	}
}

--- NEW FILE: IContainerDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IContainerDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;

namespace MCSDoc
{
	public interface IContainerDoc
	{
		string      Comments      { get; }
		string      Name          { get; }
		AccessFlags AccessFlags   { get; }
		bool        IsContained   { get; }
		string      NamespaceName { get; }

		// Returns non null only if(IsContained)
		// may throw an exception otherwise
		IContainerDoc   ContainerDoc { get; }

		IAttributeDoc[] Attributes { get; }
		IMethodDoc[]    Methods    { get; }
		IPropertyDoc[]  Properties { get; }
		IFieldDoc[]     Fields     { get; }

		IClassDoc[]     InnerClasses    { get; }
		IDelegateDoc[]  InnerDelegates  { get; }
		IEnumDoc[]      InnerEnums      { get; }
		IInterfaceDoc[] InnerInterfaces { get; }
		IStructDoc[]    InnerStructs    { get; }
	}
}

--- NEW FILE: IDelegateDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IDelegateDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */
#endregion

using Mono.CSharp;

namespace MCSDoc
{
	public interface IDelegateDoc
	{
		/// <summary>
		/// Returns document element for the
		/// base class, if any.
		/// </summary>
		IClassDoc   BaseClassDoc  { get; }
		string      NamespaceName { get; }

		// Need to get documentation
		// for the signature
	}
}

--- NEW FILE: IEnumDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IEnumDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */
#endregion

using Mono.CSharp;

namespace MCSDoc
{
	public interface IEnumDoc
	{
		/// <summary>
		/// Returns document element for the
		/// base class, if any.
		/// </summary>
		IClassDoc   BaseClass     { get; }
		string      NamespaceName { get; }

		// Need to get documentation
		// for each member also
	}
}

--- NEW FILE: IFieldDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IFieldDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */
#endregion

using Mono.CSharp;

namespace MCSDoc
{
	public interface IFieldDoc
	{
		//Documentation for the field
	}
}

--- NEW FILE: IInterfaceDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IInterfaceDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;

namespace MCSDoc
{
	public interface IInterfaceDoc
	{
		string      Comments      { get; }
		string      Name          { get; }
		AccessFlags Flags         { get; }
		string      NamespaceName { get; }

		IInterfaceDoc  BaseInterface { get; }

		IAttributeDoc[] Attributes { get; }
		IMethodDoc[]    Methods    { get; }
		IPropertyDoc[]  Properties { get; }
		IFieldDoc[]     Fields     { get; }

		IInterfaceDoc[] BaseInterfaces { get; }
	}
}

--- NEW FILE: IMethodDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IMethodDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */
#endregion

using Mono.CSharp;

namespace MCSDoc
{
	public interface IMethodDoc
	{
		//Documentation for the method
	}
}

--- NEW FILE: INamespaceDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: INamespaceDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;

namespace MCSDoc
{
	public interface INamespaceDoc
	{
		string          Comments   { get; }
		string          Name       { get; }

		INamespaceDoc[] Namespaces { get; }

		IClassDoc[]     Classes    { get; }
		IDelegateDoc[]  Delegates  { get; }
		IEnumDoc[]      Enums      { get; }
		IInterfaceDoc[] Interfaces { get; }
		IStructDoc[]    Structs    { get; }
	}
}

--- NEW FILE: IPropertyDoc.cs ---
#region Copyright Notice
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IPropertyDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */
#endregion

using Mono.CSharp;

namespace MCSDoc
{
	public interface IPropertyDoc
	{
		//Documentation for the property
	}
}

--- NEW FILE: IRootDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IRootDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;

namespace MCSDoc
{
	public interface IRootDoc
	{
		INamespaceDoc[] Namespaces { get; }

		IClassDoc[]     Classes    { get; }
		IDelegateDoc[]  Delegates  { get; }
		IEnumDoc[]      Enums      { get; }
		IInterfaceDoc[] Interfaces { get; }
		IStructDoc[]    Structs    { get; }
	}
}

--- NEW FILE: IStructDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: IStructDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using Mono.CSharp;

namespace MCSDoc
{
	public interface IStructDoc : IContainerDoc
	{
	}
}

--- NEW FILE: NamespaceDoc.cs ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: NamespaceDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using System;
using System.Collections;
using Mono.CSharp;

namespace MCSDoc
{
	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 ---
/**
 * Project: Master C# Document Generator
 * Contact: mas...@us...
 * Web:     http://csdoc.sourceforge.net
 *
 * $Id: RootDoc.cs,v 1.1 2004/11/09 08:47:21 mastergaurav Exp $
 * Copyright: (C) 2003, Gaurav Vaish
 *
 */

using System;
using System.Collections;
using Mono.CSharp;

namespace MCSDoc
{
	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();
			}
		}
	}
}