User Manual, Developers Guide and API Documentation

DynamicMatrix.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 16, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_CONTAINER_DYNAMICMATRIX
#define WNS_CONTAINER_DYNAMICMATRIX

#include <WNS/Exception.hpp>

#include <vector>
#include <list>

namespace wns { namespace container {

    template <typename T>
    class DynamicMatrix
    {
        typedef T ValueType;

        struct Cell
        {
            Cell() : value_() {}
            ValueType value_;
        };

        std::vector<DynamicMatrix*> subMatrices_;

        int dim_;
        Cell* cell_;

    public:
        DynamicMatrix(std::list<int> dimensionSizes) :
            subMatrices_(),
            dim_(dimensionSizes.size()),
            cell_(NULL)
            {
                if (dim_ != 0)
                {
                    int thisSize = dimensionSizes.front();
                    dimensionSizes.pop_front();

                    for (int ii = 0; ii < thisSize; ++ii)
                    {
                        subMatrices_.push_back( new DynamicMatrix(dimensionSizes) );
                    }
                }
                else if (dim_ == 0)
                {
                    cell_ = new Cell;
                }
            }

        ~DynamicMatrix()
            {
                if (dim_ == 0)
                {
                    delete cell_;
                }
                else
                {
                    for (size_t ii = 0; ii < subMatrices_.size(); ++ii)
                    {
                        delete subMatrices_.at(ii);
                    }
                    subMatrices_.clear();
                }
            }

        const ValueType&
        getValue(std::list<int> indices) const
            {
                if (this->dim_ == 0)
                {
                    if (! indices.empty())
                        throw(wns::Exception("Inconsistent Matrix!"));
                    if (! subMatrices_.empty())
                        throw(wns::Exception("Inconsistent Matrix!"));

                    return this->getValue();
                }

                int nextindex = indices.front();
                indices.pop_front();
                return subMatrices_.at(nextindex)->getValue(indices);
            }


        ValueType&
        getValue(std::list<int> indices)
            {
                if (this->dim_ == 0)
                {
                    if (! indices.empty())
                        throw(wns::Exception("Inconsistent Matrix!"));
                    if (! subMatrices_.empty())
                        throw(wns::Exception("Inconsistent Matrix!"));

                    return this->getValue();
                }

                int nextindex = indices.front();
                indices.pop_front();
                return subMatrices_.at(nextindex)->getValue(indices);
            }

        void
        setValue(std::list<int> indices, ValueType value)
            {
                if (this->dim_ == 0)
                {
                    if (! indices.empty())
                        throw(wns::Exception("Inconsistent Matrix!"));
                    if (! subMatrices_.empty())
                        throw(wns::Exception("Inconsistent Matrix!"));

                    this->setValue(value);
                    return;
                }

                int nextindex = indices.front();
                indices.pop_front();
                subMatrices_.at(nextindex)->setValue(indices, value);
            }

    private:
        ValueType&
        getValue()
            {
                if (dim_ == 0)
                    return cell_->value_;

                throw(wns::Exception("Inconsistent Matrix!"));
            }

        const ValueType&
        getValue() const
            {
                if (dim_ == 0)
                    return cell_->value_;

                throw(wns::Exception("Inconsistent Matrix!"));
            }

        void
        setValue(ValueType v)
            {
                if (dim_ == 0)
                {
                    cell_->value_ = v;
                    return;
                }

                throw(wns::Exception("Inconsistent Matrix!"));
            }

    };
} // container
} // wns

#endif // not defined WNS_CONTAINER_DYNAMICMATRIX

---