C# Layer tools Rhino

class justToCreateAClass {
  /// <summary>
  /// Copy properties from layer From to Layer To
  /// </summary>
  /// <param name="From"></param>
  /// <param name="To"></param>
  void MatchProperties(Layer From, Layer To) {
    To.Color = From.Color;
    To.RenderMaterialIndex = From.RenderMaterialIndex;
    To.IsExpanded = false;
    To.CommitChanges();
  }

  /// <summary>
  /// Find a layer by name
  /// </summary>
  /// <param name="name"></param>
  /// <returns></returns>
  Layer FindLayer(string name, bool isRoot) {
    int id = RhinoDocument.Layers.Find(name, true);
    if (id >= 0 && (!isRoot || RhinoDocument.Layers[id].ParentLayerId.Equals(Guid.Empty))) {
      return RhinoDocument.Layers[id];
    } else {
      return null;
    }
  }

  Layer EnsureLayer(string name) {
    return EnsureLayer(name, false);
  }

  /// <summary>
  /// Make sure layer "name" exists, find it, or create a new one.
  /// </summary>
  /// <param name="name"></param>
  /// <param name="isRoot">Make sure the layer is not a sublayer</param>
  /// <returns></returns>
  Layer EnsureLayer(string name, bool isRoot) {
    Layer l = FindLayer(name, isRoot);
    if (l == null) {
      l = new Layer();
      l.Name = name;
      int id = RhinoDocument.Layers.Add(l);
      l = RhinoDocument.Layers[id];
    }
    return l;
  }

  /// <summary>
  /// EnsureFullPath: Make sure the full path exists.
  /// </summary>
  /// <param name="name"></param>
  /// <returns></returns>
  Layer EnsureFullPath(string name) {
    Layer l = FindLayerByFullPath(name);
    if (l == null) {
      string[] segments = System.Text.RegularExpressions.Regex.Split(name, "::");
      string layerPath = segments[0];
      Layer CurrentLayer = EnsureLayer(layerPath, true);
      for (int i = 1; i < segments.Length; i++) {
        CurrentLayer = EnsureChildLayer(CurrentLayer, segments[i]);
      }
      l = CurrentLayer;
    }
    return l;
  }

  /// <summary>
  /// Find layer by full path
  /// </summary>
  /// <param name="name"></param>
  /// <returns></returns>
  Layer FindLayerByFullPath(string name) {
    int id = RhinoDocument.Layers.FindByFullPath(name, true);
    if (id >= 0) {
      return RhinoDocument.Layers[id];
    }
    return null;
  }

  /// <summary>
  /// Recurse all child layers
  /// </summary>
  /// <param name="parent"></param>
  /// <returns></returns>
  public IEnumerable<Layer> RecurseChildren(Layer parent) {
    foreach (Layer child in parent.GetChildren()) {
      yield return child;

      if (child.GetChildren() != null) {
        foreach (Layer grandchild in RecurseChildren(child)) {
          yield return grandchild;
        }
      }
    }
  }

  /// <summary>
  /// Find layer of parent by names
  /// </summary>
  /// <param name="parent"></param>
  /// <param name="name"></param>
  /// <returns></returns>
  public Layer FindChildLayer(Layer parent, string name) {
    if (parent.GetChildren() == null) {
      return null;
    }
    foreach (Layer child in parent.GetChildren()) {
      if (child.Name.Equals(name)) {
        return child;
      }
    }
    return null;
  }

  /// <summary>
  /// Make sure all child layers exist
  /// </summary>
  /// <param name="parent"></param>
  /// <param name="names"></param>
  /// <returns></returns>
  public IEnumerable<Layer> EnsureChildLayers(Layer parent, IEnumerable<string> names) {
    List<Layer> layers = new List<Layer>();
    foreach (string name in names) {
      layers.Add(EnsureChildLayer(parent, name));
    }
    return layers;
  }

  /// <summary>
  /// Make sure one child layer exists
  /// </summary>
  /// <param name="parent"></param>
  /// <param name="name"></param>
  /// <returns></returns>
  public Layer EnsureChildLayer(Layer parent, string name) {
    Layer child = FindChildLayer(parent, name);
    if (child == null) {
      child = new Layer();
      child.Name = name;
      child.ParentLayerId = parent.Id;
      int id = RhinoDocument.Layers.Add(child);
      child = RhinoDocument.Layers[id];
    }
    return child;
  }
}