MC_double_vector_vector.hpp

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2008 Damien Rohmer
**
**    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.
**
**   This program 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 General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/


#ifndef _MC_DOUBLE_VECTOR_VECTOR_HPP_
#define _MC_DOUBLE_VECTOR_VECTOR_HPP_

#include <MC_double_vector.hpp>

#include <stdlib.h>
#include <vector>
#include <list>

namespace mesh_conv
{
    class MC_double_vector_vector
    {
    public:

        //************************************************//
        //************************************************//
        //CONSTRUCTORS
        //************************************************//
        //************************************************//

        MC_double_vector_vector();
        MC_double_vector_vector(const MC_double_vector& v0);
        MC_double_vector_vector(const MC_double_vector& v0,const MC_double_vector& v1);
        MC_double_vector_vector(const MC_double_vector& v0,const MC_double_vector& v1,const MC_double_vector& v2);
        MC_double_vector_vector(const MC_double_vector& v0,const MC_double_vector& v1,const MC_double_vector& v2,const MC_double_vector& v3);

        MC_double_vector_vector(const std::list <MC_double_vector>& vec);
        MC_double_vector_vector(const std::vector <MC_double_vector>& vec);

        //************************************************//
        //************************************************//
        //Asserts
        //************************************************//
        //************************************************//

        void assert_bounds(const int& u) const;


        //************************************************//
        //************************************************//
        //Informations
        //************************************************//
        //************************************************//

        int size() const;





        //************************************************//
        //************************************************//
        //Manipulation
        //************************************************//
        //************************************************//

        void clear();

        MC_double_vector_vector& resize(const int& new_size);

        MC_double_vector_vector& add(const MC_double_vector& val);
        friend MC_double_vector_vector operator<<(const MC_double_vector_vector& vec,const MC_double_vector& value);


        MC_double_vector_vector& add(const MC_double_vector_vector& val);
        friend MC_double_vector_vector operator<<(const MC_double_vector_vector& vec,const MC_double_vector_vector& to_add);

        MC_double_vector_vector& set(const int& k_index,const MC_double_vector& new_value);
        MC_double_vector_vector& set(const MC_int_vector& k_index,const MC_double_vector_vector& new_value);

        std::pair <MC_double_vector_vector,MC_double_vector> delete_index(const int& index_to_delete) const;
        std::pair <MC_double_vector_vector,MC_double_vector_vector> delete_index(const MC_int_vector& index_to_delete) const;

        static MC_double_vector_vector empty(const int& N);

        //************************************************//
        //************************************************//
        //Math operator
        //************************************************//
        //************************************************//

        friend MC_double_vector_vector operator+(const MC_double_vector_vector& vec,const double& to_add);
        friend MC_double_vector_vector operator-(const MC_double_vector_vector& vec,const double& to_add);


        //************************************************//
        //************************************************//
        //Static initialization
        //************************************************//
        //************************************************//

        static MC_double_vector_vector repeat(const MC_double_vector& input,const int& N_repeat);

        //************************************************//
        //************************************************//
        //Get value
        //************************************************//
        //************************************************//

        const MC_double_vector& operator()(const int& index) const ;
        MC_double_vector& operator()(const int& index) ;
        const MC_double_vector& operator[](const int& index) const ;
        MC_double_vector& operator[](const int& index) ;



        MC_double_vector_vector operator()(const MC_int_vector& index) const;
        MC_double_vector_vector operator[](const MC_int_vector& index) const;




        const MC_double_vector& first() const;
        MC_double_vector& first();
        const MC_double_vector& last() const;
        MC_double_vector& last();

        const MC_double_vector* pointer() const;
        MC_double_vector* pointer_unprotected();




        //************************************************//
        //************************************************//
        //Input/Output
        //************************************************//
        //************************************************//

        friend std::ostream& operator<<(std::ostream& stream,const MC_double_vector_vector& input);

    private:

        std::vector <MC_double_vector> double_vec_list;
    };
}

#endif