public override string MakeConstant(CsCodeWriter code, string value) { if (!String.IsNullOrEmpty(value)) throw new NotSupportedException("Complex types can not have default values."); return String.Format("{0}.DefaultInstance", CsCodeWriter.Global + _type.ImplementationName); }
public override void DeclareStaticData(CsCodeWriter code) { if (code.Language != _rule.Language) return; Match m; if (!String.IsNullOrEmpty(_rule.MethodBody) && (m = new Regex(@"^(?<Name>[a-zA-Z][\w_]*)\(value\)$").Match(_rule.Code)).Success) { using (code.WriteBlock("private static bool {0}({1} value)", m.Groups["Name"].Value, _field.GetStorageType(code))) using (StringReader rdr = new StringReader(_rule.MethodBody)) { string line; while(null != (line = rdr.ReadLine())) { line = line.Trim(); if (line.Length == 0) continue; if (line.StartsWith("}")) code.Indent--; code.WriteLine(line); if (line.EndsWith("{")) code.Indent--; } } } }
public override string FromXmlString(CsCodeWriter code, string name) { return String.Format("new {0}({1})", GetPublicType(code), _generator.ValueField.FromXmlString(code, name) ); }
public override void WriteChecks(CsCodeWriter code) { if (_rule.MinValue != null) { using (code.WriteBlock("if (value.CompareTo({0}) < 0)", code.MakeConstant(_field.FieldType, _rule.MinValue))) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{2}, " + "{0}NClassify.Library.ResourceMessages.MustBeGreaterThan, TypeFields.{2}, {1}));", CsCodeWriter.Global, code.MakeConstant(_field.FieldType, _rule.MinValue), _field.PropertyName); code.WriteLine("return false;"); } } if (_rule.MaxValue != null) { using (code.WriteBlock("if (value.CompareTo({0}) < 0)", code.MakeConstant(_field.FieldType, _rule.MaxValue))) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{2}, " + "{0}NClassify.Library.ResourceMessages.MustBeLessThan, TypeFields.{2}, {1}));", CsCodeWriter.Global, code.MakeConstant(_field.FieldType, _rule.MaxValue), _field.PropertyName); code.WriteLine("return false;"); } } }
public override void MakeReadOnly(CsCodeWriter code, string value) { if (_type.ImplementationName != _type.QualifiedName) { code.WriteLine("{0} = ({0} as {1}{2}) ?? new {1}{2}({0});", value, CsCodeWriter.Global, _type.ImplementationName); code.WriteLine("(({1}{2}){0}).MakeReadOnly();", value, CsCodeWriter.Global, _type.ImplementationName); } else code.WriteLine("{0}.MakeReadOnly();", value); }
public override void WriteChecks(CsCodeWriter code) { using (code.WriteBlock("if (object.ReferenceEquals(null, value))")) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{1}, " + "{0}NClassify.Library.ResourceMessages.MustNotBeNull, TypeFields.{1}));", CsCodeWriter.Global, _field.PropertyName); code.WriteLine("return false;"); } }
public override void WriteChecks(CsCodeWriter code) { using (code.WriteBlock("if (!__valid_{0}.IsMatch(value.ToString()))", _field.CamelName)) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{2}, " + "{0}NClassify.Library.ResourceMessages.MustMatchFormat, TypeFields.{2}, {1}));", CsCodeWriter.Global, code.MakeConstant(FieldType.String, _rule.Pattern), _field.PropertyName); code.WriteLine("return false;"); } }
public override void WriteChecks(CsCodeWriter code) { if (code.Language != _rule.Language) return; using (code.WriteBlock("if (!({0}))", _rule.Code)) { code.WriteLine("if (onError != null) " + "onError(new {0}NClassify.Library.ValidationError(TypeFields.{1}, {0}NClassify.Library.ResourceMessages.InvalidField, TypeFields.{1}));", CsCodeWriter.Global, _field.PropertyName); code.WriteLine("return false;"); } }
public override void WriteChecks(CsCodeWriter code) { if (_field.FieldType != FieldType.String) throw new ApplicationException("The possible values constraints only applies to fields of type String."); using (code.WriteBlock("if (global::System.Array.BinarySearch(__in_{0}, value) < 0)", _field.CamelName)) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{2}, " + "{0}NClassify.Library.ResourceMessages.MustBeOneOf, TypeFields.{2}, string.Join(\", \", __in_{1})));", CsCodeWriter.Global, _field.CamelName, _field.PropertyName); code.WriteLine("return false;"); } }
public override void DeclareStaticData(CsCodeWriter code) { code.Write("private static readonly {0}[] __in_{1} = new {0}[] {{", _field.GetStorageType(code), _field.CamelName); int ix = 0; string[] list = (string[]) _rule.Values.Clone(); Array.Sort(list); foreach (string possible in _rule.Values) { if (ix++ > 0) code.Write(", "); code.Write(code.MakeConstant(_field.FieldType, possible)); } code.WriteLine("};"); }
public override void DeclareStaticData(CsCodeWriter code) { code.WriteLine("private static readonly " + CsCodeWriter.Global + "System.Text.RegularExpressions.Regex __valid_{0} = " + "new " + CsCodeWriter.Global + "System.Text.RegularExpressions.Regex({1}, {2});", _field.CamelName, code.MakeConstant(FieldType.String, _rule.Pattern), (_rule.Multiline ? CsCodeWriter.Global + "System.Text.RegularExpressions.RegexOptions.Multiline" : CsCodeWriter.Global + "System.Text.RegularExpressions.RegexOptions.Singleline") + (_rule.IgnoreCase ? " | " + CsCodeWriter.Global + "System.Text.RegularExpressions.RegexOptions.IgnoreCase" : "") ); }
public override void WriteChecks(CsCodeWriter code) { using (code.WriteBlock("if (!value.IsValid())")) { code.WriteLine("if (onError == null)"); code.WriteLineIndent("return false;"); code.WriteLine( "{0}System.Collections.Generic.List<{0}NClassify.Library.ValidationError> errors = " + "new {0}System.Collections.Generic.List<{0}NClassify.Library.ValidationError>();", CsCodeWriter.Global ); code.WriteLine("value.GetBrokenRules(errors.Add);"); code.WriteLine("onError(new {0}NClassify.Library.ValidationError(TypeFields.{1}, errors));", CsCodeWriter.Global, _field.PropertyName); code.WriteLine("return false;"); } }
public override void WriteChecks(CsCodeWriter code) { string accessor = ".Length"; switch (_field.FieldType) { case FieldType.Bytes: case FieldType.String: break; //case FieldType.Uri: // accessor = ".AbsoluteUri.Length"; // break; default: throw new ArgumentOutOfRangeException("Length constraint does not apply to fields of type " + _field.FieldType); } if (_rule.MinLength > 0) { using (code.WriteBlock("if (value{0} < {1})", accessor, _rule.MinLength)) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{2}, " + "{0}NClassify.Library.ResourceMessages.MustBeLongerThan, TypeFields.{2}, {1}));", CsCodeWriter.Global, _rule.MinLength, _field.PropertyName); code.WriteLine("return false;"); } } if (_rule.MaxLength < uint.MaxValue) { using (code.WriteBlock("if (value{0} > {1})", accessor, _rule.MaxLength)) { code.WriteLine( "if (onError != null) onError(new {0}NClassify.Library.ValidationError(TypeFields.{2}, " + "{0}NClassify.Library.ResourceMessages.MustBeShorterThan, TypeFields.{2}, {1}));", CsCodeWriter.Global, _rule.MaxLength, _field.PropertyName); code.WriteLine("return false;"); } } }
public override string MakeConstant(CsCodeWriter code, string value) { if (String.IsNullOrEmpty(value)) return String.Format("default({0})", GetPublicType(code)); uint tmp; if(uint.TryParse(value, out tmp)) { string name = _enum.Values.Where(e => e.Value == tmp).Select(e => e.Name).FirstOrDefault(); if (!String.IsNullOrEmpty(name)) value = name; } value = CodeWriter.ToPascalCase(value); EnumType.Item item = _enum.Values.FirstOrDefault(e => CodeWriter.ToPascalCase(e.Name) == value); if (item == null) throw new ApplicationException( String.Format("Unknown default value '{0}' for enumeration {1}", value, _enum.QualifiedName)); return String.Format("{0}.{1}", GetPublicType(code), CodeWriter.ToPascalCase(item.Name)); }
public override string FromXmlString(CsCodeWriter code, string name) { return String.Format("({1}){0}System.Enum.Parse(typeof({1}), {2}, false)", CsCodeWriter.Global, GetStorageType(code), name); }
public override string ToXmlString(CsCodeWriter code, string name) { if (XmlOptions.Format != null) return base.ToXmlString(code, name); return String.Format("{0}.ToString()", name); }
public override void WriteClone(CsCodeWriter code) { code.WriteLine("value.{0} = ({1})value.{0}.Clone();", FieldBackingName, GetStorageType(code)); }
public override void WriteCopy(CsCodeWriter code, string other) { if(_generator.IsMessage) { code.WriteLine("foreach ({0} item in {1}.{2})", _generator.GetPublicType(code), other, PropertyName); code.WriteLineIndent("{0}.Add(({1})item.Clone());", FieldBackingName, _generator.GetStorageType(code)); } else code.WriteLine("{0}.AddRange({1}.{2});", FieldBackingName, other, PropertyName); }
public override void WriteClone(CsCodeWriter code) { code.WriteLine("value.{0} = value.{0}.Clone();", FieldBackingName); }
public override void WriteXmlOutput(CsCodeWriter code, string name) { code.WriteLine("{0}.WriteXml(\"{1}\", writer);", name, XmlOptions.XmlName); }
public override void MakeReadOnly(CsCodeWriter code, string value) { code.WriteLine("{0}.MakeReadOnly();", value); }
public override void WriteXmlOutput(CsCodeWriter code, string name) { using (code.WriteBlock("foreach ({0} item in {1})", _generator.GetPublicType(code), name)) _generator.WriteXmlOutput(code, "item"); }
public override void ReadXmlMessage(CsCodeWriter code) { if (_type.ImplementationName != _type.QualifiedName) code.WriteLine("{0}{1} value = ({2} as {0}{1}) ?? new {0}{1}({2});", CsCodeWriter.Global, _type.ImplementationName, FieldBackingName); else code.WriteLine("{0}{1} value = {2};", CsCodeWriter.Global, _type.ImplementationName, FieldBackingName); code.WriteLine("if (value.IsReadOnly())"); code.WriteLineIndent("value = object.ReferenceEquals(value, {0}{1}.DefaultInstance) ? new {0}{1}() : new {0}{1}({2});", CsCodeWriter.Global, _type.ImplementationName, FieldBackingName); code.WriteLine("value.ReadXml(reader.LocalName, reader);"); code.WriteLine("{0} = value;", FieldBackingName); if (HasBackingName != null) code.WriteLine(HasBackingName + " = true;"); }
public override void ReadXmlMessage(CsCodeWriter code) { if (_generator.IsMessage) code.WriteLine("{0} child = new {0}();", ((ComplexFieldGenerator)_generator).GetImplementationType(code)); else code.WriteLine("{0} child = {1};", _generator.GetPublicType(code), _generator.MakeConstant(code, null)); code.WriteLine("(({0}NClassify.Library.IBuilder)child).ReadXml(reader.LocalName, reader);", CsCodeWriter.Global); code.WriteLine("{0}.Add(child);", FieldBackingName); }
public override string FromXmlString(CsCodeWriter code, string name) { return name; }
public override void ReadXmlValue(CsCodeWriter code, string value) { code.WriteLine("{0}.Add({1});", FieldBackingName, _generator.FromXmlString(code, value)); }
public override void WriteValidation(CsCodeWriter code) { if (_generator.HasValidator) { using(code.WriteBlock("foreach ({0} item in {1})", _generator.GetPublicType(code), FieldBackingName)) code.WriteLine("if (!IsValid{0}(item, onError)) errorCount++;", _generator.PropertyName); } }
public string GetImplementationType(CsCodeWriter code) { return CsCodeWriter.Global + _type.ImplementationName; }
public override void DeclareTypes(CsCodeWriter code) { string collection = GetStorageType(code); string itemType = _generator.GetPublicType(code); using (code.CodeRegion(collection)) using (code.DeclareClass( new CodeItem(collection) { Access = FieldAccess.Private }, new[] { CsCodeWriter.Global + "System.Collections.Generic.IList<" + _generator.GetPublicType(code) + ">", CsCodeWriter.Global + "System.ICloneable", })) { using(code.WriteBlock("private static T AssertNotNull<T>(T value) where T : class")) { code.WriteLine("if (null == value) throw new {0}System.ArgumentNullException({1});", CsCodeWriter.Global, code.MakeString(PropertyName)); code.WriteLine("return value;"); } string value = _generator.IsNullable ? "AssertNotNull(value)" : "value"; code.WriteLine("private bool _readOnly;"); code.WriteLine("private readonly {0}System.Collections.Generic.List<{1}> _contents;", CsCodeWriter.Global, itemType); using(code.WriteBlock("public {0}()", collection)) { code.WriteLine("_readOnly = false;"); code.WriteLine("_contents = new {0}System.Collections.Generic.List<{1}>();", CsCodeWriter.Global, itemType); } using (code.WriteBlock("public {0}({1}System.Collections.Generic.IList<{2}> contents, bool clone)", collection, CsCodeWriter.Global, itemType)) { code.WriteLine("_readOnly = false;"); if (!_generator.IsNullable) { code.WriteLine("_contents = new {0}System.Collections.Generic.List<{1}>(AssertNotNull(contents));", CsCodeWriter.Global, itemType); } else { code.WriteLine("_contents = new {0}System.Collections.Generic.List<{1}>(AssertNotNull(contents).Count);", CsCodeWriter.Global, itemType); using (code.WriteBlock("foreach ({0} item in contents)", _generator.GetPublicType(code))) { if (_generator.IsMessage) { code.WriteLine("if (clone)"); code.WriteLineIndent("_contents.Add(({0})AssertNotNull(item).Clone());", itemType); code.WriteLine("else"); } code.WriteLine("_contents.Add(AssertNotNull(item));"); } } } _generator.Constraints.ForAll(x => x.WriteMember(code)); using (code.WriteBlock("public void MakeReadOnly()")) { code.WriteLine("if (_readOnly) return;"); code.WriteLine("_readOnly = true;"); if (_generator.IsMessage) using (code.WriteBlock("for (int i=0; i < _contents.Count; i++)")) { _generator.MakeReadOnly(code, "_contents[i]"); } } using (code.WriteBlock("private {0}System.Collections.Generic.List<{1}> Modify", CsCodeWriter.Global, itemType)) code.WriteLine("get {{ if (!IsReadOnly) return _contents; throw new {0}System.InvalidOperationException(); }}", CsCodeWriter.Global); using (code.WriteBlock("public {0} this[int index]", itemType)) { code.WriteLine("get { return _contents[index]; }"); code.WriteLine("set {{ Modify[index] = {0}; }}", value); } code.WriteLine("public int Count { get { return _contents.Count; } }"); code.WriteLine("public bool IsReadOnly { get { return _readOnly; } }"); code.WriteLine("public void Add({0} value) {{ Modify.Add({1}); }}", itemType, value); using (code.WriteBlock("public void AddRange({1}System.Collections.Generic.ICollection<{0}> value)", itemType, CsCodeWriter.Global)) { if (_generator.IsNullable) code.WriteLine("foreach ({0} item in AssertNotNull(value)) AssertNotNull(item);", _generator.GetPublicType(code)); code.WriteLine("Modify.AddRange(AssertNotNull(value));"); } code.WriteLine("public void Insert(int index, {0} value) {{ Modify.Insert(index, {1}); }}", itemType, value); code.WriteLine("public bool Remove({0} item) {{ return Modify.Remove(item); }}", itemType); code.WriteLine("public void RemoveAt(int index) { Modify.RemoveAt(index); }"); code.WriteLine("public void Clear() { Modify.Clear(); }"); code.WriteLine("public bool Contains({0} item) {{ return _contents.Contains(item); }}", itemType); code.WriteLine("public int IndexOf({0} item) {{ return _contents.IndexOf(item); }}", itemType); code.WriteLine("public void CopyTo({0}[] array, int arrayIndex) {{ _contents.CopyTo(array, arrayIndex); }}", itemType); code.WriteLine("object {0}System.ICloneable.Clone() {{ return Clone(); }}", CsCodeWriter.Global); using (code.WriteBlock("public {0} Clone()", collection)) { code.WriteLine("return _readOnly ? this : new {0}(this, true);", collection); } code.WriteLine("public {0}System.Collections.Generic.IEnumerator<{1}> GetEnumerator()", CsCodeWriter.Global, itemType); code.WriteLine("{ return _contents.GetEnumerator(); }"); code.WriteLine("{0}System.Collections.IEnumerator {0}System.Collections.IEnumerable.GetEnumerator()", CsCodeWriter.Global); code.WriteLine("{{ return (({0}System.Collections.IEnumerable)_contents).GetEnumerator(); }}", CsCodeWriter.Global); } }
public override string MakeConstant(CsCodeWriter code, string value) { if (!String.IsNullOrEmpty(value)) throw new NotSupportedException("Unable to define a default value for an array."); return "new " + GetStorageType(code) + "()"; }