Version 1.0.0

Author: bastie

Package.resolved

@@ -13,14 +13,22 @@ let package = Package(
             targets: ["LStXML2Code"]),
         .executable(name: "BMF2Code", targets: ["BMF2Code"])
     ],
+    dependencies: [
+      .package(
+        url: "https://github.com/bastie/JavApi4Swift.git",
+        from: "0.7.3"
+      )
+    ],
     targets: [
         // Targets are the basic building blocks of a package, defining a module or a test suite.
         // Targets can depend on other targets in this package and products from dependencies.
         .target(
             name: "LStXML2Code"),
         .testTarget(
             name: "LStXML2CodeTests",
-            dependencies: ["LStXML2Code"]),
+            dependencies: ["LStXML2Code",
+                       .product(name: "JavApi", package: "JavApi4Swift")
+        ]),
         .executableTarget(
           name: "BMF2Code",
           dependencies: ["LStXML2Code"]),

Package.swift

@@ -6,12 +6,14 @@ import Foundation
 import LStXML2Code
 
 @main
+/// Quelletxtgenerator zur Nutzung des durch das BMF bereitgestellten Pseudo-Quelltext zur Berechnung der Lohnsteuerabzüge bei der Einkommensteuer.
 public struct BMF2Code {
-  
-  public static let VERSION = "0.2.1"
+  /// Interne Version
+  public static let VERSION = "1.0.0"
 
 
   // MARK: main entry point
+  /// Einsprungspunkt der Kommandozeilenanwendung
   static func main () {
     var cmdLineArgs = CommandLine.arguments
 #if DEBUG
@@ -78,6 +80,11 @@ public struct BMF2Code {
 
   // MARK: handling argument
   // handwritten parameter evaluation
+  /// Evaluierung der Parameter
+  /// - Parameters:
+  /// - Parameter arguments die Argumente to verarbeitet werden sollen
+  /// - Parameter reversedCall Information, ob die Funktion sich selbst aufgerufen hat
+  /// - Returns lediglich die benötigten Parameter zur weiteren Verarbeitung
   func evalArgs (arguments : [String], reversedCall : Bool = false) -> [String:String] {
     let supportedLang = ["java", "swift"]
     let supportedLanguages = "\(supportedLang)".replacingOccurrences(of: "[", with: "").replacingOccurrences(of: "]", with: "").replacingOccurrences(of: "\"", with: "")

Sources/BMF2Code/BMF2Code.swift

@@ -5,6 +5,11 @@
 import LStXML2Code
 import Foundation
 
+
+/// Java8 Encoding
+///
+/// Das ``JavaEncoding`` nutzt den durch das [ITZBund](https://www.itzbund.de) verwendete
+/// Java8 Quelltext in den exec Anweisungen.
 open class JavaEncoding : AbstractTreeEncoding {
   public func encode(_ value: AbstractTree) throws -> Data? {
 
@@ -25,6 +30,9 @@ open class JavaEncoding : AbstractTreeEncoding {
   var result = ""
 
   var intend = 0
+  
+  /// Durchlaufen des Baumes zur Quelltextgenerierung
+  /// - Parameter node der aktuell zu betrachtende Baumknoten
   open func traverse (node : Node) {
     var output = ""
     for _ in 0..<intend {
@@ -214,8 +222,4 @@ open class JavaEncoding : AbstractTreeEncoding {
     }
 
   }
-
-  
 }
-
-

Sources/BMF2Code/JavaEncoding.swift

@@ -5,6 +5,10 @@
 import LStXML2Code
 import Foundation
 
+
+/// ``SwiftEncoding`` unter Verwendung der [JavApi⁴Swift](https://github.com/bastie/JavApi4Swift) Version 0.7.3 oder höher
+///
+/// Basis sind die Java8 Anweisungen die das [ITZBund](https://www.itzbund.de) verwendet und durch die **JavApi⁴Swift** abgebildet werden.
 open class SwiftEncoding : AbstractTreeEncoding {
   public func encode(_ value: AbstractTree) throws -> Data? {
 
@@ -13,17 +17,21 @@ open class SwiftEncoding : AbstractTreeEncoding {
           /// Generated with BMF2Code v\(BMF2Code.VERSION) @\(Date())
           
           import Foundation
+          import JavApi
+          
+          public typealias BigDecimal = java.math.BigDecimal
+          
           
           """)
     traverse(node: root)
 
-    result.append (getAdditionalTypes())
+    // not good but work - modify source after generation
 
     // add initalizer
     let parts = result.split(separator: "{",maxSplits: 1)
     result = "\(parts[0]) {\n\n"
     result.append("  public init (\n")
-    for (offset,name) in inputVars.keys.enumerated() {
+    for (offset,name) in Array(inputVars.keys).sorted(by: {$0 < $1}).enumerated() {
       result.append("    ")
       let type = inputVars[name]!
       result.append("\(name) : \(type) = \(type)()")
@@ -40,7 +48,6 @@ open class SwiftEncoding : AbstractTreeEncoding {
     result.append("}")
     result.append("\n\(parts[1])")
 
-    
     let asString = result //"\(value.getRoot())"
     return asString.data(using: .utf8)
   }
@@ -311,118 +318,4 @@ open class SwiftEncoding : AbstractTreeEncoding {
     }
     return swiftType
   }
-
-  public func getAdditionalTypes() -> String {
-    var result = ""
-    // MARK: additional Type BigInteger
-    result.append(
-    """
-    
-    /// BigDecimal implementation in Swift - see JavApi⁴Swift project
-    public struct BigDecimal : CustomStringConvertible {
-    
-      private var scale : Int = Int.max
-      private var roundingMode : Int = ROUND_UNSET
-    
-      public static let ZERO = BigDecimal(0.0)
-      public static let ONE = BigDecimal(1.0)
-      public static let ROUND_UP = 0
-      public static let ROUND_DOWN = 1
-      public static let ROUND_UNSET = -1
-
-      private var value : Double
-      public init (_ newValue : Double = 0.0) {
-        self.value = newValue
-      }
-      public init (_ newValue : Int) {
-        self.value = Double(newValue)
-      }
-      public init (_ newValue : Int64) {
-        self.value = Double(newValue)
-      }
-
-      public static func valueOf (_ newValue : Int) -> BigDecimal {
-        return BigDecimal(newValue)
-      }
-      public static func valueOf (_ newValue : Int64) -> BigDecimal {
-        return BigDecimal(newValue)
-      }
-      public static func valueOf (_ newValue : Double) -> BigDecimal {
-        return BigDecimal(newValue)
-      }
-    
-      public func subtract (_ bd : BigDecimal) -> BigDecimal {
-        let value : Double = self.value - bd.value
-        var result = BigDecimal(value)
-        result.scale = self.scale
-        result.roundingMode = self.roundingMode
-        return result
-      }
-      
-      public func multiply (_ bd : BigDecimal) -> BigDecimal{
-        let value : Double = self.value * bd.value
-        var result = BigDecimal(value)
-        result.scale = self.scale
-        result.roundingMode = self.roundingMode
-        return result
-      }
-      public func divide (_ bd : BigDecimal) -> BigDecimal{
-        let value : Double = self.value / bd.value
-        var result = BigDecimal(value)
-        result.scale = max(self.scale,bd.scale)
-        result.roundingMode = self.roundingMode
-        return result
-      }
-      public func divide (_ bd : BigDecimal, _ accuracy : Int, _ round : Int) -> BigDecimal{
-        let value : Double = self.value / bd.value
-        var result = BigDecimal(value)
-        result.scale = self.scale
-        result.roundingMode = self.roundingMode
-        return result
-      }
-      public func add (_ bd : BigDecimal) -> BigDecimal{
-        let value : Double = self.value + bd.value
-        var result = BigDecimal(value)
-        result.scale = self.scale
-        result.roundingMode = self.roundingMode
-        return result
-      }
-      public func setScale (_ newScale : Int, _ roundingMode : Int = BigDecimal.ROUND_UNSET) -> BigDecimal {
-        var result = BigDecimal(self.value)
-        result.scale = newScale
-        result.roundingMode = roundingMode
-        return result
-      }
-
-      public func compareTo (_ bg : BigDecimal) -> Int {
-        if self.roundingMode == BigDecimal.ROUND_UNSET && bg.roundingMode == BigDecimal.ROUND_UNSET {
-          if self.value == bg.value {return 0}
-          if self.value > bg.value {return 1}
-          return -1
-        }
-        let newScale = max (self.scale, bg.scale)
-        let factor : Int = (pow (10,newScale) as NSDecimalNumber).intValue
-        let quotiend : Double = Double(factor)
-        
-        let roundedSelf = Int (Double(Int(self.value * quotiend)) / quotiend)
-        let roundedBg = Int (Double(Int(bg.value * quotiend)) / quotiend)
-
-        if roundedSelf == roundedBg {return 0}
-        if roundedSelf > roundedBg {return 1}
-        return -1
-      }
-    
-      public func longValue () -> Int64 {
-        return Int64(self.value)
-      }
-    }
-    """)
-    
-    
-    // ----------------
-    return result
-  }
-
 }
-
-

Sources/BMF2Code/SwiftEncoding.swift

@@ -8,9 +8,9 @@ Die Architektur ist darauf ausgelegt die unterliegende XML Struktur der eingeles
 
 ### Überführen des XML in eine Struktur
 
-Swift unterstützt mit dem Protokoll `Codable` das (nicht ganz so) einfache Serialisieren und Deserialisieren von mehr oder weniger komplexen Strukturen. Da das Eingabeformat ein valides XML Dokument ist nutzen wir zum Einlesen statt einem `Decoder` den SAX-Parser ``PAPXmlParser``.
+Swift unterstützt mit dem Protokoll `Codable` das (nicht ganz so) einfache Serialisieren und Deserialisieren von mehr oder weniger komplexen Strukturen. Da das Eingabeformat ein valides XML Dokument ist nutzen wir zum Einlesen statt einem `Decoder` den SAX-Parser `PAPXmlParser`.
 
-Aufgabe des ``PAPXmlParser`` ist es die XML Struktur in eine Baumstruktur zu überführen, den ``PAPTree``. Der ``PAPTree`` ist als interne IO-Struktur nach außen nicht sichtbar sondern wird über die Transformation in den ``AbstractTree`` überführt. Der ``PAPTree`` implemetiert hierfür das Protokoll `Encodable`. Dies geschieht über die Implementation der Schnittstelle `Encodable` in ``AbstractTreeEncoder``, welche jedoch die eigentlich Aufgabe in die Implementierung ``AbstractTreeEncoding`` delegiert.
+Aufgabe des `PAPXmlParser` ist es die XML Struktur in eine Baumstruktur zu überführen, den ``PAPTree``. Der ``PAPTree`` ist als interne IO-Struktur nach außen nicht sichtbar sondern wird über die Transformation in den ``AbstractTree`` überführt. Der ``PAPTree`` implemetiert hierfür das Protokoll `Encodable`. Dies geschieht über die Implementation der Schnittstelle `Encodable` in ``AbstractTreeEncoder``, welche jedoch die eigentlich Aufgabe in die Implementierung ``AbstractTreeEncoding`` delegiert.
 
 **Nur die ``AbstractTreeEncoding`` Implementation bedarf einer Anpassung, bei nicht strukturellen Änderungen dess XML.**
 

Sources/LStXML2Code/LStXML2Code.docc/Architecture.md

@@ -1,10 +1,13 @@
 import XCTest
 @testable import LStXML2Code
 
+import JavApi
+
 final class LStXML2CodeTests: XCTestCase {
     func testExample() throws {
-      let calculator = Lohnsteuer2023AbJuliBig(LZZ: 1, STKL : 1, RE4:BigDecimal(2500000))
+      let calculator = Lohnsteuer2023AbJuliBig(LZZ: 1,RE4: java.math.BigDecimal(2500000),STKL: 1)
       calculator.MAIN()
+      /*
       print (
       """
       BK       = \(calculator.BK)
@@ -25,6 +28,27 @@ final class LStXML2CodeTests: XCTestCase {
       WVFRBO   = \(calculator.WVFRBO)
       WVFRBM   = \(calculator.WVFRBM)
       """)
+      */
+      
+      // must be set
+      XCTAssertEqual(calculator.VFRB, 123000)
+      XCTAssertEqual(calculator.LSTLZZ, 176700)
+      XCTAssertEqual(calculator.WVFRB, 834700)
+      // must be zero
+      XCTAssertEqual(calculator.BK, 0)
+      XCTAssertEqual(calculator.BKS, 0)
+      XCTAssertEqual(calculator.BKV, 0)
+      XCTAssertEqual(calculator.SOLZLZZ, 0)
+      XCTAssertEqual(calculator.SOLZS, 0)
+      XCTAssertEqual(calculator.SOLZV, 0)
+      XCTAssertEqual(calculator.STS, 0)
+      XCTAssertEqual(calculator.STV, 0)
+      XCTAssertEqual(calculator.VKVLZZ, 0)
+      XCTAssertEqual(calculator.VKVSONST, 0)
+      XCTAssertEqual(calculator.VFRBS1, 0)
+      XCTAssertEqual(calculator.VFRBS2, 0)
+      XCTAssertEqual(calculator.WVFRBO, 0)
+      XCTAssertEqual(calculator.WVFRBM, 0)
     }
 }