DynamicArray.h

Go to the documentation of this file.

/*
 * 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.
 *
 * Written (W) 1999-2009 Soeren Sonnenburg
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _DYNAMIC_ARRAY_H_
#define _DYNAMIC_ARRAY_H_

#include <shogun/base/SGObject.h>
#include <shogun/base/DynArray.h>
#include <shogun/base/Parameter.h>

namespace shogun
{
template <class T> class CDynamicArray :public CSGObject
{
    public:
        CDynamicArray(int32_t p_resize_granularity=128)
        : CSGObject()
        {
            set_generic<T>();

            m_parameters->add_vector(&m_array.array,
                                     &m_array.num_elements, "array",
                                     "Memory for dynamic array.");
            m_parameters->add(&m_array.last_element_idx,
                              "last_element_idx",
                              "Element with largest index.");
            m_parameters->add(&m_array.resize_granularity,
                              "resize_granularity",
                              "shrink/grow step size.");
        }

        virtual ~CDynamicArray() {}

        inline int32_t set_granularity(int32_t g)
        {
            return m_array.set_granularity(g);
        }

        inline int32_t get_array_size()
        {
            return m_array.get_array_size();
        }

        inline int32_t get_num_elements() const
        {
            return m_array.get_num_elements();
        }

        inline T get_element(int32_t index) const
        {
            return m_array.get_element(index);
        }

        inline T get_element_safe(int32_t index) const
        {
            return m_array.get_element_safe(index);
        }

        inline bool set_element(T element, int32_t index)
        {
            return m_array.set_element(element, index);
        }

        inline bool insert_element(T element, int32_t index)
        {
            return m_array.insert_element(element, index);
        }

        inline bool append_element(T element)
        {
            return m_array.append_element(element);
        }

        inline void push_back(T element)
        { m_array.push_back(element); }

        inline void pop_back()
        {
            m_array.pop_back();
        }

        inline T back()
        {
            return m_array.back();
        }

        inline int32_t find_element(T element)
        {
            return m_array.find_element(element);
        }

        inline bool delete_element(int32_t idx)
        {
            return m_array.delete_element(idx);
        }

        inline bool resize_array(int32_t n)
        {
            return m_array.resize_array(n);
        }

        inline T* get_array() const
        {
            return m_array.get_array();
        }

        inline void set_array(T* p_array, int32_t p_num_elements,
                              int32_t array_size)
        {
            m_array.set_array(p_array, p_num_elements, array_size);
        }

        inline void clear_array()
        {
            m_array.clear_array();
        }

        inline T operator[](int32_t index) const
        {
            return m_array[index];
        }

        inline CDynamicArray<T>& operator=(CDynamicArray<T>& orig)
        {
            m_array = orig.m_array;
            return *this;
        }

        inline void shuffle() { m_array.shuffle(); }

        inline virtual const char* get_name() const
        {
            return "DynamicArray";
        }

    protected:

        DynArray<T> m_array;
};
}
#endif /* _DYNAMIC_ARRAY_H_  */