Vector.h

/*
** libutil++
** $Id: Vector.h 1702 2016-08-13 23:26:06Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__variant__Vector_H__
#define __libutilxx__sella__variant__Vector_H__

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

#include <memory>
#include <vector>

#include <boost/regex.hpp>

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

class sella::variant::Vector : public Nullable {
        public:
                typedef std::vector<Variant>::iterator iterator;
                typedef std::vector<Variant>::const_iterator const_iterator;

                static const boost::regex & Pattern(void) { static boost::regex regex("^\\[(.*)\\]$"); return regex; }
                static const int            Type = 0x50;

        public:
                /* Constructors */
                Vector() throw ();
                Vector(const std::string &value) throw (TypeCastException);
                Vector(const std::vector<std::string> &token) throw (TypeCastException);
                Vector(sella::util::MessagePack &mpack, uint32_t &offset) throw (TypeCastException);
                Vector(const std::vector<Variant> &value) throw ();
                Vector(std::vector<Variant> &&value) throw ();

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

                /* Operators */
                bool operator==(const Vector &other) const throw ();
                bool operator!=(const Vector &other) const throw ();
                Vector& operator=(const Vector &other) throw ();
                Vector& operator=(Vector &&other) throw ();
                Vector& operator+=(const Variant &other) throw ();
                Vector& operator+=(Variant &&other) throw ();
                const Variant& operator[](size_t index) const throw (RangeException);
                Variant& operator[](size_t index) throw ();

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

                const std::vector<Variant>& get() const throw (UnsupportedOperatorException);
                std::vector<Variant>& get() throw (UnsupportedOperatorException);

                size_t size() const throw ();
                bool empty() const throw ();
                void clear() throw();
                bool erase(const std::string &key, int type = 0) throw ();
                bool erase(const Variant &value) throw ();
                bool erase(size_t index) throw ();

                virtual void shrink_to_fit() throw ();
#if 1
                virtual void msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException);
#else
                virtual uint32_t msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException);
#endif
                virtual void msgpackBufferSize(size_t &size) const throw ();
                virtual std::string str(int type) const throw ();
                virtual int getType(void) throw () { return Type; }

                static bool isType(const std::string &value) throw () { return isType(value.c_str(), value.size()); }
                static bool isType(const char *value, size_t size) throw ();

        private:
                std::string json() const throw ();
                std::string cjson() const throw ();
                std::string xml() const throw ();
                std::string csv() const throw ();

                void parse(const std::vector<std::string> &token) throw (TypeCastException);
                void unmsgpack(sella::util::MessagePack &mpack, uint32_t &offset) throw (TypeCastException);

                std::vector<Variant>::iterator it;
};

#endif

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