// -*- C++ -*-
/*****************************************************************************\
 * Copyright (c) 2004 Mark Aylett <mark@emantic.co.uk>                       *
 *                                                                           *
 * Permission is hereby granted, free of charge, to any person obtaining a   *
 * copy of this software and associated documentation files (the             *
 * "Software"), to deal in the Software without restriction, including       *
 * without limitation the rights to use, copy, modify, merge, publish,       *
 * distribute, sublicense, and/or sell copies of the Software, and to permit *
 * persons to whom the Software is furnished to do so, subject to the        *
 * following conditions:                                                     *
 *                                                                           *
 * The above copyright notice and this permission notice shall be included   *
 * in all copies or substantial portions of the Software.                    *
 *                                                                           *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS   *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN *
 * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,  *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR     *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                    *
\*****************************************************************************/

/**
 * \file mar_index_cpp.h
 * \brief TODO
 */

#ifndef INCLUDED_MAR_INDEX_CPP
#define INCLUDED_MAR_INDEX_CPP

#ifndef INCLUDED_MAR_ITERATOR_CPP
#include "mar_iterator_cpp.h"
#endif // INCLUDED_MAR_ITERATOR_CPP

#ifndef INCLUDED_MAR_UTIL_CPP
#include "mar_util_cpp.h"
#endif // INCLUDED_MAR_UTIL_CPP

namespace mar {

    class index {
    public:
        typedef mar::const_iterator const_iterator;
        typedef mar::const_reverse_iterator const_reverse_iterator;
        typedef const_iterator::difference_type difference_type;
        typedef const_iterator::value_type value_type;
        typedef const_iterator::pointer const_pointer;
        typedef const_iterator::reference const_reference;
        typedef const_iterator::size_type size_type;
    private:
        archive ar_;
    public:
        explicit
        index(const handle& h)
            : ar_(h)
        {
        }
        void
        removepairs()
        {
            mar::removepairs(ar_);
        }
        archive
        retain()
        {
            return ar_;
        }
        const_iterator
        setmeta(const const_iterator& it, const void* data, size_t s)
        {
            mar::setmeta(ar_, toord(it), data, s);
            return it;
        }
        const_iterator
        setmeta(const const_iterator& it, const char* data)
        {
            mar::setmeta(ar_, toord(it), data);
            return it;
        }
        const_iterator
        setmeta(const pair& p)
        {
            return const_iterator(ar_, mar::setmeta(ar_, p));
        }
        const_iterator
        unsetmeta(const char* key)
        {
            return const_iterator(ar_, mar::unsetmeta(ar_, key).first);
        }
        const_iterator
        unsetmeta(const const_iterator& it)
        {
            mar::unsetmeta(ar_, toord(it));
            return it;
        }
        const void*
        meta(const char* key) const
        {
            return mar::meta(ar_, key);
        }
        const void*
        meta(const char* key, size_t& s) const
        {
            return mar::meta(ar_, key, s);
        }
        const void*
        meta(const const_iterator& it) const
        {
            return mar::meta(ar_, toord(it));
        }
        const void*
        meta(const const_iterator& it, size_t& s) const
        {
            return mar::meta(ar_, toord(it), s);
        }
        const void*
        meta(const const_reverse_iterator& it) const
        {
            return mar::meta(ar_, toord(it));
        }
        const void*
        meta(const const_reverse_iterator& it, size_t& s) const
        {
            return mar::meta(ar_, toord(it), s);
        }
        void
        meta(pair& p, const const_iterator& it) const
        {
            mar::meta(ar_, p, toord(it));
        }
        const_iterator
        find(const char* key) const
        {
            return const_iterator(ar_, mar::toord(ar_, key).first);
        }
        const_iterator
        begin() const
        {
            return const_iterator(ar_, 0);
        }
        const_iterator
        end() const
        {
            return const_iterator(ar_, size());
        }
        const_reverse_iterator
        rbegin() const
        {
            return const_reverse_iterator(end());
        }
        const_reverse_iterator
        rend() const
        {
            return const_reverse_iterator(begin());
        }
        const archive&
        retain() const
        {
            return ar_;
        }
        bool
        empty() const
        {
            return 0 == size();
        }
        size_type
        size() const
        {
            return metapairs(ar_);
        }
    };
}

#endif // INCLUDED_MAR_INDEX_CPP