You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@daffodil.apache.org by mb...@apache.org on 2019/11/08 14:29:57 UTC

[incubator-daffodil] 02/06: Delete ChoOrd dead code file.

This is an automated email from the ASF dual-hosted git repository.

mbeckerle pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-daffodil.git

commit b088d2edab3e5f12e5ab75efcab38224abddad96
Author: Michael Beckerle <mb...@tresys.com>
AuthorDate: Tue Nov 5 09:22:03 2019 -0500

    Delete ChoOrd dead code file.
---
 .../scala/org/apache/daffodil/dsom/ChoOrd.scala    | 134 ---------------------
 1 file changed, 134 deletions(-)

diff --git a/daffodil-core/src/main/scala/org/apache/daffodil/dsom/ChoOrd.scala b/daffodil-core/src/main/scala/org/apache/daffodil/dsom/ChoOrd.scala
deleted file mode 100644
index 7088504..0000000
--- a/daffodil-core/src/main/scala/org/apache/daffodil/dsom/ChoOrd.scala
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * 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
- *
- *     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.
- */
-
-package org.apache.daffodil.dsom
-
-import org.apache.daffodil.exceptions.Assert
-
-/**
- * ChoOrd = Choice or Ordered
- *
- * This is a tree representing elements as they appear in ordered
- * sequences or as alternatives to each other.
- *
- * This does not directly correspond to the xs:choice and xs:sequence
- * constructs of a DFDL Schema, though that can be the origin.
- *
- * The purpose of these ChoOrd trees is to establish some
- * robust invariants about the way these are nested.
- *
- * These invariants include:
- * * Elements are at the leaves.
- * * There is no unnecessary nesting. So an Ord only contains
- * leaves or Cho, and a Cho only contains leaves or Ord.
- * * There are no degenerate Cho or Ord with only 1 thing in them. Those get created
- * but squeezed out.
- */
-sealed trait ChoOrd
-case class Ord(s: Seq[ChoOrd]) extends ChoOrd {
-  Assert.invariant(s.find { _.isInstanceOf[Ord] }.isEmpty)
-}
-case class Cho(s: Seq[ChoOrd]) extends ChoOrd {
-  Assert.invariant(s.find { _.isInstanceOf[Cho] }.isEmpty)
-}
-case class Leaf(e: ElementBase) extends ChoOrd
-
-object ChoOrd {
-
-  object MT extends ChoOrd
-
-  def mkCho(s: Seq[ChoOrd]) =
-    if (s.isEmpty) MT
-    else {
-      val c = s.flatMap {
-        case MT => Nil
-        case Ord(Seq(x)) => Seq(x)
-        case Cho(c) => c
-        case x => Seq(x)
-      }
-      c match {
-        case Seq(ch @ Cho(_)) => ch
-        case _ => Cho(c)
-      }
-    }
-
-  def mkOrd(s: Seq[ChoOrd]) =
-    if (s.isEmpty) MT
-    else {
-      val c = s.flatMap {
-        case MT => Nil
-        case Cho(Seq(x)) => Seq(x)
-        case Ord(c) => c
-        case x => Seq(x)
-      }
-      c match {
-        case Seq(ord @ Ord(_)) => ord
-        case _ => Ord(c)
-      }
-    }
-
-  /**
-   * Leaf objects that are adjacent within an Ord, and which satisfy the test
-   * are coalesced into an Ord.
-   *
-   * This is used to change the Ord from representing elements in schema order
-   * to representing all possible next elements - by grouping together adjacent
-   * optional elements.
-   */
-  def groupAdjacentSatisfying(t: ChoOrd, test: Leaf => Boolean): ChoOrd = t match {
-    case ChoOrd.MT => t
-    case l: Leaf => l
-    case Cho(members) => mkCho(members.map { m => groupAdjacentSatisfying(m, test) })
-    case Ord(members) => {
-      val nestedRuns =
-        //
-        // This algorithm was surprisingly tricky - coalesce while preserving order,
-        // the adjacent leaves satisfying a predicate.
-        //
-        members.foldLeft(
-          Nil.asInstanceOf[Seq[Seq[ChoOrd]]]) {
-            // cases are on (accumulatingRuns, nextChoOrd) and produce accumulatingRuns
-            // where the first run is lengthened, or a new run is created
-            case (Seq(), choOrd) => Seq(Seq(choOrd))
-            case (Seq(priorRun @ Seq(prior: Leaf, restRun @ _*), restRuns @ _*), next: Leaf) if test(prior) && test(next) => {
-              //
-              // incorporate into current run
-              //
-              val thisRun = next +: prior +: restRun
-              val allRuns = thisRun +: restRuns // lengthen current run
-              allRuns
-            }
-            case (restRuns, next) => {
-              //
-              // start a new run
-              //
-              val thisRun = Seq(next)
-              val allRuns = thisRun +: restRuns
-              allRuns
-            }
-          }.map { _.reverse }.reverse
-      val res = mkOrd(nestedRuns.map { seq =>
-        seq match {
-          case Seq(justOne) => justOne
-          case s => mkCho(s)
-        }
-      })
-      res
-    }
-  }
-
-}