private void ValidateMessage(MessageDefinition message) { var paramNames = new HashSet <string>(); var genericConstraints = new HashSet <string>(); if (message.Options.Proto) { if (message.GenericParameters.Count > 0) { _contracts.AddError(message.ParseContext, "Cannot generate .proto for generic message {0}", message.Name); } } ValidateAttributes(message.Attributes); ValidateTags(message); foreach (var param in message.Parameters) { var errorContext = param.ParseContext ?? message.ParseContext; if (!paramNames.Add(param.Name)) { _contracts.AddError(errorContext, "Duplicate parameter name: {0}", param.Name); } ValidateType(param.Type, param.ParseContext); ValidateAttributes(param.Attributes); } foreach (var constraint in message.GenericConstraints) { var errorContext = constraint.ParseContext ?? message.ParseContext; if (!genericConstraints.Add(constraint.GenericParameterName)) { _contracts.AddError(errorContext, "Duplicate generic constraint: '{0}'", constraint.GenericParameterName); } if (!message.GenericParameters.Contains(constraint.GenericParameterName)) { _contracts.AddError(errorContext, "Undefined generic parameter: '{0}'", constraint.GenericParameterName); } if (constraint.IsClass && constraint.IsStruct) { _contracts.AddError(errorContext, "Constraint on '{0}' cannot require both class and struct", constraint.GenericParameterName); } foreach (var constraintType in constraint.Types) { ValidateType(constraintType, message.ParseContext); } } foreach (var baseType in message.BaseTypes) { ValidateType(baseType, message.ParseContext); } }
private DescriptiveObject InitDescriptiveObject(Type item, MessageType eMessageType) { DescriptiveObject messDef; if (eMessageType != MessageType.None) { messDef = new MessageDefinition() { Name = item.GetName(), FullName = item.GetFullName(), MessageType = eMessageType, Description = _xmlReader.GetSummary(item) }; } else { messDef = new DescriptiveType() { Name = item.GetName(), FullName = item.GetFullName(), Description = _xmlReader.GetSummary(item) }; } return(messDef); }
private static void ProcessMessage(MessageDefinition message) { foreach (var parameterDefinition in message.Parameters) { ProcessParameter(parameterDefinition); } }
public MessageDefinition Extract(Type type) { var result = new MessageDefinition(); var name = type.FullName; var dotNetType = type.FullName; foreach (PropertyInfo info in type.GetProperties()) { var member = new MessageDefinition() { Name = info.Name, DotNetType = info.PropertyType.Name, Parent = result, Children = new List<MessageDefinition>() }; //TODO: Needs to walk the entire object graph not just one level deep result.Children.Add(member); } result.Name = name; result.DotNetType = dotNetType; return result; }
protected string Generate(MessageDefinition message) { var contracts = new ParsedContracts(); contracts.Messages.Add(message); return(Generate(contracts)); }
public PackageGenerator(MessageDefinition messageDef, Package packageDef, DictionaryDefinition dictDef, Database db) : base(messageDef, packageDef) { this.db = db; this.dictDef = dictDef; }
public MessageDefinition Extract(Type type) { var result = new MessageDefinition(); var name = type.FullName; var dotNetType = type.FullName; foreach (PropertyInfo info in type.GetProperties()) { var member = new MessageDefinition() { Name = info.Name, DotNetType = info.PropertyType.Name, Parent = result, Children = new List <MessageDefinition>() }; //TODO: Needs to walk the entire object graph not just one level deep result.Children.Add(member); } result.Name = name; result.DotNetType = dotNetType; return(result); }
public void WhenDuplicatedKeyExceptionThrown_NonOfTheActorHandlersIsAdded() { var actorHandlersMap = new ActorHandlerMap(); var simpleMessageActor = new ConfigurableActor(new[] { new MessageHandlerDefinition { Handler = null, Message = MessageDefinition.Create <SimpleMessage>() } }); var exceptionMessageActor = new ConfigurableActor(new[] { new MessageHandlerDefinition { Handler = null, Message = MessageDefinition.Create <ExceptionMessage>() }, new MessageHandlerDefinition { Handler = null, Message = MessageDefinition.Create <SimpleMessage>() } }); actorHandlersMap.Add(simpleMessageActor); actorHandlersMap.Get(MessageIdentifier.Create <SimpleMessage>()); Assert.Throws <DuplicatedKeyException>(() => { actorHandlersMap.Add(exceptionMessageActor); }); actorHandlersMap.Get(MessageIdentifier.Create <SimpleMessage>()); Assert.Throws <KeyNotFoundException>(() => actorHandlersMap.Get(MessageIdentifier.Create <ExceptionMessage>())); }
public PLSQLGenerator(MessageDefinition messageDef, Package packageDef, code_target ct, string mapi_number) : base(messageDef, packageDef) { code_target = ct; switch (code_target) { case code_target.hapi: { tableName = "HAPIRCV"; packageName = "HAPI_Rcv_Object"; break; } case code_target.msg: { tableName = "MSG_IN"; packageName = "MessageRcv_Object"; break; } case code_target.mapi: { tableName = "MAPI_IN"; packageName = "MAPIIn_" + mapi_number + "Object"; break; } default: break; } }
public void Provider_should_return_all_matching_sla_definitions_for_given_response() { var provider = new SlaProvider(); var def1 = new SlaDefinition( MessageDefinition.Create <IRequestOne>(r => r.OneId), MessageDefinition.Create <IResponseOne>(r => r.Id), TimeSpan.FromSeconds(1)); var def2 = new SlaDefinition( MessageDefinition.Create <IRequestTwo>(r => r.TwoId), MessageDefinition.Create <IResponseTwo>(r => r.Id), TimeSpan.FromSeconds(2)); var def3 = new SlaDefinition( MessageDefinition.Create <IExtendedRequestOne>(r => r.OneId), MessageDefinition.Create <IResponseOne>(r => r.Id), TimeSpan.FromSeconds(3)); var def4 = new SlaDefinition( MessageDefinition.Create <IRequestOne>(r => r.OneId), MessageDefinition.Create <IExtendedResponseOne>(r => r.Id), TimeSpan.FromSeconds(3)); provider.Add(def1); provider.Add(def2); provider.Add(def3); provider.Add(def4); var definitions = provider.GetSlaDefinitionsFor(new Mock <IExtendedResponseOne>().Object); Assert.That(definitions.ToArray(), Is.EquivalentTo(new[] { def1, def3, def4 })); }
public void ActorHandlersMap_CanAddTwoActorsHandlingSameMessageTypeInDifferentPartitions() { var actorHandlersMap = new ActorHandlerMap(); var partition = Guid.NewGuid().ToByteArray(); var actorWithoutPartition = new ConfigurableActor(new[] { new MessageHandlerDefinition { Handler = null, Message = MessageDefinition.Create <SimpleMessage>() } }); var actorWithPartition = new ConfigurableActor(new[] { new MessageHandlerDefinition { Handler = null, Message = MessageDefinition.Create <SimpleMessage>(partition) } }); actorHandlersMap.Add(actorWithoutPartition); actorHandlersMap.Add(actorWithPartition); actorHandlersMap.Get(MessageIdentifier.Create(typeof(SimpleMessage), partition)); actorHandlersMap.Get(MessageIdentifier.Create(typeof(SimpleMessage))); }
protected internal virtual void CreateOperations(BpmnModel bpmnModel) { foreach (Interface interfaceObject in bpmnModel.Interfaces) { BpmnInterface bpmnInterface = new BpmnInterface(interfaceObject.Id, interfaceObject.Name) { Implementation = wsServiceMap[interfaceObject.ImplementationRef] }; foreach (Operation operationObject in interfaceObject.Operations) { if (!operationMap.ContainsKey(operationObject.Id)) { MessageDefinition inMessage = messageDefinitionMap[operationObject.InMessageRef]; Webservice.Operation operation = new Webservice.Operation(operationObject.Id, operationObject.Name, bpmnInterface, inMessage) { Implementation = wsOperationMap[operationObject.ImplementationRef] }; if (!string.IsNullOrWhiteSpace(operationObject.OutMessageRef)) { if (messageDefinitionMap.ContainsKey(operationObject.OutMessageRef)) { MessageDefinition outMessage = messageDefinitionMap[operationObject.OutMessageRef]; operation.OutMessage = outMessage; } } operationMap[operation.Id] = operation; } } } }
private void WriteParameterMember(MessageDefinition message, ParameterDefinition param) { if (!param.Attributes.HasAttribute(KnownTypes.ProtoMemberAttribute)) { var protoMemberParams = new StringBuilder(); protoMemberParams.Append(param.Tag); protoMemberParams.AppendFormat(", IsRequired = {0}", param.Rules == FieldRules.Required ? "true" : "false"); if (param.IsPacked) { protoMemberParams.Append(", IsPacked = true"); } WriteAttributeLine(new AttributeDefinition(KnownTypes.ProtoMemberAttribute, protoMemberParams.ToString())); } foreach (var attribute in param.Attributes) { WriteAttributeLine(attribute); } var isWritable = param.IsWritableProperty || message.Options.Mutable; Writer.Write("public {0} {1}", param.Type.NetType, Identifier(MemberCase(param.Name))); Writer.WriteLine(isWritable ? " { get; set; }" : " { get; private set; }"); Writer.WriteLine(); }
/// <summary>Sends a message to all contacts in the list.</summary> /// <param name="service">The service to use.</param> /// <param name="message">The message to show.</param> public void SendAll(IMessagingService service, MessageDefinition message) { foreach (var item in _items) { item.Send(service, message); } }
public WSInboundGenerator(MessageDefinition messageDef, Package packageDef, bool genReceiver, bool genSender, code_target ct, String ns) : base(messageDef, packageDef) { this.genReceiver = genReceiver; this.genSender = genSender; this.code_target = ct; nameSpace = ns; }
/// <summary> /// Generate the body of the <c>encode</c> function for the given <see cref="FieldsDefinition"/>. /// </summary> /// <param name="definition">The definition to generate code for.</param> /// <returns>The generated Dart <c>encode</c> function body.</returns> public string CompileEncode(FieldsDefinition definition) { return(definition switch { MessageDefinition d => CompileEncodeMessage(d), StructDefinition d => CompileEncodeStruct(d), _ => throw new InvalidOperationException($"invalid CompileEncode value: {definition}"), });
public override IEnumerable <MessageHandlerDefinition> GetInterfaceDefinition() => new[] { new MessageHandlerDefinition { Message = MessageDefinition.Create <LeaseRequestMessage>(clusterName), Handler = GetLease } };
/// <summary> /// Generate the body of the <c>encode</c> function for the given <see cref="TopLevelDefinition"/>. /// </summary> /// <param name="definition">The definition to generate code for.</param> /// <returns>The generated CPlusPlus <c>encode</c> function body.</returns> public string CompileEncode(TopLevelDefinition definition) { return(definition switch { MessageDefinition d => CompileEncodeMessage(d), StructDefinition d => CompileEncodeStruct(d), UnionDefinition d => CompileEncodeUnion(d), _ => throw new InvalidOperationException($"invalid CompileEncode kind: {definition}"), });
public override AstNode?VisitMessageDefinition(MessageDefinitionContext context) { var message = new MessageDefinition { IsCustom = context.customModifier != null }; ProcessMessage(message, context); return(message); }
private void WriteGenericConstraints(MessageDefinition message) { if (message.GenericConstraints.Count == 0) { return; } using (Indent()) { foreach (var genericConstraint in message.GenericConstraints) { Writer.Write("where "); Writer.Write(Identifier(genericConstraint.GenericParameterName)); Writer.Write(" : "); var firstConstraint = false; if (genericConstraint.IsClass) { Writer.Write("class"); } else if (genericConstraint.IsStruct) { Writer.Write("struct"); } else { firstConstraint = true; } foreach (var type in genericConstraint.Types) { if (!firstConstraint) { Writer.Write(", "); } Writer.Write(type.NetType); firstConstraint = false; } if (genericConstraint.HasDefaultConstructor && !genericConstraint.IsStruct) { if (!firstConstraint) { Writer.Write(", "); } Writer.Write("new()"); } Writer.WriteLine(); } } }
public void Definition_should_allow_to_retrieve_proper_correlation_id() { var message = new TestMessage { FirstId = Guid.NewGuid(), SecondId = Guid.NewGuid() }; var def1 = MessageDefinition.Create <TestMessage>(m => m.FirstId); var def2 = MessageDefinition.Create <TestMessage>(m => m.SecondId); Assert.That(def1.GetCorrelationId(message), Is.EqualTo(message.FirstId), "It should use FirstId"); Assert.That(def2.GetCorrelationId(message), Is.EqualTo(message.SecondId), "It should use SecondId"); }
public MessageSubscription( long id, MessageDefinition messageDefinition, INetworkTaskFactory taskFactory, IDictionary <long, IMessageSubscription> subscriptions) { _id = id; _taskFactory = taskFactory; _subscriptions = subscriptions; Definition = messageDefinition; _receivers = new List <MessageReceiveConfig>(); }
private MessageInstance createResponseMessage(object[] results, Operation operation) { MessageInstance message = null; MessageDefinition outMessage = operation.OutMessage; if (outMessage != null) { message = outMessage.CreateInstance(); message.StructureInstance.LoadFrom(results); } return(message); }
private JobResult GenerateClass(MessageDefinition msgDef, Package package, ICollection<Import> imports) { var topLevelStatements = new List<SyntaxNode>(); topLevelStatements.Add(_generator.NamespaceImportDeclaration("System")); foreach(var import in imports) { topLevelStatements.Add(_generator.NamespaceImportDeclaration(import.ImportClass)); } var members = new List<SyntaxNode>(); foreach (var msgField in msgDef.Fields) { members.Add(_generator.FieldDeclaration( $"_{msgField.FieldName}", _generator.TypeExpression(SpecialType.System_String), Accessibility.Private)); members.Add(_generator.PropertyDeclaration( $"{msgField.FieldName}", _generator.TypeExpression(SpecialType.System_String), Accessibility.Public, getAccessorStatements: new SyntaxNode[] { _generator.ReturnStatement(_generator.IdentifierName($"_{msgField.FieldName}")) }, setAccessorStatements: new SyntaxNode[] { _generator.AssignmentStatement(_generator.IdentifierName($"_{msgField.FieldName}"), _generator.IdentifierName("value")) })); } var classDefinition = _generator.ClassDeclaration(msgDef.Name, typeParameters: null, accessibility: Accessibility.Public, modifiers: DeclarationModifiers.Sealed, baseType: null, interfaceTypes: null, members: members); var packageName = package?.Name ?? "wasnull"; var ns = _generator.NamespaceDeclaration(packageName, classDefinition); topLevelStatements.Add(ns); var compilationUnit = _generator.CompilationUnit(topLevelStatements) .NormalizeWhitespace(); return new JobResult { FileContent = compilationUnit.ToFullString(), FileName = $"{msgDef.Name}.cs" }; }
private static void SetInheritanceModifier(MessageDefinition message) { if (message.InheritanceModifier != InheritanceModifier.Default) { return; } var hasInheritedMessages = message.Attributes.Any(attr => Equals(attr.TypeName, KnownTypes.ProtoIncludeAttribute)); message.InheritanceModifier = hasInheritedMessages ? InheritanceModifier.Abstract : InheritanceModifier.Sealed; }
/// <summary> /// Creates a message definition. /// </summary> /// <param name="messageFullName">The fully qualified type name to assign to the message definition.</param> /// <param name="messageLocalName">The local class name to assign to the message definition.</param> /// <param name="messageType">The message type to create the message definition from.</param> /// <param name="parentResourceKey">The resource key of the message definitions parent.</param> /// <returns>A message definition.</returns> private MessageDefinition CreateMessageDefinition(string messageFullName, string messageLocalName, TypeDefinition messageType, string parentResourceKey) { var messageDefinition = new MessageDefinition( GetCustomAttributeConstructorValue(messageType, SchemaAttributeType, 1), GetCustomAttributeConstructorValue(messageType, SchemaAttributeType, 0), messageFullName, messageLocalName, parentResourceKey + ":" + GetCustomAttributeConstructorValue(messageType, SchemaAttributeType, 1)); // Add the promoted properties. messageDefinition.PromotedProperties.AddRange(ExtractPromotedProperties(messageType)); return(messageDefinition); }
public override IEnumerable <MessageHandlerDefinition> GetInterfaceDefinition() => new[] { new MessageHandlerDefinition { Message = MessageDefinition.Create <InternalDiscoverLeaseProviderInstancesRequestMessage>(clusterName), Handler = InternalDiscoverLeaseProviderInstancesRequest }, new MessageHandlerDefinition { Message = MessageDefinition.Create <InternalDiscoverLeaseProviderInstancesResponseMessage>(clusterName), Handler = InternalDiscoverLeaseProviderInstancesResponse } };
private void WriteMessageConstructor(MessageDefinition message) { Writer.WriteLine(); Writer.Write( message.InheritanceModifier == Ast.InheritanceModifier.Abstract ? "protected" : "public" ); Writer.Write(" "); Writer.Write(Identifier(message.Name)); Writer.Write("("); var paramsToInitialize = message.Parameters .Where(param => !param.IsWritableProperty) .ToList(); var firstParam = true; foreach (var param in paramsToInitialize) { if (firstParam) { firstParam = false; } else { Writer.Write(", "); } Writer.Write("{0} {1}", param.Type.NetType, Identifier(ParameterCase(param.Name))); if (!string.IsNullOrEmpty(param.DefaultValue)) { Writer.Write(" = {0}", param.DefaultValue); } } Writer.WriteLine(")"); using (Block()) { foreach (var param in paramsToInitialize) { Writer.WriteLine("{0} = {1};", Identifier(MemberCase(param.Name)), Identifier(ParameterCase(param.Name))); } } }
/// <summary> /// Globals the advert message. /// </summary> /// <param name="message">The message.</param> protected void GlobalAdvertMessage(MessageDefinition message) { if (!message.Enabled) { return; } if (Repository.Static.GetLastIntervalById(message.Id).AddMinutes(message.Interval) < Repository.Static.Now) { Repository.Static.SetLastIntervalById(message.Id, Repository.Static.Now); QueryRunner.SendGlobalMessage(message.TextMessage.ToMessage()); Log(message, string.Format("Global advert message successfully sent.")); } }
public override IEnumerable <MessageHandlerDefinition> GetInterfaceDefinition() { return(new[] { new MessageHandlerDefinition { Message = MessageDefinition.Create <CreateLeaseProviderInstanceRequestMessage>(clusterName), Handler = CreateLeaseProviderInstance }, new MessageHandlerDefinition { Message = MessageDefinition.Create <InternalCreateLeaseProviderInstanceRequestMessage>(clusterName), Handler = InternalCreateLeaseProviderInstance } }); }
private void OnSave(object sender, EventArgs e) { if (!ValidateChildren()) { return; } Message = new MessageDefinition() { Subject = _txtSubject.Text, Message = _txtMessage.Text }; DialogResult = DialogResult.OK; Close(); }
private static void AddInterfaces(MessageDefinition message) { switch (message.Type) { case MessageType.Event: message.BaseTypes.Add(KnownTypes.EventInterface); break; case MessageType.Command: message.BaseTypes.Add(KnownTypes.CommandInterface); break; case MessageType.Custom: message.BaseTypes.Add(KnownTypes.MessageInterface); break; } }
public void BuilderVisitorShouldBuildMessage() { #region Arrange Expected NodeTree Input var root = new RootNode(); // Define base Message with One Field var message = new Node(NodeType.Message, "message"); var msgName = new Node(NodeType.Identifier, "Outer"); #region Outer Message Field nodes var field = new Node(NodeType.Field, "int32"); var type = new Node(NodeType.Type, "int32"); var name = new Node(NodeType.Identifier, "field_name"); var value = new Node(NodeType.FieldNumber, "2"); field.AddChildren(type, name, value); #endregion Outer Message Field nodes #region Nested Message nodes var nestedMsg = new Node(NodeType.Message, "message"); var nestedName = new Node(NodeType.Identifier, "Inner"); var innerField = new Node(NodeType.Field, "fixed64"); var innerType = new Node(NodeType.Type, "fixed64"); var innerName = new Node(NodeType.Identifier, "field_name2"); var innerValue = new Node(NodeType.FieldNumber, "0"); innerField.AddChildren(innerType, innerName, innerValue); #endregion Nested Message nodes #region Nested Enumeration nodes var enumnode = new Node(NodeType.Enum, "enum"); var enumname = new Node(NodeType.Identifier, "EnumName"); var enumfield0 = new Node(NodeType.EnumField, "DEFAULT"); var enumfieldname0 = new Node(NodeType.Identifier, "DEFAULT"); var enumfieldvalue0 = new Node(NodeType.FieldNumber, "0"); var enumfield1 = new Node(NodeType.EnumField, "VALONE"); var enumfieldname1 = new Node(NodeType.Identifier, "VALONE"); var enumfieldvalue1 = new Node(NodeType.FieldNumber, "1"); enumnode.AddChildren(enumname, enumfield0, enumfield1); enumfield0.AddChildren(enumfieldname0, enumfieldvalue0); enumfield1.AddChildren(enumfieldname1, enumfieldvalue1); #endregion Nested Enumeration nodes nestedMsg.AddChildren(nestedName, innerField); message.AddChildren(msgName, field, enumnode, nestedMsg); root.AddChild(message); #endregion Arrange Expected NodeTree Input #region Arrange Expected Output var expFields = new List<Field> { new Field("int32", "field_name", 2, null, false) }; var inFields = new List<Field> { new Field("fixed64", "field_name2", 0, null, false) }; var enumDefs = new List<EnumDefinition> { new EnumDefinition("EnumName", null, new List<EnumField> { new EnumField("DEFAULT", 0, null), new EnumField("VALONE", 1, null) }) }; var msgDefs = new List<MessageDefinition> { new MessageDefinition("Inner", inFields, null, null, null, null, null) }; var expected = new MessageDefinition("Outer", expFields, null, null, null, enumDefs, msgDefs); #endregion Arrange Expected Output var sut = new BuilderVisitor(); root.Accept(sut); sut.FileDescriptor.Messages.First().Should().Be(expected); }
/// <summary> /// Globals the advert message. /// </summary> /// <param name="message">The message.</param> protected void GlobalAdvertMessage(MessageDefinition message) { if (!message.Enabled) return; if (Repository.Static.GetLastIntervalById(message.Id).AddMinutes(message.Interval) < Repository.Static.Now) { Repository.Static.SetLastIntervalById(message.Id, Repository.Static.Now); QueryRunner.SendGlobalMessage(message.TextMessage.ToMessage()); Log(message, string.Format("Global advert message successfully sent.")); } }
/// <summary> /// Logs the information that request with <c>correlationId</c> would not be monitored due to fact that quota for requests of this type has been already reached. /// The log level of this message is WARN /// </summary> /// <param name="requestDefinition">Message definition.</param> /// <param name="correlationId">Correlation ID</param> protected virtual void ProcessQuotaReached(MessageDefinition requestDefinition, Guid correlationId) { _logger.WarnFormat("SLA={0} monitoring message quota reached. Message with CorrelationId={1} is not going to be monitored.", requestDefinition.Type, correlationId); }
protected virtual void ProcessMessageTimeout(MessageDefinition requestDefinition, TimeSpan elapsed, Guid correlationId) { _logSlaBreach("SLA={0} Response=monitor-timed-out ResponseTime={1} milliseconds CorrelationId={2}", new object[] { requestDefinition.Type, (long)elapsed.TotalMilliseconds, correlationId }); }
/// <summary> /// Welcomes the message. /// </summary> /// <param name="e">The <see cref="TS3QueryLib.Core.Server.Notification.EventArgs.ClientJoinedEventArgs"/> instance containing the event data.</param> /// <param name="message">The message.</param> protected void WelcomeMessage(ClientJoinedEventArgs e, MessageDefinition message) { if (!message.Enabled) return; if (e.ClientType == 0) QueryRunner.SendTextMessage( MessageTarget.Channel, message.Channel, message.TextMessage.ToMessage(new MessageContext { ClientDatabaseId = e.ClientDatabaseId, ClientNickname = e.Nickname })); Log(message, string.Format("Welcome message successfully sent to client '{0}'(id:{1}).", e.Nickname, e.ClientDatabaseId)); }
/// <summary> /// Adverts the message. /// </summary> /// <param name="message">The message.</param> protected void AdvertMessage(MessageDefinition message) { if (!message.Enabled) return; if (Repository.Static.GetLastIntervalById(message.Id).AddMinutes(message.Interval) < Repository.Static.Now) { Repository.Static.SetLastIntervalById(message.Id, Repository.Static.Now); QueryRunner.SendTextMessage( MessageTarget.Server, Repository.Connection.CredentialEntity.Self.VirtualServerId, message.TextMessage.ToMessage(new MessageContext { ServerId = Repository.Connection.CredentialEntity.Self.VirtualServerId })); Log(message, string.Format("Advert message successfully sent to server '{0}'.", Repository.Connection.CredentialEntity.Self.VirtualServerId)); } }
public SlaDefinition(MessageDefinition request, MessageDefinition response, TimeSpan sla) { Request = request; Response = response; Sla = sla; }
public override void Visit(Node node) { var name = node.Children.Single(t => t.NodeType.Equals(NodeType.Identifier)).NodeValue; var embMsg = node.Children.Where(t => t.NodeType.Equals(NodeType.Message)); var messages = new List<MessageDefinition>(); foreach (var msg in embMsg) { var msgVisitor = new MessageVisitor(Errors); msg.Accept(msgVisitor); messages.Add(msgVisitor.Message); } var embEnum = node.Children.Where(t => t.NodeType.Equals(NodeType.Enum)); var enums = new List<EnumDefinition>(); foreach (var en in embEnum) { var enumVisitor = new EnumVisitor(Errors); en.Accept(enumVisitor); enums.Add(enumVisitor.EnumDefinition); } var fieldNodes = node.Children.Where(t => t.NodeType.Equals(NodeType.Field)); var fields = new List<Field>(); foreach (var field in fieldNodes) { var fieldVisitor = new FieldVisitor(Errors); field.Accept(fieldVisitor); fields.Add(fieldVisitor.Field); } Message = new MessageDefinition(name, fields, null, null, null, enums, messages); }