DynamicObjectArray.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
 * Written (W) 2011-2012 Heiko Strathmann
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _DYNAMIC_OBJECT_ARRAY_H_
#define _DYNAMIC_OBJECT_ARRAY_H_

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

namespace shogun
{
class CDynamicObjectArray : public CSGObject
{
    public:
        CDynamicObjectArray()
        : CSGObject(), m_array(), name("Array")
        {
            m_parameters->add_vector(&m_array.array, &m_array.num_elements,
                    "array", "Memory for dynamic array.");
            SG_ADD(&m_array.last_element_idx, "last_element_idx",
                    "Element with largest index.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.resize_granularity, "resize_granularity",
                    "shrink/grow step size.", MS_NOT_AVAILABLE);

            dim1_size=1;
            dim2_size=1;
            dim3_size=1;
        }

        CDynamicObjectArray(int32_t dim1, int32_t dim2=1, int32_t dim3=1)
        : CSGObject(), m_array(dim1*dim2*dim3), name("Array")
        {
            m_parameters->add_vector(&m_array.array, &m_array.num_elements,
                    "array", "Memory for dynamic array.");
            SG_ADD(&m_array.last_element_idx, "last_element_idx",
                    "Element with largest index.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.resize_granularity, "resize_granularity",
                    "shrink/grow step size.", MS_NOT_AVAILABLE);

            dim1_size=dim1;
            dim2_size=dim2;
            dim3_size=dim3;
        }

        CDynamicObjectArray(CSGObject** p_array, int32_t p_dim1_size, bool p_free_array=true, bool p_copy_array=false)
        : CSGObject(), m_array(p_array, p_dim1_size, p_free_array, p_copy_array), name("Array")
        {
            m_parameters->add_vector(&m_array.array, &m_array.num_elements,
                    "array", "Memory for dynamic array.");
            SG_ADD(&m_array.last_element_idx, "last_element_idx",
                    "Element with largest index.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.resize_granularity, "resize_granularity",
                    "shrink/grow step size.", MS_NOT_AVAILABLE);

            dim1_size=p_dim1_size;
            dim2_size=1;
            dim3_size=1;
        }

        CDynamicObjectArray(CSGObject** p_array, int32_t p_dim1_size, int32_t p_dim2_size,
                        bool p_free_array=true, bool p_copy_array=false)
        : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size, p_free_array, p_copy_array), name("Array")
        {
            m_parameters->add_vector(&m_array.array, &m_array.num_elements,
                    "array", "Memory for dynamic array.");
            SG_ADD(&m_array.last_element_idx, "last_element_idx",
                    "Element with largest index.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.resize_granularity, "resize_granularity",
                    "shrink/grow step size.", MS_NOT_AVAILABLE);

            dim1_size=p_dim1_size;
            dim2_size=p_dim2_size;
            dim3_size=1;
        }

        CDynamicObjectArray(CSGObject** p_array, int32_t p_dim1_size, int32_t p_dim2_size,
                        int32_t p_dim3_size, bool p_free_array=true, bool p_copy_array=false)
        : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size, p_free_array, p_copy_array), name("Array")
        {
            m_parameters->add_vector(&m_array.array, &m_array.num_elements,
                    "array", "Memory for dynamic array.");
            SG_ADD(&m_array.last_element_idx, "last_element_idx",
                    "Element with largest index.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.resize_granularity, "resize_granularity",
                    "shrink/grow step size.", MS_NOT_AVAILABLE);

            dim1_size=p_dim1_size;
            dim2_size=p_dim2_size;
            dim3_size=p_dim3_size;
        }

        virtual ~CDynamicObjectArray() { unref_all(); }

        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 void get_array_size(int32_t& dim1, int32_t& dim2)
        {
            dim1=dim1_size;
            dim2=dim2_size;
        }

        inline void get_array_size(int32_t& dim1, int32_t& dim2, int32_t& dim3)
        {
            dim1=dim1_size;
            dim2=dim2_size;
            dim3=dim3_size;
        }

        inline int32_t get_dim1() { return dim1_size; }

        inline int32_t get_dim2() { return dim2_size; }

        inline int32_t get_dim3() { return dim3_size; }

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

        inline CSGObject* get_element(int32_t index) const
        {
            CSGObject* elem=m_array.get_element(index);
            SG_REF(elem);
            return elem;
        }

        inline CSGObject* element(int32_t idx1, int32_t idx2=0, int32_t idx3=0)
        {
            return get_element(idx1+dim1_size*(idx2+dim2_size*idx3));
        }

        inline CSGObject* get_last_element() const
        {
            CSGObject* e=m_array.get_last_element();
            SG_REF(e);
            return e;
        }

        inline CSGObject* get_element_safe(int32_t index) const
        {
            CSGObject* e=m_array.get_element_safe(index);
            SG_REF(e);
            return e;
        }

        inline bool set_element(CSGObject* e, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
        {
            CSGObject* old=(CSGObject*) m_array.get_element(idx1+dim1_size*(idx2+dim2_size*idx3));

            bool success=m_array.set_element(e, idx1+dim1_size*(idx2+dim2_size*idx3));
            if (success)
            {
                SG_REF(e);
                SG_UNREF(old);
            }

            /* ref before unref to prevent deletion if new=old */
            return success;
        }

        inline bool insert_element(CSGObject* e, int32_t index)
        {
            bool success=m_array.insert_element(e, index);
            if (success)
                SG_REF(e);

            return success;
        }

        inline bool append_element(CSGObject* e)
        {
            bool success=m_array.append_element(e);
            if (success)
                SG_REF(e);

            return success;
        }

        inline void push_back(CSGObject* e)
        {
            SG_REF(e);
            m_array.push_back(e);
        }

        inline void pop_back()
        {
            CSGObject* e=m_array.back();
            SG_UNREF(e);

            m_array.pop_back();
        }

        inline CSGObject* back() const
        {
            CSGObject* e=m_array.back();
            SG_REF(e);
            return e;
        }

        inline int32_t find_element(CSGObject* elem) const
        {
            return m_array.find_element(elem);
        }

        inline bool delete_element(int32_t idx)
        {
            CSGObject* e=m_array.get_element(idx);
            SG_UNREF(e);

            return m_array.delete_element(idx);
        }

        inline bool resize_array(int32_t ndim1, int32_t ndim2=1, int32_t ndim3=1)
        {
            dim1_size=ndim1;
            dim2_size=ndim2;
            dim3_size=ndim3;
            return m_array.resize_array(ndim1*ndim2*ndim3);
        }

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

        inline void reset_array()
        {
            unref_all();
            m_array.reset();
        }

        inline CDynamicObjectArray& operator=(CDynamicObjectArray& orig)
        {
            /* SG_REF all new elements (implicitly) */
            for (index_t i=0; i<orig.get_num_elements(); ++i)
                orig.get_element(i);

            /* unref after adding to avoid possible deletion */
            unref_all();

            /* copy pointer DynArray */
            m_array=orig.m_array;
            return *this;
        }

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

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

        inline void set_array_name(const char* p_name)
        {
            name=p_name;
        }

        inline const char* get_array_name() const { return name; }

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

    private:
        inline void unref_all()
        {
            /* SG_UNREF all my elements */
            for (index_t i=0; i<m_array.get_num_elements(); ++i)
            {
                CSGObject* elem=m_array.get_element(i);
                SG_UNREF(elem);
            }
        }

    private:
        DynArray<CSGObject*> m_array;

        int32_t dim1_size;

        int32_t dim2_size;

        int32_t dim3_size;

        const char* name;

};
}
#endif /* _DYNAMIC_OBJECT_ARRAY_H_  */