v_array.h

Go to the documentation of this file.

/*
  Copyright (c) 2009 Yahoo! Inc.  All rights reserved.  The copyrights
  embodied in the content of this file are licensed under the BSD
  (revised) open source license.

  Copyright (c) 2011 Berlin Institute of Technology and Max-Planck-Society.

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 3 of the License, or
  (at your option) any later version.

  Shogun adjustments (w) 2011 Shashwat Lal Das
*/

#include <stdlib.h>
#include <shogun/lib/memory.h>
#include <shogun/mathematics/Math.h>

#ifndef VARRAY_H__
#define VARRAY_H__

namespace shogun
{
template<class T> class v_array
{
public:

    v_array()
    {
        begin = NULL;
        end = NULL;
        end_array = NULL;
    }

    T& operator[](unsigned int i) { return begin[i]; }

    inline T last() { return *(end-1); }

    inline T pop() { return *(--end); }

    inline bool empty() { return begin == end; }

    inline void decr() { end--; }

    inline unsigned int index() { return end-begin; }

    inline void erase() { end = begin; }

    void push(const T &new_elem);

    void push_many(const T* new_elem, size_t num);

    void reserve(size_t length);

    void calloc_reserve(size_t length);

    v_array<T> pop(v_array< v_array<T> > &stack);

public:

    T* begin;

    T* end;

    T* end_array;

};

template<class T>
inline void v_array<T>::push(const T &new_elem)
{
    if(end == end_array)
    {
        size_t old_length = end_array - begin;
        size_t new_length = 2 * old_length + 3;
        //size_t new_length = old_length + 1;
        begin = SG_REALLOC(T, begin, new_length);
        end = begin + old_length;
        end_array = begin + new_length;
    }
    *(end++) = new_elem;
}

template<class T>
inline void v_array<T>::push_many(const T* new_elem, size_t num)
{
    if(end+num >= end_array)
    {
        size_t length = end - begin;
        size_t new_length = CMath::max(2 * (size_t)(end_array - begin) + 3,
                           end - begin + num);
        begin = SG_REALLOC(T, begin, new_length);
        end = begin + length;
        end_array = begin + new_length;
    }
    memcpy(end, new_elem, num * sizeof(T));
    end += num;
}

template<class T>
inline void v_array<T>::reserve(size_t length)
{
    size_t old_length = end_array-begin;
    begin = SG_REALLOC(T, begin, length);
    if (old_length < length)
        bzero(begin + old_length, (length - old_length)*sizeof(T));

    end = begin;
    end_array = begin + length;
}

template<class T>
inline void v_array<T>::calloc_reserve(size_t length)
{
    begin = SG_CALLOC(T, length);
    end = begin;
    end_array = begin + length;
}

template<class T>
inline v_array<T> v_array<T>::pop(v_array< v_array<T> > &stack)
{
    if (stack.end != stack.begin)
        return *(--stack.end);
    else
        return v_array<T>();
}
}
#endif  // VARRAY_H__