---

VMap.h

/*****************************************************************************
 * Author:   Valient Gough <vgough@pobox.com>
 *
 *****************************************************************************
 * Copyright (c) 2000, Valient Gough
 *
 * This library is free software; you can distribute it and/or modify it under
 * the terms of the GNU Lesser General Public License (LGPL), as published by
 * the Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library 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 LGPL in the file COPYING for more
 * details.
 *
 */
                                                                                                

#ifndef _VMap_incl_
#define _VMap_incl_


#include <string>
#include <typeinfo>

#include <rel/TypeStream.h>
#include <rel/SmartPtr.h>
#include <rel/VMapIterator.h>

using namespace std;


namespace rel
{


    class VMap
    {
    public:
        typedef SmartPtr<VMap> Ptr;

        virtual ~VMap();

        enum ErrorCode
        {
            Success = 0,

            TypeMismatch = 1, 
            NotFound = 2,     
            AlreadyExists = 3,

            NotPermitted = 4, 
            Unsupported = 5,  
            ArgumentError = 6,

            BackendError = 7  
        };                                                                          
        enum DirFlags
        {
            NoFlags       = 0x00,  
            FindOrCreate  = 0x01   
        };

        virtual Ptr findDirectory(const string &name, int flags = NoFlags);
        virtual Ptr findDirectory(const TypeStream &path, int flags = NoFlags);

        virtual Ptr createDirectory(const string &name);
        // create a [sub]directory using user specified coding (supports
        // multi-part)
        // path based convenience function
        virtual Ptr createDirectory(const TypeStream &path);

        // ---------------------- find
        // DEFUALTS to NULL
        // throws VMap_unsupported if not implemented
        virtual OpaqueValue find(const string &name);

        // find based on full path.
        // path based convenience function
        // This will interpret operations
        virtual OpaqueValue find(const TypeStream &path);

        // ---------------------- iterate
        // throws VMap_unsupported if not implemented
        virtual VMapIterator begin();
        virtual VMapIterator end();
        virtual VMapIterator at(const string &name);


        // ---------------------- insert
        // returns Unsupported if not implemented
        virtual ErrorCode insert(const string &name, const OpaqueValue &value);

        // path based convenience function
        // flags can be set to FindOrCreate in order to force creation of any
        // subdirectories leading up to the value to be inserted.  If the
        // FindOrCreate bit is not set, then it will fail if it encounters a
        // non-existant directory in the path.
        virtual ErrorCode insert(const TypeStream &path, 
                const OpaqueValue &value,
                int flags = FindOrCreate);

        // ----------------------- assign
        // does not interpret operations
        // returns Unsupported if not implemented
        virtual ErrorCode assign(const string &name, const OpaqueValue &value);

        // Assignment will follow operations which redirect to other
        // directories, but no other types.
        virtual ErrorCode assign(const TypeStream &path, 
                const OpaqueValue &value);


        // ----------------------- remove
        // returns Unsupported if not implemented
        virtual ErrorCode erase(const string &name);
        virtual ErrorCode erase(const TypeStream &path);

        // returns Unsupported if not implemented
        virtual ErrorCode clear();

    protected:
        // iterator implementation functions
        // throws VMap_unsupported if not implemented
        virtual void advanceIterator(const OpaqueValue &) const;
        // throws VMap_unsupported if not implemented
        virtual bool equalIteratorData(const OpaqueValue &a,
                const OpaqueValue &b) const;
        // throws VMap_unsupported if not implemented
        virtual void assignIteratorData(const OpaqueValue &src,
                const OpaqueValue &dest) const;
        // throws VMap_unsupported if not implemented
        virtual void getKeyValue(const OpaqueValue &iteratorData,
                std::pair<std::string,OpaqueValue> *result);

        friend VMapIterator;
    };

    typedef VMap::Ptr VMapPtr;


    OpaqueValue findFirst  (VMapPtr &map, 
            const TypeStream &path, const string &key);
    OpaqueValue findDeepest(VMapPtr &map, 
            const TypeStream &path, const string &key);


    // Specialization of smart pointer interpret from OpaqueValueDataImpl for
    // VMap types.  This implements interpret to do a map lookup.
    template<>
        bool smartPtrInterpret<VMap>(VMap *value, 
                const std::type_info &resultType,
                const OpaqueValue *args, 
                OpaqueValue *output);


} // namespace rel



rel::VMapPtr GlobalObjectMap();

void SetGlobalObjectMap(const rel::VMapPtr &globalMap);


#define GOM GlobalObjectMap()




#endif

---