LinQedIn/esperienza.cpp at master · nikname/LinQedIn · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#include <QList>
#include <QListIterator>
#include "esperienza.h"
#include "lavoro.h"

// CLASSE Esperienza_rapp
class Esperienza::Esperienza_rapp {
public:
    QList<SmartLavoro> experiencesList;
    int references;

    /** Costruttore ad 1 parametro con 1 parametro di default.
     *  Inizializza ad 1 il numero di riferimenti.
     */
    Esperienza_rapp( QList<SmartLavoro> l = QList<SmartLavoro>() ) :
        experiencesList( l ),
        references( 1 ) // Gestito da Esperienza
    {}

    /** Distruttore Esperienza_rapp.
     *  Invoca il metodo clear() sulla lista delle esperienze lavorative dell'utente.
     *
     * @param void* p  Puntatore all'oggetto Esperienza_rapp.
     */
    void operator delete( void* p ) {
        if( p ) {
            Esperienza_rapp* p_aux = static_cast<Esperienza_rapp*>( p );
            p_aux->references--;
            if( !p_aux->references )
                p_aux->experiencesList.clear();
        }
    }

    /** Metodo di utilità necessario per creare copie profonde di oggetti di tipo Esperienza_rapp.
     *
     * @return Esperienza_rapp *  Copia implicita della lista delle esperienze lavorative.
     */
    Esperienza_rapp *clone() const {
        return new Esperienza_rapp( experiencesList );
    }
};

// COSTRUTTORE Esperienza
Esperienza::Esperienza() :
    experiences( new Esperienza_rapp ),
    user_ref( 1 )
{}

// COSTRUTTORE di COPIA Esperienza
Esperienza::Esperienza( const Esperienza& n ) :
    experiences( n.experiences )
{
    user_ref++;
    experiences->references++;
}

// DISTRUTTORE Esperienza
Esperienza::~Esperienza() {
    experiences->references--;
    if( experiences->references == 0 )
        delete experiences;
}

// CLASSE Iteratore_rapp
class Esperienza::Iteratore::Iteratore_rapp {
public:
    QListIterator<SmartLavoro> it;

    /** Costruttore ad 1 parametro.
     *  Costruttore di default non disponibile.
     *
     * @param QList<SmartLavoro>  Lista di SmartLavoro sulla quale iterare.
     */
    Iteratore_rapp( QList<SmartLavoro> list ) : it( list ) {}
};

// METODO Esperienza::Iteratore::hasNext
bool Esperienza::Iteratore::hasNext() const {
    if( iterator )
        return iterator->it.hasNext();
    return false;
}

// METODO Esperienza::Iteratore::next
SmartLavoro Esperienza::Iteratore::next() {
    return iterator->it.next();
}

// METODO Esperienza::Iteratore::begin
Esperienza::Iteratore Esperienza::begin() const {
    Iteratore aux;
    aux.iterator = new Iteratore::Iteratore_rapp( experiences->experiencesList );
    return aux;
}

// METODO Esperienza::addExperience( SmartLavoro )
void Esperienza::addExperience( const SmartLavoro& l ) {
    experiences->experiencesList.append( l );
}

// METODO Esperienza::removeExperience( SmartLavoro )
void Esperienza::removeExperience( const SmartLavoro& l ) {
    experiences->experiencesList.removeAll( l );
}

// METODO Esperienza::getExperiencesList
QVector<SmartLavoro> Esperienza::getExperiencesList() const {
    QVector<SmartLavoro> v;
    QListIterator<SmartLavoro> it( experiences->experiencesList );
    while( it.hasNext() )
        v.push_back( SmartLavoro( it.next() ) );
    return v;
}

// METODO Esperienza::setExperiencesList
void Esperienza::setExperiencesList( QVector<SmartLavoro> v ) {
    if( experiences ) {
        delete experiences;
        experiences = 0;
    }
    experiences = new Esperienza_rapp();
    for( int i = 0; i < v.size(); i ++ )
        addExperience( v[i] );
}

// OVERLOADING
QDebug& operator <<( QDebug& qdbg, const Esperienza& e ) {
    qdbg << "ESPERIENZE: " << "\n";
    QVector<SmartLavoro> ex = e.getExperiencesList();
    if( ex.size() == 0 )
        qdbg << " ** Nessuna esperienza lavorativa! **" << "\n";
    else {
        for( int i = 0; i < ex.size(); i++ ) {
            qdbg << " Azienda: " << ex[i]->getCompanyName() << "\n";
            qdbg << " Ruolo: " << ex[i]->getTitle() << "\n";
            qdbg << " Inizio: " << ex[i]->getBegin().toString( "dd/MM/yyyy" ) << "\n";
            qdbg << " Fine: " << ex[i]->getEnd().toString( "dd/MM/yyyy" ) << "\n";
        }
    }
    return qdbg;
}