Merge pull request #733 from amoiseev-softheme/bugfix/monofix

[mono.git] / mcs / class / Microsoft.Build / Microsoft.Build.Construction / ProjectTargetElement.cs

diff --git a/mcs/class/Microsoft.Build/Microsoft.Build.Construction/ProjectTargetElement.cs b/mcs/class/Microsoft.Build/Microsoft.Build.Construction/ProjectTargetElement.cs
index 7d741120c6eca10f13601df086301298c8c952d2..66129eb7daf013d0c6e6ab00dfcf4a16144d035d 100644 (file)
--- a/mcs/class/Microsoft.Build/Microsoft.Build.Construction/ProjectTargetElement.cs
+++ b/mcs/class/Microsoft.Build/Microsoft.Build.Construction/ProjectTargetElement.cs
@@ -26,57 +26,149 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-using System.Collections.Generic;
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Build.Internal;
 
 namespace Microsoft.Build.Construction
 {
+        [System.Diagnostics.DebuggerDisplayAttribute ("Name={Name} #Children={Count} Condition={Condition}")]
         public class ProjectTargetElement : ProjectElementContainer
         {
-                public string AfterTargets { get; set; }
-                public string BeforeTargets { get; set; }
-                public string DependsOnTargets { get; set; }
-                public string Inputs { get; set; }
+                internal ProjectTargetElement (string name, ProjectRootElement containingProject)
+                        : this(containingProject)
+                {
+                        Name = name;
+                }
+                internal ProjectTargetElement (ProjectRootElement containingProject)
+                {
+                        ContainingProject = containingProject;
+                }
+                string afterTargets;
+                public string AfterTargets {
+                        get { return afterTargets ?? String.Empty; }
+                        set { afterTargets = value; }
+                }
+                string beforeTargets;
+                public string BeforeTargets {
+                        get { return beforeTargets ?? String.Empty; }
+                        set { beforeTargets = value; }
+                }
+                string dependsOnTargets;
+                public string DependsOnTargets {
+                        get { return dependsOnTargets ?? String.Empty; }
+                        set { dependsOnTargets = value; }
+                }
+                string inputs;
+                public string Inputs { get { return inputs ?? String.Empty; } set { inputs = value; } }
                 public ICollection<ProjectItemGroupElement> ItemGroups {
-                        get {
-                                throw new NotImplementedException ();
-                        }
+                        get { return new CollectionFromEnumerable<ProjectItemGroupElement> (
+                                new FilteredEnumerable<ProjectItemGroupElement> (Children)); }
+                }
+                string keepDuplicateOutputs;
+                public string KeepDuplicateOutputs {
+                        get { return keepDuplicateOutputs ?? String.Empty; }
+                        set { keepDuplicateOutputs = value; }
                 }
-                public string KeepDuplicateOutputs { get; set; }
-                public string Name { get; set; }
+                string name;
+                public string Name { get { return name ?? String.Empty; } set { name = value; } }
                 public ICollection<ProjectOnErrorElement> OnErrors {
-                        get {
-                                throw new NotImplementedException ();
-                        }
+                        get { return new CollectionFromEnumerable<ProjectOnErrorElement> (
+                                new FilteredEnumerable<ProjectOnErrorElement> (Children)); }
                 }
-                public string Outputs { get; set; }
+                string outputs;
+                public string Outputs { get { return outputs ?? String.Empty; } set { outputs = value; } }
                 public ICollection<ProjectPropertyGroupElement> PropertyGroups {
-                        get {
-                                throw new NotImplementedException ();
-                        }
+                        get { return new CollectionFromEnumerable<ProjectPropertyGroupElement> (
+                                new FilteredEnumerable<ProjectPropertyGroupElement> (Children)); }
                 }
-                public string Returns { get; set; }
+                string returns;
+                public string Returns { get { return returns ?? String.Empty; } set { returns = value; } }
                 public ICollection<ProjectTaskElement> Tasks {
-                        get {
-                                throw new NotImplementedException ();
-                        }
+                        get { return new CollectionFromEnumerable<ProjectTaskElement> (
+                                new FilteredEnumerable<ProjectTaskElement> (Children)); }
                 }
                 public ProjectItemGroupElement AddItemGroup ()
                 {
-                        throw new NotImplementedException ();
+                        var item = ContainingProject.CreateItemGroupElement ();
+                        AppendChild (item);
+                        return item;
                 }
                 public ProjectPropertyGroupElement AddPropertyGroup ()
                 {
-                        throw new NotImplementedException ();
+                        var property = ContainingProject.CreatePropertyGroupElement ();
+                        AppendChild (property);
+                        return property;
                 }
                 public ProjectTaskElement AddTask (string taskName)
                 {
-                        throw new NotImplementedException ();
+                        var task = ContainingProject.CreateTaskElement (taskName);
+                        AppendChild (task);
+                        return task;
                 }
                 internal override string XmlName {
-                        get {
-                                throw new NotImplementedException ();
+                        get { return "Target"; }
+                }
+
+                internal override ProjectElement LoadChildElement (string name)
+                {
+                        switch (name) {
+                        case "OnError":
+                                var error = new ProjectOnErrorElement (ContainingProject);
+                                AppendChild (error);
+                                return error;
+                        case "PropertyGroup":
+                                return AddPropertyGroup ();
+                        case "ItemGroup":
+                                return AddItemGroup ();
+                        default:
+                                return AddTask (name);
                         }
                 }
+                internal override void LoadAttribute (string name, string value)
+                {
+                        switch (name) {
+                        case "Name":
+                                Name = value;
+                                break;
+                        case "DependsOnTargets":
+                                DependsOnTargets = value;
+                                break;
+                        case "Returns":
+                                Returns = value;
+                                break;
+                        case "Inputs":
+                                Inputs = value;
+                                break;
+                        case "Outputs":
+                                Outputs = value;
+                                break;
+                        case "BeforeTargets":
+                                BeforeTargets = value;
+                                break;
+                        case "AfterTargets":
+                                AfterTargets = value;
+                                break;
+                        case "KeepDuplicateOutputs":
+                                KeepDuplicateOutputs = value;
+                                break;
+                        default:
+                                base.LoadAttribute (name, value);
+                                break;
+                        }
+                }
+                internal override void SaveValue (System.Xml.XmlWriter writer)
+                {
+                        SaveAttribute (writer, "Name", Name);
+                        SaveAttribute (writer, "DependsOnTargets", DependsOnTargets);
+                        SaveAttribute (writer, "Returns", Returns);
+                        SaveAttribute (writer, "Inputs", Inputs);
+                        SaveAttribute (writer, "Outputs", Outputs);
+                        SaveAttribute (writer, "BeforeTargets", BeforeTargets);
+                        SaveAttribute (writer, "AfterTargets", AfterTargets);
+                        SaveAttribute (writer, "KeepDuplicateOutputs", KeepDuplicateOutputs);
+                        base.SaveValue (writer);
+                }
         }
 }