1.1.0

prepend "ci" to build num
added new ci script
2024-05-09 03:58:45 +02:00 · 2023-12-22 16:21:14 +01:00 · 2023-12-22 16:19:13 +01:00 · 2023-12-22 16:15:43 +01:00 · 2023-12-22 16:05:27 +01:00
6 changed files with 62 additions and 77 deletions
--- a/.woodpecker/main.yml
+++ b/.woodpecker/main.yml
@ -0,0 +1,20 @@
+variables:
+  - &image mcr.microsoft.com/dotnet/sdk:8.0-jammy
+steps:
+  build:
+    image: *image
+    commands: dotnet build
+  test:
+    image: *image
+    commands: dotnet test --collect:"XPlat Code Coverage"
+  pack:
+    image: *image
+    commands: dotnet pack --version-suffix ci.$CI_PIPELINE_NUMBER
+  publish:
+    image: *image
+    when:
+      branch: main
+      event: push
+    commands: dotnet nuget push -s https://nuget.ellpeck.de/v3/index.json **/*.nupkg -k $BAGET_KEY -n
+    secrets:
+      - baget_key
--- a/DynamicEnums/DynamicEnum.cs
+++ b/DynamicEnums/DynamicEnum.cs
@ -105,9 +105,9 @@ namespace DynamicEnums {
        /// <returns>The newly created enum value</returns>
        /// <exception cref="ArgumentException">Thrown if the name or value passed are already present</exception>
        public static T Add<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(string name, BigInteger value) where T : DynamicEnum {
            var storage = DynamicEnum.GetStorage(typeof(T));

@ -135,9 +135,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type to add this value to</typeparam>
        /// <returns>The newly created enum value</returns>
        public static T AddValue<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(string name) where T : DynamicEnum {
            BigInteger value = 0;
            while (DynamicEnum.IsDefined(typeof(T), value))
@ -154,9 +154,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type to add this value to</typeparam>
        /// <returns>The newly created enum value</returns>
        public static T AddFlag<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(string name) where T : DynamicEnum {
            BigInteger value = 1;
            while (DynamicEnum.IsDefined(typeof(T), value))
@ -207,9 +207,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type of enum.</typeparam>
        /// <returns>All of the unique flags that make up <paramref name="combinedFlag"/>.</returns>
        public static IEnumerable<T> GetUniqueFlags<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(T combinedFlag) where T : DynamicEnum {
            // we can't use the same method here as EnumHelper.GetUniqueFlags since DynamicEnum doesn't guarantee sorted values
            var max = DynamicEnum.GetValues<T>().Max(DynamicEnum.GetValue);
@ -232,9 +232,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type of the values</typeparam>
        /// <returns>The bitwise OR (|) combination</returns>
        public static T Or<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(T left, T right) where T : DynamicEnum {
            var cache = DynamicEnum.GetStorage(typeof(T)).OrCache;
            if (!cache.TryGetValue((left, right), out var ret)) {
@ -252,9 +252,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type of the values</typeparam>
        /// <returns>The bitwise AND (&amp;) combination</returns>
        public static T And<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(T left, T right) where T : DynamicEnum {
            var cache = DynamicEnum.GetStorage(typeof(T)).AndCache;
            if (!cache.TryGetValue((left, right), out var ret)) {
@ -272,9 +272,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type of the values</typeparam>
        /// <returns>The bitwise XOR (^) combination</returns>
        public static T Xor<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(T left, T right) where T : DynamicEnum {
            var cache = DynamicEnum.GetStorage(typeof(T)).XorCache;
            if (!cache.TryGetValue((left, right), out var ret)) {
@ -291,9 +291,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type of the values</typeparam>
        /// <returns>The bitwise NEG (~) value</returns>
        public static T Neg<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(T value) where T : DynamicEnum {
            var cache = DynamicEnum.GetStorage(typeof(T)).NegCache;
            if (!cache.TryGetValue(value, out var ret)) {
@ -319,9 +319,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type that the returned dynamic enum should have</typeparam>
        /// <returns>The defined or combined dynamic enum value</returns>
        public static T GetEnumValue<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(BigInteger value) where T : DynamicEnum {
            return (T) DynamicEnum.GetEnumValue(typeof(T), value);
        }
@ -333,9 +333,9 @@ namespace DynamicEnums {
        /// <param name="value">The value whose dynamic enum value to get</param>
        /// <returns>The defined or combined dynamic enum value</returns>
        public static DynamicEnum GetEnumValue(
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            Type type, BigInteger value) {
            var storage = DynamicEnum.GetStorage(type);

@ -360,9 +360,9 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type of the dynamic enum value to parse</typeparam>
        /// <returns>The parsed enum value, or null if parsing fails</returns>
        public static T Parse<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            T>(string strg) where T : DynamicEnum {
            return (T) DynamicEnum.Parse(typeof(T), strg);
        }
@ -376,9 +376,9 @@ namespace DynamicEnums {
        /// <param name="strg">The string to parse into a dynamic enum value</param>
        /// <returns>The parsed enum value, or null if parsing fails</returns>
        public static DynamicEnum Parse(
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            Type type, string strg) {
            var cache = DynamicEnum.GetStorage(type).ParseCache;
            if (!cache.TryGetValue(strg, out var cached)) {
@ -428,9 +428,9 @@ namespace DynamicEnums {
        }

        private static DynamicEnum Construct(
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
            Type type, string name, BigInteger value) {
            return (DynamicEnum) Activator.CreateInstance(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] {name, value}, CultureInfo.InvariantCulture);
        }
@ -457,4 +457,4 @@ namespace DynamicEnums {
        }

    }
-}
+}
--- a/DynamicEnums/DynamicEnums.csproj
+++ b/DynamicEnums/DynamicEnums.csproj
@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFrameworks>net452;netstandard2.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>net452;netstandard2.0;net8.0</TargetFrameworks>
        <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <IsTrimmable>true</IsTrimmable>
+        <IsAotCompatible Condition="'$(TargetFramework)'=='net8.0'">true</IsAotCompatible>
    </PropertyGroup>
-    
+
    <PropertyGroup>
        <Authors>Ellpeck</Authors>
        <Description>Enum-like single-instance values with additional capabilities, including dynamic addition of new arbitrary values and flags</Description>
@ -13,15 +13,15 @@
        <RepositoryUrl>https://github.com/Ellpeck/DynamicEnums</RepositoryUrl>
        <PackageLicenseExpression>MIT</PackageLicenseExpression>
        <PackageReadmeFile>README.md</PackageReadmeFile>
-        <VersionPrefix>1.0.1</VersionPrefix>
+        <VersionPrefix>1.1.0</VersionPrefix>
    </PropertyGroup>
-    
+
    <ItemGroup>
        <PackageReference Include="System.ValueTuple" Version="4.5.0" Condition="'$(TargetFramework)'=='net452'" />
    </ItemGroup>
-    
-    
+
+
    <ItemGroup>
        <None Include="../README.md" Pack="true" PackagePath="" />
    </ItemGroup>
-</Project>
+</Project>
--- a/DynamicEnums/EnumHelper.cs
+++ b/DynamicEnums/EnumHelper.cs
@ -14,11 +14,11 @@ namespace DynamicEnums {
        /// <typeparam name="T">The type whose enum to get</typeparam>
        /// <returns>An enumerable of the values of the enum, in declaration order.</returns>
        public static T[] GetValues<T>() where T : struct, Enum {
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
            return Enum.GetValues<T>();
-            #else
+#else
            return (T[]) Enum.GetValues(typeof(T));
-            #endif
+#endif
        }

        /// <summary>
@ -79,4 +79,4 @@ namespace DynamicEnums {
        }

    }
-}
+}
--- a/35
+++ b/35
@ -1,35 +0,0 @@
-pipeline {
-  agent any
-  stages {
-    stage('Test') {
-      steps {
-        sh 'dotnet test --collect:"XPlat Code Coverage"'
-      }
-    }
-
-    stage('Pack') {
-      steps {
-        sh 'find . -type f -name "*.nupkg" -delete'
-        sh 'dotnet pack --version-suffix ${BUILD_NUMBER}'
-      }
-    }
-
-    stage('Publish') {
-      when {
-        branch 'main'
-      }
-      steps {
-        sh 'dotnet nuget push -s https://nuget.ellpeck.de/v3/index.json **/*.nupkg -k $BAGET -n'
-      }
-    }
-  }
-  post {
-    always {
-      nunit testResultsPattern: '**/TestResults.xml'
-      cobertura coberturaReportFile: '**/coverage.cobertura.xml'
-    }
-  }
-  environment {
-    BAGET = credentials('3db850d0-e6b5-43d5-b607-d180f4eab676')
-  }
-}
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <VSTestLogger>nunit</VSTestLogger>
        <IsPackable>false</IsPackable>
    </PropertyGroup>
-    
+
    <ItemGroup>
        <PackageReference Include="coverlet.collector" Version="3.1.2" />
        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
@ -13,7 +13,7 @@
        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
        <PackageReference Include="NunitXml.TestLogger" Version="3.0.117" />
    </ItemGroup>
-    
+
    <ItemGroup>
        <ProjectReference Include="..\DynamicEnums\DynamicEnums.csproj" />
    </ItemGroup>
Author	SHA1	Message	Date
Ell	88c75a2464	1.1.0	2023-12-22 16:21:14 +01:00
Ell	f56424cbf9	prepend "ci" to build num	2023-12-22 16:19:13 +01:00
Ell	bfa5641849	added new ci script	2023-12-22 16:15:43 +01:00
Ell	443c03b024	.net 8 update	2023-12-22 16:05:27 +01:00