hamann-ausgabe-core/HaDocument/Reactors/TraditionsReactor.cs

using HaDocument.Models;
using System.Collections.Generic;
using HaXMLReader.EvArgs;
using HaXMLReader.Interfaces;
using System;

namespace HaDocument.Reactors
{
    class TraditionsReactor : Reactor
    {
        internal Dictionary<string, Tradition> CreatedInstances;
        internal Dictionary<string, Dictionary<string, HashSet<string>>> CreatedStructure;
        private bool _normalizeWhitespace = false;

        // State
        private string Index = "";

        private string _page = "";
        private string _line = "";

        private ElementStringBinder _element = null;

        internal TraditionsReactor(IReader reader, IntermediateLibrary lib, bool normalizeWhitespace) : base(reader, lib)
        {
            _normalizeWhitespace = normalizeWhitespace;
            _lib.Traditions = new Dictionary<string, Tradition>();
            if (lib.LetterPageLines == null)
                lib.LetterPageLines = new Dictionary<string, Dictionary<string, HashSet<string>>>();
            CreatedInstances = _lib.Traditions;
            CreatedStructure = lib.LetterPageLines;
            reader.Tag += Listen;
        }

        protected override void Listen(object sender, Tag tag)
        {
            if (!tag.EndTag &&
                !tag.IsEmpty &&
                tag.Name == "letterTradition" &&
                !String.IsNullOrWhiteSpace(tag["ref"])
            )
            {
                Activate(_reader, tag);
            }
            else if (
                !tag.EndTag &&
                _active &&
                tag.Name == "ZHText"
            )
            {
                if (!CreatedStructure.ContainsKey(tag["index"]))
                    this.CreatedStructure.Add(tag["index"], new Dictionary<string, HashSet<string>>());
            }
            else if (
                !tag.EndTag &&
                _active &&
                tag.Name == "line" &&
                !String.IsNullOrWhiteSpace(tag["index"])
            )
            {
                _line = tag["index"];
                if (!CreatedStructure[Index][_page].Contains(_line))
                {
                    CreatedStructure[Index][_page].Add(_line);
                }
            }
            else if (
                !tag.EndTag &&
                _active &&
                tag.Name == "page" &&
                !String.IsNullOrWhiteSpace(tag["index"])
            )
            {
                _page = tag["index"];
                if (!CreatedStructure[Index].ContainsKey(_page))
                {
                    CreatedStructure[Index].Add(_page, new HashSet<string>());
                }
            }
        }

        protected override void Activate(IReader reader, Tag tag)
        {
            if (!_active && reader != null && tag != null)
            {
                _active = true;
                Index = tag["ref"];
                _element = new ElementStringBinder(reader, tag, Add, _normalizeWhitespace);
            }
        }

        private void Add(string element)
        {
            if (String.IsNullOrWhiteSpace(element)) return;
            var reason = new Tradition(
                Index,
                element);
            CreatedInstances.TryAdd(Index, reason);
            Reset();
        }

        protected override void Reset()
        {
            Index = "";
            _page = "";
            _line = "";
            _active = false;
            _element = null;
        }

        protected void Deactivate()
        {
            _element.Unsubscribe();
            Reset();
        }
    }
}