PageRenderTime 44ms CodeModel.GetById 18ms RepoModel.GetById 1ms app.codeStats 0ms

/source/library/Interlace/PropertyLists/PropertyArray.cs

https://bitbucket.org/VahidN/interlace
C# | 189 lines | 131 code | 33 blank | 25 comment | 4 complexity | 6a45969685b7aa180cd2e91364e46bf0 MD5 | raw file
  1. #region Using Directives and Copyright Notice
  2. // Copyright (c) 2007-2010, Computer Consultancy Pty Ltd
  3. // All rights reserved.
  4. //
  5. // Redistribution and use in source and binary forms, with or without
  6. // modification, are permitted provided that the following conditions are met:
  7. // * Redistributions of source code must retain the above copyright
  8. // notice, this list of conditions and the following disclaimer.
  9. // * Redistributions in binary form must reproduce the above copyright
  10. // notice, this list of conditions and the following disclaimer in the
  11. // documentation and/or other materials provided with the distribution.
  12. // * Neither the name of the Computer Consultancy Pty Ltd nor the
  13. // names of its contributors may be used to endorse or promote products
  14. // derived from this software without specific prior written permission.
  15. //
  16. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17. // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18. // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19. // ARE DISCLAIMED. IN NO EVENT SHALL COMPUTER CONSULTANCY PTY LTD BE LIABLE
  20. // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21. // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22. // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23. // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24. // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25. // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  26. // DAMAGE.
  27. using System;
  28. using System.Collections;
  29. using System.Collections.Generic;
  30. using System.IO;
  31. using System.Text;
  32. using Interlace.Utilities;
  33. #endregion
  34. namespace Interlace.PropertyLists
  35. {
  36. [Serializable]
  37. public class PropertyArray : IEnumerable
  38. {
  39. List<object> _list;
  40. internal PropertyArray()
  41. {
  42. _list = new List<object>();
  43. }
  44. public static PropertyArray EmptyArray()
  45. {
  46. return new PropertyArray();
  47. }
  48. public static PropertyArray FromString(string text)
  49. {
  50. if (string.IsNullOrEmpty(text)) return PropertyArray.EmptyArray();
  51. using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(text)))
  52. {
  53. using (StreamReader reader = new StreamReader(stream))
  54. {
  55. return PropertyArray.FromReader(reader, "text string");
  56. }
  57. }
  58. }
  59. public static PropertyArray FromReader(TextReader reader, string nameForExceptions)
  60. {
  61. Lexer lexer = new Lexer(reader, nameForExceptions);
  62. return Parser.Parse(lexer) as PropertyArray;
  63. }
  64. public int Count
  65. {
  66. get { return _list.Count; }
  67. }
  68. public object this[int i]
  69. {
  70. get
  71. {
  72. if (i < 0 || _list.Count <= i) throw new IndexOutOfRangeException();
  73. return _list[i];
  74. }
  75. }
  76. public string PersistToString()
  77. {
  78. return GetPersistString();
  79. }
  80. private string GetPersistString()
  81. {
  82. Writer writer = new Writer();
  83. writer.WriteArray(this);
  84. return writer.ToString();
  85. }
  86. public string StringAt(int i)
  87. {
  88. return this[i] as string;
  89. }
  90. public int? IntegerAt(int i)
  91. {
  92. return this[i] as int?;
  93. }
  94. public bool? BooleanAt(int i)
  95. {
  96. return this[i] as bool?;
  97. }
  98. public byte[] DataAt(int i)
  99. {
  100. return this[i] as byte[];
  101. }
  102. public PropertyArray ArrayAt(int i)
  103. {
  104. return this[i] as PropertyArray;
  105. }
  106. public PropertyDictionary DictionaryAt(int i)
  107. {
  108. return this[i] as PropertyDictionary;
  109. }
  110. public void AppendValue(object value)
  111. {
  112. _list.Add(value);
  113. }
  114. public void AppendValues(PropertyArray values)
  115. {
  116. foreach(object value in values)
  117. {
  118. _list.Add(value);
  119. }
  120. }
  121. public void AppendValues(IEnumerable<object> values)
  122. {
  123. foreach(object value in values)
  124. {
  125. _list.Add(value);
  126. }
  127. }
  128. public IEnumerator GetEnumerator()
  129. {
  130. return _list.GetEnumerator();
  131. }
  132. public object[] ToArray()
  133. {
  134. return _list.ToArray();
  135. }
  136. public override string ToString()
  137. {
  138. Dictionary<Type, int> typeCount = new Dictionary<Type, int>();
  139. foreach(object item in _list)
  140. {
  141. Type itemType = item.GetType();
  142. if (!typeCount.ContainsKey(itemType))
  143. {
  144. typeCount[itemType] = 0;
  145. }
  146. typeCount[itemType]++;
  147. }
  148. List<string> outputStrings = new List<string>();
  149. foreach(KeyValuePair<Type, int> pair in typeCount)
  150. {
  151. outputStrings.Add(string.Format("{0}: {1}", pair.Key.Name, pair.Value));
  152. }
  153. return NaturalStrings.FormatList(outputStrings, FormatListFormat.AllCommasList);
  154. }
  155. }
  156. }