plc4net/tools/code-gen/model/Definitions.cs - plc4x - Git at Google

 //
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //      https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 //

 using System.Collections.Generic;
 using System.Linq;
 using org.apache.plc4net.tools.codegen.model.terms;

 namespace org.apache.plc4net.tools.codegen.model
 {
     /// <summary>A top-level named type in an mspec file.</summary>
     public abstract class TypeDefinition
     {
         public required string Name { get; set; }

         /// <summary>Attributes on the type header, e.g.
         /// <c>byteOrder='"BIG_ENDIAN"'</c>.</summary>
         public Dictionary<string, Term> Attributes { get; } = new Dictionary<string, Term>();

         public Term? GetAttribute(string name) =>
             Attributes.TryGetValue(name, out var v) ? v : null;
     }

     /// <summary>A parser argument in a type header: <c>(bit response)</c>.</summary>
     public sealed class Argument
     {
         public required string Name { get; set; }
         public required TypeReference Type { get; set; }
     }

     /// <summary>
     /// A structured type - a <c>[type]</c> or a <c>[discriminatedType]</c>.
     /// A discriminated parent is the one whose fields include a
     /// <see cref="fields.TypeSwitchField"/>; its children are also
     /// <see cref="ComplexTypeDefinition"/> instances, linked by
     /// <see cref="ParentName"/> / <see cref="DiscriminatorValues"/>.
     /// </summary>
     public sealed class ComplexTypeDefinition : TypeDefinition
     {
         public List<Argument> Arguments { get; } = new List<Argument>();

         public List<fields.Field> Fields { get; } = new List<fields.Field>();

         // ── discriminated-type wiring ────────────────────────────

         /// <summary>Set on a child type: the parent it extends.</summary>
         public string? ParentName { get; set; }

         /// <summary>Set on a child type: the case values, positionally matched
         /// against the parent's <see cref="fields.TypeSwitchField.Discriminators"/>.
         /// A null entry is a wildcard (the case listed fewer values).</summary>
         public IReadOnlyList<Term?>? DiscriminatorValues { get; set; }

         public bool IsDiscriminatedParent =>
             Fields.Any(f => f is fields.TypeSwitchField);

         public bool IsDiscriminatedChild => ParentName != null;

         public fields.TypeSwitchField? TypeSwitch =>
             Fields.OfType<fields.TypeSwitchField>().FirstOrDefault();

         /// <summary>The fields that hold a value and therefore get a property
         /// and a constructor parameter (everything except const / implicit /
         /// reserved / virtual / typeSwitch and the abstract markers).</summary>
         public IEnumerable<fields.Field> PropertyFields =>
             Fields.Where(f => f.IsProperty);

         /// <summary>
         /// On a discriminated parent: the property fields declared before the
         /// <c>typeSwitch</c>. A child inherits these - the parent reads and
         /// writes them, and passes them to the child's <c>StaticParse</c> and
         /// on to <c>base(...)</c>.
         /// </summary>
         public IEnumerable<fields.Field> PrefixPropertyFields =>
             Fields.TakeWhile(f => f is not fields.TypeSwitchField).Where(f => f.IsProperty);

         /// <summary>
         /// On a discriminated parent: the property fields declared after the
         /// <c>typeSwitch</c> - a shared trailer (S7's COTPPacket parameters /
         /// payload). The child reads and writes these, after its own body.
         /// </summary>
         public IEnumerable<fields.Field> SuffixPropertyFields =>
             Fields.SkipWhile(f => f is not fields.TypeSwitchField).Skip(1).Where(f => f.IsProperty);

         /// <summary>
         /// On a discriminated parent: the pre-<c>typeSwitch</c> fields that
         /// carry a value a child might reference in an expression - property
         /// fields plus discriminators, implicit and const fields. The parent
         /// reads them and passes them to the child's <c>StaticParse</c>.
         /// </summary>
         public IEnumerable<fields.Field> PrefixContextFields =>
             Fields.TakeWhile(f => f is not fields.TypeSwitchField)
                   .Where(f => f.Name != null
                       && f is not fields.ReservedField);

         /// <summary>Pre-<c>typeSwitch</c> implicit fields - a child recomputes
         /// these at the top of its serialize / length.</summary>
         public IEnumerable<fields.ImplicitField> PrefixImplicitFields =>
             Fields.TakeWhile(f => f is not fields.TypeSwitchField).OfType<fields.ImplicitField>();

         /// <summary>All fields up to and including the <c>typeSwitch</c> - what
         /// a discriminated parent's own <c>StaticParse</c> / <c>Serialize</c>
         /// covers.</summary>
         public IEnumerable<fields.Field> FieldsThroughSwitch
         {
             get
             {
                 foreach (var f in Fields)
                 {
                     yield return f;
                     if (f is fields.TypeSwitchField)
                     {
                         yield break;
                     }
                 }
             }
         }

         /// <summary>The fields after the <c>typeSwitch</c> in declaration
         /// order (a superset of <see cref="SuffixPropertyFields"/> - includes
         /// reserved / const trailers too).</summary>
         public IEnumerable<fields.Field> FieldsAfterSwitch =>
             Fields.SkipWhile(f => f is not fields.TypeSwitchField).Skip(1);

         public IEnumerable<fields.ConstField> ConstFields => Fields.OfType<fields.ConstField>();
     }

     /// <summary>An <c>[enum]</c> type.</summary>
     public sealed class EnumTypeDefinition : TypeDefinition
     {
         /// <summary>The wire type: <c>uint 8</c> for
         /// <c>[enum uint 8 ModbusErrorCode ...]</c>. Null for a bare
         /// <c>[enum Name ...]</c> (rare; treated as an int).</summary>
         public SimpleTypeReference? BaseType { get; set; }

         /// <summary>Per-constant parameters: <c>(uint 8 dataTypeSize)</c>.</summary>
         public List<Argument> Arguments { get; } = new List<Argument>();

         public List<EnumValue> Values { get; } = new List<EnumValue>();

         /// <summary><c>[enum PlcValueType external='true']</c>: the type lives
         /// outside the mspec (hand-written in the SPI). The generator emits no
         /// file for it and skips any accessor that would return it.</summary>
         public bool IsExternal =>
             GetAttribute("external") is terms.BooleanLiteral { Value: true }
             || GetAttribute("external") is terms.StringLiteral { Value: "true" };
     }

     /// <summary>One constant in an enum.</summary>
     public sealed class EnumValue
     {
         public required string Name { get; set; }

         /// <summary>The wire value, e.g. <c>0x02</c>. Null when the mspec
         /// left it out (the constant then just names a slot).</summary>
         public Term? Value { get; set; }

         /// <summary>Values for the enum's <see cref="EnumTypeDefinition.Arguments"/>,
         /// positionally: <c>['1' BOOL ['2']]</c> gives <c>dataTypeSize = 2</c>.</summary>
         public IReadOnlyList<Term> ConstantValues { get; set; } = System.Array.Empty<Term>();
     }

     /// <summary>
     /// A <c>[dataIo]</c> type - parses to / serializes from an
     /// <c>IPlcValue</c> rather than a generated class. The <c>typeSwitch</c>
     /// picks the wire layout from the parser arguments (S7's <c>DataItem</c>
     /// keys on <c>dataProtocolId</c>); each case yields one <c>PlcValue</c>.
     /// </summary>
     public sealed class DataIoTypeDefinition : TypeDefinition
     {
         public List<Argument> Arguments { get; } = new List<Argument>();

         /// <summary>Set only when the dataIo actually has a <c>typeSwitch</c>
         /// (always true in practice, but the builder sets this after
         /// construction, so it is not <c>required</c>).</summary>
         public fields.TypeSwitchField? TypeSwitch { get; set; }

         /// <summary>The <c>typeSwitch</c> cases, in declaration order. Unlike a
         /// discriminated type's children these are not lifted to top-level
         /// types - the case names repeat (<c>CHAR</c>, <c>STRING</c>, <c>TIME</c>
         /// each appear twice) and a case is a value shape, not a class.</summary>
         public List<ComplexTypeDefinition> Cases { get; } = new List<ComplexTypeDefinition>();
     }
 }
	//
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	//

	using System.Collections.Generic;
	using System.Linq;
	using org.apache.plc4net.tools.codegen.model.terms;

	namespace org.apache.plc4net.tools.codegen.model
	{
	/// <summary>A top-level named type in an mspec file.</summary>
	public abstract class TypeDefinition
	{
	public required string Name { get; set; }

	/// <summary>Attributes on the type header, e.g.
	/// <c>byteOrder='"BIG_ENDIAN"'</c>.</summary>
	public Dictionary<string, Term> Attributes { get; } = new Dictionary<string, Term>();

	public Term? GetAttribute(string name) =>
	Attributes.TryGetValue(name, out var v) ? v : null;
	}

	/// <summary>A parser argument in a type header: <c>(bit response)</c>.</summary>
	public sealed class Argument
	{
	public required string Name { get; set; }
	public required TypeReference Type { get; set; }
	}

	/// <summary>
	/// A structured type - a <c>[type]</c> or a <c>[discriminatedType]</c>.
	/// A discriminated parent is the one whose fields include a
	/// <see cref="fields.TypeSwitchField"/>; its children are also
	/// <see cref="ComplexTypeDefinition"/> instances, linked by
	/// <see cref="ParentName"/> / <see cref="DiscriminatorValues"/>.
	/// </summary>
	public sealed class ComplexTypeDefinition : TypeDefinition
	{
	public List<Argument> Arguments { get; } = new List<Argument>();

	public List<fields.Field> Fields { get; } = new List<fields.Field>();

	// ── discriminated-type wiring ────────────────────────────

	/// <summary>Set on a child type: the parent it extends.</summary>
	public string? ParentName { get; set; }

	/// <summary>Set on a child type: the case values, positionally matched
	/// against the parent's <see cref="fields.TypeSwitchField.Discriminators"/>.
	/// A null entry is a wildcard (the case listed fewer values).</summary>
	public IReadOnlyList<Term?>? DiscriminatorValues { get; set; }

	public bool IsDiscriminatedParent =>
	Fields.Any(f => f is fields.TypeSwitchField);

	public bool IsDiscriminatedChild => ParentName != null;

	public fields.TypeSwitchField? TypeSwitch =>
	Fields.OfType<fields.TypeSwitchField>().FirstOrDefault();

	/// <summary>The fields that hold a value and therefore get a property
	/// and a constructor parameter (everything except const / implicit /
	/// reserved / virtual / typeSwitch and the abstract markers).</summary>
	public IEnumerable<fields.Field> PropertyFields =>
	Fields.Where(f => f.IsProperty);

	/// <summary>
	/// On a discriminated parent: the property fields declared before the
	/// <c>typeSwitch</c>. A child inherits these - the parent reads and
	/// writes them, and passes them to the child's <c>StaticParse</c> and
	/// on to <c>base(...)</c>.
	/// </summary>
	public IEnumerable<fields.Field> PrefixPropertyFields =>
	Fields.TakeWhile(f => f is not fields.TypeSwitchField).Where(f => f.IsProperty);

	/// <summary>
	/// On a discriminated parent: the property fields declared after the
	/// <c>typeSwitch</c> - a shared trailer (S7's COTPPacket parameters /
	/// payload). The child reads and writes these, after its own body.
	/// </summary>
	public IEnumerable<fields.Field> SuffixPropertyFields =>
	Fields.SkipWhile(f => f is not fields.TypeSwitchField).Skip(1).Where(f => f.IsProperty);

	/// <summary>
	/// On a discriminated parent: the pre-<c>typeSwitch</c> fields that
	/// carry a value a child might reference in an expression - property
	/// fields plus discriminators, implicit and const fields. The parent
	/// reads them and passes them to the child's <c>StaticParse</c>.
	/// </summary>
	public IEnumerable<fields.Field> PrefixContextFields =>
	Fields.TakeWhile(f => f is not fields.TypeSwitchField)
	.Where(f => f.Name != null
	&& f is not fields.ReservedField);

	/// <summary>Pre-<c>typeSwitch</c> implicit fields - a child recomputes
	/// these at the top of its serialize / length.</summary>
	public IEnumerable<fields.ImplicitField> PrefixImplicitFields =>
	Fields.TakeWhile(f => f is not fields.TypeSwitchField).OfType<fields.ImplicitField>();

	/// <summary>All fields up to and including the <c>typeSwitch</c> - what
	/// a discriminated parent's own <c>StaticParse</c> / <c>Serialize</c>
	/// covers.</summary>
	public IEnumerable<fields.Field> FieldsThroughSwitch
	{
	get
	{
	foreach (var f in Fields)
	{
	yield return f;
	if (f is fields.TypeSwitchField)
	{
	yield break;
	}
	}
	}
	}

	/// <summary>The fields after the <c>typeSwitch</c> in declaration
	/// order (a superset of <see cref="SuffixPropertyFields"/> - includes
	/// reserved / const trailers too).</summary>
	public IEnumerable<fields.Field> FieldsAfterSwitch =>
	Fields.SkipWhile(f => f is not fields.TypeSwitchField).Skip(1);

	public IEnumerable<fields.ConstField> ConstFields => Fields.OfType<fields.ConstField>();
	}

	/// <summary>An <c>[enum]</c> type.</summary>
	public sealed class EnumTypeDefinition : TypeDefinition
	{
	/// <summary>The wire type: <c>uint 8</c> for
	/// <c>[enum uint 8 ModbusErrorCode ...]</c>. Null for a bare
	/// <c>[enum Name ...]</c> (rare; treated as an int).</summary>
	public SimpleTypeReference? BaseType { get; set; }

	/// <summary>Per-constant parameters: <c>(uint 8 dataTypeSize)</c>.</summary>
	public List<Argument> Arguments { get; } = new List<Argument>();

	public List<EnumValue> Values { get; } = new List<EnumValue>();

	/// <summary><c>[enum PlcValueType external='true']</c>: the type lives
	/// outside the mspec (hand-written in the SPI). The generator emits no
	/// file for it and skips any accessor that would return it.</summary>
	public bool IsExternal =>
	GetAttribute("external") is terms.BooleanLiteral { Value: true }
	\|\| GetAttribute("external") is terms.StringLiteral { Value: "true" };
	}

	/// <summary>One constant in an enum.</summary>
	public sealed class EnumValue
	{
	public required string Name { get; set; }

	/// <summary>The wire value, e.g. <c>0x02</c>. Null when the mspec
	/// left it out (the constant then just names a slot).</summary>
	public Term? Value { get; set; }

	/// <summary>Values for the enum's <see cref="EnumTypeDefinition.Arguments"/>,
	/// positionally: <c>['1' BOOL ['2']]</c> gives <c>dataTypeSize = 2</c>.</summary>
	public IReadOnlyList<Term> ConstantValues { get; set; } = System.Array.Empty<Term>();
	}

	/// <summary>
	/// A <c>[dataIo]</c> type - parses to / serializes from an
	/// <c>IPlcValue</c> rather than a generated class. The <c>typeSwitch</c>
	/// picks the wire layout from the parser arguments (S7's <c>DataItem</c>
	/// keys on <c>dataProtocolId</c>); each case yields one <c>PlcValue</c>.
	/// </summary>
	public sealed class DataIoTypeDefinition : TypeDefinition
	{
	public List<Argument> Arguments { get; } = new List<Argument>();

	/// <summary>Set only when the dataIo actually has a <c>typeSwitch</c>
	/// (always true in practice, but the builder sets this after
	/// construction, so it is not <c>required</c>).</summary>
	public fields.TypeSwitchField? TypeSwitch { get; set; }

	/// <summary>The <c>typeSwitch</c> cases, in declaration order. Unlike a
	/// discriminated type's children these are not lifted to top-level
	/// types - the case names repeat (<c>CHAR</c>, <c>STRING</c>, <c>TIME</c>
	/// each appear twice) and a case is a value shape, not a class.</summary>
	public List<ComplexTypeDefinition> Cases { get; } = new List<ComplexTypeDefinition>();
	}
	}