libxmltv/Core/XMLTVProgram.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using libxmltv.Interfaces;
using System.Xml.Linq;
using System.Reflection;
using System.IO;
using System.Diagnostics;
using System.Globalization;

namespace libxmltv.Core
{
    [Serializable]
    internal class XMLTVProgram : XMLTVBase<XMLTVRuntimeInstance>, IXMLTVProgram
    {
        public XMLTVProgram()
            : base(null, XMLTVConstants.Programs.RootElement)
        {
            InternalDictionaryAddKnownProperties();
         
        }
        public XMLTVProgram(XMLTVRuntimeInstance instance, XElement node)
            : base(instance, XMLTVConstants.Programs.RootElement)
        {
            InternalDictionaryAddKnownProperties();
            try {
            xmltv_logger.Verbose.Debug.WriteLine("Creating Instance of XMLTVProgram");
            Create(node);
            xmltv_logger.Verbose.Debug.WriteLine("Created Instance of XMLTVProgram");
            UpdateInstance();
            }
            catch (IOException ex) { Debug.WriteLine(ex.ToString()); }
        }
        #region IXMLTVProgram members
        //public int Id { get; set; }
        //public DateTime Start { get; set; }
        //public DateTime Stop { get; set; }
        //public IXMLTVChannel Channel { get; set; }
        //public string Title { get; set; }
        //public string SubTitle { get; set; }
        //public string Description { get; set; }

        private void InternalDictionaryAddKnownProperties()
        {
            Properties = new Dictionary<string, object>();
            Properties.Add("Id", 0);
            Properties.Add(XMLTVConstants.Programs.ProgramStart, new DateTime());
            Properties.Add(XMLTVConstants.Programs.ProgramStop, new DateTime());
            Properties.Add(XMLTVConstants.Programs.ProgramChannelId, string.Empty);
            Properties.Add(XMLTVConstants.Programs.ProgramTitle, string.Empty);
            Properties.Add(XMLTVConstants.Programs.ProgramSubTitle, string.Empty);
            Properties.Add(XMLTVConstants.Programs.ProgramDescription, string.Empty);
        }

        public Dictionary<string, object> Properties { get; private set; }

        private void InternalDictionaryTestOrThrow()
        {
            if (Properties == null) { throw new NullReferenceException("Properties collection has not been initialized."); }
            //if (Properties.Count == 0) { throw new IndexOutOfRangeException("Properties collection has 0 elements."); }
        }
        private void InternalProperyExistsOrThrow(string propertyname)
        {
            InternalDictionaryTestOrThrow();
            //if (!ContainsProperty(propertyname)) { throw new KeyNotFoundException(string.Format("Property '{0}' does not exist.", propertyname)); }
        }

        public void RemoveProperty(string propertyname)
        {
            if (ContainsProperty(propertyname))
            {
                Properties.Remove(propertyname);
            }
            else
            {
                throw new ArgumentException(string.Format("Property '{0}' deos not exist", propertyname), propertyname);
            }
        }

        public void AddProperty(string propertyname) { AddProperty(propertyname, new object()); }
        public void AddProperty(string propertyname, object propertyvalue)
        {
            if (!ContainsProperty(propertyname))
            {
                Properties.Add(propertyname, propertyvalue);
            }
            else
            {
                SetProperty(propertyname, propertyvalue);
            }
        }
        public bool ContainsProperty(string propertyname)
        {
            return Properties.ContainsKey(propertyname);
        }
        public object GetProperty(string propertyname)
        {
            InternalProperyExistsOrThrow(propertyname);
            if (!ContainsProperty(propertyname)) { throw new KeyNotFoundException(string.Format("Property '{0}' does not exist.", propertyname)); }
            return Properties[propertyname];            
        }
        public void SetProperty(string propertyname, object propertyvalue)
        {
            InternalProperyExistsOrThrow(propertyname);
            if (!ContainsProperty(propertyname)) { throw new KeyNotFoundException(string.Format("Property '{0}' does not exist.", propertyname)); }
            Properties[propertyname] = propertyvalue;
        }
        #endregion
        public override string ToString()
        {
            return string.Format("{0}: {1} - {2} ({3}) ['{4}' <==> '{5}']",
                GetProperty("Id").ToString(),
                GetProperty(XMLTVConstants.Programs.ProgramTitle).ToString(),
                GetProperty(XMLTVConstants.Programs.ProgramSubTitle).ToString(),
                GetProperty(XMLTVConstants.Programs.ProgramChannelId).ToString(),
                ((DateTime)GetProperty(XMLTVConstants.Programs.ProgramStart)).ToString("yyyy/MM/dd hh:mm tt"),
                ((DateTime)GetProperty(XMLTVConstants.Programs.ProgramStop)).ToString("yyyy/MM/dd hh:mm tt"));
        }


        private void UpdateInstance()
        {
            bool found_field = false;
            var instance_type = this.GetInstance().GetType();
            var fields = instance_type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (var field in fields)
            {
                if (field.FieldType == typeof(List<IXMLTVProgram>))
                {
                    found_field = true;
                    try
                    {
                        
                        var list = (List<IXMLTVProgram>)field.GetValue(this.GetInstance());
                        this.SetProperty("Id", list.Count + 1);
                        list.Add(this);
                        xmltv_logger.Verbose.Debug.WriteLine("Updating instance with program information: {0}", this.ToString());
                        field.SetValue(this.GetInstance(), list);
                        break;
                    }
                    catch (Exception ex)
                    {
                        xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
                        xmltv_logger.Verbose.Error.WriteLine(ex.ToString());
                    }
                }
            }
            if (!found_field)
            {
                xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
            }
        }

        private void Create(XElement node)
        {
            //if (node.HasAttributes)
            //{
            //    var start = node.Attribute(XMLTVConstants.Programs.ProgramStart);
            //    this.Start = start == null ? new DateTime() : ParseDate(start.Value);
            //    if (!this.Start.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_start: {0}", start); }

            //    var stop = node.Attribute(XMLTVConstants.Programs.ProgramStop);
            //    this.Stop = stop == null ? new DateTime() : ParseDate(stop.Value);
            //    if (!this.Stop.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_stop: {0}", stop); }

            //    var channelid = node.Attribute(XMLTVConstants.Programs.ProgramChannelId);
            //    if (!string.IsNullOrEmpty(this.channelid)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channelid: {0}", channelid); }
            //    IXMLTVChannel channel = new XMLTVChannel();
            //    string _channelid = channelid == null ? string.Empty : channelid.Value;
            //    this.Channel = this.GetInstance().Channels.Find(m => m.Id == _channelid);
            //    if (this.Channel == null) { this.Channel = new XMLTVChannel(); }
            //    if (!string.IsNullOrEmpty(_channelid)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channel: {0}", this.Channel.ToString()); }            //}
            //try
            //{
            //    var title = node.Descendants(XMLTVConstants.Programs.ProgramTitle).FirstOrDefault();
            //    this.Title = title == null ? string.Empty : title.Value;
            //}
            //catch (Exception) { this.Title = string.Empty; }
            //if (!string.IsNullOrEmpty(this.Title)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_title: {0}", this.Title == string.Empty ? "empty" : this.Title); }
            //try
            //{
            //    var subtitle = node.Descendants(XMLTVConstants.Programs.ProgramSubTitle).FirstOrDefault();
            //    this.SubTitle = subtitle == null ? string.Empty : subtitle.Value;
            //}
            //catch (Exception) { this.SubTitle = string.Empty; }
            //if (!string.IsNullOrEmpty(this.SubTitle)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_subtitle: {0}", this.SubTitle == string.Empty ? "empty" : this.SubTitle); }
            //try
            //{
            //    var description = node.Descendants(XMLTVConstants.Programs.ProgramDescription).FirstOrDefault();
            //    this.Description = description == null ? string.Empty : description.Value; ;
            //}
            //catch (Exception) { this.Description = string.Empty; }
            //if (!string.IsNullOrEmpty(this.Description)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_description: {0}", this.Description == string.Empty ? "empty" : this.Description); }

            //ParseExtraData(node);

            var nodes = node.DescendantsAndSelf().ToList();
            foreach (var sub_node in nodes)
            {
                if (this.GetInstance().IsAborting)
                {
                    break;
                }
                CreateHandlerForProgramMetaDataNode(sub_node);
            }
        }
        private static DateTime ParseDate(string timeStamp)
        {
            DateTime dt = new DateTime();
            try
            {
                dt = DateTime.ParseExact(timeStamp, "yyyyMMddHHmmss zzzz", System.Globalization.CultureInfo.CurrentCulture);
            }
            catch (Exception ex) { throw ex; }
            return dt;
        }

        private void CreateHandlerForProgramMetaDataNode(XElement node)
        {

            Type t = this.GetType();
            Assembly asm = t.Assembly;
            var types = asm.GetTypes();
            var classes = types.ToList().FindAll(
                m => 
                    m.DeclaringType == t &&
                    m.IsClass &&
                    !m.IsSealed
                );
            classes.TrimExcess();

            object raw_instance = null;
            BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
            CultureInfo culture = CultureInfo.CurrentCulture;
            Type handler_type = null;
            foreach (var type in classes)
            {
                if (type.BaseType != null && type.BaseType == typeof(XMLTVBase<XMLTVProgram>))
                {
                    var iface = type.GetInterface("IXMLTVHandler", true);
                    if (iface != null)
                    {
                        var handler_prop = type.GetProperty("Handler");
                        if (handler_prop != null)
                        {
                            var ctors = type.GetConstructors(flags);
                            bool has_default_ctor = false;
                            foreach (var ctor in ctors) { if (ctor.GetParameters().Count() == 0) { has_default_ctor = true; } }
                            if (!has_default_ctor) { continue; }
                            raw_instance = Activator.CreateInstance(type, flags, null, new object[0], culture);
                            if (raw_instance != null)
                            {
                                object handler_value = handler_prop.GetValue(raw_instance, null);
                                if (handler_value != null && handler_value.ToString() == node.Name.ToString())
                                {
                                    handler_type = type;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            if (handler_type == null)
            {
                StringBuilder node_builder = new StringBuilder();
                node_builder.AppendFormat("<{0} ", node.Name);
                if (node.HasAttributes) { foreach (var attribute in node.Attributes()) { node_builder.AppendFormat("{0}=\"{1}\" ", attribute.Name, attribute.Value); } }
                string node_text = string.Format("{0}>", node_builder.ToString().TrimEnd(new char[] { ' ' }));
                xmltv_logger.Verbose.Warn.WriteLine("Ignoring unhandled extra meta-data: {0}", node_text);
            }
            else
            {
                raw_instance = Activator.CreateInstance(handler_type, flags, null, new object[] { this, node }, culture);
            }
        }


        #region sub-classes
        #region program title
        private class title : XMLTVBase<XMLTVProgram>
        {
            public title() : base(null, XMLTVConstants.Programs.ProgramTitle) { }
            public title(XMLTVProgram instance, XElement node)
                : base(instance, XMLTVConstants.Programs.ProgramTitle)
            {                
                if(node == null){throw new NullReferenceException("The node instance was null");}                
                if (node.Value != null)
                {
                    instance.AddProperty(XMLTVConstants.Programs.ProgramTitle, node.Value);
                    xmltv_logger.Verbose.Debug.WriteLine("\tprogram_title: {0}", node.Value);
                }                
            }
        }
        #endregion
        #region program stop/start/channel (programme)
        private class programme : XMLTVBase<XMLTVProgram>
        {
            public programme() : base(null, XMLTVConstants.Programs.RootElement) { }
            public programme(XMLTVProgram instance, XElement node)
                : base(instance, XMLTVConstants.Programs.RootElement)
            {
                if (node == null) { throw new NullReferenceException("The node instance was null"); }
                if (node.HasAttributes)
                {                    
                    var start = node.Attribute(XMLTVConstants.Programs.ProgramStart);
                    var t_start = start == null ? new DateTime() : ParseDate(start.Value);
                    if (!t_start.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_start: {0}", start); }
                    instance.AddProperty(XMLTVConstants.Programs.ProgramStart, t_start);

                    var stop = node.Attribute(XMLTVConstants.Programs.ProgramStop);
                    var t_stop = stop == null ? new DateTime() : ParseDate(stop.Value);
                    if (!t_stop.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_stop: {0}", stop); }
                    instance.AddProperty(XMLTVConstants.Programs.ProgramStop, t_stop);

                    var channelid = node.Attribute(XMLTVConstants.Programs.ProgramChannelId);
                    if (channelid != null)
                    {
                        if (!string.IsNullOrEmpty(channelid.Value)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channelid: {0}", channelid.Value); }
                        instance.AddProperty(XMLTVConstants.Programs.ProgramChannelId, channelid.Value);
                    }
                    
                }
            }
        }
        #endregion
        #endregion
    }
}
1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Text;
5	using libxmltv.Interfaces;
6	using System.Xml.Linq;
7	using System.Reflection;
8	using System.IO;
9	using System.Diagnostics;
10	using System.Globalization;
11
12	namespace libxmltv.Core
13	{
14	[Serializable]
15	internal class XMLTVProgram : XMLTVBase<XMLTVRuntimeInstance>, IXMLTVProgram
16	{
17	public XMLTVProgram()
18	: base(null, XMLTVConstants.Programs.RootElement)
19	{
20	InternalDictionaryAddKnownProperties();
21
22	}
23	public XMLTVProgram(XMLTVRuntimeInstance instance, XElement node)
24	: base(instance, XMLTVConstants.Programs.RootElement)
25	{
26	InternalDictionaryAddKnownProperties();
27	try {
28	xmltv_logger.Verbose.Debug.WriteLine("Creating Instance of XMLTVProgram");
29	Create(node);
30	xmltv_logger.Verbose.Debug.WriteLine("Created Instance of XMLTVProgram");
31	UpdateInstance();
32	}
33	catch (IOException ex) { Debug.WriteLine(ex.ToString()); }
34	}
35	#region IXMLTVProgram members
36	//public int Id { get; set; }
37	//public DateTime Start { get; set; }
38	//public DateTime Stop { get; set; }
39	//public IXMLTVChannel Channel { get; set; }
40	//public string Title { get; set; }
41	//public string SubTitle { get; set; }
42	//public string Description { get; set; }
43
44	private void InternalDictionaryAddKnownProperties()
45	{
46	Properties = new Dictionary<string, object>();
47	Properties.Add("Id", 0);
48	Properties.Add(XMLTVConstants.Programs.ProgramStart, new DateTime());
49	Properties.Add(XMLTVConstants.Programs.ProgramStop, new DateTime());
50	Properties.Add(XMLTVConstants.Programs.ProgramChannelId, string.Empty);
51	Properties.Add(XMLTVConstants.Programs.ProgramTitle, string.Empty);
52	Properties.Add(XMLTVConstants.Programs.ProgramSubTitle, string.Empty);
53	Properties.Add(XMLTVConstants.Programs.ProgramDescription, string.Empty);
54	}
55
56	public Dictionary<string, object> Properties { get; private set; }
57
58	private void InternalDictionaryTestOrThrow()
59	{
60	if (Properties == null) { throw new NullReferenceException("Properties collection has not been initialized."); }
61	//if (Properties.Count == 0) { throw new IndexOutOfRangeException("Properties collection has 0 elements."); }
62	}
63	private void InternalProperyExistsOrThrow(string propertyname)
64	{
65	InternalDictionaryTestOrThrow();
66	//if (!ContainsProperty(propertyname)) { throw new KeyNotFoundException(string.Format("Property '{0}' does not exist.", propertyname)); }
67	}
68
69	public void RemoveProperty(string propertyname)
70	{
71	if (ContainsProperty(propertyname))
72	{
73	Properties.Remove(propertyname);
74	}
75	else
76	{
77	throw new ArgumentException(string.Format("Property '{0}' deos not exist", propertyname), propertyname);
78	}
79	}
80
81	public void AddProperty(string propertyname) { AddProperty(propertyname, new object()); }
82	public void AddProperty(string propertyname, object propertyvalue)
83	{
84	if (!ContainsProperty(propertyname))
85	{
86	Properties.Add(propertyname, propertyvalue);
87	}
88	else
89	{
90	SetProperty(propertyname, propertyvalue);
91	}
92	}
93	public bool ContainsProperty(string propertyname)
94	{
95	return Properties.ContainsKey(propertyname);
96	}
97	public object GetProperty(string propertyname)
98	{
99	InternalProperyExistsOrThrow(propertyname);
100	if (!ContainsProperty(propertyname)) { throw new KeyNotFoundException(string.Format("Property '{0}' does not exist.", propertyname)); }
101	return Properties[propertyname];
102	}
103	public void SetProperty(string propertyname, object propertyvalue)
104	{
105	InternalProperyExistsOrThrow(propertyname);
106	if (!ContainsProperty(propertyname)) { throw new KeyNotFoundException(string.Format("Property '{0}' does not exist.", propertyname)); }
107	Properties[propertyname] = propertyvalue;
108	}
109	#endregion
110	public override string ToString()
111	{
112	return string.Format("{0}: {1} - {2} ({3}) ['{4}' <==> '{5}']",
113	GetProperty("Id").ToString(),
114	GetProperty(XMLTVConstants.Programs.ProgramTitle).ToString(),
115	GetProperty(XMLTVConstants.Programs.ProgramSubTitle).ToString(),
116	GetProperty(XMLTVConstants.Programs.ProgramChannelId).ToString(),
117	((DateTime)GetProperty(XMLTVConstants.Programs.ProgramStart)).ToString("yyyy/MM/dd hh:mm tt"),
118	((DateTime)GetProperty(XMLTVConstants.Programs.ProgramStop)).ToString("yyyy/MM/dd hh:mm tt"));
119	}
120
121
122
123
124	private void UpdateInstance()
125	{
126	bool found_field = false;
127	var instance_type = this.GetInstance().GetType();
128	var fields = instance_type.GetFields(BindingFlags.Public \| BindingFlags.NonPublic \| BindingFlags.Instance);
129	foreach (var field in fields)
130	{
131	if (field.FieldType == typeof(List<IXMLTVProgram>))
132	{
133	found_field = true;
134	try
135	{
136
137	var list = (List<IXMLTVProgram>)field.GetValue(this.GetInstance());
138	this.SetProperty("Id", list.Count + 1);
139	list.Add(this);
140	xmltv_logger.Verbose.Debug.WriteLine("Updating instance with program information: {0}", this.ToString());
141	field.SetValue(this.GetInstance(), list);
142	break;
143	}
144	catch (Exception ex)
145	{
146	xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
147	xmltv_logger.Verbose.Error.WriteLine(ex.ToString());
148	}
149	}
150	}
151	if (!found_field)
152	{
153	xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
154	}
155	}
156
157	private void Create(XElement node)
158	{
159	//if (node.HasAttributes)
160	//{
161	// var start = node.Attribute(XMLTVConstants.Programs.ProgramStart);
162	// this.Start = start == null ? new DateTime() : ParseDate(start.Value);
163	// if (!this.Start.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_start: {0}", start); }
164
165	// var stop = node.Attribute(XMLTVConstants.Programs.ProgramStop);
166	// this.Stop = stop == null ? new DateTime() : ParseDate(stop.Value);
167	// if (!this.Stop.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_stop: {0}", stop); }
168
169	// var channelid = node.Attribute(XMLTVConstants.Programs.ProgramChannelId);
170	// if (!string.IsNullOrEmpty(this.channelid)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channelid: {0}", channelid); }
171	// IXMLTVChannel channel = new XMLTVChannel();
172	// string _channelid = channelid == null ? string.Empty : channelid.Value;
173	// this.Channel = this.GetInstance().Channels.Find(m => m.Id == _channelid);
174	// if (this.Channel == null) { this.Channel = new XMLTVChannel(); }
175	// if (!string.IsNullOrEmpty(_channelid)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channel: {0}", this.Channel.ToString()); } //}
176	//try
177	//{
178	// var title = node.Descendants(XMLTVConstants.Programs.ProgramTitle).FirstOrDefault();
179	// this.Title = title == null ? string.Empty : title.Value;
180	//}
181	//catch (Exception) { this.Title = string.Empty; }
182	//if (!string.IsNullOrEmpty(this.Title)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_title: {0}", this.Title == string.Empty ? "empty" : this.Title); }
183	//try
184	//{
185	// var subtitle = node.Descendants(XMLTVConstants.Programs.ProgramSubTitle).FirstOrDefault();
186	// this.SubTitle = subtitle == null ? string.Empty : subtitle.Value;
187	//}
188	//catch (Exception) { this.SubTitle = string.Empty; }
189	//if (!string.IsNullOrEmpty(this.SubTitle)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_subtitle: {0}", this.SubTitle == string.Empty ? "empty" : this.SubTitle); }
190	//try
191	//{
192	// var description = node.Descendants(XMLTVConstants.Programs.ProgramDescription).FirstOrDefault();
193	// this.Description = description == null ? string.Empty : description.Value; ;
194	//}
195	//catch (Exception) { this.Description = string.Empty; }
196	//if (!string.IsNullOrEmpty(this.Description)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_description: {0}", this.Description == string.Empty ? "empty" : this.Description); }
197
198	//ParseExtraData(node);
199
200	var nodes = node.DescendantsAndSelf().ToList();
201	foreach (var sub_node in nodes)
202	{
203	if (this.GetInstance().IsAborting)
204	{
205	break;
206	}
207	CreateHandlerForProgramMetaDataNode(sub_node);
208	}
209	}
210	private static DateTime ParseDate(string timeStamp)
211	{
212	DateTime dt = new DateTime();
213	try
214	{
215	dt = DateTime.ParseExact(timeStamp, "yyyyMMddHHmmss zzzz", System.Globalization.CultureInfo.CurrentCulture);
216	}
217	catch (Exception ex) { throw ex; }
218	return dt;
219	}
220
221	private void CreateHandlerForProgramMetaDataNode(XElement node)
222	{
223
224	Type t = this.GetType();
225	Assembly asm = t.Assembly;
226	var types = asm.GetTypes();
227	var classes = types.ToList().FindAll(
228	m =>
229	m.DeclaringType == t &&
230	m.IsClass &&
231	!m.IsSealed
232	);
233	classes.TrimExcess();
234
235	object raw_instance = null;
236	BindingFlags flags = BindingFlags.Public \| BindingFlags.NonPublic \| BindingFlags.Instance;
237	CultureInfo culture = CultureInfo.CurrentCulture;
238	Type handler_type = null;
239	foreach (var type in classes)
240	{
241	if (type.BaseType != null && type.BaseType == typeof(XMLTVBase<XMLTVProgram>))
242	{
243	var iface = type.GetInterface("IXMLTVHandler", true);
244	if (iface != null)
245	{
246	var handler_prop = type.GetProperty("Handler");
247	if (handler_prop != null)
248	{
249	var ctors = type.GetConstructors(flags);
250	bool has_default_ctor = false;
251	foreach (var ctor in ctors) { if (ctor.GetParameters().Count() == 0) { has_default_ctor = true; } }
252	if (!has_default_ctor) { continue; }
253	raw_instance = Activator.CreateInstance(type, flags, null, new object[0], culture);
254	if (raw_instance != null)
255	{
256	object handler_value = handler_prop.GetValue(raw_instance, null);
257	if (handler_value != null && handler_value.ToString() == node.Name.ToString())
258	{
259	handler_type = type;
260	break;
261	}
262	}
263	}
264	}
265	}
266	}
267	if (handler_type == null)
268	{
269	StringBuilder node_builder = new StringBuilder();
270	node_builder.AppendFormat("<{0} ", node.Name);
271	if (node.HasAttributes) { foreach (var attribute in node.Attributes()) { node_builder.AppendFormat("{0}=\"{1}\" ", attribute.Name, attribute.Value); } }
272	string node_text = string.Format("{0}>", node_builder.ToString().TrimEnd(new char[] { ' ' }));
273	xmltv_logger.Verbose.Warn.WriteLine("Ignoring unhandled extra meta-data: {0}", node_text);
274	}
275	else
276	{
277	raw_instance = Activator.CreateInstance(handler_type, flags, null, new object[] { this, node }, culture);
278	}
279	}
280
281
282
283	#region sub-classes
284	#region program title
285	private class title : XMLTVBase<XMLTVProgram>
286	{
287	public title() : base(null, XMLTVConstants.Programs.ProgramTitle) { }
288	public title(XMLTVProgram instance, XElement node)
289	: base(instance, XMLTVConstants.Programs.ProgramTitle)
290	{
291	if(node == null){throw new NullReferenceException("The node instance was null");}
292	if (node.Value != null)
293	{
294	instance.AddProperty(XMLTVConstants.Programs.ProgramTitle, node.Value);
295	xmltv_logger.Verbose.Debug.WriteLine("\tprogram_title: {0}", node.Value);
296	}
297	}
298	}
299	#endregion
300	#region program stop/start/channel (programme)
301	private class programme : XMLTVBase<XMLTVProgram>
302	{
303	public programme() : base(null, XMLTVConstants.Programs.RootElement) { }
304	public programme(XMLTVProgram instance, XElement node)
305	: base(instance, XMLTVConstants.Programs.RootElement)
306	{
307	if (node == null) { throw new NullReferenceException("The node instance was null"); }
308	if (node.HasAttributes)
309	{
310	var start = node.Attribute(XMLTVConstants.Programs.ProgramStart);
311	var t_start = start == null ? new DateTime() : ParseDate(start.Value);
312	if (!t_start.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_start: {0}", start); }
313	instance.AddProperty(XMLTVConstants.Programs.ProgramStart, t_start);
314
315	var stop = node.Attribute(XMLTVConstants.Programs.ProgramStop);
316	var t_stop = stop == null ? new DateTime() : ParseDate(stop.Value);
317	if (!t_stop.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_stop: {0}", stop); }
318	instance.AddProperty(XMLTVConstants.Programs.ProgramStop, t_stop);
319
320	var channelid = node.Attribute(XMLTVConstants.Programs.ProgramChannelId);
321	if (channelid != null)
322	{
323	if (!string.IsNullOrEmpty(channelid.Value)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channelid: {0}", channelid.Value); }
324	instance.AddProperty(XMLTVConstants.Programs.ProgramChannelId, channelid.Value);
325	}
326
327	}
328	}
329	}
330	#endregion
331	#endregion
332	}
333	}