private static EnumerationTarget CreateEnumerationTarget(XPathNavigator api, ReferenceLinkType linkType)
{
EnumerationTarget enumeration = new EnumerationTarget();
string typeId = (string)api.Evaluate(topicIdExpression);
string file = (string)api.Evaluate(topicFileExpression);
// Create tar
List <MemberTarget> members = new List <MemberTarget>();
XPathNodeIterator elementNodes = api.Select("elements/element");
foreach (XPathNavigator elementNode in elementNodes)
{
string memberId = elementNode.GetAttribute("api", String.Empty);
// try to get name from attribute on element node
string memberName = elementNode.GetAttribute("name", String.Empty);
if (String.IsNullOrEmpty(memberName))
{
// if we can't do that, try to get the name by searching the file for the <api> element of that member
XPathNavigator memberApi = api.SelectSingleNode(String.Format(
"following-sibling::api[@id='{0}']", memberId));
if (memberApi != null)
{
memberName = (string)memberApi.Evaluate(apiNameExpression);
}
else
{
// if all else fails, get the name by parsing the identifier
string arguments;
string type;
ReferenceTextUtilities.DecomposeMemberIdentifier(memberId,
out type, out memberName, out arguments);
}
}
MemberTarget member = new MemberTarget();
member.id = memberId; // get Id from element
member.file = file; // get file from type file
member.type = linkType;
member.name = memberName; // get name from element
member.containingType = new SimpleTypeReference(typeId); // get containing type from this type
members.Add(member);
}
enumeration.elements = members;
return(enumeration);
}
public static TypeTarget ReadTypeTarget(XmlReader reader)
{
if (reader == null || reader.NodeType != XmlNodeType.Element)
{
return(null);
}
switch (reader.Name)
{
case "TypeTarget":
TypeTarget typeTarget = new TypeTarget();
typeTarget.ReadXml(reader);
return(typeTarget);
case "EnumerationTarget":
EnumerationTarget enumTarget = new EnumerationTarget();
enumTarget.ReadXml(reader);
return(enumTarget);
}
return(null);
}
/// <summary>
/// This is overridden to load the SQL dictionary in a thread-safe manner
/// </summary>
/// <param name="maxDegreeOfParallelism">This can be used to override the maximum degree of parallelism.
/// By default, it is -1 to allow as many threads as possible.</param>
protected override void LoadTargetDictionary(int maxDegreeOfParallelism = -1)
{
var namespaceFileFilter = this.NamespaceFileFilter;
Parallel.ForEach(Directory.EnumerateFiles(this.DirectoryPath, this.FilePattern, this.Recurse ?
SearchOption.AllDirectories : SearchOption.TopDirectoryOnly),
new ParallelOptions {
MaxDegreeOfParallelism = maxDegreeOfParallelism
},
file =>
{
using (SqlConnection cn = new SqlConnection(connectionString))
using (SqlCommand cmd = new SqlCommand())
{
cn.Open();
cmd.Connection = cn;
cmd.Parameters.Add(new SqlParameter("@key", SqlDbType.VarChar, 768));
cmd.CommandText = String.Format(CultureInfo.InvariantCulture,
"Select TargetKey From Targets Where GroupId = '{0}' And TargetKey = @key",
base.DictionaryId);
cmd.Parameters[0].Value = "N:" + Path.GetFileNameWithoutExtension(file);
// Skip the file if not in a defined filter or if it's already in the dictionary
if ((namespaceFileFilter.Count != 0 && !namespaceFileFilter.Contains(Path.GetFileName(file))) ||
cmd.ExecuteScalar() != null)
{
return;
}
this.BuildComponent.WriteMessage(MessageLevel.Info, "Indexing targets in {0}", file);
cmd.CommandText = String.Format(CultureInfo.InvariantCulture,
"IF NOT EXISTS(Select * From Targets Where GroupId = '{0}' And TargetKey = @key) " +
"Insert Targets (GroupId, TargetKey, TargetValue) Values ('{0}', @key, @value) " +
"ELSE Update Targets Set TargetValue = @value Where GroupId = '{0}' " +
"And TargetKey = @key", base.DictionaryId);
cmd.Parameters.Add(new SqlParameter("@value", SqlDbType.VarBinary));
BinaryFormatter bf = new BinaryFormatter
{
Context = new StreamingContext(StreamingContextStates.Persistence)
};
try
{
XPathDocument document = new XPathDocument(file);
foreach (var t in XmlTargetDictionaryUtilities.EnumerateTargets(document.CreateNavigator()))
{
cmd.Parameters[0].Value = t.Id;
using (MemoryStream ms = new MemoryStream())
{
bf.Serialize(ms, t);
cmd.Parameters[1].Value = ms.GetBuffer();
cmd.ExecuteNonQuery();
}
// Enumeration targets have members we need to add too. We can't use the
// Target.Add() method here so we must do it manually.
EnumerationTarget et = t as EnumerationTarget;
if (et != null)
{
foreach (var el in et.Elements)
{
cmd.Parameters[0].Value = el.Id;
using (MemoryStream ms = new MemoryStream())
{
bf.Serialize(ms, el);
cmd.Parameters[1].Value = ms.GetBuffer();
cmd.ExecuteNonQuery();
}
}
}
}
}
catch (XmlSchemaException e)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
"The reference targets file '{0}' is not valid. The error message is: {1}", file,
e.GetExceptionMessage()));
}
catch (XmlException e)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
"The reference targets file '{0}' is not well-formed XML. The error message is: {1}",
file, e.GetExceptionMessage()));
}
catch (IOException e)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
"An access error occured while opening the reference targets file '{0}'. The error " +
"message is: {1}", file, e.GetExceptionMessage()));
}
}
});
}
public static Target ReadTarget(XmlReader reader)
{
if (reader == null || reader.NodeType != XmlNodeType.Element)
{
return(null);
}
switch (reader.Name)
{
case "Target":
Target target = new Target();
target.ReadXml(reader);
return(target);
case "NamespaceTarget":
NamespaceTarget namespaceTarget = new NamespaceTarget();
namespaceTarget.ReadXml(reader);
return(namespaceTarget);
case "TypeTarget":
TypeTarget typeTarget = new TypeTarget();
typeTarget.ReadXml(reader);
return(typeTarget);
case "EnumerationTarget":
EnumerationTarget enumTarget = new EnumerationTarget();
enumTarget.ReadXml(reader);
return(enumTarget);
case "MemberTarget":
MemberTarget memberTarget = new MemberTarget();
memberTarget.ReadXml(reader);
return(memberTarget);
case "ConstructorTarget":
ConstructorTarget constructorTarget = new ConstructorTarget();
constructorTarget.ReadXml(reader);
return(constructorTarget);
case "ProcedureTarget":
ProcedureTarget procedTarget = new ProcedureTarget();
procedTarget.ReadXml(reader);
return(procedTarget);
case "EventTarget":
EventTarget eventTarget = new EventTarget();
eventTarget.ReadXml(reader);
return(eventTarget);
case "PropertyTarget":
PropertyTarget propertyTarget = new PropertyTarget();
propertyTarget.ReadXml(reader);
return(propertyTarget);
case "MethodTarget":
MethodTarget methodTarget = new MethodTarget();
methodTarget.ReadXml(reader);
return(methodTarget);
}
return(null);
}
