c_virtual_file_system/Superblock.hpp at main · ButterDevelop/c_virtual_file_system · 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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
#ifndef SEMESTRALNIPRACE_SUPERBLOCK_HPP
#define SEMESTRALNIPRACE_SUPERBLOCK_HPP


#include <string>
#include <cmath>
#include "Constants.hpp"

using std::string;


class Superblock {
public:

    /**
     * Constructor for superblock
     */
    Superblock();

    /**
     * Constructor for superblock
     *
     * @param diskSize - size of disk in bytes
     */
    Superblock(int32_t diskSize);

    /**
     * Copy constructor
     *
     * @param other - other superblock
     */
    Superblock(const Superblock& other);

    /**
     * Assignment operator
     *
     * @param other - other superblock
     * @return this superblock
     */
    Superblock& operator=(const Superblock& other);

    /**
     * Destructor
     */
    ~Superblock();

    /**
     * Gets signature
     *
     * @return signature
     */
    const char* getSignature() const;

    /**
     * Sets signature
     *
     * @param signature - new signature
     */
    void setSignature(const char* signature);

    /**
     * Gets disk size
     *
     * @return disk size
     */
    int32_t getDiskSize() const;

    /**
     * Sets disk size
     *
     * @param diskSize - new disk size
     */
    void setDiskSize(int32_t diskSize);

    /**
     * Gets cluster size
     *
     * @return cluster size
     */
    int32_t getClusterSize() const;

    /**
     * Sets cluster size
     *
     * @param clusterSize - new cluster size
     */
    void setClusterSize(int32_t clusterSize);

    /**
     * Gets cluster count
     *
     * @return cluster count
     */
    int32_t getClusterCount() const;

    /**
     * Sets cluster count
     *
     * @param clusterCount - new cluster count
     */
    void setClusterCount(int32_t clusterCount);

    /**
     * Gets inode count
     *
     * @return inode count
     */
    int32_t getInodeCount() const;

    /**
     * Sets inode count
     *
     * @param inodeCount - new inode count
     */
    void setInodeCount(int32_t inodeCount);

    /**
     * Gets bitmap cluster count
     *
     * @return bitmap cluster count
     */
    int32_t getBitmapClusterCount() const;

    /**
     * Sets bitmap cluster count
     *
     * @param bitmapClusterCount - new bitmap cluster count
     */
    void setBitmapClusterCount(int32_t bitmapClusterCount);

    /**
     * Gets inode cluster count
     *
     * @return inode cluster count
     */
    int32_t getInodeClusterCount() const;

    /**
     * Sets inode cluster count
     *
     * @param inodeClusterCount - new inode cluster count
     */
    void setInodeClusterCount(int32_t inodeClusterCount);

    /**
     * Gets data cluster count
     *
     * @return data cluster count
     */
    int32_t getDataClusterCount() const;

    /**
     * Sets data cluster count
     *
     * @param dataClusterCount - new data cluster count
     */
    void setDataClusterCount(int32_t dataClusterCount);

    /**
     * Gets bitmap start address
     *
     * @return bitmap start address
     */
    int32_t getBitmapStartAddress() const;

    /**
     * Sets bitmap start address
     *
     * @param bitmapStartAddress - new bitmap start address
     */
    void setBitmapStartAddress(int32_t bitmapStartAddress);

    /**
     * Gets inode start address
     *
     * @return inode start address
     */
    int32_t getInodeStartAddress() const;

    /**
     * Sets inode start address
     *
     * @param inodeStartAddress - new inode start address
     */
    void setInodeStartAddress(int32_t inodeStartAddress);

    /**
     * Gets data start address
     *
     * @return data start address
     */
    int32_t getDataStartAddress() const;

    /**
     * Sets data start address
     *
     * @param dataStartAddress - new data start address
     */
    void setDataStartAddress(int32_t dataStartAddress);

private:
    char* signature;
    int32_t diskSize;
    int32_t clusterSize;
    int32_t clusterCount;
    int32_t inodeCount;
    int32_t bitmapClusterCount;
    int32_t inodeClusterCount;
    int32_t dataClusterCount;
    int32_t bitmapStartAddress;
    int32_t inodeStartAddress;
    int32_t dataStartAddress;
};

/**
 * Initializes superblock
 *
 * @param disk_size - size of disk in bytes
 * @return pointer to superblock
 */
Superblock* superblockInit(int32_t disk_size);

#endif //SEMESTRALNIPRACE_SUPERBLOCK_HPP