[nant-commits] CVS: nant/src/NAnt.DotNet/Types Module.cs, NONE, 1.1 ModuleCollection.cs, NONE, 1.1 ModuleSet.cs, NONE, 1.1 EmbeddedResourceCollection.cs, 1.1, 1.2

[Gert D. <dri...@us...>]

Update of /cvsroot/nant/nant/src/NAnt.DotNet/Types
In directory sc8-pr-cvs7.sourceforge.net:/tmp/cvs-serv29918/src/NAnt.DotNet/Types

Modified Files:
	EmbeddedResourceCollection.cs 
Added Files:
	Module.cs ModuleCollection.cs ModuleSet.cs 
Log Message:
Introduced <moduleset> global type.

--- NEW FILE: Module.cs ---
// NAnt - A .NET build tool
// Copyright (C) 2001-2007 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Gert Driesen (ger...@ar...)

using System;
using System.IO;
using System.Text;

using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;

namespace NAnt.DotNet.Types {
    /// <summary>
    /// Represents a metadata file without assembly manifest.
    /// </summary>
    [Serializable]
    public class Module : Element {
        #region Public Instance Properties

        /// <summary>
        /// The path of the module.
        /// </summary>
        [TaskAttribute("file", Required=true)]
        [StringValidator(AllowEmpty=false)]
        public string File {
            get {
                if (ModuleSet != null && _file != null) {
                    return Path.Combine (ModuleSet.Dir.FullName, _file);
                }
                return _file;
            }
            set { _file = value; }
        }

        /// <summary>
        /// File name where the module should be copied to before it is compiled
        /// into an assembly.
        /// </summary>
        [TaskAttribute("target", Required=false)]
        public string Target {
            get { return _target; }
            set { _target = StringUtils.ConvertEmptyToNull(value); }
        }

        /// <summary>
        /// Gets or sets the <see cref="ModuleSet" /> that contains the module.
        /// </summary>
        public ModuleSet ModuleSet {
            get { return _moduleSet; }
            set { _moduleSet = value; }
        }

        #endregion Public Instance Properties

        #region Override implementation of Object

        /// <summary>
        /// Returns a textual representation of the module, which can be used as
        /// argument for command-line tools.
        /// </summary>
        /// <returns>
        /// A textual representation of the path, file[,target].
        /// </returns>
        public override string ToString() {
            if (File == null) {
                return null;
            }

            StringBuilder sb = new StringBuilder();
            sb.Append(File);
            if (Target != null) {
                sb.Append(",");
                sb.Append(Target);
            }
            return sb.ToString();
        }

        #endregion Override implementation of Object

        #region Private Instance Fields

        private string _file;
        private string _target;
        private ModuleSet _moduleSet;

        #endregion Private Instance Fields
    }
}

--- NEW FILE: ModuleCollection.cs ---
// NAnt - A .NET build tool
// Copyright (C) 2001-2007 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Gert Driesen (ger...@ar...)

using System;
using System.Collections;

using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;

namespace NAnt.DotNet.Types {
    /// <summary>
    /// Contains a collection of <see cref="Module" /> items.
    /// </summary>
    /// <remarks>
    /// Do not yet expose this to build authors.
    /// </remarks>
    [Serializable()]
    public class ModuleCollection : IList, IEnumerable {
        #region Public Instance Constructor

        /// <summary>
        /// Initializes a new instance of the <see cref="ModuleCollection" />
        /// for the specified <see cref="ModuleSet" />.
        /// </summary>
        /// <param name="moduleSet">The <see cref="ModuleSet" /> containing the collection.</param>
        /// <exception cref="ArgumentNullException"><paramref name="moduleSet" /> is <see langword="true" />.</exception>
        public ModuleCollection(ModuleSet moduleSet) {
            if (moduleSet == null) {
                throw new ArgumentNullException("moduleSet");
            }
            _moduleSet = moduleSet;
            _list = new ArrayList();
        }

        #endregion Public Instance Constructor

        #region Public Instance Properties

        /// <summary>
        /// Gets or sets the item at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index of the item to get or set.</param>
        /// <exception cref="ArgumentOutOfRangeException">The <paramref name="index" /> parameter is less than 0 or greater than or equal to the value of the <see cref="Count" /> property of the <see cref="ModuleCollection" />.</exception>
        [System.Runtime.CompilerServices.IndexerName("Item")]
        public Module this[int index] {
            get { 
                if (index < 0 || index >= Count) {
                    throw new ArgumentOutOfRangeException("index", index, "Invalid value.");
                }
                return (Module) List[index];
            }
            set {
                if (index < 0 || index >= Count) {
                    throw new ArgumentOutOfRangeException("index", index, "Invalid value.");
                }
                List[index] = value;
            }
        }

        #endregion Public Instance Properties

        #region Protected Instance Properties

        /// <summary>
        /// Gets the list of elements contained in the 
        /// <see cref="ModuleCollection" /> instance.
        /// </summary>
        /// <value>
        /// An <see cref="ArrayList" /> containing the elements of the 
        /// collection.
        /// </value>
        protected ArrayList List {
            get { return _list; }
        }

        #endregion Protected Instance Properties

        #region Implementation of IEnumerable

        /// <summary>
        /// Returns an enumerator that can iterate through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="ModuleEnumerator"/> for the entire collection.
        /// </returns>
        IEnumerator IEnumerable.GetEnumerator() {
            return List.GetEnumerator();
        }

        #endregion Implementation of IEnumerable

        #region Implementation of ICollection

        /// <summary>
        /// Gets a value indicating whether access to the collection is 
        /// synchronized (thread-safe).
        /// </summary>
        /// <value>
        /// <see langword="false" />.
        /// </value>
        bool ICollection.IsSynchronized {
            get { return false; }
        }

        /// <summary>
        /// Gets the number of items in the collection.
        /// </summary>
        /// <value>
        /// The number of items in the collection.
        /// </value>
        public int Count {
            get { return List.Count; }
        }

        /// <summary>
        /// Copies the items of the collection to an <see cref="Array" />,
        /// starting at a particular index.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="Array" /> that is the destination of the items copied from the collection. The <see cref="Array" /> must have zero-based indexing.</param>
        /// <param name="index">The zero-based index in <paramref name="array" /> at which copying begins.</param>
        public void CopyTo(Array array, int index) {
            List.CopyTo(array, index);
        }

        /// <summary>
        /// Gets an object that can be used to synchronize access to the 
        /// collection.
        /// </summary>
        /// <value>
        /// An object that can be used to synchronize access to the collection.
        /// </value>
        object ICollection.SyncRoot {
            get { return this; }
        }

        #endregion Implementation of ICollection

        #region Implementation of IList

        /// <summary>
        /// Gets a value indicating whether the collection has a fixed size.
        /// </summary>
        /// <value>
        /// <see langword="false" />.
        /// </value>
        public bool IsFixedSize {
            get { return false; }
        }

        /// <summary>
        /// Gets a value indicating whether the collection has a fixed size.
        /// </summary>
        /// <value>
        /// <see langword="false" />.
        /// </value>
        public bool IsReadOnly {
            get { return false; }
        }

        /// <summary>
        /// Gets or sets the item at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index of the item to get or set.</param>
        /// <exception cref="ArgumentOutOfRangeException">The <paramref name="index" /> parameter is less than 0 or greater than or equal to the value of the <see cref="Count" /> property of the <see cref="ModuleCollection" />.</exception>
        object IList.this[int index] {
            get { return this[index]; }
            set { 
                if (value == null) {
                    throw new ArgumentNullException ("value");
                }
                if (!(value is Module)) {
                    throw new ArgumentException ("Value is not a Module");
                }
                this[index] = (Module) value;
            }
        }

        /// <summary>
        /// Removes all items from the collection.
        /// </summary>
        public void Clear() {
            List.Clear();
        }

        /// <summary>
        /// Inserts a <see cref="Module" /> into the collection at the
        /// specified index.
        /// </summary>
        /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
        /// <param name="value">The <see cref="Module"/> to insert.</param>
        void IList.Insert(int index, object value) {
            if (value == null) {
                throw new ArgumentNullException ("value");
            }
            if (!(value is Module)) {
                throw new ArgumentException ("Value is not a Module");
            }
            Insert(index, (Module) value);
        }

        /// <summary>
        /// Removes the specified <see cref="Module"/> from the
        /// collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> to remove from the collection.</param>
        void IList.Remove(object value) {
            if (value == null) {
                throw new ArgumentNullException ("value");
            }
            if (!(value is Module)) {
                throw new ArgumentException ("Value is not a Module");
            }
            Remove((Module) value);
        }

        /// <summary>
        /// Removes an item at a specific index.
        /// </summary>
        /// <param name="index">The zero-based index of the item to remove.</param>
        /// <exception cref="ArgumentOutOfRangeException">The <paramref name="index" /> parameter is less than 0 or greater than or equal to the value of the <see cref="Count" /> property of the <see cref="ModuleCollection" />.</exception>
        public void RemoveAt(int index) {
            if (index < 0 || index >= Count) {
                throw new ArgumentOutOfRangeException("index", index, "Invalid value.");
            }
            List.RemoveAt(index);
        }

        /// <summary>
        /// Determines whether a <see cref="Module"/> is in the collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> to locate in the collection.</param> 
        /// <returns>
        /// <see langword="true" /> if <paramref name="value" /> is found in the 
        /// collection; otherwise, <see langword="false" />.
        /// </returns>
        bool IList.Contains(object value) {
            if (value == null) {
                throw new ArgumentNullException ("value");
            }
            if (!(value is Module)) {
                throw new ArgumentException ("Value is not a Module");
            }
            return List.Contains((Module) value);
        }

        /// <summary>
        /// Gets the location of a <see cref="Module"/> in the collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> object to locate.</param> 
        /// <returns>
        /// The zero-based location of the <see cref="Module" /> in the
        /// collection.
        /// </returns>
        /// <remarks>
        /// If the <see cref="Module"/> is not currently a member of 
        /// the collection, -1 is returned.
        /// </remarks>
        int IList.IndexOf(object value) {
            if (value == null) {
                throw new ArgumentNullException ("value");
            }
            if (!(value is Module)) {
                throw new ArgumentException ("Value is not a Module");
            }
            return IndexOf((Module) value);
        }

        /// <summary>
        /// Adds a <see cref="Module"/> to the end of the collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> to be added to the end of the collection.</param> 
        /// <returns>
        /// The position into which the new item was inserted.
        /// </returns>
        int IList.Add(object value) {
            if (value == null) {
                throw new ArgumentNullException ("value");
            }
            if (!(value is Module)) {
                throw new ArgumentException ("Value is not a Module");
            }
            return Add((Module) value);
        }

        #endregion Implementation of IList

        #region Public Instance Methods

        /// <summary>
        /// Adds the items of a <see cref="ModuleCollection"/> to the end of the collection.
        /// </summary>
        /// <param name="items">The <see cref="ModuleCollection"/> to be added to the end of the collection.</param> 
        public void AddRange(ModuleCollection items) {
            for (int i = 0; (i < items.Count); i = (i + 1)) {
                Add(items[i]);
            }
        }

        /// <summary>
        /// Adds a <see cref="Module"/> to the end of the collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> to be added to the end of the collection.</param> 
        /// <returns>
        /// The position into which the new item was inserted.
        /// </returns>
        public int Add(Module value) {
            if (value.ModuleSet != null) {
                throw new ArgumentException("Module is already linked to other ModuleSet.");
            }
            value.ModuleSet = _moduleSet;
            return List.Add(value);
        }

        /// <summary>
        /// Returns an enumerator that can iterate through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="ModuleEnumerator"/> for the entire collection.
        /// </returns>
        public ModuleEnumerator GetEnumerator() {
            return new ModuleEnumerator(this);
        }

        /// <summary>
        /// Inserts a <see cref="Module" /> into the collection at the
        /// specified index.
        /// </summary>
        /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
        /// <param name="value">The <see cref="Module"/> to insert.</param>
        public void Insert(int index, Module value) {
            if (value.ModuleSet != null) {
                throw new ArgumentException("Module is already linked to other ModuleSet.");
            }
            value.ModuleSet = _moduleSet;
            List.Insert(index, value);
        }

        /// <summary>
        /// Removes the specified <see cref="Module"/> from the
        /// collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> to remove from the collection.</param>
        public void Remove(Module value) {
            List.Remove(value);
            if (value.ModuleSet == _moduleSet) {
                value.ModuleSet = null;
            }
        }

        /// <summary>
        /// Determines whether a <see cref="Module"/> is in the collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> to locate in the collection.</param> 
        /// <returns>
        /// <see langword="true" /> if <paramref name="value" /> is found in the 
        /// collection; otherwise, <see langword="false" />.
        /// </returns>
        public bool Contains(Module value) {
            return List.Contains(value);
        }

        /// <summary>
        /// Gets the location of a <see cref="Module"/> in the collection.
        /// </summary>
        /// <param name="value">The <see cref="Module"/> object to locate.</param> 
        /// <returns>
        /// The zero-based location of the <see cref="Module" /> in the
        /// collection.
        /// </returns>
        /// <remarks>
        /// If the <see cref="Module"/> is not currently a member of 
        /// the collection, -1 is returned.
        /// </remarks>
        public int IndexOf(Module value) {
            return List.IndexOf(value);
        }

        #endregion Public Instance Methods

        #region Private Instance Fields

        private readonly ModuleSet _moduleSet;
        private readonly ArrayList _list;

        #endregion Private Instance Fields
    }

    /// <summary>
    /// Enumerates the <see cref="Module"/> items of a <see cref="ModuleCollection"/>.
    /// </summary>
    public class ModuleEnumerator : IEnumerator {
        #region Internal Instance Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ModuleEnumerator"/> class
        /// with the specified <see cref="ModuleCollection"/>.
        /// </summary>
        /// <param name="arguments">The collection that should be enumerated.</param>
        internal ModuleEnumerator(ModuleCollection arguments) {
            IEnumerable temp = (IEnumerable) (arguments);
            _baseEnumerator = temp.GetEnumerator();
        }

        #endregion Internal Instance Constructors

        #region Implementation of IEnumerator
            
        /// <summary>
        /// Gets the current item in the collection.
        /// </summary>
        /// <returns>
        /// The current item in the collection.
        /// </returns>
        public Module Current {
            get { return (Module) _baseEnumerator.Current; }
        }

        /// <summary>
        /// Gets the current item in the collection.
        /// </summary>
        /// <returns>
        /// The current item in the collection.
        /// </returns>
        object IEnumerator.Current {
            get { return Current; }
        }

        /// <summary>
        /// Advances the enumerator to the next item of the collection.
        /// </summary>
        /// <returns>
        /// <see langword="true" /> if the enumerator was successfully advanced 
        /// to the next item; <see langword="false" /> if the enumerator has 
        /// passed the end of the collection.
        /// </returns>
        public bool MoveNext() {
            return _baseEnumerator.MoveNext();
        }

        /// <summary>
        /// Sets the enumerator to its initial position, which is before the 
        /// first item in the collection.
        /// </summary>
        public void Reset() {
            _baseEnumerator.Reset();
        }
            
        #endregion Implementation of IEnumerator

        #region Private Instance Fields
    
        private IEnumerator _baseEnumerator;

        #endregion Private Instance Fields
    }
}

--- NEW FILE: ModuleSet.cs ---
// NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Gert Driesen (ger...@ar...)

using System;
using System.IO;

using NAnt.Core;
using NAnt.Core.Attributes;

namespace NAnt.DotNet.Types {
    /// <summary>
    /// <para>
    /// One or more modules to compile into an assembly.
    /// </para>
    /// </summary>
    /// <example>
    ///   <para>
    ///   Define a global <c>&lt;moduleset&gt;</c> that can be referenced by
    ///   other tasks or types.
    ///   </para>
    ///   <code>
    ///     <![CDATA[
    ///         <moduleset id="client-modules" dir="${build}">
    ///             <module file="Client.netmodule" />
    ///             <module file="Common.netmodule" />
    ///         </moduleset>
    ///     ]]>
    ///   </code>
    /// </example>
    [Serializable()]
    [ElementName("moduleset")]
    public class ModuleSet : DataTypeBase {
        #region Private Instance Fields

        private readonly ModuleCollection _modules;
        private DirectoryInfo _dir;

        #endregion Private Instance Fields

         #region Public Instance Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ModuleSet" /> class.
        /// </summary>
        public ModuleSet() {
            _modules = new ModuleCollection(this);
        }

        #endregion Public Instance Constructors

        #region Public Instance Properties

        /// <summary>
        /// The base of the directory of this <see cref="ModuleSet" />. 
        /// The default is the project base directory.
        /// </summary>
        [TaskAttribute("dir")]
        public DirectoryInfo Dir {
            get {
                if (_dir == null) {
                    if (Project != null) {
                        return new DirectoryInfo(Project.BaseDirectory);
                    }
                }   
                return _dir;
            }
            set { _dir = value; }
        }

        /// <summary>
        /// The modules to add to this <see cref="ModuleSet" />.
        /// </summary>
        [BuildElementArray("module")]
        public ModuleCollection Modules {
            get { return _modules; }
        }

        #endregion Public Instance Properties
    }
}
Index: EmbeddedResourceCollection.cs
===================================================================
RCS file: /cvsroot/nant/nant/src/NAnt.DotNet/Types/EmbeddedResourceCollection.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** EmbeddedResourceCollection.cs	6 Mar 2006 19:08:35 -0000	1.1
--- EmbeddedResourceCollection.cs	13 Jan 2007 14:13:04 -0000	1.2
***************
*** 20,24 ****
  using System;
  using System.Collections;
- //using System.Text;
  
  using NAnt.Core;
--- 20,23 ----