xmlelement.h

/* Copyright (C) 2015 David Eller <david@larosterna.com>
 * 
 * Commercial License Usage
 * Licensees holding valid commercial licenses may use this file in accordance
 * with the terms contained in their respective non-exclusive license agreement.
 * For further information contact david@larosterna.com .
 *
 * GNU General Public License Usage
 * Alternatively, this file may be used under the terms of the GNU General
 * Public License version 3.0 as published by the Free Software Foundation and
 * appearing in the file gpl.txt included in the packaging of this file.
 */
 
#ifndef GENUA_XMLELEMENT_H
#define GENUA_XMLELEMENT_H

#include "forward.h"
#include "sharedvector.h"
#include "xcept.h"
#include "typecode.h"
#include "algo.h"

#include <map>    
#include <list>
#include <string>
#include <cstring>
#include <boost/shared_array.hpp>

class ZipFile;

class XmlElement
{
public:

  enum StorageFormat {PlainText, ZippedXml, Lz4Compressed};

  typedef boost::shared_ptr<char[]>  BlobType;

  typedef std::map<std::string, std::string> StringMap;
  typedef SharedVector<XmlElement> ElementList;
  typedef ElementList::const_iterator const_iterator;
  typedef ElementList::iterator mutable_iterator;
  typedef StringMap::const_iterator attr_iterator;

  explicit XmlElement(const std::string & tg = "") : m_tag(tg), m_nbytes(0) {}

  explicit XmlElement(std::string && tg) : m_tag(std::move(tg)), m_nbytes(0) {}

  XmlElement(const std::string & tg, const std::string & content)
    : m_tag(tg) {text(content);}

  XmlElement(XmlElement &&a) :
    m_tag(std::move(a.m_tag)), m_txt(std::move(a.m_txt)),
    m_attributes(std::move(a.m_attributes)),
    m_siblings(std::move(a.m_siblings)),
    m_typecode(a.m_typecode),
    m_blob(std::move(a.m_blob)),
    m_nbytes(a.m_nbytes) {}

  XmlElement(const XmlElement &) = default;

  XmlElement & operator= (XmlElement &&a) {
    if (&a != this) {
      m_tag = std::move(a.m_tag);
      m_txt = std::move(a.m_txt);
      m_attributes = std::move(a.m_attributes);
      m_siblings = std::move(a.m_siblings);
      m_typecode = a.m_typecode;
      m_blob = std::move(a.m_blob);
      m_nbytes = a.m_nbytes;
    }
    return *this;
  }

  XmlElement & operator= (const XmlElement &) = default;

  bool empty() const {
    return (m_siblings.size() == 0) and m_attributes.empty() and
        m_txt.empty() and (m_nbytes == 0);
  }

  const std::string & name() const {return m_tag;}

  void rename(const std::string & s) {m_tag = s;}

  bool hasAttribute(const std::string & key) const
  {return m_attributes.find(key) != m_attributes.end();}

  const std::string & attribute(const std::string & key) const;

  const std::string & attribute(const std::string & key,
                                const std::string & strDefault) const;

  attr_iterator attrBegin() const {return m_attributes.begin();}

  attr_iterator attrEnd() const {return m_attributes.end();}

  double attr2float(const std::string & key, double x) const;

  int attr2int(const std::string & key, int x) const;

  bool attr2bool(const std::string & key, bool x) const;

  template <class Streamable>
  bool fromAttribute(const std::string & key, Streamable & sth) const
  {
    attr_iterator itr = m_attributes.find(key);
    if (itr == m_attributes.end()) {
      return false;
    } else {
      std::stringstream ss;
      ss << itr->second;
      ss >> sth;
    }
    return true;
  }

  std::string & attribute(const std::string & key) {return m_attributes[key];}

  std::string & operator[] (const std::string & key) {return m_attributes[key];}

  const std::string & text() const {return m_txt;}

  std::string & text() {
    m_nbytes = 0; m_typecode = TypeCode::None; m_blob.reset();
    return m_txt;
  }

  void text(const std::string & s) {
    m_nbytes = 0;
    m_typecode = TypeCode::None;
    m_blob.reset();
    m_txt=s;
  }

  void text(const char *ptr, size_t n) {
    m_nbytes = 0;
    m_typecode = TypeCode::None;
    m_blob.reset();
    m_txt.assign(ptr, ptr+n);
  }

  const_iterator begin() const {return m_siblings.begin();}

  const_iterator end() const {return m_siblings.end();}

  const_iterator findChild(const std::string & s) const;

  const XmlElement *findNode(const std::string & path) const;

  const XmlElement *findAnyTag(const std::string &tag) const;

  mutable_iterator mbegin() {return m_siblings.begin();}

  mutable_iterator mend() {return m_siblings.end();}

  size_t append(const XmlElement & c) {
    m_siblings.push_back(c);
    return m_siblings.size() - 1;
  }

  size_t append(XmlElement &&c) {
    m_siblings.push_back(std::move(c));
    return m_siblings.size() - 1;
  }

  size_t replaceAppend(const XmlElement &c);

  XmlElement & append(const std::string &childTag,
                      const std::string &childText = std::string());

  template <class ElementType>
  XmlElement & append(const std::string &childTag,
                      size_t nvalues, const ElementType values[],
                      bool share = false)
  {
    XmlElement childElement(childTag);
    childElement["count"] = std::to_string(nvalues);
    childElement.asBinary(nvalues, values, share);
    size_t idx = this->append( std::move(childElement) );
    return m_siblings[idx];
  }

  uint children() const {return m_siblings.size();}

  void eraseChild(uint k) {
    m_siblings.erase( m_siblings.begin() + k );
  }

  void replace(uint k, const XmlElement & xe) {
    assert(k < m_siblings.size());
    m_siblings[k] = xe;
  }

  template <typename ScalarType>
  void asBinary(size_t nval, const ScalarType a[], bool share = false) {
    TypeCode tc = TypeCode::of<ScalarType>();
    m_typecode = tc.value();
    m_nbytes = nval * sizeof(ScalarType);
    if (share) {
      m_blob = BlobType((char *) a, null_deleter());
    } else {
      m_blob = BlobType(new char[m_nbytes]);
      memcpy(&m_blob[0], a, m_nbytes);
    }
    m_attributes["bdata_bytes"] = std::to_string(m_nbytes);
    m_attributes["bdata_type"] = TypeCode(m_typecode).toString();

    // default storage format is little endian
    if (is_bigendian())
      m_attributes["bdata_bigendian"] = "true";
  }

  void fetch(size_t n, int a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, uint a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, int8_t a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, uint8_t a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, int16_t a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, uint16_t a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, int64_t a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, uint64_t a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, float a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, double a[]) const {
    fetchAnything(n, a);
  }

  void fetch(size_t n, std::complex<float> a[]) const {
    fetchAnything(2*n, (float *) a);
  }

  void fetch(size_t n, std::complex<double> a[]) const {
    fetchAnything(2*n, (double *) a);
  }

  int blobType() const {return m_typecode;}

  const char *blobPointer() const {assert(m_blob); return &m_blob[0];}

  size_t blobBytes() const {return m_nbytes;}

  BlobType blob() const {return m_blob;}

  void shrink();

  void detach();

  bool read(std::istream &in, int format);

  bool write(std::ostream &os, int format) const;

  void read(const std::string & fname);

  void read(ZipFile & zf);

  void write(const std::string & fname, StorageFormat fmt) const;

  BinFileNodePtr toGbf(bool share = true) const;

  void fromGbf(const BinFileNodePtr &bfp, bool share=true);

#ifdef HAVE_HDF5

  void toHdf5(Hdf5Group &parent) const;

#endif

  // deprecated interface
  void array2text(size_t n, const double a[]) {asBinary(n, a, false);}

  // deprecated interface
  void array2text(size_t n, const float a[]) {asBinary(n, a, false);}

  // deprecated interface
  void array2text(size_t n, const int a[]) {asBinary(n, a, false);}

  // deprecated interface
  void array2text(size_t n, const uint a[]) {asBinary(n, a, false);}

  // deprecated interface
  size_t text2array(size_t n, double a[]) const {fetch(n,a); return n;}

  // deprecated interface
  size_t text2array(size_t n, float a[]) const {fetch(n,a); return n;}

  // deprecated interface
  size_t text2array(size_t n, int a[]) const {fetch(n,a); return n;}

  // deprecated interface
  size_t text2array(size_t n, uint a[]) const {fetch(n,a); return n;}

  void zwrite(const std::string & zfile, int compression = 1) const;

  void zread(const std::string & zfile);

protected:

  void zwrite(std::ostream & xs, ZipFile & zf, uint indent) const;

  void zread(ZipFile & zf);

  void xwrite(const std::string & fname) const;

  void xread(std::istream & in);

  void xwrite(std::ostream & os, uint indent=0) const;

  template <typename Scalar>
  void fetchAnything(size_t n, Scalar a[]) const {
    if (m_nbytes > 0) {
      TypeCode tc(m_typecode);
      size_t nval = m_nbytes / tc.width();
      if (nval < n)
        throw Error("XmlElement::fetch() Requested more data than stored in this node.");

      if ( not tc.extract(nval, blobPointer(), a) )
        throw Error(std::string("XmlElement::fetch() Type mismatch: ")
                    +tc.toString()+" != "+TypeCode::of<Scalar>().toString());

    } else if (not m_txt.empty()) {
      const char *pos = m_txt.c_str();
      char *tail(0);
      size_t i;
      for (i=0; i<n; ++i) {
        if (not TypeCode::fromString(pos, &tail, a[i]))
          break;
        pos = tail;
      }
      if (i < n) {
        std::string msg = "XmlElement::fetch(int) failed to find "
                          "enough elements in CDATA.";
        msg += " Node: " + name() + " Expected: " + std::to_string(n)
               + " Found: " + std::to_string(i);
        msg += " Text: " + std::string(pos).substr(0, 6) + "...";
        throw Error(msg);
      }
    }
  }

  void binaryToText(std::ostream & os) const;

private:

  std::string m_tag, m_txt;

  StringMap m_attributes;

  ElementList m_siblings;

  int m_typecode;

  BlobType m_blob;

  size_t m_nbytes;
};



#endif