private static string GetProjectItemUniqueName(string baseName, IVsTemplate template, IItemContainer parent)
{
Guard.NotNull(() => baseName, baseName);
Guard.NotNull(() => template, template);
Guard.NotNull(() => parent, parent);
var directoryBase = System.IO.Path.GetDirectoryName(parent.PhysicalPath);
var files = Directory.EnumerateFiles(directoryBase);
var contentProjectItem = template.TemplateContent.Items.OfType <VSTemplateTemplateContentProjectItem>().FirstOrDefault();
if (contentProjectItem == null)
{
return(baseName);
}
var outputExtension = System.IO.Path.GetExtension(contentProjectItem.TargetFileName);
var uniqueName = UniqueNameGenerator.EnsureUnique(
baseName,
newName => !files.Any(file => System.IO.Path.GetFileName(file).Equals(
string.Format(CultureInfo.InvariantCulture, @"{0}{1}", System.IO.Path.GetFileNameWithoutExtension(newName), outputExtension),
StringComparison.OrdinalIgnoreCase)));
return(string.Format(
CultureInfo.InvariantCulture,
@"{0}{1}",
System.IO.Path.GetFileNameWithoutExtension(uniqueName),
System.IO.Path.GetExtension(baseName)));
}
private static IDbSelectable CreateNewSelectableForWrappingSelect(
IDbSelect dbSelect, IDbSelectable selectable, DbReference dbRef, Expression m,
IDbObjectFactory dbFactory, UniqueNameGenerator nameGenerator)
{
if (dbRef == null)
{
return(selectable);
}
var oCol = selectable as IDbColumn;
if (oCol != null)
{
return(dbFactory.BuildColumn(dbRef, oCol.GetAliasOrName(), oCol.ValType));
}
var oRefCol = selectable as IDbRefColumn;
if (oRefCol != null)
{
return(dbFactory.BuildRefColumn(dbRef, oRefCol.Alias, oRefCol));
}
if (selectable is IDbFunc oDbFunc)
{
if (string.IsNullOrEmpty(oDbFunc.Alias))
{
oDbFunc.Alias = nameGenerator.GenerateAlias(dbSelect, oDbFunc.Name, true);
}
return(dbFactory.BuildColumn(dbRef, oDbFunc.Alias, oDbFunc.ReturnType));
}
return(dbFactory.BuildColumn(dbRef, selectable.Alias, typeof(string)));
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var dbSelect = state.ResultStack.Peek() as IDbSelect;
if (dbSelect != null)
{
dbSelect.Selection.IsDistinct = true;
}
var caller = m.GetCaller();
var entityInfo = caller.NodeType == ExpressionType.MemberAccess
? this._infoProvider.FindEntityInfo(caller.Type)
: null;
// if the caller of the Distinct function is a Entity
// We need to add its primary keys into the query so that the result
// of distinct is correct. Otherwise, it will only distinct on join keys
if (entityInfo != null)
{
foreach (var pk in entityInfo.Keys)
{
var pkColumn = _dbFactory.BuildColumn(dbSelect.GetReturnEntityRef(), pk.DbName, pk.ValType);
dbSelect.Selection.Add(pkColumn);
}
}
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
// there may not be a preidcate in any method call
IDbObject condition = null;
if (m.GetArguments().Any())
{
condition = state.ResultStack.Pop();
}
var childSelect = (IDbSelect)state.ResultStack.Pop();
var dbSelect = (IDbSelect)state.ResultStack.Peek();
childSelect.Where = condition.ToBinary(_dbFactory);
var dbJoin = dbSelect.Joins.Single(j => ReferenceEquals(j.To.Referee, childSelect));
IDbBinary whereClause = null;
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var joinKey in dbJoin.Condition.GetOperands().OfType <IDbColumn>().Where(c => ReferenceEquals(c.Ref, dbJoin.To)))
{
var pkColumn = _dbFactory.BuildColumn(dbJoin.To, joinKey.Name, joinKey.ValType.DotNetType, joinKey.Alias);
var binary = _dbFactory.BuildBinary(pkColumn, DbOperator.IsNot, _dbFactory.BuildConstant(null));
whereClause = whereClause.UpdateBinary(binary, _dbFactory);
}
state.ResultStack.Push(whereClause);
}
protected void CreateAggregation(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator,
IDbSelect childSelect, IDbFunc dbFunc)
{
var dbSelect = (IDbSelect)state.ResultStack.Peek();
if (childSelect == null)
{
state.ResultStack.Push(dbFunc);
return;
}
var alias = nameGenerator.GenerateAlias(dbSelect, dbFunc.Name, true);
dbFunc.Alias = alias;
childSelect.Selection.Add(dbFunc);
var cRef = dbSelect.Joins.Single(j => ReferenceEquals(j.To.Referee, childSelect)).To;
var column = _dbFactory.BuildColumn(cRef, alias, m.Method.ReturnType);
var dbDefaultVal = _dbFactory.BuildConstant(Activator.CreateInstance(m.Method.ReturnType));
var dbIsNullFunc = _dbFactory.BuildNullCheckFunc(column, dbDefaultVal);
state.ResultStack.Push(dbIsNullFunc);
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var arguments = state.ResultStack.Pop();
var dbSelect = (IDbSelect)state.ResultStack.Pop();
var selections = SqlTranslationHelper.ProcessSelection(arguments, _dbFactory);
foreach (var selectable in selections)
{
SqlTranslationHelper.UpdateJoinType(selectable.Ref);
dbSelect.Selection.Add(selectable);
}
var newSelectRef = _dbFactory.BuildRef(dbSelect);
var newSelect = _dbFactory.BuildSelect(newSelectRef);
newSelectRef.Alias = nameGenerator.GenerateAlias(dbSelect, TranslationConstants.SubSelectPrefix, true);
selections = selections.Concat(dbSelect.Selection.Where(s => s.IsJoinKey)).ToArray();
foreach (var selectable in selections)
{
var newSelectable = CreateNewSelectableForWrappingSelect(selectable, newSelectRef, _dbFactory);
newSelect.Selection.Add(newSelectable);
}
state.ResultStack.Push(newSelect);
}
public static string GetUniqueInstanceName(this IGuidanceManager guidanceManager, string baseName)
{
Guard.NotNull(() => guidanceManager, guidanceManager);
Guard.NotNull(() => baseName, baseName);
return(UniqueNameGenerator.EnsureUnique(baseName,
newName => !guidanceManager.InstantiatedGuidanceExtensions.Any(ge => ge.InstanceName.Equals(newName, StringComparison.OrdinalIgnoreCase))));
}
public void GenerateFrom_Should_Not_Throw_Exception()
{
var category = (Category)_domainFactory.CreateCategory("IoC/DI");
#pragma warning disable 168
var uniqueName = UniqueNameGenerator.GenerateFrom(_database.CategoryDataSource, category.Name);
#pragma warning restore 168
}
private static string GetUniqueName(ModelElement element, string baseName, IDictionary <string, ModelElement> siblingNames)
{
Guard.NotNull(() => element, element);
Guard.NotNull(() => baseName, baseName);
return(UniqueNameGenerator.EnsureUnique(baseName,
newName => !siblingNames.ContainsKey(newName), true));
}
protected override string GetSymbolTargetName(AstSymbol symbol)
{
if (symbol.IsValidFrame)
{
return(UniqueNameGenerator.GetUniqueName(symbol.Name));
}
throw new InvalidOperationException();
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var dbConstants = (IDbConstant)state.ResultStack.Pop();
var dbExpression = (IDbSelectable)state.ResultStack.Pop();
var dbBinary = _dbFactory.BuildFunc("MyFunc", false, dbExpression, dbConstants);
state.ResultStack.Push(dbBinary);
}
protected override SyntaxToken CreateMethodName()
{
// change this to more smarter one.
var semanticModel = this.SemanticDocument.SemanticModel;
var nameGenerator = new UniqueNameGenerator(semanticModel);
var scope = this.CSharpSelectionResult.GetContainingScope();
return(SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(scope, "NewMethod")));
}
static void Main(string[] args)
{
AgentCommandLineOptions options = CommandLineParser.ParseArgs <AgentCommandLineOptions>(args, new AgentCommandLineOptions());
GameMasterSettings settings = Configuration.FromFile <GameMasterSettings>(options.Conf);
GameMasterClient client = new GameMasterClient(new Connection(options.Address, options.Port), settings,
new Logger(UniqueNameGenerator.GetUniqueName(settings.GameDefinition.GameName)), new Game(), new Ranking());
client.Connect();
client.Disconnect();
}
public void Generate_Should_Return_Correct_UniqueName_When_DataSource_Is_Empty()
{
var database = new Mock <IDatabase>();
database.SetupGet(d => d.CategoryDataSource).Returns(new List <Category>().AsQueryable());
string uniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, "C");
Assert.Equal("C", uniqueName);
}
public SagaBuilderState(Type currentEvent, string currentState, ISagaModel model,
IServiceProvider serviceProvider, UniqueNameGenerator uniqueNameGenerator, ISagaStep parentStep)
{
CurrentEvent = currentEvent;
CurrentState = currentState;
Model = model;
ServiceProvider = serviceProvider;
UniqueNameGenerator = uniqueNameGenerator;
ParentStep = parentStep;
}
private static string GetAbbreviationForWellKnownModules(IDocumentAnalysis analysis, string fullyQualifiedName)
{
if (WellKnownAbbreviationMap.TryGetValue(fullyQualifiedName, out var abbreviation))
{
// for now, use module wide unique name for abbreviation. even though technically we could use
// context based unique name since variable declared in lower scope will hide it and there is no conflict
return(UniqueNameGenerator.Generate(analysis, abbreviation));
}
return(null);
}
protected override SyntaxToken CreateMethodName()
{
var methodName = "NewMethod";
var containingScope = this.CSharpSelectionResult.GetContainingScope();
methodName = GetMethodNameBasedOnExpression(methodName, containingScope);
var semanticModel = this.SemanticDocument.SemanticModel;
var nameGenerator = new UniqueNameGenerator(semanticModel);
return(SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(containingScope, methodName)));
}
CompletionItem CreateNewMethodCreationItem(SyntaxNode parent, SemanticModel semanticModel, ITypeSymbol delegateType, int position, string optDelegateName, IMethodSymbol delegateMethod, CancellationToken cancellationToken)
{
var sb = new StringBuilder();
string varName = optDelegateName ?? "Handle" + delegateType.Name;
var curType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol> (position, cancellationToken);
var uniqueName = new UniqueNameGenerator(semanticModel).CreateUniqueMethodName(parent, varName);
var pDict = ImmutableDictionary <string, string> .Empty;
pDict = pDict.Add("RightSideMarkup", "<span size='small'>" + GettextCatalog.GetString("Creates new method") + "</span>");
var indent = "\t";
sb = new StringBuilder();
var enclosingSymbol = semanticModel.GetEnclosingSymbol(position, default(CancellationToken));
if (enclosingSymbol != null && enclosingSymbol.IsStatic)
{
sb.Append("static ");
}
sb.Append("void ");
int pos2 = sb.Length;
sb.Append(uniqueName);
sb.Append(' ');
sb.Append("(");
for (int k = 0; k < delegateMethod.Parameters.Length; k++)
{
if (k > 0)
{
sb.Append(", ");
}
sb.Append(CSharpAmbience.SafeMinimalDisplayString(delegateMethod.Parameters [k], semanticModel, position, MonoDevelop.Ide.TypeSystem.Ambience.LabelFormat));
}
sb.Append(")");
sb.Append(eolMarker);
sb.Append(indent);
sb.Append("{");
sb.Append(eolMarker);
sb.Append(indent);
sb.Append(oneIndentMarker);
//int cursorPos = pos + sb.Length;
sb.Append(indent);
sb.Append("}");
sb.Append(eolMarker);
pDict = pDict.Add("Position", position.ToString());
pDict = pDict.Add("NewMethod", sb.ToString());
pDict = pDict.Add("MethodName", varName);
return(CompletionItem.Create(uniqueName, properties: pDict, tags: newMethodTags, rules: NewMethodRules));
}
private string GetProjectUniqueName(string baseName)
{
Guard.NotNull(() => baseName, baseName);
var directoryBase = System.IO.Path.GetDirectoryName(this.solution.PhysicalPath);
IEnumerable <string> subDirectoriesNames =
Directory.EnumerateDirectories(directoryBase).Select(dir => System.IO.Path.GetFileName(dir));
var uniqueName = UniqueNameGenerator.EnsureUnique(
baseName,
newName => !subDirectoriesNames.Any(dir => dir.Equals(newName, StringComparison.OrdinalIgnoreCase)));
return(uniqueName);
}
/// <summary> Translate to SQL </summary>
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var dbExpression = GetAggregationTarget(m, state);
IDbSelect childSelect = null;
if (!m.GetCaller().Type.IsGrouping())
{
childSelect = state.ResultStack.Pop() as IDbSelect;
}
// if the aggregation does not have expression, it means
// the caller of the aggregation method must be a Select method call
// In this case, the actual expression that we need to aggregate on,
// will be inside the child select statement
if (dbExpression == null && childSelect != null)
{
// to get the actual expression, we need to first unwrap the child select
// because the translation of Select call always wrap the actual select
childSelect = (IDbSelect)childSelect.From.Referee;
dbExpression = childSelect.Selection.Last(
s => string.IsNullOrEmpty(s.Alias) ||
!s.Alias.EndsWith(TranslationConstants.JoinKeySuffix));
childSelect.Selection.Remove(dbExpression);
childSelect.GroupBys.Remove(dbExpression);
}
if (dbExpression == null)
{
throw new NotSupportedException("Can not aggregate.");
}
if (!(dbExpression is IDistinctable))
{
throw new NotSupportedException("Expression must be Distinctable");
}
var distinctable = (IDistinctable)dbExpression;
distinctable.IsDistinct = true;
var dbFunc = _dbFactory.BuildFunc("count", true, m.Method.ReturnType, dbExpression);
CreateAggregation(m, state, nameGenerator, childSelect, dbFunc);
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var predicate = BuildCondition(m, state);
IDbSelect childSelect = null;
if (!m.GetCaller().Type.IsGrouping())
{
childSelect = state.ResultStack.Pop() as IDbSelect;
}
var dbCountFunc = _dbFactory.BuildFunc(m.Method.Name.ToLower(), true, m.Method.ReturnType, predicate);
CreateAggregation(m, state, nameGenerator, childSelect, dbCountFunc);
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
// group by can be a column, a expression, or a list of columns / expressions
var arguments = state.ResultStack.Pop();
var dbSelect = (IDbSelect)state.ResultStack.Pop();
var groupBys = dbSelect.GroupBys;
groupBys.IsSingleKey = !(arguments is IDbList <DbKeyValue>);
var selections = SqlTranslationHelper.ProcessSelection(arguments, _dbFactory);
foreach (var selectable in selections)
{
SqlTranslationHelper.UpdateJoinType(selectable.Ref);
var refCol = selectable as IDbRefColumn;
// if we group on a ref column, we are actaully group by on the primary key
// of the entity that ref column referring to. In the refering entity is actually
// another ref column, then we will need to get the primay key recursive from RefTo
if (refCol?.RefTo != null)
{
foreach (var pk in refCol.GetPrimaryKeys())
{
refCol.RefTo.AddToReferedSelect(_dbFactory, pk.Name, pk.ValType);
}
}
dbSelect.GroupBys.Add(selectable);
}
// if the group by is a single expression like groupby(x => x.Children.Count())
// it will be translated into a expression and will not have alias
// in this case, we will need to give it an alias which will be used later
if (groupBys.IsSingleKey)
{
var column = groupBys.Single();
if (column.Alias == null)
{
column.Alias = "Key";
}
}
state.ResultStack.Push(dbSelect);
}
public static async Task StartAsync(Brain brain, string name, IDeviceBuilder[] devices, IPAddress ipAddress, int port, CancellationToken cancellationToken)
{
if (Server._host != null)
{
throw new InvalidOperationException("Host is already running - it must be stopped to start a new host.");
}
if (brain == null)
{
throw new ArgumentNullException(nameof(brain));
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Non-blank name is required.", nameof(name));
}
if (devices == null || devices.Length == 0 || Array.IndexOf(devices, default) != -1)
{
throw new ArgumentException("Devices collection can not be null/empty or contain null.", nameof(devices));
}
if (port < 0 || port > ushort.MaxValue)
{
throw new ArgumentException("Invalid port.", nameof(port));
}
string adapterName = $"src-{UniqueNameGenerator.Generate(name)}";
IHost host = Server.CreateHostBuilder(brain, adapterName, devices, ipAddress, port).Build();
await host.StartAsync(cancellationToken).ConfigureAwait(false);
Server._host = host;
ILogger <Brain> logger = host.Services.GetRequiredService <ILogger <Brain> >();
string baseUrl = $"http://{ipAddress}:{port}";
for (int i = 0; i < Constants.MaxConnectionRetries; i++)
{
try
{
await brain.PostAsync("registerSdkDeviceAdapter", new { Name = adapterName, BaseUrl = baseUrl }, cancellationToken).ConfigureAwait(false);
logger.LogInformation("SDK Adapter registered on brain @ http://{host}:{port}", brain.HostName, brain.Port);
return;
}
catch
{
logger.LogWarning("Failed to register with brain {times} time(s).", i + 1);
}
}
throw new ApplicationException("Failed to connect to brain.");
}
public void Generate_Should_Return_Correct_UniqueName_When_Second_Name_Starts_With_First_Entity_Name()
{
var categoryList = new List <Category>();
var database = new Mock <IDatabase>();
database.SetupGet(d => d.CategoryDataSource).Returns(categoryList.AsQueryable());
var category1 = (Category)_factory.CreateCategory("IoC-DI");
category1.UniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, category1.Name);
categoryList.Add(category1);
Thread.Sleep(500);
string uniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, "IoC");
Assert.Equal("IoC", uniqueName);
}
public void Generate_Should_Return_Correct_UniqueName_When_DataSource_Contains_One_Item()
{
var categoryList = new List <Category>();
var database = new Mock <IDatabase>();
database.SetupGet(d => d.CategoryDataSource).Returns(categoryList.AsQueryable());
var category = (Category)_factory.CreateCategory("C");
category.UniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, category.Name);
categoryList.Add(category);
Thread.Sleep(500);
string uniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, "C++");
Assert.Equal("C-2", uniqueName);
}
protected void CreateAggregation(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator,
IDbSelect childSelect, IDbFunc dbFunc)
{
var dbSelect = (IDbSelect)state.ResultStack.Peek();
if (childSelect == null)
{
state.ResultStack.Push(dbFunc);
return;
}
var alias = nameGenerator.GenerateAlias(dbSelect, dbFunc.Name, true);
dbFunc.Alias = alias;
childSelect.Selection.Add(dbFunc);
/**
* Aggregation can happen after a method that generate new select.
* In this case, join from the main select to the child select will not be
* updated yet at this stage, so we need to correct the join to on the
* correct child select statment.
* For example:
* var query = db.Blogs
* .Where(b => b.BlogId > 0)
* .Select(b => new
* {
* b.BlogId,
* Cnt = b.Posts.Select(p => p.Title).Distinct().Count()
* });
* `b.Posts.Select(p => p.Title).Distinct()` will create a new child select and
* it will not be the one that the main select is currently targeting, so we
* need to correct the join target.
*/
ReLinkToChildSelect(dbSelect, childSelect);
var cRef = dbSelect.Joins.Single(j => ReferenceEquals(j.To.Referee, childSelect)).To;
var column = _dbFactory.BuildColumn(cRef, alias, m.Method.ReturnType);
var dbDefaultVal = _dbFactory.BuildConstant(Activator.CreateInstance(m.Method.ReturnType));
var dbIsNullFunc = _dbFactory.BuildNullCheckFunc(m.Method.ReturnType, column, dbDefaultVal);
state.ResultStack.Push(dbIsNullFunc);
}
/// <summary>
/// Creates and opens a new blank solution
/// </summary>
internal static void CreateBlankSolution(this EnvDTE.DTE dte, IRegistryReader reader)
{
Guard.NotNull(() => dte, dte);
//Close existing solution
if (dte.Solution.IsOpen)
{
dte.Solution.Close(true);
}
// Determine next available solution directory
var defaultSaveLocation = GetDefaultProjectSaveLocation(reader);
if (string.IsNullOrEmpty(defaultSaveLocation))
{
throw new InvalidOperationException(Resources.DteExtensions_CreateNewSolution_FailedDirSearch);
}
var existingSolutionFolders = Directory.GetDirectories(defaultSaveLocation).Select(dir => new DirectoryInfo(dir).Name);
var nextSolutionDir = UniqueNameGenerator.EnsureUnique(NewSolutionNamePrefix, existingSolutionFolders, true);
// Create solution directory
var solutionDir = Path.Combine(defaultSaveLocation, nextSolutionDir);
if (!Directory.Exists(solutionDir))
{
Directory.CreateDirectory(solutionDir);
}
// Save and Open new solution
var solutionFullPath = Path.Combine(solutionDir, nextSolutionDir);
try
{
dte.Solution.Create(solutionDir, nextSolutionDir);
dte.Solution.SaveAs(solutionFullPath);
}
catch (COMException)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
Resources.DteExtensions_CreateNewSolution_FailedCreate, solutionDir));
}
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var joinType = (IDbConstant)state.ResultStack.Pop();
var selection = state.ResultStack.Pop();
var joinCondition = (IDbBinary)state.ResultStack.Pop();
var toSelect = (IDbSelect)state.ResultStack.Pop();
var fromSelect = (IDbSelect)state.ResultStack.Pop();
var toSelectRef = _dbFactory.BuildRef(toSelect, nameGenerator.GenerateAlias(fromSelect, "sq", true));
// todo: review how join condition is translated
// create result selection for final select
UpdateSelection(fromSelect, selection, toSelectRef);
// create join to inner select
var joinKeys = joinCondition.GetOperands().OfType <IDbColumn>().Where(c => c.Ref.OwnerSelect == toSelect);
foreach (var joinKey in joinKeys)
{
toSelect.Selection.Remove(joinKey);
var alias = nameGenerator.GenerateAlias(toSelect, joinKey.Name + "_jk", true);
var innerCol = _dbFactory.BuildColumn(joinKey);
innerCol.Alias = alias;
toSelect.Selection.Add(innerCol);
joinKey.Ref = toSelectRef;
joinKey.Name = alias;
joinKey.Alias = string.Empty;
}
var dbJoin = _dbFactory.BuildJoin(toSelectRef, fromSelect, joinCondition, (DbJoinType)joinType.Val);
fromSelect.Joins.Add(dbJoin);
var finalSelectRef = _dbFactory.BuildRef(fromSelect, nameGenerator.GenerateAlias(null, "sq", true));
var finalSelect = _dbFactory.BuildSelect(finalSelectRef);
state.ResultStack.Push(finalSelect);
}
public static string CalculateNextUniqueChildItemName <T>(this IItemContainer parent, string childNameSeed) where T : IItemContainer
{
Guard.NotNull(() => parent, parent);
Guard.NotNull(() => childNameSeed, childNameSeed);
if ((typeof(T).IsAssignableFrom(typeof(ISolution))) ||
((parent is IProject || parent is IItem || parent is IFolder) && typeof(T).IsAssignableFrom(typeof(ISolutionFolder))) ||
((parent is IFolder || parent is IItem) && typeof(T).IsAssignableFrom(typeof(IProject))) ||
((parent is ISolution || parent is ISolutionFolder || parent is IItem) && typeof(T).IsAssignableFrom(typeof(IFolder))))
{
throw new InvalidOperationException();
}
var extension = Path.GetExtension(childNameSeed);
var seed = Path.GetFileNameWithoutExtension(childNameSeed);
return(String.Format(CultureInfo.CurrentCulture, @"{0}{1}",
UniqueNameGenerator.EnsureUnique(seed,
newName => parent.Items.Where(item => String.IsNullOrEmpty(extension) ? item.Name.Equals(newName, StringComparison.OrdinalIgnoreCase)
: item.Name.Equals(Path.ChangeExtension(newName, extension), StringComparison.OrdinalIgnoreCase)).FirstOrDefault() == null), extension));
}
public override void Translate(
MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator)
{
var vals = new List <object>();
while (state.ResultStack.Peek() is IDbConstant)
{
var dbConstants = (IDbConstant)state.ResultStack.Pop();
if (dbConstants.Val is IEnumerable val)
{
vals = val.Cast <object>().ToList();
break;
}
vals.Insert(0, dbConstants.Val);
}
var dbExpression = (IDbSelectable)state.ResultStack.Pop();
var dbBinary = vals.Count == 0
? _dbFactory.BuildBinary(_dbFactory.BuildConstant(0), DbOperator.Equal, _dbFactory.BuildConstant(1))
: _dbFactory.BuildBinary(dbExpression, DbOperator.In, _dbFactory.BuildConstant(vals, true));
state.ResultStack.Push(dbBinary);
}
/// <summary>
/// Generate names for the provided <see cref="Schema"/>
/// </summary>
public static void GenerateAllNames(Schema schema)
{
IDatabaseNameGenerator nameGenerator = new DefaultDatabaseNameGenerator(schema.Store);
UniqueNameGenerator uniqueChecker = new UniqueNameGenerator();
LinkedElementCollection<Table> tables = schema.TableCollection;
// Generate table names
uniqueChecker.GenerateUniqueElementNames(
tables,
delegate(object element, int phase)
{
return nameGenerator.GenerateTableName((Table)element, phase);
},
delegate(object element, string elementName)
{
((Table)element).Name = elementName;
});
foreach (Table table in tables)
{
//column names
uniqueChecker.GenerateUniqueElementNames(
table.ColumnCollection,
delegate(object element, int phase)
{
return nameGenerator.GenerateColumnName((Column)element, phase);
},
delegate(object element, string elementName)
{
((Column)element).Name = elementName;
});
}
// Constraint names, unique across the schema
uniqueChecker.GenerateUniqueElementNames(
IterateConstraints(schema),
delegate(object element, int phase)
{
return nameGenerator.GenerateConstraintName((Constraint)element, phase);
},
delegate(object element, string elementName)
{
((Constraint)element).Name = elementName;
});
}
