public override void because()
{
mappings = model.BuildMappings();
target_mapping = mappings
.SelectMany(x => x.Classes)
.FirstOrDefault(x => x.Type == typeof(Target));
}
public Stream GetStream(ClassMapping clazz,string directory,out string fileName)
{
directoryForOutput = directory;
if (!string.IsNullOrEmpty(directoryForOutput))
{
if (!Directory.Exists(directoryForOutput))
Directory.CreateDirectory(directoryForOutput);
}
try
{
fileName = GetFileName(clazz);
}
catch
{
fileName = clazz.GeneratedName + ".cs";
log.Error("Error processing template for file name. " + fileName + " used.");
}
string toSave = Path.Combine(directoryForOutput, fileName);
FileStream output = new FileStream(toSave, FileMode.Create, FileAccess.ReadWrite);
log.Debug("Flushing output on file:" + output.Name);
fileName = toSave;
return output;
}
/// <summary>
/// Returns true if you need to call "CreateStoreRoom" before storing any
/// data. This method is "Missing" not "Exists" because implementations that
/// do not use a store room can return "false" from this method without
/// breaking either a user's app or the spirit of the method.
///
/// Store room typically corresponds to "table".
/// Firebird doesn't appear to support the SQL standard information_schema.
/// </summary>
/// <returns>Returns true if you need to call "CreateStoreRoom"
/// before storing any data.</returns>
public override bool StoreRoomMissing(ClassMapping mapping)
{
int count = SqlConnectionUtilities.XSafeIntQuery(_connDesc,
"select count(*) from rdb$relations where rdb$relation_name = '" +
mapping.Table.ToUpper() + "'", null);
return count == 0;
}
private ISubclassMapping CreateSubclass(ClassMapping mapping)
{
if (mapping.Discriminator == null)
return new JoinedSubclassMapping();
return new SubclassMapping();
}
public void TestCheckStoreRoomMissing()
{
OleDbOracleDaLayer ddl =
new OleDbOracleDaLayer(
(OleDbDescriptor)
ConnectionDescriptor.LoadFromConfig(
new Config("..\\..\\Tests\\OracleDao.config", "OracleDaoConfig"), "DAO"));
// Make sure the store room to test does not exist
var colDef = new ClassMapColDefinition("Id", "Id", "INTEGER");
var cm = new ClassMapping("test", "UNITTEST.StoreroomDoesNotExist", new List<ClassMapColDefinition>{colDef}, false);
ddl.DeleteStoreRoom(cm);
try
{
// Hasn't been added yet, should not exist
Assert.IsTrue(
ddl.StoreRoomMissing(cm), "Oracle storeroom should not exist");
ddl.CreateStoreRoom(cm);
// Correct name, should exist
Assert.IsFalse(
ddl.StoreRoomMissing(cm), "Oracle Storeroom should exist");
}
finally
{
// Delete the storeromm, no matter what
ddl.DeleteStoreRoom(cm);
}
// Storeroom should be gone
Assert.IsTrue(
ddl.StoreRoomMissing(cm), "Oracle storeroom should not exist");
}
public ClassInspector(ClassMapping mapping)
{
this.mapping = mapping;
propertyMappings.Map(x => x.LazyLoad, x => x.Lazy);
propertyMappings.Map(x => x.ReadOnly, x => x.Mutable);
propertyMappings.Map(x => x.EntityType, x => x.Type);
}
public void ShouldMapByteArrayAsTimestampSqlType()
{
var mapping = new ClassMapping { Type = typeof(Target) };
mapper.Map(mapping, typeof(Target).GetProperty("Version"));
mapping.Version.Columns.All(x => x.SqlType == "timestamp").ShouldBeTrue();
}
public void ShouldMapByteArrayAsBinaryBlob()
{
var mapping = new ClassMapping { Type = typeof(Target) };
mapper.Map(mapping, typeof(Target).GetProperty("Version"));
mapping.Version.Type.ShouldEqual(new TypeReference("BinaryBlob"));
}
/// <summary>
/// Create the data reader.
/// </summary>
/// <param name="layer">Layer creating it.</param>
/// <param name="mapping">Mapping for the class stored in the data store.</param>
/// <param name="criteria">Criteria for which instances you want.</param>
/// <param name="objects">Iterator over the list of objects.</param>
public MemoryDataReader(UnqueryableDaLayer layer, ClassMapping mapping, DaoCriteria criteria,
IEnumerator<MemoryObject> objects)
: base(layer, mapping, criteria, GetConfig(mapping))
{
_objects = objects;
PreProcessSorts();
}
public void ShouldMapByteArrayAsNotNull()
{
var mapping = new ClassMapping { Type = typeof(Target) };
mapper.Map(mapping, typeof(Target).GetProperty("Version"));
mapping.Version.Columns.All(x => x.NotNull == true).ShouldBeTrue();
}
public void ShouldSetContainingEntityType()
{
var mapping = new ClassMapping { Type = typeof(Target) };
mapper.Map(mapping, typeof(Target).GetProperty("Version").ToMember());
mapping.Version.ContainingEntityType.ShouldEqual(typeof(Target));
}
public void ShouldMapByteArrayWithUnsavedValueOfNull()
{
var mapping = new ClassMapping { Type = typeof(Target) };
mapper.Map(mapping, typeof(Target).GetProperty("Version"));
mapping.Version.UnsavedValue.ShouldEqual(null);
}
public void ShouldMapInheritedByteArray()
{
var mapping = new ClassMapping { Type = typeof(SubTarget) };
mapper.Map(mapping, typeof(SubTarget).GetProperty("Version"));
Assert.That(mapping.Version, Is.Not.Null);
}
public void ShouldMapByteArrayAsNotNull()
{
var mapping = new ClassMapping { Type = typeof(Target) };
mapper.Map(mapping, typeof(Target).GetProperty("Version").ToMember());
SpecificationExtensions.ShouldBeTrue(mapping.Version.Columns.All(x => x.NotNull == true));
}
public void ShouldMapByteArrayAsBinaryBlob()
{
var mapping = new ClassMapping();
mapping.Set(x => x.Type, Layer.Defaults, typeof(Target));
mapper.Map(mapping, typeof(Target).GetProperty("Version").ToMember());
mapping.Version.Type.ShouldEqual(new TypeReference("BinaryBlob"));
}
public void ShouldMapByteArrayAsNotNull()
{
var mapping = new ClassMapping();
mapping.Set(x => x.Type, Layer.Defaults, typeof(Target));
mapper.Map(mapping, typeof(Target).GetProperty("Version").ToMember());
mapping.Version.Columns.All(x => x.NotNull).ShouldBeTrue();
}
public void ShouldMapByteArrayWithUnsavedValueOfNull()
{
var mapping = new ClassMapping();
mapping.Set(x => x.Type, Layer.Defaults, typeof(Target));
mapper.Map(mapping, typeof(Target).GetProperty("Version").ToMember());
mapping.Version.UnsavedValue.ShouldEqual(null);
}
public void ShouldMapInheritedByteArray()
{
var mapping = new ClassMapping();
mapping.Set(x => x.Type, Layer.Defaults, typeof(SubTarget));
mapper.Map(mapping, typeof(SubTarget).GetProperty("Version").ToMember());
Assert.That(mapping.Version, Is.Not.Null);
}
public override void ProcessClass(ClassMapping mapping)
{
var subclasses = FindClosestSubclasses(mapping.Type);
foreach (var provider in subclasses)
mapping.AddSubclass(provider.GetSubclassMapping(CreateSubclass(mapping)));
base.ProcessClass(mapping);
}
public void ShouldWriteAny()
{
var mapping = new ClassMapping();
mapping.AddAny(new AnyMapping());
writer.VerifyXml(mapping)
.Element("any").Exists();
}
public void ShouldWriteBag()
{
var mapping = new ClassMapping();
mapping.AddCollection(new BagMapping());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
public void ShouldWriteCache()
{
var mapping = new ClassMapping();
mapping.Cache = new CacheMapping();
writer.VerifyXml(mapping)
.Element("cache").Exists();
}
public void ShouldSetContainingEntityType()
{
var mapping = new ClassMapping();
mapping.Set(x => x.Type, Layer.Defaults, typeof(Target));
mapper.Map(mapping, typeof(Target).GetProperty("Version").ToMember());
mapping.Version.ContainingEntityType.ShouldEqual(typeof(Target));
}
public void ShouldWriteSqlUpdate()
{
var mapping = new ClassMapping();
mapping.AddStoredProcedure(new StoredProcedureMapping("sql-update", "update ABC"));
writer.VerifyXml(mapping)
.Element("sql-update").Exists();
}
public DiscriminatorMapping(ClassMapping parentClass)
{
ParentClass = parentClass;
attributes = new AttributeStore<DiscriminatorMapping>();
attributes.SetDefault(x => x.NotNull, true);
attributes.SetDefault(x => x.Insert, true);
attributes.SetDefault(x => x.Type, typeof(string));
}
public void ShouldMapHashSetAsSet()
{
var classMapping = new ClassMapping();
classMapping.Set(x => x.Type, Layer.Defaults, typeof(PropertyTarget));
mapper.Map(classMapping, typeof(PropertyTarget).GetProperty("HashSet").ToMember());
classMapping.Collections
.First().Collection.ShouldEqual(Collection.Set);
}
public ClassMapping Map(Type classType, List<AutoMapType> types)
{
var classMap = new ClassMapping { Type = classType };
classMap.SetDefaultValue(x => x.Name, classType.AssemblyQualifiedName);
classMap.SetDefaultValue(x => x.TableName, GetDefaultTableName(classType));
mappingTypes = types;
return (ClassMapping)MergeMap(classType, classMap, new List<string>());
}
public override void ProcessClass(ClassMapping mapping)
{
var subclasses = subclassProviders
.Select(x => x.GetSubclassMapping(CreateSubclass(mapping)))
.Where(x => x.Type.BaseType == mapping.Type);
foreach (var subclass in subclasses)
mapping.AddSubclass(subclass);
base.ProcessClass(mapping);
}
public ClassMapping Map(Type classType, List<AutoMapType> types)
{
var classMap = new ClassMapping();
classMap.Set(x => x.Type, Layer.Defaults, classType);
classMap.Set(x => x.Name, Layer.Defaults, classType.AssemblyQualifiedName);
classMap.Set(x => x.TableName, Layer.Defaults, GetDefaultTableName(classType));
mappingTypes = types;
return (ClassMapping)MergeMap(classType, classMap, new List<Member>());
}
public void CanAddClassMappings()
{
var hibMap = new HibernateMapping();
var classMap1 = new ClassMapping();
var classMap2 = new ClassMapping();
hibMap.AddClass(classMap1);
hibMap.AddClass(classMap2);
hibMap.Classes.ShouldContain(classMap1);
hibMap.Classes.ShouldContain(classMap2);
}
public FhirbaseJsonWriter(StringWriter sw, Type t) : base(sw)
{
m_mapping = s_modelInspector.FindClassMappingByType(t);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClassMappingBuilder{TEntity}"/> class.
/// </summary>
/// <param name="classMapping">The class mapping.</param>
public ClassMappingBuilder(ClassMapping classMapping)
{
ClassMapping = classMapping;
}
//this should be refactored into read(ITypedElement parent, Base existing)
private void read(ClassMapping mapping, IEnumerable <ITypedElement> members, Base existing)
{
foreach (var memberData in members)
{
var memberName = memberData.Name; // tuple: first is name of member
// Find a property on the instance that matches the element found in the data
// NB: This function knows how to handle suffixed names (e.g. xxxxBoolean) (for choice types).
var mappedProperty = mapping.FindMappedElementByName(memberName);
if (mappedProperty != null)
{
// Message.Info("Handling member {0}.{1}", mapping.Name, memberName);
object value = null;
// For primitive members we can save time by not calling the getter
if (!mappedProperty.IsPrimitive)
{
value = mappedProperty.GetValue(existing);
if (value != null && !mappedProperty.IsCollection)
{
RaiseFormatError($"Element '{mappedProperty.Name}' must not repeat", memberData.Location);
}
}
var reader = new DispatchingReader(memberData, Settings, arrayMode: false);
// Since we're still using both ClassMappings and the newer IElementDefinitionSummary provider at the same time,
// the member might be known in the one (POCO), but unknown in the provider. This is only in theory, since the
// provider should provide exactly the same information as the mappings. But better to get a clear exception
// when this happens.
value = reader.Deserialize(mappedProperty, memberName, value);
if (mappedProperty.RepresentsValueElement && mappedProperty.ElementType.IsEnum() && value is String)
{
if (!Settings.AllowUnrecognizedEnums)
{
if (EnumUtility.ParseLiteral((string)value, mappedProperty.ElementType) == null)
{
RaiseFormatError($"Literal '{value}' is not a valid value for enumeration '{mappedProperty.ElementType.Name}'", _current.Location);
}
}
((Primitive)existing).ObjectValue = value;
//var prop = ReflectionHelper.FindPublicProperty(mapping.NativeType, "RawValue");
//prop.SetValue(existing, value, null);
//mappedProperty.SetValue(existing, null);
}
else
{
mappedProperty.SetValue(existing, value);
}
}
else
{
if (Settings.AcceptUnknownMembers == false)
{
RaiseFormatError($"Encountered unknown member '{memberName}' while de-serializing", memberData.Location);
}
else
{
Message.Info("Skipping unknown member " + memberName);
}
}
}
}
ClassMapping IMappingProvider.GetClassMapping()
{
var mapping = new ClassMapping(attributes.CloneInner());
mapping.Type = typeof(T);
mapping.Name = typeof(T).AssemblyQualifiedName;
foreach (var property in properties)
{
mapping.AddProperty(property.GetPropertyMapping());
}
foreach (var component in components)
{
mapping.AddComponent(component.GetComponentMapping());
}
if (version != null)
{
mapping.Version = version.GetVersionMapping();
}
foreach (var oneToOne in oneToOnes)
{
mapping.AddOneToOne(oneToOne.GetOneToOneMapping());
}
foreach (var collection in collections)
{
mapping.AddCollection(collection.GetCollectionMapping());
}
foreach (var reference in references)
{
mapping.AddReference(reference.GetManyToOneMapping());
}
foreach (var any in anys)
{
mapping.AddAny(any.GetAnyMapping());
}
foreach (var subclass in subclasses.Values)
{
mapping.AddSubclass(subclass.GetSubclassMapping());
}
foreach (var join in joins)
{
mapping.AddJoin(join);
}
if (discriminator != null)
{
mapping.Discriminator = ((IDiscriminatorMappingProvider)discriminator).GetDiscriminatorMapping();
}
if (cache != null)
{
mapping.Cache = cache;
}
if (id != null)
{
mapping.Id = id.GetIdentityMapping();
}
if (compositeId != null)
{
mapping.Id = compositeId.GetCompositeIdMapping();
}
if (naturalId != null)
{
mapping.NaturalId = naturalId.GetNaturalIdMapping();
}
if (!mapping.IsSpecified("TableName"))
{
mapping.SetDefaultValue(x => x.TableName, GetDefaultTableName());
}
foreach (var filter in filters)
{
mapping.AddFilter(filter.GetFilterMapping());
}
foreach (var storedProcedure in storedProcedures)
{
mapping.AddStoredProcedure(storedProcedure.GetStoredProcedureMapping());
}
mapping.Tuplizer = tuplizerMapping;
return(mapping);
}
public virtual bool HasExtends(ClassMapping cmap)
{
return(GetExtends(cmap).Length != 0);
}
public virtual bool HasImplements(ClassMapping cmap)
{
return(GetImplements(cmap).Length != 0);
}
public virtual string FieldsAsArguments(SupportClass.ListCollectionSupport fieldslist, ClassMapping classMapping,
IDictionary class2classmap)
{
StringBuilder buf = new StringBuilder();
bool first = true;
for (IEnumerator fields = fieldslist.GetEnumerator(); fields.MoveNext();)
{
if (first)
{
first = false;
}
else
{
buf.Append(", ");
}
FieldProperty field = (FieldProperty)fields.Current;
buf.Append(field.fieldcase);
}
return(buf.ToString());
}
public virtual void DoImports(ClassMapping classMapping, StreamWriter writer)
{
writer.WriteLine(languageTool.GenerateImports(classMapping));
writer.WriteLine();
}
private int DoFields(ClassMapping classMapping, IDictionary class2classmap, StringWriter writer, string vetoSupport,
string changeSupport, int fieldTypes, SupportClass.ListCollectionSupport fieldz)
{
// field accessors
for (IEnumerator fields = fieldz.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
if (field.GeneratedAsProperty)
{
// getter
string getAccessScope = GetFieldScope(field, "scope-get", "public");
if (field.GetMeta("field-description") != null)
{
//writer.WriteLine(" /** \n" + languageTool.toJavaDoc(field.getMetaAsString("field-description"), 4) + " */");
writer.WriteLine(" /// <summary>\n" + languageTool.ToJavaDoc(field.GetMetaAsString("field-description"), 4) +
"\n /// </summary>");
}
writer.Write(" " + getAccessScope + " virtual " + field.FullyQualifiedTypeName + " " + field.Propcase);
if (classMapping.Interface)
{
writer.WriteLine(";");
}
else
{
writer.WriteLine();
writer.WriteLine(" {");
writer.WriteLine(" get { return this." + field.fieldcase + "; }");
//writer.WriteLine(" {");
//writer.WriteLine(" return this." + field.FieldName + ";");
//writer.WriteLine(" }");
}
// setter
int fieldType = 0;
if (field.GetMeta("beans-property-type") != null)
{
string beansPropertyType = field.GetMetaAsString("beans-property-type").Trim().ToLower();
if (beansPropertyType.Equals("constraint"))
{
fieldTypes = (fieldTypes | CONSTRAINT);
fieldType = CONSTRAINT;
}
else if (beansPropertyType.Equals("bound"))
{
fieldTypes = (fieldTypes | BOUND);
fieldType = BOUND;
}
}
string setAccessScope = GetFieldScope(field, "scope-set", "public");
writer.Write(" set");
writer.Write((fieldType & CONSTRAINT) == CONSTRAINT ? " throws PropertyVetoException " : "");
if (classMapping.Interface)
{
writer.WriteLine(";");
}
else
{
writer.WriteLine();
writer.WriteLine(" {");
if ((fieldType & CONSTRAINT) == CONSTRAINT || (fieldType & BOUND) == BOUND)
{
writer.WriteLine(" object oldValue = " + GetFieldAsObject(true, field) + ";");
}
if ((fieldType & CONSTRAINT) == CONSTRAINT)
{
writer.WriteLine(" " + vetoSupport + ".fireVetoableChange(\"" + field.fieldcase + "\",");
writer.WriteLine(" oldValue,");
writer.WriteLine(" " + GetFieldAsObject(false, field) + ");");
}
writer.WriteLine(" this." + field.fieldcase + " = value;");
if ((fieldType & BOUND) == BOUND)
{
writer.WriteLine(" " + changeSupport + ".firePropertyChange(\"" + field.fieldcase + "\",");
writer.WriteLine(" oldValue,");
writer.WriteLine(" " + GetFieldAsObject(false, field) + ");");
}
writer.WriteLine(" }");
}
writer.WriteLine(" }");
writer.WriteLine();
// add/remove'rs (commented out for now)
/*
* if(field.getForeignClass()!=null) {
* ClassName foreignClass = field.getForeignClass();
*
* string trueforeign = getTrueTypeName(foreignClass, class2classmap);
* classMapping.addImport(trueforeign);
*
* // Try to identify the matching set method on the child.
* ClassMapping forignMap = (ClassMapping) class2classmap.get(foreignClass.getFullyQualifiedName());
*
* if(forignMap!=null) {
* Iterator foreignFields = forignMap.getFields().iterator();
* while (foreignFields.hasNext()) {
* Field ffield = (Field) foreignFields.next();
* if(ffield.isIdentifier()) {
* log.Debug("Trying to match " + ffield.getName() + " with " + field.getForeignKeys());
* }
* }
*
* } else {
* log.Error("Could not find foreign class's mapping - cannot provide bidirectional setters!");
* }
*
* string addAccessScope = getFieldScope(field, "scope", "scope-add");
* writer.println(" " + setAccessScope + " void add" + field.getAsSuffix() + StringHelper.OPEN + shortenType(trueforeign, classMapping.getImports()) + " a" + field.getName() + ") {");
* writer.println(" this." + getterType + field.getAsSuffix() + "().add(a" + field.getName() + ");");
* writer.println(" a" + field.getName() + ".setXXX(this);");
* writer.println(" }");
* writer.println();
*
*
* }
*/
}
}
return(fieldTypes);
}
public override void Render(string savedToPackage, string savedToClass, ClassMapping classMapping,
IDictionary class2classmap, StreamWriter mainwriter)
{
mainwriter.WriteLine("using System;");
mainwriter.WriteLine(
@"//------------------------------------------------------------------------------
// <autogenerated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------
");
GeneratePackageDelaration(savedToPackage, classMapping, mainwriter);
mainwriter.WriteLine("{");
// switch to another writer to be able to insert the actually
// used imports when whole class has been rendered.
StringWriter writer = new StringWriter();
// class declaration
if (classMapping.GetMeta("class-description") == null)
{
writer.WriteLine(
@" /// <summary>
/// POJO for {0}
/// </summary>
/// <remark>
/// This class is autogenerated
/// </remark>
",
classMapping.ClassName);
}
else
{
writer.WriteLine("/// <summary>\n" + languageTool.ToJavaDoc(classMapping.GetMetaAsString("class-description"), 0) +
"\n/// </summary>");
}
string classScope = classMapping.Scope;
string declarationType = classMapping.DeclarationType;
//classMapping.addImport(typeof(System.Runtime.Serialization.ISerializable));
//string modifiers = classMapping.getModifiers();
if (classMapping.ShouldBeAbstract() && (classScope.IndexOf("abstract") == -1))
{
writer.Write("abstract " + classScope + " " + declarationType + " " + savedToClass);
}
else
{
writer.Write(classScope + " " + declarationType + " " + savedToClass);
}
if (languageTool.HasExtends(classMapping) || languageTool.HasImplements(classMapping))
{
writer.Write(" : ");
}
if (languageTool.HasExtends(classMapping))
{
writer.Write(languageTool.GetExtends(classMapping));
}
if (languageTool.HasExtends(classMapping) && languageTool.HasImplements(classMapping))
{
writer.Write(", ");
}
if (languageTool.HasImplements(classMapping))
{
writer.Write(languageTool.GetImplements(classMapping));
}
writer.WriteLine(" {");
writer.WriteLine();
// switch to another writer to be able to insert the
// veto- and changeSupport fields
StringWriter propWriter = new StringWriter();
if (!classMapping.Interface)
{
DoFields(classMapping, class2classmap, propWriter);
DoConstructors(savedToClass, classMapping, class2classmap, propWriter);
}
string vetoSupport = MakeSupportField("vetos", classMapping.AllFields);
string changeSupport = MakeSupportField("changes", classMapping.AllFields);
int fieldTypes = DoFieldAccessors(classMapping, class2classmap, propWriter, vetoSupport, changeSupport);
if (!classMapping.Interface)
{
DoSupportMethods(fieldTypes, vetoSupport, changeSupport, propWriter);
DoToString(classMapping, propWriter);
DoEqualsAndHashCode(savedToClass, classMapping, propWriter);
}
if (classMapping.GetMeta("class-code") != null)
{
propWriter.WriteLine("// The following is extra code specified in the hbm.xml files");
SupportClass.ListCollectionSupport extras = classMapping.GetMeta("class-code");
IEnumerator iter = extras.GetEnumerator();
while (iter.MoveNext())
{
string code = iter.Current.ToString();
propWriter.WriteLine(code);
}
propWriter.WriteLine("// end of extra code specified in the hbm.xml files");
}
propWriter.WriteLine("}");
//insert change and VetoSupport
if (!classMapping.Interface)
{
DoSupports(fieldTypes, classMapping, vetoSupport, changeSupport, writer);
}
writer.Write(propWriter.ToString());
// finally write the imports
DoImports(classMapping, mainwriter);
mainwriter.Write(writer.ToString());
mainwriter.WriteLine("\n}");
}
public virtual void DoEqualsAndHashCode(string savedToClass, ClassMapping classMapping, StringWriter writer)
{
if (classMapping.MustImplementEquals())
{
writer.WriteLine(" public override bool Equals(object obj) {");
writer.WriteLine(" if(this == obj) return true;");
writer.WriteLine(" if((obj == null) || (obj.GetType() != this.GetType())) return false;");
writer.WriteLine(" " + savedToClass + " castObj = (" + savedToClass + ") obj;");
writer.Write(" return (castObj != null) ");
int usedFields = 0;
SupportClass.ListCollectionSupport idFields = new SupportClass.ListCollectionSupport();
for (IEnumerator fields = classMapping.Fields.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
if (field.GetMetaAsBool("use-in-equals"))
{
writer.Write(" && (this." + field.fieldcase + " == castObj." + field.fieldcase + ")");
usedFields++;
}
if (field.Identifier)
{
idFields.Add(field);
}
}
if (usedFields == 0)
{
log.Warn("No properties has been marked as being used in equals/hashcode for " + classMapping.Name +
". Using object identifier which is RARELY safe to use! See http://hibernate.org/109.html");
for (IEnumerator fields = idFields.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
writer.Write(" && (this." + field.fieldcase + " == castObj." + field.fieldcase + ")");
}
}
writer.WriteLine(";");
writer.WriteLine(" }");
writer.WriteLine();
writer.WriteLine(" public override int GetHashCode() {");
writer.WriteLine(" int hash = 69;");
//writer.Write(" return");
for (IEnumerator fields = classMapping.Fields.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
if (field.GetMetaAsBool("use-in-equals"))
{
//writer.Write("\n " + field.FieldName + ".GetHashCode() ^");
writer.WriteLine(" hash = 31 * hash + " + field.fieldcase + ".GetHashCode();");
}
}
if (usedFields == 0)
{
for (IEnumerator fields = idFields.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
//writer.Write("\n " + field.FieldName + ".GetHashCode() ^");
writer.WriteLine(" hash = 31 * hash + " + field.fieldcase + ".GetHashCode();");
}
}
//writer.WriteLine(" 0;");
writer.WriteLine(" return hash;");
writer.WriteLine(" }");
writer.WriteLine();
}
}
public virtual void DoConstructors(string savedToClass, ClassMapping classMapping, IDictionary class2classmap,
StringWriter writer)
{
// full constructor
SupportClass.ListCollectionSupport allFieldsForFullConstructor = classMapping.AllFieldsForFullConstructor;
writer.WriteLine(" /// <summary>\n /// full constructor\n /// </summary>");
string fullCons = " public " + savedToClass + StringHelper.OpenParen;
fullCons += languageTool.FieldsAsParameters(allFieldsForFullConstructor, classMapping, class2classmap);
writer.Write(fullCons + ")");
//invoke super to initialize superclass...
SupportClass.ListCollectionSupport supersConstructorFields = classMapping.FieldsForSupersFullConstructor;
if (!(supersConstructorFields.Count == 0))
{
writer.Write(" : base(");
bool first = true;
for (IEnumerator fields = supersConstructorFields.GetEnumerator(); fields.MoveNext();)
{
if (first)
{
first = false;
}
else
{
writer.Write(", ");
}
FieldProperty field = (FieldProperty)fields.Current;
writer.Write(field.FieldName);
}
writer.Write(")");
}
writer.WriteLine();
writer.WriteLine(" {");
// initialisation of localfields
for (IEnumerator fields = classMapping.LocalFieldsForFullConstructor.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
if (field.GeneratedAsProperty)
{
writer.WriteLine(" this." + field.FieldName + " = " + field.FieldName + ";");
}
}
writer.WriteLine(" }");
writer.WriteLine();
// no args constructor (if fullconstructor had any arguments!)
if (allFieldsForFullConstructor.Count > 0)
{
writer.WriteLine(" /// <summary>\n /// default constructor\n /// </summary>");
writer.WriteLine(" public " + savedToClass + "() {");
writer.WriteLine(" }");
writer.WriteLine();
}
// minimal constructor (only if the fullconstructor had any arguments)
if ((allFieldsForFullConstructor.Count > 0) && classMapping.NeedsMinimalConstructor())
{
SupportClass.ListCollectionSupport allFieldsForMinimalConstructor = classMapping.AllFieldsForMinimalConstructor;
writer.WriteLine(" /// <summary>\n /// minimal constructor\n /// </summary>");
string minCons = " public " + savedToClass + "(";
bool first = true;
for (IEnumerator fields = allFieldsForMinimalConstructor.GetEnumerator(); fields.MoveNext();)
{
if (first)
{
first = false;
}
else
{
minCons = minCons + ", ";
}
FieldProperty field = (FieldProperty)fields.Current;
minCons = minCons +
LanguageTool.ShortenType(LanguageTool.GetTrueTypeName(field, class2classmap), classMapping.Imports) + " " +
field.FieldName;
}
writer.Write(minCons + ")");
// invoke super to initialize superclass...
SupportClass.ListCollectionSupport supersMinConstructorFields = classMapping.FieldsForSupersMinimalConstructor;
if (!(supersMinConstructorFields.Count == 0))
{
writer.Write(" : base(");
bool first2 = true;
for (IEnumerator fields = supersMinConstructorFields.GetEnumerator(); fields.MoveNext();)
{
if (first2)
{
first2 = false;
}
else
{
writer.Write(StringHelper.CommaSpace);
}
FieldProperty field = (FieldProperty)fields.Current;
writer.Write(field.FieldName);
}
writer.Write(")");
}
writer.WriteLine();
writer.WriteLine(" {");
// initialisation of localfields
for (IEnumerator fields = classMapping.LocalFieldsForMinimalConstructor.GetEnumerator(); fields.MoveNext();)
{
FieldProperty field = (FieldProperty)fields.Current;
if (field.GeneratedAsProperty)
{
writer.WriteLine(" this." + field.FieldName + " = " + field.FieldName + ";");
}
}
writer.WriteLine(" }");
writer.WriteLine();
}
}
public override void because()
{
mappings = model.BuildMappings().ToList();
targetMapping = mappings.SelectMany(x => x.Classes).FirstOrDefault(x => x.Type == typeof(Root));
}
public virtual string GetSaveToPackage(ClassMapping classMapping)
{
return(classMapping.GeneratedPackageName);
}
public void AddClass(ClassMapping classMapping)
{
classes.Add(classMapping);
}
public virtual string GetSaveToClassName(ClassMapping classMapping)
{
return(classMapping.GeneratedName);
}
public virtual string FieldsAsParameters(SupportClass.ListCollectionSupport fieldslist, ClassMapping classMapping,
IDictionary class2classmap)
{
StringBuilder buf = new StringBuilder();
bool first = true;
for (IEnumerator fields = fieldslist.GetEnumerator(); fields.MoveNext();)
{
if (first)
{
first = false;
}
else
{
buf.Append(", ");
}
FieldProperty field = (FieldProperty)fields.Current;
buf.Append(ShortenType(field.FullyQualifiedTypeName, classMapping.Imports) + " " + field.fieldcase);
}
return(buf.ToString());
}
protected internal virtual void GeneratePackageDelaration(string savedToPackage, ClassMapping classMapping, StreamWriter w)
{
string string_Renamed = GetPackageDeclaration(savedToPackage, classMapping);
if (string_Renamed.Length > 0)
{
w.WriteLine(string_Renamed);
}
else
{
w.WriteLine("// default package");
}
}
public virtual void Render(string savedToPackage, string savedToClass, ClassMapping classMapping,
IDictionary class2classmap, StreamWriter writer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ListGeneratorBuilder{TEntity}"/> class.
/// </summary>
/// <param name="classMapping">The class mapping.</param>
public ListGeneratorBuilder(ClassMapping classMapping) : base(classMapping)
{
Random(2, 10);
}
public void TestMixedDataTypeDetection()
{
var mapping = ClassMapping.Create(typeof(ComplexNumber));
// cannot have a datatype with a profile....
}
private void read(ClassMapping mapping, IEnumerable <Tuple <string, IFhirReader> > members, Base existing)
{
//bool hasMember;
foreach (var memberData in members)
{
//hasMember = true;
var memberName = memberData.Item1; // tuple: first is name of member
// Find a property on the instance that matches the element found in the data
// NB: This function knows how to handle suffixed names (e.g. xxxxBoolean) (for choice types).
var mappedProperty = mapping.FindMappedElementByName(memberName);
if (mappedProperty != null)
{
// Message.Info("Handling member {0}.{1}", mapping.Name, memberName);
object value = null;
// For primitive members we can save time by not calling the getter
if (!mappedProperty.IsPrimitive)
{
value = mappedProperty.GetValue(existing);
if (value != null && !mappedProperty.IsCollection)
{
throw Error.Format($"Element '{mappedProperty.Name}' must not repeat", _current);
}
}
var reader = new DispatchingReader(memberData.Item2, Settings, arrayMode: false);
value = reader.Deserialize(mappedProperty, memberName, value);
if (mappedProperty.RepresentsValueElement && mappedProperty.ElementType.IsEnum() && value is String)
{
if (!Settings.AllowUnrecognizedEnums)
{
if (EnumUtility.ParseLiteral((string)value, mappedProperty.ElementType) == null)
{
throw Error.Format("Literal '{0}' is not a valid value for enumeration '{1}'".FormatWith(value, mappedProperty.ElementType.Name), _current);
}
}
((Primitive)existing).ObjectValue = value;
//var prop = ReflectionHelper.FindPublicProperty(mapping.NativeType, "RawValue");
//prop.SetValue(existing, value, null);
//mappedProperty.SetValue(existing, null);
}
else
{
mappedProperty.SetValue(existing, value);
}
}
else
{
if (Settings.AcceptUnknownMembers == false)
{
throw Error.Format("Encountered unknown member '{0}' while de-serializing".FormatWith(memberName), _current);
}
else
{
Message.Info("Skipping unknown member " + memberName);
}
}
}
}
public void TestMixedDataTypeDetection()
{
Assert.ThrowsException <ArgumentException>(() => ClassMapping.Create(typeof(ComplexNumber)));
// cannot have a datatype with a profile....
}
public FhirbaseJsonReader(object json, Type t)
{
m_reader = new JsonTextReader(new StringReader(json as string));
m_mapping = s_modelInspector.FindClassMappingByType(t);
}
public override IDesignModel GenerateDesignModel(IXmlElement xmlElement, DesignModelParseContext context)
{
var sourceDesignModelName = xmlElement.GetStringAttributeValue("src");
var sourceDesignModelNameSet = !string.IsNullOrWhiteSpace(sourceDesignModelName);
var destinationDesignModelName = xmlElement.GetStringAttributeValue("dest");
var destinationDesignModelNameSet = !string.IsNullOrWhiteSpace(destinationDesignModelName);
if (sourceDesignModelNameSet && destinationDesignModelNameSet)
{
throw new ParseException(xmlElement.ParseLocation, $"Both 'src' and 'dest' attributes cannot be set.");
}
if (!sourceDesignModelNameSet && !destinationDesignModelNameSet)
{
throw new ParseException(xmlElement.ParseLocation, $"Either 'src' or 'dest' attribute must be set.");
}
var currentDesignModel = context.DesignModel;
if (!(currentDesignModel is IClassModel currentClassModel))
{
throw new ParseException(xmlElement.ParseLocation, $"Mapping model '{currentDesignModel.FullyQualifiedName}' must be a class-like design model.");
}
var ns = currentDesignModel.Namespace;
var sourceReference = sourceDesignModelNameSet
? _designModelCollection.CreateClassModelReference(ns, xmlElement.ParseLocation, sourceDesignModelName)
: currentClassModel.CreateClassModelReference(xmlElement.ParseLocation);
var destinationReference = destinationDesignModelNameSet
? _designModelCollection.CreateClassModelReference(ns, xmlElement.ParseLocation, destinationDesignModelName)
: currentClassModel.CreateClassModelReference(xmlElement.ParseLocation);
var classMapping = new ClassMapping
{
Name = xmlElement.GetStringAttributeValue("name", null),
Source = sourceReference,
Destination = destinationReference,
MapAttributes = xmlElement.GetBoolAttributeValue("attributes", true),
MapRelations = xmlElement.GetBoolAttributeValue("relations", true),
AddMissing = xmlElement.GetBoolAttributeValue("add-missing", true),
TwoWay = xmlElement.GetBoolAttributeValue("two-way", true),
ParseLocation = xmlElement.ParseLocation
};
foreach (var attributeElement in xmlElement.GetChildElments("Attribute"))
{
var mapping = new AttributeMapping
{
Source = new ClassAttributeReference(attributeElement.GetStringAttributeValue("src"), attributeElement.ParseLocation),
Destination = new ClassAttributeReference(attributeElement.GetStringAttributeValue("dest"), attributeElement.ParseLocation),
ParseLocation = attributeElement.ParseLocation
};
classMapping.AttributeMappings.Add(mapping);
}
foreach (var relationElement in xmlElement.GetChildElments("Relation"))
{
var relationMapping = new RelationMapping
{
Source = new ClassRelationReference(relationElement.GetStringAttributeValue("src"), relationElement.ParseLocation),
Destination = new ClassRelationReference(relationElement.GetStringAttributeValue("dest"), relationElement.ParseLocation),
MapAttributes = relationElement.GetBoolAttributeValue("attributes", true),
AddMissing = relationElement.GetBoolAttributeValue("add-missing", true),
TwoWay = relationElement.GetBoolAttributeValue("two-way", true),
ParseLocation = relationElement.ParseLocation
};
foreach (var attributeElement in relationElement.GetChildElments("Attribute"))
{
var relationAttributeMapping = new AttributeMapping
{
Source = new ClassAttributeReference(attributeElement.GetStringAttributeValue("src"), attributeElement.ParseLocation),
Destination = new ClassAttributeReference(attributeElement.GetStringAttributeValue("dest"), attributeElement.ParseLocation),
ParseLocation = attributeElement.ParseLocation
};
relationMapping.AttributeMappings.Add(relationAttributeMapping);
}
classMapping.RelationMappings.Add(relationMapping);
}
currentClassModel.SetClassMappingData(classMapping);
return(null);
}
public void LoadSettingsFromXml()
{
#region load profiles
cmbParserProfile.Items.Clear();
cbTextExtractor.Items.Clear();
ClientConfiguration = ConfigXmlDocument.Clients.Find(c => c.ClientName == ClientName);
JobConfiguration = ClientConfiguration.ETLs.Find(etl => etl.ETLName == ETLName);
foreach (ClassMapping extractorMapping in EasyETLEnvironment.Extractors)
{
cbTextExtractor.Items.Add(extractorMapping.DisplayName);
}
foreach (ClassMapping classMapping in EasyETLEnvironment.Parsers)
{
if ((classMapping.Class.GetEasyFields().Count() == 0) || (!classMapping.Class.GetEasyFields().Select(p => p.Value.DefaultValue).Contains(null)))
{
cmbParserProfile.Items.Add(classMapping.DisplayName);
}
}
foreach (EasyETLParser easyETLParser in ClientConfiguration.Parsers)
{
cmbParserProfile.Items.Add(easyETLParser.ActionName);
}
#endregion
#region load all available actions
chkAvailableActions.Items.Clear();
fpActions.Controls.Clear();
foreach (EasyETLAction etlAction in ClientConfiguration.Actions)
{
string actionName = etlAction.ActionName;
string className = etlAction.ClassName;
if (EasyETLEnvironment.Actions.Where(a => a.DisplayName == className).Count() > 0)
{
ClassMapping cMapping = EasyETLEnvironment.Actions.Where(a => a.DisplayName == className).First();
chkAvailableActions.Items.Add(etlAction.ActionName);
Button btnControl = new Button
{
AutoSize = true,
Text = etlAction.ActionName
};
btnControl.Click += btnControl_Click;
fpActions.Controls.Add(btnControl);
}
}
#endregion
#region load all available exports
chkAvailableExports.Items.Clear();
cmbExport.Items.Clear();
foreach (EasyETLWriter easyETLWriter in ClientConfiguration.Writers)
{
string actionName = easyETLWriter.ActionName;
string className = easyETLWriter.ClassName;
ClassMapping exportClassMapping = EasyETLEnvironment.Writers.Find(w => w.DisplayName == className);
if (exportClassMapping != null)
{
chkAvailableExports.Items.Add(actionName);
}
}
#endregion
#region load all available data sources
cmbDatasource.Items.Clear();
foreach (EasyETLDatasource easyETLDatasource in ClientConfiguration.Datasources)
{
cmbDatasource.Items.Add(easyETLDatasource.ActionName);
}
#endregion
#region load all available endpoints
cmbEndpoint.Items.Clear();
foreach (EasyETLEndpoint easyETLEndpoint in ClientConfiguration.Endpoints)
{
cmbEndpoint.Items.Add(easyETLEndpoint.ActionName);
}
#endregion
#region Actions Load
foreach (EasyETLJobAction easyETLJobAction in JobConfiguration.Actions)
{
int loadIndex = chkAvailableActions.Items.IndexOf(easyETLJobAction.ActionName);
bool toCheck = (easyETLJobAction.IsEnabled);
if (loadIndex >= 0)
{
chkAvailableActions.SetItemChecked(loadIndex, toCheck);
}
if (easyETLJobAction.IsDefault)
{
cmbDefaultAction.Text = easyETLJobAction.ActionName;
}
}
DisplayActionButtonsAsNeeded();
#endregion
#region Transformations Load
cbOnLoadProfiles.Text = JobConfiguration.Transformations.DuringLoad.SaveProfileName;
txtOnLoadFileName.Text = JobConfiguration.Transformations.DuringLoad.SaveFileName;
txtOnLoadContents.Text = String.Join(Environment.NewLine, JobConfiguration.Transformations.DuringLoad.SettingsCommands);
chkUseXsltTemplate.Checked = JobConfiguration.Transformations.AfterLoad.UseXslt;
cbTransformProfiles.Text = JobConfiguration.Transformations.AfterLoad.SaveProfileName;
txtTransformFileName.Text = JobConfiguration.Transformations.AfterLoad.SaveFileName;
txtXsltFileName.Text = JobConfiguration.Transformations.AfterLoad.XsltFileName;
txtTransformText.Text = String.Join(Environment.NewLine, JobConfiguration.Transformations.AfterLoad.SettingsCommands);
rbUseDatasetLoad.Checked = !JobConfiguration.Transformations.Dataset.UseCustom;
rbUseCustomTableLoad.Checked = JobConfiguration.Transformations.Dataset.UseCustom;
txtNodeMapping.Text = String.Join(Environment.NewLine, JobConfiguration.Transformations.Dataset.SettingsCommands);
#endregion
#region ParserOptions Load
cmbParserProfile.Text = JobConfiguration.ParseOptions.ProfileName;
#endregion
#region Output Settings Load
foreach (EasyETLJobExport easyETLJobExport in JobConfiguration.Exports)
{
int loadIndex = chkAvailableExports.Items.IndexOf(easyETLJobExport.ExportName);
bool toCheck = (easyETLJobExport.IsEnabled);
if (loadIndex >= 0)
{
chkAvailableExports.SetItemChecked(loadIndex, toCheck);
}
}
#endregion
#region Permissions Settings
btnSaveSettings.Visible = false;
EasyETLPermission etlPermission = JobConfiguration.DefaultPermission;
chkCanEditConfiguration.Checked = etlPermission.CanEditSettings;
chkShowConfigurationOnLoad.Checked = etlPermission.DisplaySettingsOnLoad;
chkCanAddData.Checked = etlPermission.CanAddData;
chkCanEditData.Checked = etlPermission.CanEditData;
chkCanDeleteData.Checked = etlPermission.CanDeleteData;
chkCanExportData.Checked = etlPermission.CanExportData;
ToggleDisplayConfigurationSection(chkShowConfigurationOnLoad.Checked && etlPermission.CanViewSettings);
chkAutoRefresh.Visible = chkCanEditConfiguration.Checked;
btnSaveSettings.Visible = chkCanEditConfiguration.Checked;
pnlExport.Visible = chkCanExportData.Checked;
#endregion
#region Datasource Node Load
if (!String.IsNullOrWhiteSpace(JobConfiguration.Datasource.SourceType))
{
tabDataSource.SelectTab("tabDatasource" + JobConfiguration.Datasource.SourceType);
}
cmbEndpoint.Text = JobConfiguration.Datasource.Endpoint;
txtFileName.Text = JobConfiguration.Datasource.FileName;
chkUseTextExtractor.Checked = JobConfiguration.Datasource.UseTextExtractor;
cbTextExtractor.Text = JobConfiguration.Datasource.TextExtractor;
nudMaxRows.Value = JobConfiguration.Datasource.MaxRows > 0 ? JobConfiguration.Datasource.MaxRows : 0;
chkHasMaxRows.Checked = JobConfiguration.Datasource.HasMaxRows;
cmbDatasource.Text = JobConfiguration.Datasource.DataSource;
txtTextContents.Text = JobConfiguration.Datasource.TextContents;
txtDatabaseQuery.Text = JobConfiguration.Datasource.Query;
#endregion
chkAutoRefresh.Checked = JobConfiguration.AutoRefresh; // (xNode.Attributes.GetNamedItem("autorefresh") == null) ? false : Boolean.Parse(xNode.Attributes.GetNamedItem("autorefresh").Value);
}
public void MutableShouldBeTrueByDefaultOnClassMapping()
{
var mapping = new ClassMapping();
mapping.Mutable.ShouldBeTrue();
}
public void LoadDataToGridView()
{
if (stopWatch.IsRunning)
{
stopWatch.Stop();
}
if ((tabDataSource.SelectedTab == tabDatasourceText) && (txtTextContents.TextLength == 0))
{
return;
}
if ((tabDataSource.SelectedTab == tabDatasourceFile) && (txtFileName.TextLength == 0))
{
return;
}
if ((tabDataSource.SelectedTab == tabDatasourceDatabase) && (String.IsNullOrWhiteSpace(cmbDatasource.Text)))
{
return;
}
AbstractFileEasyEndpoint endpoint = null;
if (tabDataSource.SelectedTab == tabDatasourceFile)
{
endpoint = GetEndpoint();
if (endpoint == null)
{
return;
}
if (endpoint.GetList(txtFileName.Text).Length == 0)
{
return;
}
}
stopWatch.Restart();
intAutoNumber = 0;
this.UseWaitCursor = true;
Application.DoEvents();
lblRecordCount.Text = "";
txtRegexContents.Text = "";
cmbTableName.Items.Clear();
AbstractContentExtractor extractor = null;
if ((chkUseTextExtractor.Checked) && (EasyETLEnvironment.Extractors.Find(e => e.DisplayName == cbTextExtractor.Text) != null))
{
extractor = (AbstractContentExtractor)Activator.CreateInstance(EasyETLEnvironment.Extractors.Find(e => e.DisplayName == cbTextExtractor.Text).Class);
}
try
{
EasyXmlDocument xDoc = new EasyXmlDocument();
xDoc.OnProgress += xDoc_OnProgress;
if (tabDataSource.SelectedTab == tabDatasourceDatabase)
{
DatasourceEasyParser dbep = null;
if ((cmbDatasource.SelectedItem != null) && (ClientConfiguration.Datasources.Find(ds => ds.ActionName == cmbDatasource.SelectedItem.ToString()) != null))
{
dbep = ClientConfiguration.Datasources.Find(ds => ds.ActionName == cmbDatasource.SelectedItem.ToString()).CreateDatasource();
if (chkHasMaxRows.Checked)
{
dbep.MaxRecords = Convert.ToInt64(nudMaxRows.Value);
}
xDoc.LoadXml(dbep.Load(txtDatabaseQuery.Text).OuterXml);
}
}
else
{
AbstractEasyParser ep = null;
if (ClientConfiguration.Parsers.Where(p => p.ActionName == cmbParserProfile.Text).Count() > 0)
{
ep = ClientConfiguration.Parsers.Find(p => p.ActionName == cmbParserProfile.Text).CreateParser();
}
if ((ep == null) && (EasyETLEnvironment.Parsers.Where(p => p.DisplayName == cmbParserProfile.Text).Count() > 0))
{
ClassMapping parserClassMapping = EasyETLEnvironment.Parsers.Where(p => p.DisplayName == cmbParserProfile.Text).First();
ep = (AbstractEasyParser)Activator.CreateInstance(parserClassMapping.Class);
}
if (ep != null)
{
ep.ProgressInterval = 100;
if (chkHasMaxRows.Checked)
{
ep.MaxRecords = Convert.ToInt64(nudMaxRows.Value);
}
if (!String.IsNullOrWhiteSpace(txtOnLoadContents.Text))
{
ep.OnLoadSettings = txtOnLoadContents.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
}
if ((tabDataSource.SelectedTab == tabDatasourceFile))
{
Stream fileStream = endpoint.GetStream(txtFileName.Text);
if (extractor != null)
{
extractor.FileName = txtFileName.Text;
}
xDoc.Load(fileStream, ep, extractor);
}
else
{
xDoc.LoadStr(txtTextContents.Text, ep, extractor);
}
txtExceptions.Text = "";
if ((ep != null) && (ep.Exceptions.Count > 0))
{
MessageBox.Show("There were " + ep.Exceptions.Count + " Exceptions while loading the document");
foreach (MalformedLineException mep in ep.Exceptions)
{
txtExceptions.Text += String.Format("(Line {0} - {1}", mep.LineNumber, mep.Message) + Environment.NewLine;
}
}
}
}
ezDoc = xDoc;
try
{
TransformDataFromEzDoc();
}
catch (Exception ex)
{
MessageBox.Show("Error Transforming document." + Environment.NewLine + ex.Message);
}
}
catch (Exception ex)
{
MessageBox.Show("Error loading contents..." + Environment.NewLine + ex.Message);
}
endpoint = null;
this.UseWaitCursor = false;
}
public PassThroughMappingProvider(ClassMapping mapping)
{
this.mapping = mapping;
}
public PocoComplexTypeSerializationInfo(ClassMapping classMapping)
{
_classMapping = classMapping;
}