Das BGB als XML

(Verwendungsbeispiel)

Wer, aus welchen Gründen auch immer, das bürgerliche Gesetzbuch in seine Anwendung implementieren will, der wird sich über das “BGB als XML” freuen.

Download als .zip-Archiv
Download als .xml (ca. 3,3 MB)

Dank des universellen XML-Formats kann das BGB plattform- und programmiersprachenunabhängig eingebunden werden. Der einfachheit halber enthält es kein Inhaltsverzeichnis und keine Hierarchie. Es beschränkt sich lediglich auf die Normen und handelt sich um die aktuellste Ausgabe zum Zeitpunkt der Erstellung (Juli 2012).

So schaut beispielsweise ein XML-Knoten (“Norm”) aus:

    
      (1) Der Finder kann von dem Empfangsberechtigten einen Finderlohn
verlangen. Der Finderlohn beträgt von dem Werte der Sache bis zu 500
Euro fünf vom Hundert, von dem Mehrwert drei vom Hundert, bei Tieren
drei vom Hundert. Hat die Sache nur für den Empfangsberechtigten einen
Wert, so ist der Finderlohn nach billigem Ermessen zu bestimmen.
(2) Der Anspruch ist ausgeschlossen, wenn der Finder die Anzeigepflicht
verletzt oder den Fund auf Nachfrage verheimlicht.
      Neugefasst durch Bek. v. 2.1.2002 I 42
      § 971
      
    

Wer seine Anwendung ohnehin in C# .NET schreibt, der kann direkt meinen Deserializer und die dazugehörige Wrapperklasse verwenden:

 
[Serializable]
    public class BGB
    {
        private List<Norm> _Normen;

        public List<Norm> Normen
        {
            get { return _Normen; }
            set { _Normen = value; }
        }

        [Serializable]
        public class Norm
        {
            private string _text;

            public string Text
            {
                get { return _text; }
                set { _text = value; }
            }

            private string _appendix;

            public string Appendix
            {
                get { return _appendix; }
                set { _appendix = value; }
            }

            private string _paragraph;

            public string Paragraph
            {
                get { return _paragraph; }
                set { _paragraph = value; }
            }

            private string _title;

            public string Title
            {
                get { return _title; }
                set { _title = value; }
            }
        }

        public BGB()
        {
            _Normen = new List<Norm>();
        }

        public void AddNorm(Norm Norm)
        {
            _Normen.Add(Norm);
        }
    }

Der (De-)Serializer:

 
public class Serializer
    {
        public void SerializeToXMLString<T>(T XMLObj, Stream s, Encoding encoding, bool removeNamespace)
        {
            try
            {
                XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
                XmlTextWriter xmlSink = new XmlTextWriter(s, encoding);
                xmlSink.Formatting = Formatting.Indented;

                if (removeNamespace)
                {
                    XmlSerializerNamespaces xs = new XmlSerializerNamespaces();
                    xs.Add("", "");
                    xmlSerializer.Serialize(xmlSink, XMLObj, xs);
                }
                else
                    xmlSerializer.Serialize(xmlSink, XMLObj);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);

                if (ex.InnerException != null)
                    Console.WriteLine(ex.InnerException);
            }
        }

        public void SerializeObjectToXMLFile<T>(T XMLObj, string Filename, Encoding encoding, bool removeNamespace)
        {
            FileStream fs = new FileStream(Filename, FileMode.Create);
            SerializeToXMLString<T>(XMLObj, fs, encoding, removeNamespace);
        }

        public void SerializeObjectToXMLFile<T>(T o, string Filename)
        {
            SerializeObjectToXMLFile<T>(o, Filename, Encoding.Unicode, true);
        }

        private MemoryStream GetUTF16MS(string xml)
        {
            // Encode the XML string in a UTF-8 byte array
            byte[] encodedString = Encoding.Unicode.GetBytes(xml);

            // Put the byte array into a stream and rewind it to the beginning
            MemoryStream ms = new MemoryStream(encodedString);
            ms.Flush();
            ms.Position = 0;
            return ms;
        }

        private bool DeserializeFromXMLString<T>(string XML, ref T myObject, bool allow_log)
        {
            if (XML == string.Empty)
                return false;

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
            MemoryStream ms = GetUTF16MS(XML);

            try
            {
                XmlReader xmlReader = XmlReader.Create(ms);
                while (xmlReader.Read())
                { }

                ms.Position = 0;
            }
            catch (Exception ex)
            {
                if (allow_log)
                    Console.WriteLine(ex.Message);

                return false;
            }

            //StringReader sr = new StringReader(XML);
            //myObject = (T)xmlSerializer.Deserialize(sr);
            myObject = (T)xmlSerializer.Deserialize(ms);

            return true;
        }

        public bool deserializeObjectByXML<T>(string data, ref T myObject, bool allow_log)
        {
            return DeserializeFromXMLString(data, ref myObject, allow_log);
        }
    }