VectorOverArray.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <cassert>
 
#include <string>
#include <stdexcept>
 
#include <OnixS/CME/MDH/Bootstrap.h>
#include <OnixS/CME/MDH/messaging/Integral.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

template <typename ItemType, typename SizeType>
class VectorOverArray
{
public:
    typedef ItemType Item;

    typedef SizeType Size;

    typedef const Item* ConstIterator;

    typedef Item* Iterator;

    VectorOverArray()
        : items_(nullptr)
        , size_(0)
        , capacity_(0)
    {
    }

    VectorOverArray(Item* items, Size capacity)
        : items_(items)
        , size_(0)
        , capacity_(capacity)
    {
    }

    ~VectorOverArray()
    {
        resize(0);
    }

    bool empty() const
    {
        return (0 == size_);
    }

    Size size() const
    {
        return size_;
    }

    Size capacity() const
    {
        return capacity_;
    }

    Iterator begin()
    {
        return items_;
    }

    ConstIterator begin() const
    {
        return items_;
    }

    Iterator end()
    {
        return (items_ + size_);
    }

    ConstIterator end() const
    {
        return (items_ + size_);
    }

    Item& front()
    {
        assert(0 < size_);
 
        return items_[0];
    }

    const Item& front() const
    {
        assert(0 < size_);
 
        return items_[0];
    }

    Item& operator[](Size index)
    {
        assert(index < size_);
 
        return items_[index];
    }

    const Item& operator[](Size index) const
    {
        assert(index < size_);
 
        return items_[index];
    }

    Item& at(Size index)
    {
        if (index < size_)
            return items_[index];
 
        throw std::out_of_range("Index outside of range.");
    }

    const Item& at(Size index) const
    {
        if (index < size_)
            return items_[index];
 
        throw std::out_of_range("Index outside of range.");
    }

    Item& insertExtrude(Size index)
    {
        assert(index < size_);
 
        Item* const toBeUpdated = items_ + index;
 
        Item* target = items_ + size_ - 1;
        Item* source = target - 1;
 
        while (target != toBeUpdated)
        {
            target->~Item();
 
            new (target--) Item(*source--);
        }
 
        return *toBeUpdated;
    }

    void erase(Size index)
    {
        assert(index < size_);
 
        Item* const theEnd = end();
        Item* const toBeErased = items_ + index;
 
        Item* target = toBeErased;
        Item* source = toBeErased + 1;
 
        while (source != theEnd)
        {
            target->~Item();
 
            new (target++) Item(*source++);
        }
 
        target->~Item();
 
        --size_;
    }

    void resize(Size newSize, const Item& item = Item())
    {
        assert(newSize <= capacity_);
 
        if (newSize > size_)
        {
            while (size_ != newSize)
                new (items_ + size_++) Item(item);
        }
        else
        {
            while (size_ != newSize)
                (items_ + --size_)->~Item();
        }
    }
 
private:
    Item* items_;
    Size size_;
 
    const Size capacity_;
 
    VectorOverArray(const VectorOverArray&);
 
    VectorOverArray& operator=(const VectorOverArray&);
};
 
// Throws exception on copy failure.
template <typename TargetSize, typename SourceSize>
void throwVectorCopyOverflow(TargetSize targetSize, SourceSize sourceSize)
{
    std::string error;
 
    error += "Cannot copy items because number "
             "of source items exceeds target capacity "
             "[sourceItemCount=";
 
    Messaging::toStr(error, sourceSize);
 
    error += ",targetCapacity=";
 
    Messaging::toStr(error, targetSize);
 
    error += "]. ";
 
    throw std::runtime_error(error);
}

template <typename TargetItem, typename TargetSize, typename SourceItem, typename SourceSize>
void copy(
    VectorOverArray<TargetItem, TargetSize>& target,
    const VectorOverArray<SourceItem, TargetSize>& source,
    SourceSize itemCount = static_cast<SourceSize>(-1)
)
{
    itemCount = (itemCount > source.size()) ? source.size() : itemCount;
 
    if (itemCount > target.capacity())
    {
        throwVectorCopyOverflow(target.capacity(), itemCount);
    }
 
    target.resize(itemCount);
 
    while (itemCount)
    {
        --itemCount;
 
        target[itemCount] = source[itemCount];
    }
}
 
ONIXS_CMEMDH_NAMESPACE_END