public T Create(string xukLN, string xukNS)
{
//string qname = String.Format("{0}:{1}", xukNS, xukLN);
UglyPrettyName name = new UglyPrettyName(!PrettyFormat ? xukLN : null, PrettyFormat ? xukLN : null);
QualifiedName qname = new QualifiedName(name, xukNS);
Type t = LookupType(qname);
if (t == null)
{
#if DEBUG
Debugger.Break();
#endif
return(null);
}
T obj = Create(t);
TypeAndQNames tt = LookupTypeAndQNames(qname);
DebugFix.Assert(tt != null);
if (tt.Type == null)
{
// not real type of qname => type of first available ancestor in the type inheritance chain.
obj.MissingTypeOriginalXukedName = tt.QName;
}
return(obj);
}
private Type LookupType(QualifiedName qname)
{
if (qname == null)
{
#if DEBUG
Debugger.Break();
#endif
return(null);
}
TypeAndQNames typeAndQNames = LookupTypeAndQNames(qname);
if (typeAndQNames != null)
{
if (typeAndQNames.Type != null)
{
return(typeAndQNames.Type);
}
#if DEBUG
Debugger.Break();
#endif
return(LookupType(typeAndQNames.BaseQName));
}
#if DEBUG
Debugger.Break();
#endif
return(null);
}
private TypeAndQNames RegisterType(Type t)
{
if (!typeof(T).IsAssignableFrom(t))
{
string msg = String.Format(
"Only Types inheriting {0} can be registered with the factory", typeof(T).FullName);
throw new MethodParameterIsWrongTypeException(msg);
}
if (t.IsAbstract)
{
string msg = String.Format(
"The abstract Type {0} cannot be registered with the factory", t.FullName);
throw new MethodParameterIsWrongTypeException(msg);
}
TypeAndQNames tq = new TypeAndQNames();
tq.QName = GetXukQualifiedName(t);
tq.Type = t;
tq.ClassName = t.FullName;
tq.AssemblyName = t.Assembly.GetName();
tryAgain:
if (t.BaseType != null && typeof(T).IsAssignableFrom(t.BaseType)) // && t.BaseType != typeof(T))
{
if (t.BaseType.IsAbstract)
{
t = t.BaseType;
goto tryAgain;
}
TypeAndQNames existing = typeAlreadyRegistered(t.BaseType);
if (existing == null)
{
QualifiedName qCheck = XukAble.GetXukQualifiedName(t.BaseType);
if (string.IsNullOrEmpty(qCheck.NamespaceUri) ||
qCheck.LocalName == null ||
string.IsNullOrEmpty(qCheck.LocalName.Pretty) ||
string.IsNullOrEmpty(qCheck.LocalName.Ugly))
{
#if DEBUG
Debugger.Break();
#endif
t = t.BaseType;
goto tryAgain;
}
existing = RegisterType(t.BaseType);
}
if (existing != null)
{
tq.BaseQName = new QualifiedName(
new UglyPrettyName(existing.QName.LocalName.Ugly, existing.QName.LocalName.Pretty),
existing.QName.NamespaceUri);
}
}
RegisterType(tq);
return(tq);
}
protected void XukInRegisteredType(XmlReader source)
{
if (Type_NAME.Match(source.LocalName) &&
source.NamespaceURI == XukAble.XUK_NS)
{
TypeAndQNames tq = new TypeAndQNames();
readTypeAndQNamesFromXmlReader(tq, source, PrettyFormat);
if (tq.Type == null)
{
#if DEBUG
Debugger.Break();
#endif
RegisterType(tq);
}
else
{
TypeAndQNames tq_ = RegisterType(tq.Type);
DebugFix.Assert(tq_.AssemblyName.Name == tq.AssemblyName.Name);
//DebugFix.Assert(tq_.AssemblyName.Version == tq.AssemblyName.Version);
DebugFix.Assert(tq_.ClassName == tq.ClassName);
DebugFix.Assert(tq_.Type == tq.Type);
DebugFix.Assert(tq_.QName.NamespaceUri == tq.QName.NamespaceUri);
DebugFix.Assert(tq_.QName.LocalName.Ugly == tq.QName.LocalName.Ugly);
DebugFix.Assert(tq_.QName.LocalName.Pretty == tq.QName.LocalName.Pretty);
if (tq_.BaseQName != null && tq.BaseQName != null)
{
DebugFix.Assert(tq_.BaseQName.NamespaceUri == tq.BaseQName.NamespaceUri);
if (!String.IsNullOrEmpty(tq.BaseQName.LocalName.Ugly))
{
DebugFix.Assert(tq_.BaseQName.LocalName.Ugly == tq.BaseQName.LocalName.Ugly);
}
if (!String.IsNullOrEmpty(tq.BaseQName.LocalName.Pretty))
{
DebugFix.Assert(tq_.BaseQName.LocalName.Pretty == tq.BaseQName.LocalName.Pretty);
}
}
}
}
if (!source.IsEmptyElement)
{
source.ReadSubtree().Close();
}
}
private void readTypeAndQNamesFromXmlReader(TypeAndQNames tq, XmlReader rd, bool pretty)
{
tq.AssemblyName = new AssemblyName(ReadXukAttribute(rd, AssemblyName_NAME));
if (ReadXukAttribute(rd, AssemblyVersion_NAME) != null)
{
tq.AssemblyName.Version = new Version(ReadXukAttribute(rd, AssemblyVersion_NAME));
}
tq.ClassName = ReadXukAttribute(rd, FullName_NAME);
if (tq.AssemblyName != null && tq.ClassName != null)
{
try
{
Assembly a = Assembly.Load(tq.AssemblyName);
try
{
tq.Type = a.GetType(tq.ClassName);
}
catch (Exception ex)
{
#if DEBUG
Debugger.Break();
#endif
Console.WriteLine("ClassName: " + tq.ClassName);
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
tq.Type = null;
}
}
catch (Exception ex)
{
#if DEBUG
Debugger.Break();
#endif
Console.WriteLine("AssemblyName: " + tq.AssemblyName);
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
tq.Type = null;
}
}
else
{
#if DEBUG
Debugger.Break();
#endif
Console.WriteLine("Type XukIn error?!");
Console.WriteLine("AssemblyName: " + tq.AssemblyName);
Console.WriteLine("ClassName: " + tq.ClassName);
tq.Type = null;
}
string xukLocalName = ReadXukAttribute(rd, XukLocalName_NAME);
UglyPrettyName name = null;
if (tq.Type != null)
{
UglyPrettyName nameCheck = GetXukName(tq.Type);
DebugFix.Assert(nameCheck != null);
if (nameCheck != null)
{
if (pretty)
{
DebugFix.Assert(xukLocalName == nameCheck.Pretty);
}
else
{
DebugFix.Assert(xukLocalName == nameCheck.Ugly);
}
name = nameCheck;
}
}
DebugFix.Assert(name != null);
if (name == null)
{
name = new UglyPrettyName(
!pretty ? xukLocalName : null,
pretty ? xukLocalName : null);
}
tq.QName = new QualifiedName(
name,
ReadXukAttribute(rd, XukNamespaceUri_NAME) ?? "");
string baseXukLocalName = ReadXukAttribute(rd, BaseXukLocalName_NAME);
if (!string.IsNullOrEmpty(baseXukLocalName))
{
UglyPrettyName nameBase = new UglyPrettyName(
!pretty ? baseXukLocalName : null,
pretty ? baseXukLocalName : null);
tq.BaseQName = new QualifiedName(
nameBase,
ReadXukAttribute(rd, BaseXukNamespaceUri_NAME) ?? "");
}
else
{
tq.BaseQName = null;
}
}
//public void RefreshQNames()
//{
// foreach (TypeAndQNames tq in mRegisteredTypeAndQNames)
// {
// if (tq.Type != null)
// {
// tq.QName = GetXukQualifiedName(tq.Type);
// if (tq.BaseQName != null
// && tq.Type.BaseType != null)
// {
// tq.BaseQName = GetXukQualifiedName(tq.Type.BaseType);
// }
// }
// }
// {
// Dictionary<string, TypeAndQNames> newDict = new Dictionary<string, TypeAndQNames>();
// Dictionary<string, TypeAndQNames>.Enumerator enu = mRegisteredTypeAndQNamesByQualifiedName.GetEnumerator();
// while (enu.MoveNext())
// {
// KeyValuePair<string, TypeAndQNames> pair = enu.Current;
// TypeAndQNames tq = new TypeAndQNames();
// if (pair.Value.Type != null)
// {
// tq.QName = GetXukQualifiedName(pair.Value.Type);
// tq.Type = pair.Value.Type;
// tq.ClassName = pair.Value.Type.FullName;
// tq.AssemblyName = pair.Value.Type.Assembly.GetName();
// if (pair.Value.BaseQName != null)
// {
// tq.BaseQName = GetXukQualifiedName(pair.Value.Type.BaseType);
// }
// }
// else
// {
// tq.QName = new QualifiedName(pair.Value.QName.LocalName, pair.Value.QName.NamespaceUri);
// tq.Type = null;
// tq.ClassName = pair.Value.ClassName;
// tq.AssemblyName = pair.Value.AssemblyName;
// if (pair.Value.BaseQName != null)
// {
// tq.BaseQName = new QualifiedName(pair.Value.BaseQName.LocalName, pair.Value.BaseQName.NamespaceUri);
// }
// }
// newDict.Add(tq.QName.FullyQualifiedName, tq);
// }
// mRegisteredTypeAndQNamesByQualifiedName.Clear();
// mRegisteredTypeAndQNamesByQualifiedName = newDict;
// }
// {
// Dictionary<Type, TypeAndQNames> newDict = new Dictionary<Type, TypeAndQNames>();
// Dictionary<Type, TypeAndQNames>.Enumerator enu = mRegisteredTypeAndQNamesByType.GetEnumerator();
// while (enu.MoveNext())
// {
// KeyValuePair<Type, TypeAndQNames> pair = enu.Current;
// TypeAndQNames tq = new TypeAndQNames();
// if (pair.Value.Type != null)
// {
// tq.QName = GetXukQualifiedName(pair.Value.Type);
// tq.Type = pair.Value.Type;
// tq.ClassName = pair.Value.Type.FullName;
// tq.AssemblyName = pair.Value.Type.Assembly.GetName();
// if (pair.Value.BaseQName != null)
// {
// tq.BaseQName = GetXukQualifiedName(pair.Value.Type.BaseType);
// }
// newDict.Add(pair.Value.Type, tq);
// }
// }
// mRegisteredTypeAndQNamesByType.Clear();
// mRegisteredTypeAndQNamesByType = newDict;
// }
//}
private void RegisterType(TypeAndQNames tq)
{
DebugFix.Assert(tq.Type != null);
bool isTypeAlreadyRegistered = false;
if (tq.Type != null)
{
isTypeAlreadyRegistered = typeAlreadyRegistered(tq.Type) != null;
}
foreach (TypeAndQNames typeAndQNames in mRegisteredTypeAndQNames)
{
// Does this QName resolve an existing registered BaseQName?
if (typeAndQNames.BaseQName != null
&& (string.IsNullOrEmpty(typeAndQNames.BaseQName.LocalName.Ugly) ||
string.IsNullOrEmpty(typeAndQNames.BaseQName.LocalName.Pretty))
&& typeAndQNames.BaseQName.NamespaceUri == tq.QName.NamespaceUri
&& (tq.QName.LocalName.Ugly != null && typeAndQNames.BaseQName.LocalName.Ugly == tq.QName.LocalName.Ugly ||
tq.QName.LocalName.Pretty != null && typeAndQNames.BaseQName.LocalName.Pretty == tq.QName.LocalName.Pretty)
)
{
#if DEBUG
Debugger.Break();
#endif
string ugly = typeAndQNames.BaseQName.LocalName.Ugly ?? tq.QName.LocalName.Ugly;
string pretty = typeAndQNames.BaseQName.LocalName.Pretty ?? tq.QName.LocalName.Pretty;
DebugFix.Assert(!string.IsNullOrEmpty(ugly));
DebugFix.Assert(!string.IsNullOrEmpty(pretty));
typeAndQNames.BaseQName = new QualifiedName(new UglyPrettyName(ugly, pretty), typeAndQNames.BaseQName.NamespaceUri);
}
// Can this BaseQName be resolved by an existing registered QName?
if (tq.BaseQName != null
&& (string.IsNullOrEmpty(tq.BaseQName.LocalName.Ugly) ||
string.IsNullOrEmpty(tq.BaseQName.LocalName.Pretty))
&& tq.BaseQName.NamespaceUri == typeAndQNames.QName.NamespaceUri
&& (typeAndQNames.QName.LocalName.Ugly != null && tq.BaseQName.LocalName.Ugly == typeAndQNames.QName.LocalName.Ugly ||
typeAndQNames.QName.LocalName.Pretty != null && tq.BaseQName.LocalName.Pretty == typeAndQNames.QName.LocalName.Pretty)
)
{
#if DEBUG
Debugger.Break();
#endif
string ugly = tq.BaseQName.LocalName.Ugly ?? typeAndQNames.QName.LocalName.Ugly;
string pretty = tq.BaseQName.LocalName.Pretty ?? typeAndQNames.QName.LocalName.Pretty;
DebugFix.Assert(!string.IsNullOrEmpty(ugly));
DebugFix.Assert(!string.IsNullOrEmpty(pretty));
tq.BaseQName = new QualifiedName(new UglyPrettyName(ugly, pretty), tq.BaseQName.NamespaceUri);
}
}
//DebugFix.Assert(!isTypeAlreadyRegistered);
if (!isTypeAlreadyRegistered)
{
mRegisteredTypeAndQNames.Add(tq);
}
}
