RMonoVariantArray_Def.h

/*
    Copyright 2020 David "Alemarius Nexus" Lerch
 
    This file is part of RemoteMono.
 
    RemoteMono is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    RemoteMono 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 Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with RemoteMono.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "../config.h"
 
#include <vector>
#include "RMonoVariant_Def.h"
 
 
 
namespace remotemono
{
 
 
 
class RMonoVariant;
 
 
 
class RMonoVariantArray
{
public:
    typedef RMonoVariantArray Self;
 
    typedef RMonoVariant Variant;
 
public:
    RMonoVariantArray() : isnull(false) {}
 
    RMonoVariantArray(std::nullptr_t) : isnull(true) {}
 
 
    RMonoVariantArray(const Self& other) : vec(other.vec), isnull(other.isnull) {}
 
    RMonoVariantArray(Self&& other) : vec(std::move(other.vec)), isnull(other.isnull) { other.isnull = true; }
 
 
    RMonoVariantArray(const std::vector<Variant>& vec) : vec(vec), isnull(false) {}
 
    RMonoVariantArray(std::vector<Variant>&& vec) : vec(vec), isnull(false) {}
 
 
    RMonoVariantArray(std::initializer_list<Variant>&& list) : vec(list), isnull(false) {}
 
 
    template <typename... VariantT>
    RMonoVariantArray(VariantT... list) : vec({list...}), isnull(false) {}
 
 
    Self& operator=(const Self& other)
    {
        if (&other != this) {
            vec = other.vec;
            isnull = other.isnull;
        }
        return *this;
    }
 
    Self& operator=(Self&& other)
    {
        if (&other != this) {
            vec = std::move(other.vec);
            isnull = other.isnull;
            other.isnull = true;
        }
        return *this;
    }
 
 
    size_t size() const { return vec.size(); }
 
    bool isNull() const { return isnull; }
 
 
    typename std::vector<Variant>::iterator begin() { return vec.begin(); }
 
    typename std::vector<Variant>::const_iterator begin() const { return vec.begin(); }
 
 
    typename std::vector<Variant>::iterator end() { return vec.end(); }
 
    typename std::vector<Variant>::const_iterator end() const { return vec.end(); }
 
 
    Variant& operator[](size_t idx) { return vec[idx]; }
 
    const Variant& operator[](size_t idx) const { return vec[idx]; }
 
 
    std::vector<Variant>& data() { return vec; }
 
    const std::vector<Variant>& data() const { return vec; }
 
private:
    std::vector<Variant> vec;
    bool isnull;
};
 
 
 
};