---

more/net/directory.h

Go to the documentation of this file.

//  Copyright (C) 2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: directory.h,v 1.1 2002/06/02 21:43:24 petter_urkedal Exp $

#ifndef MORE_NET_DIRECTORY_H
#define MORE_NET_DIRECTORY_H

#include <more/bits/experimental.h>  // !! and just a sketch !!

namespace more {
namespace net {

  template<typename Object>
  struct dynamic_object
  {
      operator=(Object const& o) const;
  };


  struct directory
  {
      enum state_type
      {
          state_incomplete,
          state_unchanged,
          state_added,
          state_replaced,
          state_deleted
      };

      struct attribute
      {
          std::string const& key() const;
          std::string const& value() const;
          void set_value(std::string const&);
//        gistream value_streamed();
//        gostream set_value_streamed();
      private:
          state_type    m_state;
          std::string   m_key;
          std::string   m_value;
      };

      typedef std::multimap<std::string, attr_value> attr_map;

      struct entry
      {
          explicit entry(std::string const& rdn)
              : m_state(state_incomplete), m_rdn(rdn) {}

          std::string const& rdn();
          void insert(std::pair<std::string, std::string> const& attr);
          void commit();

          std::string get(std::string const& tag);
          void put(std::string const& tag, std::string const& tag);
          io::gistream get_streamed(std::string const& tag);
          io::gostream insert_streamed(std::string const& tag);

          bool operator<(entry const& rhs) const { return rdn() < rhs.rdn(); }

      private:
          state_type                    m_state;
          std::string                   m_rdn;
          attr_map                      m_attrs;
          unsigned int                  m_name_ref_cnt;
          unsigned int                  m_full_ref_cnt;
          unsigned int                  m_unfold_cnt;
      };

  private:
      typedef gen::ntree<entry, std::set> entry_tree;
      typedef entry_tree::iterator entry_iterator;
      typedef entry_tree::const_iterator entry_const_iterator;

  public:
      struct full_one_range : gen::noncopyable
      {
          typedef entry_iterator iterator;
          typedef entry_const_iterator const_iterator;

          full_one_range(directory& dir, iterator it_cxt)
              : m_dir(&dir),
                m_it_cxt(it_cxt)
          {
              m_dir->unfold(it_cxt);
          }

          full_one_range(full_one_range const& rng)
              : m_dir(rng.dir),
                m_it_cxt(rng.m_it_cxt)
          {
              m_dir->unfold(m_it_cxt);
          }

          full_one_range& operator=(full_one_range const& rng)
          {
              m_dir->fold(m_it_cxt);
              m_dir = rng.m_dir;
              m_it_cxt = rng.m_it_cxt;
              m_dir->unfold(m_it_cxt);
          }

          ~full_one_range()
          {
              m_dir->fold(m_it_cxt);
          }

          iterator begin() { return m_it_cxt->branches().begin(); }
          iterator end() { return m_it_cxt->branches().end(); }

      private:
          directory*    m_dir;
          iterator      m_it_cxt;
      };

      struct full_one_iterator
          : std::iterator<std::bidirectional_iterator_tag, entry>
      {
          full_one_iterator(directory* dir, entry_iterator const& subit)
              : m_dir(dir), m_subit(subit)
          {
              m_dir->unfold(subit);
          }

          ~full_one_iterator()
          {
              m_dir->fold(m_subit);
          }

          full_one_iterator(full_one_iterator const& it)
              : m_dir(it.m_dir),
                m_subit(it.m_subit)
          {
              ++m_subit->m_unfold_count;
          }

          full_one_iterator& operator=(full_one_iterator const& rhs)
          {
              m_dir->fold(m_subit);
              m_dir = rhs.m_dir;
              m_subit = rhs.m_subit;
              ++m_subit->m_unfold_count;
          }

          full_one_iterator& operator++() { ++m_subit; return *this; }
          full_one_iterator& operator--() { --m_subit; return *this; }

          full_one_iterator operator++(int)
          {
              full_one_iterator tmp(*this);
              ++*this;
              return tmp;
          }

          full_one_iterator operator--(int)
          {
              full_one_iterator tmp(*this);
              --*this;
              return tmp;
          }

          entry& operator*() { return *m_subit; }
          entry* operator->() { return m_subit->operator->(); }

      private:
          directory*            m_dir;
          entry_iterator        m_subit;
      };

      explicit directory(std::string server);

      iterator root() { return m_tree.root(); }
      const_iterator root() const { return m_tree.root(); }      

  private:
      void unfold(iterator it);
      void fold(iterator it);

      entry_tree m_tree;
  };

}} // ::more::net
#endif

---