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/ConflatedUDP/Bootstrap.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

/// Implements vector-like container over 
/// built-in array of fixed size being 
/// referenced.
template
<
    typename ItemType,
    typename SizeType
>
class VectorOverArray
{
public:
    /// Aliases container item type. 
    typedef ItemType Item;

    /// Aliases dimension type. 
    typedef SizeType Size;

    /// Aliases constant iterator type. 
    typedef const Item* ConstIterator;

    /// Aliases mutable iterator type. 
    typedef Item* Iterator;

    /// Initializes instance with no items.
    VectorOverArray()
    : items_(NULL)
    , size_(0)
    , capacity_(0)
    {
    }

    /// Initializes instance over given fixed-size array.
    VectorOverArray(
        Item* items, 
        Size capacity)
        : items_(items)
        , size_(0)
        , capacity_(capacity)
    {
    }

    /// Cleans everything up.
    ~VectorOverArray()
    {
        resize(0);
    }

    /// Indicates whether instance has no items.
    bool 
    empty() const
    {
        return (0 == size_);
    }

    /// Number of items.
    Size
    size() const
    {
        return size_;
    }

    /// Total capacity of container.
    Size
    capacity() const
    {
        return capacity_;
    }

    /// Iterator referencing to the first item.
    Iterator 
    begin()
    {
        return items_;
    }

    /// Iterator referencing to the first item.
    ConstIterator 
    begin() const
    {
        return items_;
    }

    /// Iterator referencing to the item behind the last item.
    Iterator 
    end()
    {
        return (items_ + size_);
    }

    /// Iterator referencing to the item behind the last item.
    ConstIterator 
    end() const
    {
        return (items_ + size_);
    }

    /// Provides access to the front item if available. 
    Item&
    front()
    {
        assert(0 < size_);

        return items_[0];
    }

    /// Provides access to the front item if available. 
    const Item&
    front() const
    {
        assert(0 < size_);

        return items_[0];
    }

    /// Accesses to item by index.
    Item& 
    operator[](
        Size index)
    {
        assert(index < size_);

        return items_[index];
    }

    /// Accesses to item by index.
    const Item& 
    operator[](
        Size index) const
    {
        assert(index < size_);

        return items_[index];
    }

    /// Accesses to item by index 
    /// checking access bounds.
    Item&
    at(
        Size index)
    {
        if (index < size_)
            return items_[index];

        throw std::out_of_range
        (
            "Index outside of range."
        );
    }

    /// Accesses to item by index 
    /// checking access bounds.
    const Item&
    at(
        Size index) const
    {
        if (index < size_)
            return items_[index];

        throw std::out_of_range
        (
            "Index outside of range."
        );
    }

    /// Inserts new item to given position.
    /// Items under higher indices are moved back. 
    /// Last item is extruded thus keeping size of
    /// or container constant. 
    ///
    /// @return Reference to an item at 
    /// requested position for further update.
    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;
    }

    /// Erases item at given position.
    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_;
    }

    /// Resizes container. 
    /// 
    /// If vector is enlarged, new items 
    /// constructed as copies of given instance.
    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=";

    toStr(error, sourceSize);

    error += ",targetCapacity=";

    toStr(error, targetSize);

    error += "]. ";

    throw std::runtime_error(error);
}

/// Copies items from source to target.
/// Items are not required to be of same type
/// thus compatible types can be copied. 
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_CONFLATEDUDP_NAMESPACE_END