Coverage report for lib/src/line_splitting/rule_set.dart

// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file

// for details. All rights reserved. Use of this source code is governed by a

// BSD-style license that can be found in the LICENSE file.

library dart_style.src.line_splitting.rule_set;

import '../rule/rule.dart';

/// An optimized data structure for storing a set of values for some rules.

///

/// This conceptually behaves roughly like a `Map<Rule, int>`, but is much

/// faster since it avoids hashing. Instead, it assumes the line splitter has

/// provided an ordered list of [Rule]s and that each rule's [index] field has

/// been set to point to the rule in the list.

///

/// Internally, this then just stores the values in a sparse list whose indices

/// are the indices of the rules.

class RuleSet {

  List<int> _values;

  /// Returns `true` of [rule] is bound in this set.

    // Treat hardened rules as implicitly bound.

  }

  /// Gets the bound value for [rule] or [Rule.unsplit] if it is not bound.

    // Hardened rules are implicitly bound.

    if (value != null) return value;

    return Rule.unsplit;

  }

  /// Invokes [callback] for each rule in [rules] with the rule's value, which

  /// will be `null` if it is not bound.

    var i = 0;

    }

  }

  /// Creates a new [RuleSet] with the same bound rule values as this one.

  /// Binds [rule] to [value] then checks to see if that violates any

  /// constraints.

  ///

  /// Returns `true` if all constraints between the bound rules are valid. Even

  /// if not, this still modifies the [RuleSet].

  ///

  /// If an unbound rule gets constrained to `-1` (meaning it must split, but

  /// can split any way it wants), invokes [onSplitRule] with it.

    // Test this rule against the other rules being bound.

      var otherValue;

      // Hardened rules are implicitly bound.

      } else {

      }

      if (otherValue == null) {

        // The other rule is unbound, so see if we can constrain it eagerly to

        // a value now.

          // If we know the rule has to split and there's only one way it can,

          // just bind that.

          } else {

          }

        } else if (constraint != null) {

          // Bind the other rule to its value and recursively propagate its

          // constraints.

        }

      } else {

        // It's already bound, so see if the new rule's constraint disallows

        // that value.

        } else if (constraint != null) {

        }

        // See if the other rule's constraint allows us to use this value.

        } else if (constraint != null) {

        }

      }

    }

    return true;

  }

}

/// For each chunk, this tracks if it has been split and, if so, what the

/// chosen column is for the following line.

///

/// Internally, this uses a list where each element corresponds to the column

/// of the chunk at that index in the chunk list, or `null` if that chunk did

/// not split. This had about a 10% perf improvement over using a [Set] of

/// splits.

class SplitSet {

  List<int> _columns;

  /// The cost of the solution that led to these splits.

  int _cost;

  /// Creates a new empty split set for a line with [numChunks].

  /// Marks the line after chunk [index] as starting at [column].

  }

  /// Returns `true` if the chunk at [splitIndex] should be split.

  /// Gets the zero-based starting column for the chunk at [index].

  /// Sets the resulting [cost] for the splits.

  ///

  /// This can only be called once.

  }

      }

    }

  }

}