HDFAttributes.cc

/*
 * $Id: HDFAttributes.cc,v 1.8 2006/03/29 14:21:35 brook Exp $
 */

/*
 * ClearSilver++ Software License.
 *
 * Copyright (c) 2005,2006 Brook Milligan <brook@nmsu.edu>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "HDFAttributes.h"
#include <stdexcept>
#include <string>
#include <string.h>
#include <ClearSilver/util/neo_hdf.h>
#include "ClearSilverError.h"
#include "ClearSilverException.h"

#if HAVE_BROKEN_HDF_SET_ATTR
static NEOERR* XXX_hdf_set_attr (HDF *hdf, const char *name,
                                 const char *key, const char *value);
#endif // HAVE_BROKEN_HDF_SET_ATTR

namespace ClearSilver
{

  // constructors
  HDFAttributes::HDFAttributes ()
    : path_(), head_(0) {}

  HDFAttributes::HDFAttributes (const Nodes& path, _attr* head)
    : path_(path), head_(head) {}

  HDFAttributes::HDFAttributes (const HDFAttributes& a)
    : path_(a.path_), head_(a.head_) {}

  HDFAttributes::~HDFAttributes () throw() {}

  // assignment
  HDFAttributes&
  HDFAttributes::operator = (const HDFAttributes& a)
  {
    HDFAttributes a_(a);
    swap (a_);
    return *this;
  }

  // swap contents
  void
  HDFAttributes::swap (HDFAttributes& a) throw()
  {
    std::swap (path_, a.path_);
    std::swap (head_, a.head_);
  }

  HDFAttributes::size_type
  HDFAttributes::size () const
  {
    HDF_ATTR* node = head_;
    size_type n = 0;
    while (node != 0)
      {
        ++n;
        node = node->next;
      }
    return n;
  }

  // is the container empty?
  bool
  HDFAttributes::empty () const
  {
    return head_ == 0;
  }

  HDFAttributes::size_type
  HDFAttributes::count (const key_type& key)
  {
    HDF_ATTR* node = head_;
    size_type n = 0;
    while (node != 0)
      {
        if (strcmp (key, node->key) == 0)
          ++n;
        node = node->next;
      }
    return n;
  }

  HDFAttributes::iterator
  HDFAttributes::find (const key_type& key)
  {
    HDF_ATTR* node = head_;
    while (node != 0)
      {
        if (strcmp (key, node->key) == 0)
          return iterator (node);
        node = node->next;
      }
    return iterator();
  }

  HDFAttributes::const_iterator
  HDFAttributes::find (const key_type& key) const
  {
    HDF_ATTR* node = head_;
    while (node != 0)
      {
        if (strcmp (key, node->key) == 0)
          return const_iterator (node);
        node = node->next;
      }
    return const_iterator();
  }

  HDFAttributes::mapped_type
  HDFAttributes::operator [] (const key_type& key)
  {
    iterator i = find (key);
    if (i)
      return i.value_->second;

    ClearSilverError error (hdf_set_attr (path_.top().top().get(),
                                          path_.path().c_str(), key, ""));
    if (error)
      {
        std::string message;
        message += "ClearSilver::HDFAttributes::operator[](const key_type&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
    i = find (key);
    return i.value_->second;
  }

  HDFAttributes::iterator
  HDFAttributes::begin ()
  {
    return iterator (head_);
  }

  HDFAttributes::iterator
  HDFAttributes::end ()
  {
    return iterator();
  }

  HDFAttributes::const_iterator
  HDFAttributes::begin () const
  {
    return const_iterator (head_);
  }

  HDFAttributes::const_iterator
  HDFAttributes::end () const
  {
    return const_iterator();
  }

  std::pair<HDFAttributes::iterator,bool>
  HDFAttributes::insert (const value_type& value)
  {
    iterator i = find (value.first);
    if (i)
      return std::pair<HDFAttributes::iterator,bool>(i, false);
#if HAVE_BROKEN_HDF_SET_ATTR
    ClearSilverError error (XXX_hdf_set_attr (path_.top().get(), 0,
                                              value.first, value.second));
#else // HAVE_BROKEN_HDF_SET_ATTR
    ClearSilverError error (hdf_set_attr (path_.top().top().get(),
                                          path_.path().c_str(),
                                          value.first, value.second));
#endif // HAVE_BROKEN_HDF_SET_ATTR
    if (error)
      {
        std::string message;
        message += "ClearSilver::HDFAttributes::insert(const value_type&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
    i = find (value.first);
    return std::pair<HDFAttributes::iterator,bool>(i, true);
  }

  // XXX - ignore hint
  HDFAttributes::iterator
  HDFAttributes::insert (iterator, const value_type& value)
  {
    return insert (value).first;
  }

  HDFAttributes::size_type
  HDFAttributes::erase (const key_type& key) throw()
  {
    iterator i = find (key);
    if (i)
      {
        erase (i);
        return 1;
      }
    else
      return 0;
  }

  void
  HDFAttributes::erase (iterator i)
  {
    if (i == begin())           // must advance head_
      head_ = head_->next;

#if HAVE_BROKEN_HDF_SET_ATTR
    ClearSilverError error (XXX_hdf_set_attr (path_.top().get(), 0,
                                              i.value_->first, 0));
#else // HAVE_BROKEN_HDF_SET_ATTR
    ClearSilverError error (hdf_set_attr (path_.top().top().get(),
                                          path_.path().c_str(),
                                          i.value_->first, 0));
#endif // HAVE_BROKEN_HDF_SET_ATTR
    if (error)
      {
        std::string message;
        message += "ClearSilver::HDFAttributes::erase(iterator): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
  }

  void
  HDFAttributes::erase (iterator begin, iterator end)
  {
    while (begin != end)
      {
        iterator i = begin++;
        erase (i);
      }
  }

  void
  HDFAttributes::clear () throw()
  {
    erase (begin(), end());
  }

  bool
  operator == (const HDFAttributes& a1, const HDFAttributes& a2)
  {
    return a1.head_ == a2.head_;
  }

  bool&
  HDFAttributes::debug ()
  {
    static bool debug_ = false;
    return debug_;
  }


  HDFAttributes::mapped_type::mapped_type ()
    : value_(0), valuep_(&value_) {}
  HDFAttributes::mapped_type::mapped_type (const char* v)
    : value_(strdup(v)), valuep_(&value_) {}
  HDFAttributes::mapped_type::mapped_type (std::string v)
    : value_(strdup(v.c_str())), valuep_(&value_) {}
  HDFAttributes::mapped_type::mapped_type (char** v)
    : value_(0), valuep_(v)
    {
      if (!valuep_ || !*valuep_)
        {
          std::string message;
          message += "ClearSilver::HDFAttributes::mapped_type::mapped_type ";
          message += "(char**): ";
          message += "nil pointer argument";
          throw std::invalid_argument (message);
        }
    }
  HDFAttributes::mapped_type::mapped_type (const mapped_type& v)
    : value_(0), valuep_(&value_)
  {
    if (*v.valuep_ == v.value_) // v owns its data
      value_ = strdup(v.value_);
    else
      valuep_ = v.valuep_;
  }
HDFAttributes::mapped_type::~mapped_type () throw()
    {
      if (value_)
        free(value_);
    }
  HDFAttributes::mapped_type&
  HDFAttributes::mapped_type::operator = (const mapped_type& v)
  {
    mapped_type v_(v);
    swap(v_);
    return *this;
  }
  HDFAttributes::mapped_type&
  HDFAttributes::mapped_type::operator = (const char* v)
  {
    if (!v)
      {
        std::string message;
        message += "ClearSilver::HDFAttributes::mapped_type::operator = ";
        message += "(const char*): ";
        message += "nil pointer argument";
        throw std::invalid_argument (message);
      }
    
    char* v_ = strdup(v);
    free (*valuep_);
    *valuep_ = v_;
    return *this;
  }
  void
  HDFAttributes::mapped_type::swap (mapped_type& v) throw()
  {
    std::swap (value_, v.value_);
    std::swap (valuep_, v.valuep_);
  }
  HDFAttributes::mapped_type::operator char* ()
  {
    return *valuep_;
  }
  HDFAttributes::mapped_type::operator const char* () const
  { return *valuep_; }


  HDFAttributes::iterator::iterator () : node_(0), value_() {}

  HDFAttributes::iterator::iterator (_attr* node)
    : node_(node), value_()
  {
    if (node_)
      value_ =
        boost::shared_ptr<value_type>
        (new value_type(node_->key, &node_->value));
  }

  HDFAttributes::iterator::iterator (const iterator& i)
    : node_(i.node_), value_(i.value_) {}

  HDFAttributes::iterator::~iterator () throw() {}

  HDFAttributes::iterator::iterator&
  HDFAttributes::iterator::operator = (const iterator& i)
  {
    HDFAttributes::iterator i_(i);
    swap(i_);
    return *this;
  }

  void
  HDFAttributes::iterator::swap (iterator& i) throw ()
  {
    std::swap (node_, i.node_);
    std::swap (value_, i.value_);
  }

  HDFAttributes::iterator::operator bool () const
  {
    return node_ != 0;
  }

  HDFAttributes::value_type
  HDFAttributes::iterator::operator * ()
  {
    return *value_;
  }

  HDFAttributes::value_type*
  HDFAttributes::iterator::operator -> ()
  {
    return value_.get();
  }

  HDFAttributes::iterator&
  HDFAttributes::iterator:: operator ++ ()
  {
    if (node_)
      {
        if (node_->next)
          {
            HDFAttributes::iterator i (node_->next);
            swap (i);
          }
        else
          { 
            HDFAttributes::iterator i;
            swap (i);
          }
      }
    return *this;
  }

  HDFAttributes::iterator
  HDFAttributes::iterator::operator ++ (int)
  {
    HDFAttributes::iterator i (*this);
    operator ++();
    return i;
  }

  bool
  operator == (const HDFAttributes::iterator& i1,
               const HDFAttributes::iterator& i2)
  {
    return i1.node_ == i2.node_;
  }


  HDFAttributes::const_iterator::const_iterator () : node_(0), value_() {}

  HDFAttributes::const_iterator::const_iterator (_attr* node)
    : node_(node), value_()
  {
    if (node_)
      value_ =
        boost::shared_ptr<value_type>
        (new value_type(node_->key, &node_->value));
  }

  HDFAttributes::const_iterator::const_iterator (const const_iterator& i)
    : node_(i.node_), value_(i.value_) {}

  HDFAttributes::const_iterator::~const_iterator () throw() {}

  HDFAttributes::const_iterator::const_iterator&
  HDFAttributes::const_iterator::operator = (const const_iterator& i)
  {
    HDFAttributes::const_iterator i_(i);
    swap(i_);
    return *this;
  }

  void
  HDFAttributes::const_iterator::swap (const_iterator& i) throw ()
  {
    std::swap (node_, i.node_);
    std::swap (value_, i.value_);
  }

  HDFAttributes::const_iterator::operator bool () const
  {
    return node_ != 0;
  }

  HDFAttributes::value_type
  HDFAttributes::const_iterator::operator * ()
  {
    return *value_;
  }

  HDFAttributes::value_type*
  HDFAttributes::const_iterator::operator -> ()
  {
    return value_.get();
  }

  HDFAttributes::const_iterator&
  HDFAttributes::const_iterator:: operator ++ ()
  {
    if (node_)
      {
        if (node_->next)
          {
            HDFAttributes::const_iterator i (node_->next);
            swap (i);
          }
        else
          { 
            HDFAttributes::const_iterator i;
            swap (i);
          }
      }
    return *this;
  }

  HDFAttributes::const_iterator
  HDFAttributes::const_iterator::operator ++ (int)
  {
    HDFAttributes::const_iterator i (*this);
    operator ++();
    return i;
  }

  bool
  operator == (const HDFAttributes::const_iterator& i1,
               const HDFAttributes::const_iterator& i2)
  {
    return i1.node_ == i2.node_;
  }

};                              // namespace ClearSilver

#if HAVE_BROKEN_HDF_SET_ATTR

/*
 * The following function is to replace the analogous one from the
 * ClearSilver C library which is broken, at least in v0.9.14 and
 * v0.10.3.  In particular, the head of the list is advanced
 * incorrectly by the library version (see below).  Because this
 * version is only for use by the erase() method above and the actual
 * node is known, the argument list is slightly different from the
 * original.  Specifically, the correct node is known by the caller
 * and need not be found by walking the list.  The correct node is
 * therefore passed as the hdf argument and the name argument is
 * ignored.  Except for the lines marked with XXX below, this function
 * is a verbatim copy from the C library v0.9.14.  As soon as this bug
 * is fixed, this code will be removed from here.
 */

NEOERR* XXX_hdf_set_attr (HDF *hdf, const char *name, const char *key, const char *value)
{
  HDF *obj = hdf;               // XXX - don't walk the tree for this version
  HDF_ATTR *attr, *last;

  // _walk_hdf(hdf, name, &obj);        // XXX - see above
  if (obj == NULL) 
    return nerr_raise(NERR_ASSERT, "Unable to set attribute on none existant node");

  if (obj->attr != NULL)
  {
    attr = obj->attr;
    last = attr;
    while (attr != NULL)
    {
      if (!strcmp(attr->key, key))
      {
        if (attr->value) free(attr->value);
        /* a set of NULL deletes the attr */
        if (value == NULL)
        {
          if (attr == obj->attr) // XXX - originally if (last == obj->attr)
            obj->attr = attr->next;
          else
            last->next = attr->next;
          free(attr->key);
          free(attr);
          return STATUS_OK;
        }
        attr->value = strdup(value);
        if (attr->value == NULL)
          return nerr_raise(NERR_NOMEM, "Unable to set attr %s to %s", key, value);
        return STATUS_OK;
      }
      last = attr;
      attr = attr->next;
    }
    last->next = (HDF_ATTR *) calloc(1, sizeof(HDF_ATTR));
    if (last->next == NULL)
      return nerr_raise(NERR_NOMEM, "Unable to set attr %s to %s", key, value);
    attr = last->next;
  }
  else
  {
    if (value == NULL) return STATUS_OK;
    obj->attr = (HDF_ATTR *) calloc(1, sizeof(HDF_ATTR));
    if (obj->attr == NULL)
      return nerr_raise(NERR_NOMEM, "Unable to set attr %s to %s", key, value);
    attr = obj->attr;
  }
  attr->key = strdup(key);
  attr->value = strdup(value);
  if (attr->key == NULL || attr->value == NULL)
    return nerr_raise(NERR_NOMEM, "Unable to set attr %s to %s", key, value);

  return STATUS_OK;
}
#endif // HAVE_BROKEN_HDF_SET_ATTR

---