FeatureExtensions.cs

// -------------------------------------------------------------------------------------------------
// <copyright file="FeatureExtensions.cs" company="Starion Group S.A.">
//
//    Copyright (C) 2022-2026 Starion Group S.A.
//
//    Licensed 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
//
//        http://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.
//
// </copyright>
// ------------------------------------------------------------------------------------------------

namespace SysML2.NET.Core.POCO.Core.Features
{
    using System;
    using System.Collections.Generic;

    using SysML2.NET.Core.Core.Types;
    using SysML2.NET.Core.POCO.Core.Types;
    using SysML2.NET.Core.POCO.Root.Annotations;
    using SysML2.NET.Core.POCO.Root.Elements;
    using SysML2.NET.Core.POCO.Root.Namespaces;

    /// <summary>
    /// The <see cref="FeatureExtensions"/> class provides extensions methods for
    /// the <see cref="IFeature"/> interface
    /// </summary>
    internal static class FeatureExtensions
    {
        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IFeature> ComputeChainingFeature(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IFeature ComputeCrossFeature(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IType ComputeEndOwningType(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IFeature ComputeFeatureTarget(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IType> ComputeFeaturingType(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static ICrossSubsetting ComputeOwnedCrossSubsetting(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IFeatureChaining> ComputeOwnedFeatureChaining(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IFeatureInverting> ComputeOwnedFeatureInverting(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IRedefinition> ComputeOwnedRedefinition(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IReferenceSubsetting ComputeOwnedReferenceSubsetting(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<ISubsetting> ComputeOwnedSubsetting(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<ITypeFeaturing> ComputeOwnedTypeFeaturing(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IFeatureTyping> ComputeOwnedTyping(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IFeatureMembership ComputeOwningFeatureMembership(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IType ComputeOwningType(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Computes the derived property.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// the computed result
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IType> ComputeType(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Return the directionOf this Feature relative to the given type.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="type">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="FeatureDirectionKind" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static FeatureDirectionKind? ComputeDirectionForOperation(this IFeature featureSubject, IType type)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// If a Feature has no declaredShortName or declaredName, then its effective shortName is given by the
        /// effective shortName of the Feature returned by the namingFeature() operation, if any.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected <see cref="string" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static string ComputeRedefinedEffectiveShortNameOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// If a Feature has no declaredName or declaredShortName                            , then its
        /// effective name is given by the effective name of the Feature returned by the namingFeature()
        /// operation, if any.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected <see cref="string" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static string ComputeRedefinedEffectiveNameOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// By default, the naming Feature of a Feature is given by its first redefinedFeature of its first
        /// ownedRedefinition, if any.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected <see cref="IFeature" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IFeature ComputeNamingFeatureOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="excludeImplied">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected collection of <see cref="IType" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IType> ComputeRedefinedSupertypesOperation(this IFeature featureSubject, bool excludeImplied)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Check whether this Feature directly redefines the given redefinedFeature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="redefinedFeature">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeRedefinesOperation(this IFeature featureSubject, IFeature redefinedFeature)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Check whether this Feature directly redefines the named library Feature. libraryFeatureName must
        /// conform to the syntax of a KerML qualified name and must resolve to a Feature in global scope.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="libraryFeatureName">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeRedefinesFromLibraryOperation(this IFeature featureSubject, string libraryFeatureName)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Check whether this Feature directly or indirectly specializes a Feature whose last two
        /// chainingFeatures are the given Features first and second.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="first">
        /// No documentation provided
        /// </param>
        /// <param name="second">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeSubsetsChainOperation(this IFeature featureSubject, IFeature first, IFeature second)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// A Feature is compatible with an otherType if it either directly or indirectly specializes the
        /// otherType or if the otherType is also a Feature and all of the following are true.                  
        ///          <ol>                            <li>Neither this Feature or the otherType have any
        /// ownedFeatures.</li>                            <li>This Feature directly or indirectly redefines a
        /// Feature that is also directly or indirectly redefined by the otherType.</li>                        
        /// <li>This Feature can access the otherType.                            </li></ol>
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="otherType">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeRedefinedIsCompatibleWithOperation(this IFeature featureSubject, IType otherType)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Return the Features used to determine the types of this Feature (other than this Feature itself). If
        /// this Feature is not conjugated, then the typingFeatures consist of all subsetted Features, except
        /// from CrossSubsetting, and the last chainingFeature (if any). If this Feature is conjugated, then the
        /// typingFeatures are only its originalType (if the originalType is a Feature).                        
        ///    <strong>Note.</strong> CrossSubsetting is excluded from the determination of the type of a
        /// Feature in order to avoid circularity in the construction of implied CrossSubsetting relationships.
        /// The validateFeatureCrossFeatureType requires that the crossFeature of a Feature have the same type
        /// as the Feature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected collection of <see cref="IFeature" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IFeature> ComputeTypingFeaturesOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// If isCartesianProduct is true, then return the list of Types whose Cartesian product can be
        /// represented by this Feature. (If isCartesianProduct is not true, the operation will still return a
        /// valid value, it will just not represent anything useful.)
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected collection of <see cref="IType" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IType> ComputeAsCartesianProductOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Check whether this Feature can be used to represent a Cartesian product of Types.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeIsCartesianProductOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Return whether this Feature is an owned cross Feature of an end Feature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeIsOwnedCrossFeatureOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// If this Feature is an end Feature of its owningType, then return the first ownedMember of the
        /// Feature that is a Feature, but not a Multiplicity or a MetadataFeature, and whose owningMembership
        /// is not a FeatureMembership. If this exists, it is the crossFeature of the end Feature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected <see cref="IFeature" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static IFeature ComputeOwnedCrossFeatureOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Return this Feature and all the Features that are directly or indirectly Redefined by this Feature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <returns>
        /// The expected collection of <see cref="IFeature" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static List<IFeature> ComputeAllRedefinedFeaturesOperation(this IFeature featureSubject)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Return if the featuringTypes of this Feature are compatible with the given type. If type is null,
        /// then check if this Feature is explicitly or implicitly featured by Base::Anything. If this Feature
        /// has isVariable = true, then also consider it to be featured within its owningType. If this Feature
        /// is a feature chain whose first chainingFeature has isVariable = true, then also consider it to be
        /// featured within the owningType of its first chainingFeature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="type">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeIsFeaturedWithinOperation(this IFeature featureSubject, IType type)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// A Feature can access another feature if the other feature is featured within one of the direct or
        /// indirect featuringTypes of this Feature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="feature">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeCanAccessOperation(this IFeature featureSubject, IFeature feature)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }

        /// <summary>
        /// Return whether the given type must be a featuringType of this Feature. If this Feature has
        /// isVariable = false, then return true if the type is the owningType of the Feature. If isVariable =
        /// true, then return true if the type is a Feature representing the snapshots of the owningType of this
        /// Feature.
        /// </summary>
        /// <param name="featureSubject">
        /// The subject <see cref="IFeature"/>
        /// </param>
        /// <param name="type">
        /// No documentation provided
        /// </param>
        /// <returns>
        /// The expected <see cref="bool" />
        /// </returns>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        internal static bool ComputeIsFeaturingTypeOperation(this IFeature featureSubject, IType type)
        {
            throw new NotSupportedException("Create a GitHub issue when this method is required");
        }
    }
}