private static MCommit GetRootCommit(MRepository repository)
{
MSubBranch mSubBranch = repository.SubBranches
.FirstOrDefault(b => b.Value.IsActive && b.Value.Name == BranchName.Master).Value;
if (mSubBranch == null)
{
Asserter.FailFast($"Repository {repository.WorkingFolder} does not have a master branch");
}
IEnumerable <MCommit> firstAncestors = mSubBranch.TipCommit.FirstAncestorsAnSelf();
MCommit rootCommit = firstAncestors.Last();
return(rootCommit);
}
public void AddOrUpdateItem(IDataItem item, int stamp)
{
switch (item)
{
case DataLine line:
modelLineService.AddOrUpdateLine(line, stamp);
break;
case DataLink link:
modelLinkService.AddOrUpdateLink(link, stamp);
break;
case DataNode node:
modelNodeService.AddOrUpdateNode(node, stamp);
break;
default:
throw Asserter.FailFast($"Unknown item type {item}");
}
}
/// <summary>
/// Resolves an instance for the specified type.
/// </summary>
private object ResolveInstance(Type type)
{
List <Func <object> > providers;
if (IsLazy(type))
{
// The type is a Lazy<T>, lets resolve the provider for T
Type genericArgument = type.GetGenericArguments()[0];
if (registeredTypes.TryGetValue(genericArgument, out providers))
{
Func <object> provider = providers.Last();
// Create a Lazy<T> provider, which resolves the instance of T once when user needs it
return(DynamicCreateLazy(genericArgument, provider));
}
}
if (IsEnumerable(type))
{
// The type is an IEnumerable<T>, lets return all providers for type T
Type genericArgument = type.GetGenericArguments()[0];
if (registeredTypes.TryGetValue(genericArgument, out providers))
{
IEnumerable <object> instances = providers.Select(provider => provider());
return(DynamicCastToTypedList(genericArgument, instances));
}
// No registered types, return empty list
return(DynamicCastToTypedList(genericArgument, Enumerable.Empty <object>()));
}
if (registeredTypes.TryGetValue(type, out providers))
{
// Return a created object
Func <object> provider = providers.Last();
return(provider());
}
throw Asserter.FailFast("Not supported type " + type.FullName);
}
private static string ToNodeTypeText(NodeType nodeNodeType)
{
switch (nodeNodeType)
{
case NodeType.NameSpace:
return(JsonCacheTypes.NodeType.NameSpace);
case NodeType.Type:
return(JsonCacheTypes.NodeType.Type);
case NodeType.Member:
return(JsonCacheTypes.NodeType.Member);
case NodeType.None:
return(null);
case NodeType.Solution:
return(JsonCacheTypes.NodeType.Solution);
case NodeType.Assembly:
return(JsonCacheTypes.NodeType.Assembly);
case NodeType.Group:
return(JsonCacheTypes.NodeType.Group);
case NodeType.Dll:
return(JsonCacheTypes.NodeType.Dll);
case NodeType.Exe:
return(JsonCacheTypes.NodeType.Exe);
case NodeType.SolutionFolder:
return(JsonCacheTypes.NodeType.SolutionFolder);
case NodeType.PrivateMember:
return(JsonCacheTypes.NodeType.Member);
default:
throw Asserter.FailFast($"Unexpected type {nodeNodeType}");
}
}
private static NodeType ToNodeType(string nodeType)
{
switch (nodeType)
{
case null:
return(NodeType.None);
case NodeData.SolutionType:
return(NodeType.Solution);
case NodeData.SolutionFolderType:
return(NodeType.SolutionFolder);
case NodeData.AssemblyType:
return(NodeType.Assembly);
case NodeData.GroupType:
return(NodeType.Group);
case NodeData.DllType:
return(NodeType.Dll);
case NodeData.ExeType:
return(NodeType.Exe);
case NodeData.NameSpaceType:
return(NodeType.NameSpace);
case NodeData.TypeType:
return(NodeType.Type);
case NodeData.MemberType:
return(NodeType.Member);
default:
throw Asserter.FailFast($"Unexpected type {nodeType}");
}
}
public static JsonCacheTypes.Item ToCacheJsonItem(IDataItem item)
{
switch (item)
{
case DataNode modelNode:
return(new JsonCacheTypes.Item {
Node = ToCacheJsonNode(modelNode)
});
case DataLink modelLink:
return(new JsonCacheTypes.Item {
Link = ToJsonLink(modelLink)
});
case DataLine modelLine:
return(new JsonCacheTypes.Item {
Line = ToCacheJsonLine(modelLine)
});
default:
throw Asserter.FailFast($"Unsupported item {item?.GetType()}");
}
}
public void RegisterTypes(Assembly assembly)
{
try
{
ContainerBuilder builder = new ContainerBuilder();
// Need to make Autofac find also "internal" constructors e.g. windows dialogs
DefaultConstructorFinder constructorFinder = new DefaultConstructorFinder(
type => type.GetConstructors(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance));
// Register single instance types
builder.RegisterAssemblyTypes(assembly)
.Where(IsSingleInstance)
.FindConstructorsWith(constructorFinder)
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance()
.OwnedByLifetimeScope();
// Register non single instance types
builder.RegisterAssemblyTypes(assembly)
.Where(t => !IsSingleInstance(t))
.FindConstructorsWith(constructorFinder)
.AsSelf()
.AsImplementedInterfaces()
.OwnedByLifetimeScope();
container = builder.Build();
}
catch (Exception e)
{
Log.Error($"Failed to register types {e}");
Asserter.FailFast(e);
throw;
}
}
