public void NewAzureSBNamespaceGetsDefaultLocation()
{
// Setup
Mock <ServiceBusClientExtensions> client = new Mock <ServiceBusClientExtensions>();
MockCommandRuntime mockCommandRuntime = new MockCommandRuntime();
string name = "test";
string location = "West US";
NamespaceType type = NamespaceType.NotificationHub;
NewAzureSBNamespaceCommand cmdlet = new NewAzureSBNamespaceCommand()
{
Name = name,
CommandRuntime = mockCommandRuntime,
NamespaceType = type,
Client = client.Object,
Location = location
};
ExtendedServiceBusNamespace expected = new ExtendedServiceBusNamespace {
Name = name, Region = location, NamespaceType = type
};
client.Setup(f => f.CreateNamespace(name, location, type, true)).Returns(expected);
// Test
cmdlet.ExecuteCmdlet();
// Assert
ExtendedServiceBusNamespace actual = mockCommandRuntime.OutputPipeline[0] as ExtendedServiceBusNamespace;
Assert.Equal <ExtendedServiceBusNamespace>(expected, actual);
}
private static IEnumerable <FunctionSymbol> GetAccessibleDecoratorFunctions(NamespaceType namespaceType, Symbol?enclosingDeclarationSymbol)
{
// Local function.
IEnumerable <FunctionSymbol> GetAccessible(IEnumerable <FunctionSymbol> symbols, TypeSymbol targetType, FunctionFlags flags) =>
symbols.Where(functionSymbol => functionSymbol.Overloads.Any(overload =>
overload.Flags.HasFlag(flags) &&
namespaceType.DecoratorResolver.TryGetDecorator(overload)?.CanAttachTo(targetType) == true));
var knownDecoratorFunctions = namespaceType.DecoratorResolver.GetKnownDecoratorFunctions().Values;
return(enclosingDeclarationSymbol switch
{
ParameterSymbol parameterSymbol => GetAccessible(knownDecoratorFunctions, parameterSymbol.Type, FunctionFlags.ParameterDecorator),
VariableSymbol variableSymbol => GetAccessible(knownDecoratorFunctions, variableSymbol.Type, FunctionFlags.VariableDecorator),
ResourceSymbol resourceSymbol => GetAccessible(knownDecoratorFunctions, resourceSymbol.Type, FunctionFlags.ResoureDecorator),
ModuleSymbol moduleSymbol => GetAccessible(knownDecoratorFunctions, moduleSymbol.Type, FunctionFlags.ModuleDecorator),
OutputSymbol outputSymbol => GetAccessible(knownDecoratorFunctions, outputSymbol.Type, FunctionFlags.OutputDecorator),
/*
* The decorator is dangling if enclosingDeclarationSymbol is null. Return all decorator factory functions since
* we don't know which kind of declaration it will attach to.
*/
null => knownDecoratorFunctions,
_ => Enumerable.Empty <FunctionSymbol>()
});
public NamespaceSymbol(string name, IEnumerable <FunctionOverload> functionOverloads, IEnumerable <BannedFunction> bannedFunctions)
: base(name)
{
var methodResolver = new FunctionResolver(functionOverloads, bannedFunctions);
Type = new NamespaceType(name, Enumerable.Empty <TypeProperty>(), methodResolver);
}
public ResourceType(NamespaceType declaringNamespace, ResourceTypeReference typeReference, ResourceScope validParentScopes, ITypeReference body)
: base(typeReference.FormatName())
{
DeclaringNamespace = declaringNamespace;
TypeReference = typeReference;
ValidParentScopes = validParentScopes;
Body = body;
}
public RegisterNamespaceTransactionBuilder SetRootNamespace(string name)
{
NamespaceType = NamespaceType.ROOT_NAMESPACE;
SetNamespaceName(name);
SetNamespaceId(new NamespaceId(name));
return(Self());
}
public ResourceType(NamespaceType declaringNamespace, ResourceTypeReference typeReference, ResourceScope validParentScopes, ITypeReference body, ImmutableHashSet <string> uniqueIdentifierProperties)
: base(typeReference.FormatName())
{
DeclaringNamespace = declaringNamespace;
TypeReference = typeReference;
ValidParentScopes = validParentScopes;
Body = body;
UniqueIdentifierProperties = uniqueIdentifierProperties;
}
/// <summary>
/// Initializes a new instance of the
/// ServiceBusNamespaceCreateParameters class with required arguments.
/// </summary>
public ServiceBusNamespaceCreateParameters(string region, NamespaceType namespaceType)
: this()
{
if (region == null)
{
throw new ArgumentNullException("region");
}
this.Region = region;
this.NamespaceType = namespaceType;
}
public ResourceType?TryGetDefinedType(NamespaceType declaringNamespace, ResourceTypeReference reference, ResourceTypeGenerationFlags flags)
{
if (resourceTypes.TryGetValue(reference) is not {
} resourceType)
{
return(null);
}
return(new(declaringNamespace, resourceType.TypeReference, resourceType.ValidParentScopes, resourceType.Body, UniqueIdentifierProperties));
}
/// <summary>
/// Initializes a new instance of the
/// ServiceBusNamespaceCreateParameters class with required arguments.
/// </summary>
public ServiceBusNamespaceCreateParameters(string region, NamespaceType namespaceType)
: this()
{
if (region == null)
{
throw new ArgumentNullException("region");
}
this.Region = region;
this.NamespaceType = namespaceType;
}
public RegisterNamespaceTransactionBuilder SetSubNamespace(NamespaceId parentId, string name)
{
NamespaceType = NamespaceType.SUB_NAMESPACE;
SetNamespaceName(name);
SetParentId(parentId);
var subNamespace = IdGenerator.GenerateSubNamespaceIdFromParentId(parentId.Id, name);
SetNamespaceId(new NamespaceId(subNamespace));
return(Self());
}
internal static string ToSerializedValue(this NamespaceType value)
{
switch (value)
{
case NamespaceType.Messaging:
return("Messaging");
case NamespaceType.NotificationHub:
return("NotificationHub");
}
return(null);
}
/// <summary>
/// 创建一个具有 IIRAPNamespaceSet 接口的实例，返回
/// 该实例的 IIRAPNamespaceSet 接口
/// </summary>
/// <param name="namespaceType"></param>
/// <returns></returns>
public static IIRAPNamespaceSet CreatInstance(
NamespaceType namespaceType)
{
switch (namespaceType)
{
case NamespaceType.Sys:
return(new IRAPSysNamespaceSet());
case NamespaceType.Biz:
return(new IRAPBizNamespaceSet());
default:
return(null);
}
}
public static IEnumerable<NamespaceType> GetAllNamespaces(string cleanString, SpecData specificationData)
{
var namespaces = new List<NamespaceType>();
foreach (Match _namespace in NamespaceParser.Matches(cleanString))
{
var namespaceDefinition = new NamespaceType
{
Name = _namespace.Groups["name"].Value.Trim(),
IsPartial = !string.IsNullOrWhiteSpace(_namespace.Groups["partial"].Value.Trim()),
ExtendedAttribute = CleanString(_namespace.Groups["extended"].Value),
SpecNames = new[] { specificationData.Name }
};
if (!string.IsNullOrWhiteSpace(namespaceDefinition.ExtendedAttribute))
{
var exposed = namespaceDefinition.Exposed.ToList();
foreach (Match m in NamespaceExtendedParser.Matches(namespaceDefinition.ExtendedAttribute))
{
namespaceDefinition.SecureContext = namespaceDefinition.SecureContext || !string.IsNullOrWhiteSpace(m.Groups["securecontext"].Value.Trim());
var exposedValue = RegexLibrary.GroupingCleaner.Replace(m.Groups["exposed"].Value, string.Empty);
if (!string.IsNullOrWhiteSpace(exposedValue))
{
exposed.AddRange(exposedValue.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(api => api.Trim()));
}
}
namespaceDefinition.Exposed = exposed.Distinct();
}
namespaceDefinition.Members = _namespace.Groups["members"].Length > 0 ? GetAllNamespaceMembers(_namespace.Groups["members"].Value, specificationData) : new List<NamespaceMember>();
if (!namespaces.Contains(namespaceDefinition))
{
namespaces.Add(namespaceDefinition);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Duplicate namespace: " + namespaceDefinition.Name);
Console.ForegroundColor = ConsoleColor.Gray;
}
}
return namespaces;
}
/// <summary>
/// Initializes a new instance of the <see cref="NamespaceInfo" /> class.
/// </summary>
/// <param name="active">The namespace is active</param>
/// <param name="index">The namespace index</param>
/// <param name="metaId">The namespace metaId</param>
/// <param name="type">The namespace type, namespace and sub namespace.</param>
/// <param name="depth">The namespace depth</param>
/// <param name="levels">The namespace level</param>
/// <param name="parentId">The namespace parent</param>
/// <param name="owner">The owner of the namespace</param>
/// <param name="startHeight">The height at which the ownership begins.</param>
/// <param name="endHeight">The height at which the ownership ends.</param>
/// <param name="alias"> The alias linked to a namespace.</param>
public NamespaceInfo(bool?active, int?index, string metaId, NamespaceType type, int?depth,
List <NamespaceId> levels, NamespaceId parentId, PublicAccount owner, ulong startHeight, ulong endHeight,
Alias alias)
{
Active = active;
Index = index;
MetaId = metaId;
Type = type;
Depth = depth;
Levels = levels;
ParentId = parentId;
Owner = owner;
StartHeight = startHeight;
EndHeight = endHeight;
Alias = alias;
}
/// <summary>
/// Initializes a new instance of the <see cref="RegisterNamespaceTransaction" /> class.
/// </summary>
/// <param name="networkType"></param>
/// <param name="version"></param>
/// <param name="deadline"></param>
/// <param name="maxFee"></param>
/// <param name="namespaceName"></param>
/// <param name="namespaceId"></param>
/// <param name="namespaceType"></param>
/// <param name="duration"></param>
/// <param name="parentId"></param>
/// <param name="signature"></param>
/// <param name="signer"></param>
/// <param name="transactionInfo"></param>
public RegisterNamespaceTransaction(NetworkType networkType, int version, Deadline deadline, ulong?maxFee,
string namespaceName, NamespaceId namespaceId, NamespaceType namespaceType, ulong?duration,
NamespaceId parentId = null, string signature = null, PublicAccount signer = null,
TransactionInfo transactionInfo = null)
: base(networkType, version, EntityType.REGISTER_NAMESPACE, deadline, maxFee, signature, signer,
transactionInfo)
{
if (string.IsNullOrEmpty(namespaceName))
{
throw new ArgumentNullException(nameof(namespaceName));
}
if (!Enum.IsDefined(typeof(NetworkType), networkType))
{
throw new InvalidEnumArgumentException(nameof(networkType), networkType.GetValue(),
typeof(NetworkType));
}
if (namespaceType != NamespaceType.ROOT_NAMESPACE && namespaceType != NamespaceType.SUB_NAMESPACE)
{
throw new ArgumentOutOfRangeException(nameof(namespaceType));
}
if (namespaceType == NamespaceType.ROOT_NAMESPACE)
{
if (!duration.HasValue)
{
throw new ArgumentNullException(nameof(duration));
}
}
else
{
if (parentId == null)
{
throw new ArgumentNullException(nameof(parentId));
}
}
Duration = duration;
NamespaceName = namespaceName;
NamespaceType = namespaceType;
NamespaceId = namespaceId;
ParentId = parentId;
}
/// <summary>
/// Generates the bytes.
/// </summary>
/// <returns>System.Byte[].</returns>
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var namespaceNameLength = (uint)Encoding.UTF8.GetBytes(NamespaceId.Name).Length;
// create vectors
var signatureVector = NamespaceCreationTransactionBuffer.CreateSignatureVector(builder, new byte[64]);
var signerVector = NamespaceCreationTransactionBuffer.CreateSignerVector(builder, GetSigner());
var feeVector = NamespaceCreationTransactionBuffer.CreateFeeVector(builder, Fee.ToUInt8Array());
var deadlineVector = NamespaceCreationTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array());
var durationParentId = ParentId == null?Duration.ToUInt8Array() : ParentId.Id.ToUInt8Array();
var durationParentIdVector = NamespaceCreationTransactionBuffer.CreateDurationParentIdVector(builder, durationParentId);
var namespaceIdVector = NamespaceCreationTransactionBuffer.CreateNamespaceIdVector(builder, IdGenerator.GenerateId(NamespaceType == 0x00 ? 0 : IdGenerator.GenerateId(0, ParentId.Name), NamespaceId.Name).ToUInt8Array());
var name = NamespaceCreationTransactionBuffer.CreateNamespaceNameVector(builder, Encoding.UTF8.GetBytes(NamespaceId.Name));
ushort version = ushort.Parse(NetworkType.GetNetworkByte().ToString("X") + "0" + Version.ToString("X"), System.Globalization.NumberStyles.HexNumber);
// Add to buffer
NamespaceCreationTransactionBuffer.StartNamespaceCreationTransactionBuffer(builder);
NamespaceCreationTransactionBuffer.AddSize(builder, 138 + namespaceNameLength);
NamespaceCreationTransactionBuffer.AddSignature(builder, signatureVector);
NamespaceCreationTransactionBuffer.AddSigner(builder, signerVector);
NamespaceCreationTransactionBuffer.AddVersion(builder, version);
NamespaceCreationTransactionBuffer.AddType(builder, TransactionTypes.Types.RegisterNamespace.GetValue());
NamespaceCreationTransactionBuffer.AddFee(builder, feeVector);
NamespaceCreationTransactionBuffer.AddDeadline(builder, deadlineVector);
NamespaceCreationTransactionBuffer.AddNamespaceType(builder, NamespaceType.GetValue());
NamespaceCreationTransactionBuffer.AddDurationParentId(builder, durationParentIdVector);
NamespaceCreationTransactionBuffer.AddNamespaceId(builder, namespaceIdVector);
NamespaceCreationTransactionBuffer.AddNamespaceNameSize(builder, (byte)namespaceNameLength);
NamespaceCreationTransactionBuffer.AddNamespaceName(builder, name);
// Calculate size
var codedNamespace = NamespaceCreationTransactionBuffer.EndNamespaceCreationTransactionBuffer(builder);
builder.Finish(codedNamespace.Value);
return(new NamespaceCreateionTransactionSchema().Serialize(builder.SizedByteArray()));
}
/// <summary>
/// Creates a new folder.
/// </summary>
private FolderState CreateFolder(NodeState parent, string path, string name, NamespaceType namespaceType)
{
ushort namespaceIndex = NamespaceIndexes[(int)namespaceType];
var folder = new FolderState(parent)
{
SymbolicName = name,
ReferenceTypeId = ReferenceTypes.Organizes,
TypeDefinitionId = ObjectTypeIds.FolderType,
NodeId = new NodeId(path, namespaceIndex),
BrowseName = new QualifiedName(path, namespaceIndex),
DisplayName = new LocalizedText("en", name),
WriteMask = AttributeWriteMask.None,
UserWriteMask = AttributeWriteMask.None,
EventNotifier = EventNotifiers.None
};
parent?.AddChild(folder);
return(folder);
}
public void NewAzureSBNamespaceNoACSSuccessfull()
{
// Setup
MockCommandRuntime mockCommandRuntime = new MockCommandRuntime();
Mock <ServiceBusClientExtensions> client = new Mock <ServiceBusClientExtensions>();
string name = "test1";
string location = "West US";
NamespaceType type = NamespaceType.NotificationHub;
NewAzureSBNamespaceCommand cmdlet = new NewAzureSBNamespaceCommand()
{
Name = name,
Location = location,
CreateACSNamespace = false,
NamespaceType = type,
CommandRuntime = mockCommandRuntime,
Client = client.Object
};
ExtendedServiceBusNamespace expected = new ExtendedServiceBusNamespace {
Name = name, Region = location, NamespaceType = type
};
client.Setup(f => f.CreateNamespace(name, location, type, false)).Returns(expected);
client.Setup(f => f.GetServiceBusRegions()).Returns(new List <ServiceBusLocation>()
{
new ServiceBusLocation()
{
Code = location
}
});
// Test
cmdlet.ExecuteCmdlet();
// Assert
ExtendedServiceBusNamespace actual = mockCommandRuntime.OutputPipeline[0] as ExtendedServiceBusNamespace;
Assert.Equal <ExtendedServiceBusNamespace>(expected, actual);
}
public void CreatesNewSBCaseInsensitiveRegion()
{
// Setup
MockCommandRuntime mockCommandRuntime = new MockCommandRuntime();
Mock <ServiceBusClientExtensions> client = new Mock <ServiceBusClientExtensions>();
string name = "test";
string location = "West US";
NamespaceType type = NamespaceType.Messaging;
NewAzureSBNamespaceCommand cmdlet = new NewAzureSBNamespaceCommand()
{
Name = name,
Location = location.ToLower(),
CommandRuntime = mockCommandRuntime,
Client = client.Object
};
ExtendedServiceBusNamespace expected = new ExtendedServiceBusNamespace {
Name = name, Region = location, NamespaceType = NamespaceType.Messaging
};
client.Setup(f => f.CreateNamespace(name, location.ToLower(), type, true)).Returns(expected);
client.Setup(f => f.GetServiceBusRegions()).Returns(new List <ServiceBusLocation>()
{
new ServiceBusLocation()
{
Code = location
}
});
// Test
cmdlet.ExecuteCmdlet();
// Assert
ExtendedServiceBusNamespace actual = mockCommandRuntime.OutputPipeline[0] as ExtendedServiceBusNamespace;
Assert.Equal <ExtendedServiceBusNamespace>(expected, actual);
}
/// <summary>
/// 自分の親になり得る，かつ，名前空間構成要素になりうる要素タイプを取得します
/// </summary>
/// <param name="type"> 名前空間構成要素タイプ </param>
/// <returns> 親になる名前空間構成要素タイプの集合 </returns>
public static NamespaceType[] GetParentTypes(NamespaceType type)
{
switch (type) {
case NamespaceType.Package:
return new NamespaceType[] { };
case NamespaceType.Class:
return new[] { NamespaceType.Class, NamespaceType.Package };
case NamespaceType.Function:
return new[] {
NamespaceType.Class, NamespaceType.Package,
NamespaceType.Function
};
case NamespaceType.Variable:
return new[] {
NamespaceType.Class, NamespaceType.Function,
NamespaceType.TemporaryScope
};
case NamespaceType.TemporaryScope:
return new[]
{ NamespaceType.Function, NamespaceType.TemporaryScope };
default:
throw new InvalidOperationException();
}
}
public SimpleComplexElementAttribute(NamespaceType namespaceType)
: base(namespaceType)
{
}
public virtual ExtendedServiceBusNamespace CreateNamespace(string name, string location, NamespaceType type, bool createACSNamespace = false)
{
location = string.IsNullOrEmpty(location) ? GetDefaultLocation() : location;
if (!Regex.IsMatch(name, ServiceBusConstants.NamespaceNamePattern))
{
throw new ArgumentException(string.Format(Resources.InvalidNamespaceName, name), "Name");
}
ServiceBusClient.Namespaces.CreateNamespace(name, new ServiceBusNamespaceCreateParameters { Region = location, CreateACSNamespace = createACSNamespace, NamespaceType = type});
// Wait until the namespace is activated
while (!IsActiveNamespace(name))
{
Thread.Sleep(SleepDuration);
}
return GetExtendedServiceBusNamespace(name);
}
/// <summary>
/// Process a generic `Assign` statement.
/// </summary>
/// <param name="nsType"></param>
protected void ProcessAssignment(NamespaceType nsType)
{
DmlSyntaxError badAssign = DmlSyntaxError.BadAssignmentStatement();
Advance(exception: badAssign);
Instruction assigner; // The instruction that performs the assignment.
// Check for a global identifier.
if (DmlTokens.IsMatch(CurrentToken, DmlTokens.AT))
{
Advance(exception: badAssign);
if (DmlTokens.IsMatch(CurrentToken, DmlTokens.UQNAME))
{
assigner = new AssignGlobal(CurrentToken);
}
else
{
throw DmlSyntaxError.BadGlobalName(CurrentToken);
}
}
// Check for an instance bound indentifier.
else if (DmlTokens.IsMatch(CurrentToken, DmlTokens.DOLLAR))
{
switch (nsType)
{
case NamespaceType.BulletInit:
case NamespaceType.BulletUpdate:
Advance(exception: badAssign);
if (DmlTokens.IsName(CurrentToken))
{
switch (CurrentToken)
{
// Assign directly to the bullet direction.
case DmlTokens.INTRINSIC_DIRECTION:
assigner = AssignIntrinsicBulletProperty.Direction;
break;
// Assign directly to the bullet speed.
case DmlTokens.INTRINSIC_SPEED:
assigner = AssignIntrinsicBulletProperty.Speed;
break;
// Assign directly to the bullet colour.
case DmlTokens.INTRINSIC_COLOUR:
assigner = AssignIntrinsicBulletProperty.Colour;
break;
case DmlTokens.INTRINSIC_SPRITE:
assigner = AssignIntrinsicBulletProperty.Sprite;
break;
default:
assigner = new AssignBulletBound(CurrentToken);
break;
}
}
else
{
throw DmlSyntaxError.BadVariableName(CurrentToken);
}
break;
default:
throw DmlSyntaxError.BadAssignmentNamespace();
}
}
// Check for an ordinary local name.
else if (DmlTokens.IsMatch(CurrentToken, DmlTokens.UQNAME))
{
assigner = new AssignLocal(CurrentToken);
}
else
{
throw DmlSyntaxError.BadVariableName(CurrentToken);
}
// Read the expression.
Advance(exception: badAssign);
string[] expression_tokens = GetUntil(DmlTokens.EOL);
ProcessExpression(expression_tokens);
Instructions.Add(assigner);
}
public RegisterNamespaceTransactionBuilder SetNamespaceType(NamespaceType namespaceType)
{
NamespaceType = namespaceType;
return(Self());
}
/// <summary>
/// Get value extension
/// </summary>
/// <param name="type">The namespace type</param>
/// <returns>NamespaceType</returns>
public static byte GetValueInByte(this NamespaceType type)
{
return((byte)type);
}
public TagElementAttribute(NamespaceType namespaceType)
: this()
{
NamespaceType = namespaceType;
}
public BuiltInNamespaceSymbol(string name, NamespaceType type)
: base(name)
{
Type = type;
}
public bool Match(SourceStream source, out NamespaceType result)
{
result = null;
if (!source.IsValid())
{
return(false);
}
var slice = source.GetSlice();
SkipCommentsAndWhitespace(slice);
if (!slice.MatchString(KeywordNamespace))
{
return(false);
}
SkipCommentsAndWhitespace(slice);
string namespace_name = string.Empty;
name_match:
if (!slice.ReadWord(out string name))
{
throw new ParseError($"expected namespace 'name'.", slice);
}
if (!name.IsNameLegal())
{
slice.MoveBy(-name.Length);
throw new ParseError($"'{name}' is not a legal namespace.", slice);
}
namespace_name += name;
SkipCommentsAndWhitespace(slice);
if (slice.MatchString(TokenNameExtension))
{
namespace_name += TokenNameExtension;
goto name_match;
}
if (!slice.MatchString(TokenNamespaceFirst))
{
throw new ParseError($"expected '{TokenNamespaceFirst}'.", slice);
}
var types = new TypeList();
var parsers = new GrammarParserDelegate[]
{
MatchStruct,
match_enum,
MatchNamespace,
};
while (slice.IsValid())
{
SkipCommentsAndWhitespace(slice);
if (slice.MatchString(TokenNamespaceFinal))
{
break;
}
if (!MatchAny(slice, parsers, out BaseType type))
{
throw new ParseError("cannot parse", slice);
}
types.Add(type);
}
var span = source.Join(slice);
result = new NamespaceType(namespace_name, types, span);
return(true);
}
public ResourceType?TryGenerateFallbackType(NamespaceType declaringNamespace, ResourceTypeReference reference, ResourceTypeGenerationFlags flags) => null;
public static Symbol ResolveNamespaceQualifiedFunction(FunctionFlags allowedFlags, Symbol?foundSymbol, IdentifierSyntax identifierSyntax, NamespaceType namespaceType)
=> ResolveSymbolInternal(
allowedFlags,
foundSymbol,
identifierSyntax,
getNameSuggestions: () =>
{
var knowFunctionNames = namespaceType.MethodResolver.GetKnownFunctions().Keys;
return(allowedFlags.HasAnyDecoratorFlag()
? knowFunctionNames.Concat(namespaceType.DecoratorResolver.GetKnownDecoratorFunctions().Keys)
: knowFunctionNames);
},
getMissingNameError: (builder, suggestedName) => suggestedName switch {
null => builder.FunctionDoesNotExistInNamespace(namespaceType, identifierSyntax.IdentifierName),
public virtual ExtendedServiceBusNamespace CreateNamespace(string name, string location, NamespaceType type, bool createACSNamespace = false)
{
location = string.IsNullOrEmpty(location) ? GetDefaultLocation() : location;
if (!Regex.IsMatch(name, ServiceBusConstants.NamespaceNamePattern))
{
throw new ArgumentException(string.Format(Resources.InvalidNamespaceName, name), "Name");
}
ServiceBusClient.Namespaces.CreateNamespace(name, new ServiceBusNamespaceCreateParameters {
Region = location, CreateACSNamespace = createACSNamespace, NamespaceType = type
});
// Wait until the namespace is activated
while (!IsActiveNamespace(name))
{
Thread.Sleep(SleepDuration);
}
return(GetExtendedServiceBusNamespace(name));
}
/// <summary>
/// 名前空間要素タイプから対応する Unified 型（型オブジェクト）へ変換します
/// </summary>
/// <param name="type"> 名前空間構成要素タイプ </param>
/// <returns> type に対応する Unified 型（型オブジェクト）の集合 </returns>
public static IEnumerable<Type> Namespace2UnifiedType(
NamespaceType type)
{
switch (type) {
case NamespaceType.Package:
return new List<Type>
{ UnifiedNamespaceDefinition.Create().GetType() };
case NamespaceType.Class:
return new List<Type>
{ UnifiedClassDefinition.Create().GetType() };
case NamespaceType.Function:
return new List<Type>
{ UnifiedFunctionDefinition.Create().GetType() };
case NamespaceType.TemporaryScope:
return new List<Type> {
UnifiedForeach.Create().GetType(),
UnifiedFor.Create().GetType(),
UnifiedWhile.Create().GetType(),
UnifiedDoWhile.Create().GetType(),
};
default:
throw new InvalidOperationException();
}
}
public NamespaceSymbol(string name, IEnumerable <FunctionOverload> functionOverloads, IEnumerable <BannedFunction> bannedFunctions, IEnumerable <Decorator> decorators)
: base(name)
{
Type = new NamespaceType(name, Enumerable.Empty <TypeProperty>(), functionOverloads, bannedFunctions, decorators);
}
/// <summary>
/// Get value extension
/// </summary>
/// <param name="type">The namespace type</param>
/// <returns>NamespaceType</returns>
public static int GetValue(this NamespaceType type)
{
return((int)type);
}
public SimpleElementAttribute(NamespaceType namespaceType)
{
NamespaceType = namespaceType;
}
/// <summary>
/// Process a generic `Assign` statement.
/// </summary>
/// <param name="nsType"></param>
protected void ProcessAssignment(NamespaceType nsType)
{
DmlSyntaxError badAssign = DmlSyntaxError.BadAssignmentStatement();
Advance(exception: badAssign);
Instruction assigner; // The instruction that performs the assignment.
// Check for a global identifier.
if (DmlTokens.IsMatch(CurrentToken, DmlTokens.AT))
{
Advance(exception: badAssign);
if (DmlTokens.IsMatch(CurrentToken, DmlTokens.UQNAME))
assigner = new AssignGlobal(CurrentToken);
else
throw DmlSyntaxError.BadGlobalName(CurrentToken);
}
// Check for an instance bound indentifier.
else if (DmlTokens.IsMatch(CurrentToken, DmlTokens.DOLLAR))
{
switch (nsType)
{
case NamespaceType.BulletInit:
case NamespaceType.BulletUpdate:
Advance(exception: badAssign);
if (DmlTokens.IsName(CurrentToken))
{
switch (CurrentToken)
{
// Assign directly to the bullet direction.
case DmlTokens.INTRINSIC_DIRECTION:
assigner = AssignIntrinsicBulletProperty.Direction;
break;
// Assign directly to the bullet speed.
case DmlTokens.INTRINSIC_SPEED:
assigner = AssignIntrinsicBulletProperty.Speed;
break;
// Assign directly to the bullet colour.
case DmlTokens.INTRINSIC_COLOUR:
assigner = AssignIntrinsicBulletProperty.Colour;
break;
case DmlTokens.INTRINSIC_SPRITE:
assigner = AssignIntrinsicBulletProperty.Sprite;
break;
default:
assigner = new AssignBulletBound(CurrentToken);
break;
}
}
else
throw DmlSyntaxError.BadVariableName(CurrentToken);
break;
default:
throw DmlSyntaxError.BadAssignmentNamespace();
}
}
// Check for an ordinary local name.
else if (DmlTokens.IsMatch(CurrentToken, DmlTokens.UQNAME))
assigner = new AssignLocal(CurrentToken);
else
{
throw DmlSyntaxError.BadVariableName(CurrentToken);
}
// Read the expression.
Advance(exception: badAssign);
string[] expression_tokens = GetUntil(DmlTokens.EOL);
ProcessExpression(expression_tokens);
Instructions.Add(assigner);
}
