/builddir/build/BUILD/libutil++-1.4.0/src/sella/variant/Object.h

/*
** libutil++
** $Id: Object.h 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__variant__Object_H__
#define __libutilxx__sella__variant__Object_H__

#include "../../common.h"
#include "TypeCastException.h"
#include "Nullable.h"

#include <memory>

#include <boost/regex.hpp>

namespace sella {
        namespace variant {
                class Object;
                class Variant;
        }
}

class sella::variant::Object : public Nullable {
        public:
                typedef std::map<std::string, Variant>::iterator iterator;
                typedef std::map<std::string, Variant>::const_iterator const_iterator;
                static const boost::regex       Pattern;
                static const boost::regex       NodePattern;
                static const int                                Type = 0x51;

        public:
                /* Constructors */
                Object() throw ();
                Object(const std::string &value) throw (TypeCastException);
                Object(const std::vector<std::string> &token) throw (TypeCastException);
                Object(const std::map<std::string, Variant> &value) throw ();

                Object(const Object &other) throw ();
                virtual ~Object() throw ();

                /* Operators */
                bool operator==(const Object &other) const throw ();
                bool operator!=(const Object &other) const throw ();
                Object& operator=(const Object &other) throw ();
                Object& operator+=(const Variant &other) throw ();
                const Variant& operator[](const std::string &key) const throw ();
                Variant& operator[](const std::string &key) throw ();

                /* Public Member Functions */
                iterator begin() throw ();
                iterator end() throw ();
                const_iterator cbegin() const throw ();
                const_iterator cend() const throw ();

                const std::map<std::string, Variant>* getObject() const throw (UnsupportedOperatorException);
                size_t size() const throw ();
                bool empty() const throw ();
                bool erase(const Variant &key) throw ();

                virtual const std::string& str() const throw ();

        private:
                std::map<std::string, Variant>& getRef() throw ();
                const std::map<std::string, Variant>& getRef() const throw ();
                void parse(const std::vector<std::string> &token) throw (TypeCastException);

                std::map<std::string, Variant>::iterator it;
};

#endif

/*
** vim: noet ts=3 sw=3
*/

---