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
|
/* Copyright (C) 2015 Mike Fleetwood
*
* 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 2 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/>.
*/
/* Minimal implementation of a class with some behaviours like a std::vector<Partition>.
* However internally the class manages pointers to Partition objects allowing for
* Partition object polymorphism.
* Reference:
* C++ Reference to std::vector
* http://www.cplusplus.com/reference/vector/vector/
*/
#ifndef GPARTED_PARTITIONVECTOR_H
#define GPARTED_PARTITIONVECTOR_H
#include "Partition.h"
#include <cstddef>
#include <vector>
namespace GParted
{
class Partition; // Forward declarations as Partition and PartitionVector are
class PartitionVector; // mutually recursive classes.
// References:
// Mutually recursive classes
// http://stackoverflow.com/questions/3410637/mutually-recursive-classes
// recursive definition in CPP
// http://stackoverflow.com/questions/4300420/recursive-definition-in-cpp
class PartitionVector {
public:
typedef size_t size_type;
typedef std::vector<Partition *>::iterator iterator;
PartitionVector() {};
PartitionVector( const PartitionVector & src );
~PartitionVector();
void swap( PartitionVector & other );
PartitionVector & operator=( PartitionVector rhs );
// Iterators
iterator begin() { return v.begin(); };
// Capacity
bool empty() const { return v.empty(); };
// Element access
Partition & operator[]( size_type n ) { return *v[n]; };
const Partition & operator[]( size_type n ) const { return *v[n]; };
size_type size() const { return v.size(); };
const Partition & front() const { return *v.front(); };
const Partition & back() const { return *v.back(); };
// Modifiers
void pop_back();
void erase( const iterator position );
void clear();
void push_back_adopt( Partition * partition );
void insert_adopt( iterator position, Partition * partition );
void replace_at( size_type n, const Partition * partition );
private:
std::vector<Partition *> v;
};
int find_extended_partition( const PartitionVector & partitions );
} //GParted
#endif /* GPARTED_PARTITIONVECTOR_H */
|
