/* 
 * File:   CreationTool.cxx
 * Author: riveros
 * 
 * Created on 23 mars 2012, 10:12
 */

#include "CreationTool.h"

std::string Mthd::Aux::toString ( float n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( double n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( long double n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( char n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( unsigned char n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( short n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( unsigned short n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( int n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( long int n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( unsigned int n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( unsigned long n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( unsigned long long n ) {
    std::ostringstream oss ;
    oss << n ;
    return oss.str ( ) ;
}

std::string Mthd::Aux::toString ( std::vector<int> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<float> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<double> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<long double> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<long int> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<unsigned int> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<unsigned long> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<unsigned long long> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::basic_string<char> > v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return _vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< int > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< float > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< double > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< long int > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< long double > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< unsigned int > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< unsigned long > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::vector<std::vector< unsigned long long > > v ) {
    std::ostringstream oss ;
    std::string _vector_of_vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        std::string _vector = std::string ( "" ) ;
        for ( long unsigned int j = 0 ; j < v.at ( j ).size ( ) ; j ++ ) {
            oss << v.at ( i ).at ( j ) ;
            _vector += oss.str ( ) ;
            if ( i + 1 < v.size ( ) ) {
                ///         ELEMENTS SPLIT TOKEN      ///
                _vector += "," ;
            }
        }
        if ( i + 1 < _vector_of_vector.size ( ) ) {
            ///         VECTOR SPLIT TOKEN      ///
            _vector_of_vector += _vector + "@@@@@" ;
        }
    }
    return _vector_of_vector ;
}

std::string Mthd::Aux::toString ( std::string n ) {
    return n ;
}

char* Mthd::Aux::toCharArrray ( float n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( double n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( long double n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( char n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( unsigned char n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( short n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( unsigned short n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( int n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( long int n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( unsigned int n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( long unsigned int n ) {
    std::ostringstream oss ;
    oss << n ;
    return const_cast < char* > ( oss.str ( ).data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::string n ) {
    return const_cast < char* > ( n.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<int> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<float> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<double> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<long double> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<long int> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<unsigned int> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<unsigned long> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

char* Mthd::Aux::toCharArrray ( std::vector<unsigned long long> v ) {
    std::ostringstream oss ;
    std::string _vector = std::string ( "" ) ;
    for ( long unsigned int i = 0 ; i < v.size ( ) ; i ++ ) {
        oss << v.at ( i ) ;
        _vector += oss.str ( ) ;
        if ( i + 1 < v.size ( ) ) {
            _vector += "," ;
        }
    }
    return const_cast < char* > ( _vector.data ( ) ) ;
}

std::string Mthd::Aux::replace_str ( std::string input , std::string old_str , std::string new_str ) {
    size_t found = input.find ( old_str ) ;
    while ( found != std::string::npos ) {
        input.replace ( found , old_str.length ( ) , new_str ) ;
        found = input.find ( old_str ) ;
    }
    return input ;
}

bool Mthd::Aux::str_ends_with ( std::string total_str , std::string sub_str ) {
    size_t found = total_str.find ( sub_str ) ;
    if ( found != std::string::npos ) {
        return true ;
    }
    return false ;
}