API tools faq
paste
Advertisement
Guest User

twitter.cpp

a guest
May 22nd, 2015
217
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 14.90 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #include <string>
  3. #include <cstdlib>
  4. #include "UsuarioTwitter.hpp"
  5. #include "twitter.hpp"
  6. #include <fstream>
  7. #include <cstddef>
  8. #include <cassert>
  9. #include <iostream>
  10. using namespace std;
  11. using namespace bblProgII;
  12.  
  13. namespace{
  14.  
  15.     void leer(ifstream& f_in, string& seg){    
  16.         f_in >> ws;
  17.         getline(f_in,seg);
  18.     }
  19.  
  20. }
  21. namespace bblProgII{
  22.  
  23.  
  24.         // Constructor por defecto
  25.         // Inicializa la red como red vacía, sin usuarios y sin
  26.         // sin ningún usuario conectado
  27.         Twitter::Twitter() {
  28.                 usuarios=NULL;
  29.                 usuario_conectado=NULL;
  30.                 num_users=0;
  31.             }
  32.        
  33.        
  34.  
  35.         // Constructor extendido para cargar toda la red social desde disco.
  36.         // Recibe como parámetro el nombre del fichero con la lista de usuarios
  37.         // de la red. A partir de ahí, carga desde disco todos los seguidores,
  38.         // usuarios seguidos y tweets de cada uno de los
  39.         // usuarios de la red.
  40.         // Si el fichero de la lista de usuario existe, se procede a la carga
  41.         // de la red desde disco y se devuelve 'true' a través del parámetro
  42.         // 'red_cargada'. Si no, la red permanece vacía y se devuelve
  43.         // 'false' a través del parámetro.
  44.         // Los ficheros de datos de cada usuario tienen como nombre el
  45.         // nombre del usuario y como extensión '.seg' para los seguidores,
  46.         // '.sig' para los usuarios seguidos y '.twt' para los tweets.
  47.         Twitter::Twitter(const std::string &fic_lista_usuarios, bool &red_cargada){
  48.            
  49.             ifstream f_in;                     
  50.             f_in.open(fic_lista_usuarios.c_str());         
  51.             bool ok=true;
  52.             Resultado res_seg,res_sig,res_twt, res;
  53.             std::string user;
  54.        
  55.             if(f_in.fail()){                   
  56.                 red_cargada=false;
  57.             }else{
  58.                 UsuarioTwitter nombreUsuario;
  59.                 red_cargada=true;                      
  60.                 leer(f_in, user);
  61.            
  62.                 while(!f_in.fail() && ok){
  63.                
  64.                     nombreUsuario.establecer_id(user);
  65.                     // cout << nombreUsuario.obtener_id(); // Con esto compruebo que la lectura de los datos del fichero es correcta
  66.                
  67.                     nombreUsuario.cargar_todo (nombreUsuario.obtener_id()+".seg", nombreUsuario.obtener_id()+".sig",
  68.                                               nombreUsuario.obtener_id()+".twt", res_seg, res_sig, res_twt);
  69.            
  70.                 //  cout << nombreUsuario.obtener_id() << "***" << num_users << endl;
  71.                     //cout << nombreUsuario.obtener_id() << "***" << l << endl;
  72.             //      nombreUsuario.imprimir_seguidores(0);
  73.             //      nombreUsuario.imprimir_siguiendo(0);
  74.             //      nombreUsuario.imprimir_tweets(0);
  75.                     // aqui creo que tengo que ir añandiendo cada usuario a la lista de usuarios
  76.                     // Cargo usuario --> añado a usuarios->usuario y actualizo el ptr->sig ( AÑADIR AL FINAL)
  77.                     // Ya hay unna funcion que es  void insertar_usuario(const UsuarioTwitter &nuevo_usuario);
  78.                    
  79.                     this->insertar_usuario(nombreUsuario,res);   //¿POR QUE NO PUEDO HACER ESTO? VIOLACION DE SEGMENTO
  80.                     leer(f_in, user);
  81.                     num_users++;               
  82.             }
  83.                 ok= ok && f_in.eof();
  84.            
  85.             f_in.close();
  86.         }
  87.                                
  88.        
  89.       }
  90.  
  91.         // Constructor de copia de la clase
  92.         Twitter::Twitter(const Twitter &otro_twitter){
  93.            
  94.             PtrUsuario aux1, aux2=otro_twitter.usuarios;
  95.             usuarios=NULL;
  96.             if(aux2!=NULL){
  97.                 usuarios=new NodoUsuario;
  98.                 usuarios->sig=NULL;
  99.                 aux1=usuarios;
  100.                 aux2=aux2->sig;
  101.                 while(aux2!=NULL){
  102.                     aux1->sig=new NodoUsuario;
  103.                     aux1=aux1->sig;
  104.                     aux1->usuario=aux2->usuario;
  105.                     aux1->sig=NULL;
  106.                     aux2=aux2->sig;            
  107.                 }
  108.             }          
  109.         }
  110.  
  111.         // Operador de asignación
  112.      Twitter &  Twitter::operator=(const Twitter &otro_twitter){
  113.            
  114.             /*if(this!=otro_twitter){
  115.                 num_users=otro_twitter.num_users;
  116.                 for(unsigned i=0;i<num_users;i++){
  117.                    
  118.            
  119.            
  120.             }*/
  121.         }
  122.  
  123.         // Destructor de la clase.
  124.         //
  125.         Twitter::~Twitter(){
  126.             borrar_todo();
  127.         }
  128.  
  129.         // Devuelve el número de usuarios de la red social
  130.         unsigned Twitter::num_usuarios() const{
  131.             return num_users;
  132.         }
  133.         // Devuelve el id del usuario actualmente conectado. Si no hay usuario
  134.         // conectado, devuelve una cadena vacía
  135.         std::string Twitter::usuario_actual() const{
  136.             return usuarios->usuario.obtener_id();
  137.         }
  138.        
  139.         //------------------------------------------------------------------
  140.         // PARA EL USUARIO ACTUAL. |
  141.         // ------------------------|
  142.         //
  143.         // Devuelve los seguidores del usuario conectado
  144.         // Si no hay usuario conectado, los métodos
  145.         // devuelven false a través de 'conectado'. Si no, devuelven true.
  146.         // Devuelve la lista de seguidores
  147.         void Twitter::obtener_seguidores(Usuarios &lista_seg, bool &conectado) const{
  148.        
  149.        
  150.         }
  151.  
  152.         // Devuelve la lista de usuarios a los que se sigue el usuario conectado
  153.         void Twitter::obtener_siguiendo(Usuarios &lista_sig, bool &conectado) const{
  154.        
  155.         }
  156.  
  157.         // Devuelve la lista de tweets del usuario conectado
  158.         void Twitter::obtener_tweets(Tweets &lista_tweets, bool &conectado) const{
  159.        
  160.         }
  161.  
  162.         // OPCIONAL!
  163.         // Devuelve la lista de menciones al usuario conectado
  164.         // void obtener_menciones(Menciones &lista_men, bool &conectado) const;        
  165.  
  166.         // Indica si un determinado usuario es seguidor del usuario conectado
  167.         void Twitter::me_sigue(const std::string &otro_usuario, bool &mesigue, bool &conectado) const{
  168.        
  169.         }
  170.  
  171.         // Indica si este usuario conectado está siguiendo a otro
  172.         void Twitter::estoy_siguiendo(const std::string &otro_usuario, bool &sigo, bool &conectado) const{
  173.        
  174.         }
  175.  
  176.         // Devuelve el número de seguidores del usuario conectado
  177.         void Twitter::num_seguidores(unsigned &mesigue, bool &conectado) const{
  178.        
  179.         }
  180.  
  181.         // Devuelve el número de usuarios a los que sigue el usuario conectado
  182.         void Twitter::num_siguiendo(unsigned &siguiendo, bool &conectado) const{
  183.        
  184.         }
  185.  
  186.         // Devuelve el número de tweets del usuario
  187.         void Twitter::num_tweets(unsigned &n, bool &conectado) const{
  188.        
  189.         }
  190.  
  191.         // OPCIONAL!
  192.         // Devuelve el número de menciones
  193.         // void num_menciones(unsigned &n, bool &conectado) const;        
  194.  
  195.         // Imprime por pantalla la lista de seguidores
  196.         // Si num_imprime == 0, imprime todos los seguidores.
  197.         // PRECONDICIÓN: num_imprime <= num_seguidores
  198.         void Twitter::imprimir_seguidores(unsigned num_imprime, bool &conectado) const{
  199.        
  200.         }
  201.  
  202.         // Imprime por pantalla la lista de usuarios a los que sigue
  203.         // Si num_imprime == 0, imprime todos los usuarios a los que sigue.
  204.         // PRECONDICIÓN: num_imprime <= num_siguiendo
  205.         void Twitter::imprimir_siguiendo(unsigned num_imprime, bool &conectado) const{
  206.        
  207.         }
  208.  
  209.         // Imprime por pantalla la lista de tweets
  210.         // Si num_imprime == 0, imprime todos los tweets del usuario.
  211.         // PRECONDICIÓN: num_imprime <= num_tweets
  212.         void Twitter::imprimir_tweets(unsigned num_imprime, bool &conectado) const{
  213.        
  214.         }
  215.  
  216.         // OPCIONAL!
  217.         // Imprime por pantalla la lista de menciones del usuario conectado
  218.         // Si num_imprime == 0, imprime todas las menciones.
  219.         // PRECONDICIÓN: num_imprime <= num_menciones
  220.         // void imprimir_menciones(const unsigned num_imprime, bool &conectado) const;
  221.  
  222.         // Modifica el identificador del usuario actualmente conectado.
  223.         // Además, deben actualizarse las listas de 'seguidores' y
  224.         // 'siguiendo' de los demás usuarios de la red, de manera
  225.         // que el nuevo indentificador de usuario sustituya al
  226.         // antiguo en aquellas listas de usuarios donde aparecía.
  227.         // Devuelve 'true' si ha sido posible modificar el usuario
  228.         // actualmente conectado (el usuario existe en la red)
  229.         void Twitter::establecer_id(const std::string &nuevo_id, bool &conectado){
  230.            
  231.         }
  232.  
  233.         // Inserta un usuario en la lista de usuarios a los que sigue-
  234.         // El usuario debe estar conectado y el usuario al que se quiere
  235.         // seguir debe existir. Si no hay usuario conectado actualmente,
  236.         // se devuelve 'false' a través de 'conectado'. Si el usuario que
  237.         // se quiere incluir en la lista de usuarios seguidos no existe en la
  238.         // red, se devuelve 'NO_EXISTE' a través de 'res'.
  239.         // Si ambos usuarios existen, se actualizan las listas de seguidores
  240.         // y siguiendo.Si la lista de seguidores o siguiendo están
  241.         // llenas, se devuelve 'LISTA_LLENA' a través de 'res'.
  242.         void Twitter::nuevo_siguiendo(const std::string &nuevo, Resultado &res, bool &conectado){
  243.        
  244.         }
  245.  
  246.         // Inserta un nuevo tweet al final de la lista de tweets. Si la lista de
  247.         // tweets está llena, se devuelve 'LISTA_LLENA' a través de 'res'. Si no,
  248.         // se devuelve 'OK'. La longitud máxima
  249.         void Twitter::nuevo_tweet(const Tweet &nuevo, Resultado &res, bool &conectado){
  250.        
  251.         }
  252.  
  253.         // Elimina un usuario en la lista de usuarios a los que sigue
  254.         // El usuario debe estar conectado y el usuario al que se quiere
  255.         // dejar de seguir debe existir. Si no hay usuario conectado actualmente,
  256.         // se devuelve 'false' a través de 'conectado'. Si el usuario que
  257.         // se quiere eliminar de la lista de usuarios seguidos no existe en la
  258.         // red, se devuelve 'NO_EXISTE' a través de 'res'. Si ambos usuarios
  259.         // existen, se actualizan las lista se de seguidores y siguiendo,
  260.         // eliminando los nombres de los usuarios correspondientes.
  261.         void Twitter::eliminar_siguiendo(const std::string &usuario, Resultado &res, bool &conectado){
  262.        
  263.         }
  264.  
  265.         // OPCIONAL!
  266.         // Se obtiene la lista de menciones que los demás usuarios de
  267.         // la red tienen con el usuario actualmente conectado y se
  268.         // almacenan en la lista de menciones del usuario actualmente
  269.         // conectado.
  270.         // Las menciones comienzan todas con el carácter ampsersand ('@').
  271.         // void obtener_menciones(bool &conectado);
  272.  
  273.  
  274.      
  275.         //------------------------------------------------------------------
  276.         // MÉTODOS DE LA RED SOCIAL
  277.  
  278.         // Imprime por pantalla los usuarios actuales de la red social
  279.         void Twitter::imprimir_usuarios() const{
  280.            
  281.             PtrUsuario ptr=usuarios;
  282.             while((ptr!=NULL)){
  283.                 usuarios->usuario.obtener_id();
  284.                 ptr=ptr->sig;          
  285.             }
  286.         }
  287.  
  288.         // Cambia el usuario actualmente conectado a la red. Si el usuario
  289.         // existe, se cambia el usuario y se devuelve 'OK' a través del
  290.         // parámetro 'res'. Si el usuario no existe, se mantiene el usuario
  291.         // actual y se devuelve 'NO_EXISTE' a través del parámetro 'res'
  292.         void Twitter::cambiar_usuario_actual(const std::string &nuevo_id_actual, Resultado &res){
  293.        
  294.         }
  295.  
  296.         // Insertar un nuevo usuario en la red social, a partir de su
  297.         // id de usuario, con todos sus datos vacíos (lista de seguidores,
  298.         // lista de tweets, etc.). Si el id del nuevo usuario no existe,
  299.         // se inserta en la red y se devuelve 'OK' a través del parámetro
  300.         // 'res'. Si el usuario ya existía, se devuelve 'YA_EXISTE' a
  301.         // través de 'res'.
  302.         void Twitter::insertar_usuario(const std::string &nuevo_usuario, Resultado &res){
  303.            
  304.            
  305.             PtrUsuario ptr=buscar_usuario(nuevo_usuario);
  306.             if(ptr!=NULL){
  307.                 res=YA_EXISTE;
  308.             }else{
  309.                 //insertar_final(nuevo_usuario);
  310.                 res=OK;
  311.             }
  312.            
  313.         }
  314.  
  315.         // Insertar un nuevo usuario en la red social.
  316.         // Si el id del nuevo usuario no existe,
  317.         // se inserta en la red y se devuelve 'OK' a través del parámetro
  318.         // 'res'. Si el usuario ya existía, se devuelve 'YA_EXISTE' a
  319.         // través de 'res'.
  320.         void Twitter::insertar_usuario(const UsuarioTwitter &nuevo_usuario, Resultado &res){
  321.            
  322.            
  323.             PtrUsuario ptr=buscar_usuario(nuevo_usuario.obtener_id()); // ¿¿¿¿ERROR!!!!!!!!
  324.            
  325.             if(ptr!=NULL){
  326.                 res=YA_EXISTE;
  327.             }else{
  328.                 //insertar_final(nuevo_usuario);
  329.                 res=OK;
  330.             }
  331.         }
  332.  
  333.         // Elimina un usuario en la red social, a partir de su
  334.         // id de usuario. Si el id del nuevo usuario existe,
  335.         // se elimina de la red y se devuelve 'OK' a través del parámetro
  336.         // 'res'. Deben actualizarse la lista de seguidores y siguiendo
  337.         // en las listas de los demás usuarios de la red.
  338.         // Si el usuario no existía, se devuelve 'NO_EXISTE' a
  339.         // través de 'res'.
  340.         void Twitter::eliminar_usuario(const std::string &usuario, Resultado &res){
  341.        
  342.         }
  343.  
  344.         // Guarda toda la red social en disco. El nombre de fichero con los nombres de
  345.         // usuario se pasa como parámetro. Los datos de cada usuario se guardan
  346.         // según se indica en la clase UsuarioTwitter
  347.         void Twitter::guardar_todo(const std::string &nom_fic_usuario) const{
  348.        
  349.         }
  350.      
  351.      
  352.         // MÉTODOS PRIVADOS:
  353.        
  354.         // Busca un usuario en la lista de usuarios. Si lo encuentra,
  355.         // devuelve un puntero al nodo de la lista que contiene el usuario.
  356.         // Si no lo encuentra, devuelve NULL
  357.        Twitter::PtrUsuario Twitter::buscar_usuario(const std::string &id_usuario) const{
  358.            
  359.            
  360.             PtrUsuario ptr=usuarios;
  361.             while((ptr!=NULL)&&(ptr->usuario.obtener_id()!=id_usuario)){
  362.                 ptr=ptr->sig;
  363.             }    
  364.            
  365.             return ptr;
  366.        }
  367.  
  368.         // Eliminar toda la lista de usuarios
  369.         void Twitter::borrar_todo(){
  370.        
  371.             PtrUsuario aux;
  372.             while(usuarios!=NULL){
  373.                 aux=usuarios;
  374.                 usuarios=usuarios->sig;
  375.                 delete aux;
  376.             }
  377.         }
  378.      
  379.  
  380.         // Insertar un nuevo usuario al final de la lista de usuarios
  381.        
  382.        
  383.         void Twitter::insertar_final(const UsuarioTwitter &nuevo_usuario){                     
  384.                
  385.                 PtrUsuario ptr,nuevo;              
  386.                
  387.                 nuevo=new NodoUsuario;
  388.                 nuevo->usuario=nuevo_usuario;                  
  389.                 nuevo->sig=NULL;
  390.    
  391.                 if(usuarios==NULL){
  392.                    
  393.                     usuarios=nuevo;
  394.                 }else{
  395.                     ptr=usuarios;
  396.                     while(ptr->sig!=NULL){
  397.                         ptr=ptr->sig;
  398.                     }                  
  399.                     ptr->sig=nuevo;
  400.                 }                  
  401.            
  402.         }
  403.  
  404.         // Eliminar un usuario de la lista de usuarios
  405.         // PRECONDICIÓN: el usuario existe
  406.         void Twitter::borrar_usuario(const std::string &id_usuario){
  407.              
  408.                
  409.         }
  410.        
  411.  
  412. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!