MC_int_vector.hpp

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2009  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_INT_VECTOR_H_
#define MC_INT_VECTOR_H_

#include <stdlib.h>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <iostream>

#include <MC_curve.hpp>
#include <MC_v3d.hpp>

namespace mesh_conv
{

    class MC_int_pair;
    class MC_int_pair_less;

    // helper class to compare struct
    class comparator_less_int_int
    {
         public:
        bool operator()(const std::pair<int,int> a,const std::pair <int,int> b) const
        {return (a.first<b.first);}
    };



  class MC_int_vector
  {

  public:

    //************************************************//
    //************************************************//
    //CONSTRUCTORS
    //************************************************//
    //************************************************//
    
    MC_int_vector();
    MC_int_vector(const int& u0);
    MC_int_vector(const int& u0,const int& u1);
    MC_int_vector(const int& u0,const int& u1,const int& u2);
    MC_int_vector(const int& u0,const int& u1,const int& u2,const int& u3);
    MC_int_vector(const int& u0,const int& u1,const int& u2,const int& u3,const int& u4);
    MC_int_vector(const int& u0,const int& u1,const int& u2,const int& u3,const int& u4,const int& u5);
    MC_int_vector(const std::string& in,const std::string& separator=" ");

    MC_int_vector(const std::set <int>& vec);
    MC_int_vector(const std::set <unsigned int>& vec);

    MC_int_vector(const std::map <int,int> &vec);
    MC_int_vector(const std::list <int> &vec);
    MC_int_vector(const std::vector <int> &vec);
    MC_int_vector(const MC_int_vector& vec);

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

    void assert_bounds(const int& u) const;



    //************************************************//
    //************************************************//
    //change type
    //************************************************//
    //************************************************//

    std::vector <int>& get_vector();
    const std::vector <int>& to_vector() const;

    std::set <int> to_set() const;
    std::map <int,int> to_map() const;
    std::list <int> to_list() const;

    MC_v3d to_v3d() const;
    

    //************************************************//
    //************************************************//
    //Initialize value
    //************************************************//
    //************************************************//

    static MC_int_vector zeros(const int& new_size);

    static MC_int_vector linspace(const int& begin,const int& end,const double& iteration=1);

    //************************************************//
    //************************************************//
    //manipulate
    //************************************************//
    //************************************************//

    void clear();

    MC_int_vector& resize(const int& new_size);

    MC_int_vector& add(const int& val);
    friend MC_int_vector operator<<(const MC_int_vector& vec,const int& value);


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

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

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

    MC_int_vector mapping(const std::map<int,int> map_to_apply) const;

    MC_int_vector inverted() const;

//    /** \brief inverse a mapping <index_0->index_1> from a map (the mapping must be a bijection) */
//    static std::map <int,int> reverse_index_mapping(const std::map<int,int>& input_mapping);

    //************************************************//
    //************************************************//
    //Build
    //************************************************//
    //************************************************//

    static std::list <MC_int_vector> connected_component(const std::set<MC_int_pair,MC_int_pair_less>& pair_set);


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

    int size() const;

    int find(const int& to_find) const;

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

    MC_int_vector operator-() const;

    friend MC_int_vector operator+(const MC_int_vector& vec,const int& to_add);
    friend MC_int_vector operator-(const MC_int_vector& vec,const int& to_sub);
    friend MC_int_vector operator*(const MC_int_vector& vec,const int& to_mult);
    friend MC_int_vector operator/(const MC_int_vector& vec,const int& to_subdiv);



    friend MC_int_vector operator+(const MC_int_vector& vec,const MC_int_vector& to_add);
    friend MC_int_vector operator-(const MC_int_vector& vec,const MC_int_vector& to_sub);
    friend MC_int_vector operator*(const MC_int_vector& vec,const MC_int_vector& to_mult);
    friend MC_int_vector operator/(const MC_int_vector& vec,const MC_int_vector& to_subdiv);



    MC_int_vector& operator+=(const int& to_add);
    MC_int_vector& operator-=(const int& to_sub);
    MC_int_vector& operator*=(const int& to_mult);
    MC_int_vector& operator/=(const int& to_subdiv);

    MC_int_vector& operator+=(const MC_int_vector& to_add);
    MC_int_vector& operator-=(const MC_int_vector& to_sub);
    MC_int_vector& operator*=(const MC_int_vector& to_mult);
    MC_int_vector& operator/=(const MC_int_vector& to_subdiv);


    friend MC_int_vector operator<(const MC_int_vector& vec,const int& val);
    friend MC_int_vector operator<=(const MC_int_vector& vec,const int& val);
    friend MC_int_vector operator>(const MC_int_vector& vec,const int& val);
    friend MC_int_vector operator>=(const MC_int_vector& vec,const int& val);
    friend MC_int_vector operator==(const MC_int_vector& vec,const int& val);



    friend MC_int_vector operator<(const int& val,const MC_int_vector& vec);
    friend MC_int_vector operator<=(const int& val,const MC_int_vector& vec);
    friend MC_int_vector operator>(const int& val,const MC_int_vector& vec);
    friend MC_int_vector operator>=(const int& val,const MC_int_vector& vec);
    friend MC_int_vector operator==(const int& val,const MC_int_vector& vec);



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

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

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


    const int& first() const;
    int& first();
    const int& last() const;
    int& last();

    MC_int_vector& erase_last();


    const int* pointer() const;

    //************************************************//
    //************************************************//
    //OUTPUT
    //************************************************//
    //************************************************//
    
    friend std::ostream& operator<<(std::ostream& output,const mesh_conv::MC_int_vector& in);

    friend mesh_conv::MC_int_vector& operator>>(std::istream& input,mesh_conv::MC_int_vector& vec);


  private:
    
    std::vector <int> int_list;

  };




}

#endif