├── user.cpp
├── user.h
├── main.cpp
├── widget.h
├── cglobal.cpp
├── cglobal.h
├── mainwindow.h
├── memory_monitor.h
├── data_define.cpp
├── systemwindow.ui
├── dialog_gen_data.h
├── folder_manager.h
├── memory_monitor.ui
├── disk_monitor.h
├── dialog_delete_data.h
├── gendatathread.h
├── disk_manager.h
├── window_exe_data.h
├── gendatathread.cpp
├── cereal
    ├── external
    │   ├── rapidjson
    │   │   ├── internal
    │   │   │   ├── swap.h
    │   │   │   ├── strfunc.h
    │   │   │   ├── ieee754.h
    │   │   │   └── pow10.h
    │   │   ├── cursorstreamwrapper.h
    │   │   ├── ostreamwrapper.h
    │   │   ├── memorybuffer.h
    │   │   ├── memorystream.h
    │   │   ├── filereadstream.h
    │   │   ├── filewritestream.h
    │   │   ├── error
    │   │   │   └── en.h
    │   │   ├── stringbuffer.h
    │   │   ├── istreamwrapper.h
    │   │   └── fwd.h
    │   ├── rapidxml
    │   │   ├── license.txt
    │   │   ├── rapidxml_utils.hpp
    │   │   └── rapidxml_iterators.hpp
    │   └── base64.hpp
    ├── types
    │   ├── map.hpp
    │   ├── unordered_map.hpp
    │   ├── functional.hpp
    │   ├── utility.hpp
    │   ├── atomic.hpp
    │   ├── complex.hpp
    │   ├── list.hpp
    │   ├── deque.hpp
    │   ├── optional.hpp
    │   ├── forward_list.hpp
    │   ├── string.hpp
    │   ├── chrono.hpp
    │   ├── stack.hpp
    │   ├── concepts
    │   │   └── pair_associative_container.hpp
    │   ├── array.hpp
    │   ├── set.hpp
    │   ├── unordered_set.hpp
    │   ├── valarray.hpp
    │   ├── variant.hpp
    │   ├── tuple.hpp
    │   ├── vector.hpp
    │   ├── queue.hpp
    │   └── common.hpp
    ├── version.hpp
    └── details
    │   ├── polymorphic_impl_fwd.hpp
    │   ├── util.hpp
    │   └── static_object.hpp
├── README.md
├── memory_manager.h
├── systemwindow.h
├── OperatingSystem.pro
├── memory_monitor.cpp
├── dialog_delete_data.cpp
├── mainwindow.cpp
├── dialog_delete_data.ui
├── dialog_gen_data.cpp
├── folder_manager.cpp
├── disk_monitor.cpp
├── mainwindow.ui
├── window_exe_data.cpp
└── dialog_gen_data.ui


/user.cpp:
--------------------------------------------------------------------------------
1 | #include "user.h"
2 | 
3 | User::User()
4 | {
5 | 
6 | }
7 | 
8 | std::string User::userName = "未命名";
9 | 


--------------------------------------------------------------------------------
/user.h:
--------------------------------------------------------------------------------
 1 | #ifndef USER_H
 2 | #define USER_H
 3 | 
 4 | #include <string>
 5 | 
 6 | class User
 7 | {
 8 | public:
 9 |     User();
10 |     // 用户名
11 |     static std::string userName;
12 | };
13 | 
14 | #endif // USER_H
15 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "mainwindow.h"
 2 | #include <QApplication>
 3 | 
 4 | int main(int argc, char *argv[])
 5 | {
 6 |     QApplication a(argc, argv);
 7 |     MainWindow w;
 8 |     w.show();
 9 | 
10 |     return a.exec();
11 | }
12 | 


--------------------------------------------------------------------------------
/widget.h:
--------------------------------------------------------------------------------
 1 | #ifndef WIDGET_H
 2 | #define WIDGET_H
 3 | 
 4 | #include <QWidget>
 5 | #include "main_form.h"
 6 | 
 7 | namespace Ui{
 8 |     class Widget;
 9 | }
10 | 
11 | class Widget : public QWidget
12 | {
13 | public:
14 |     explicit Widget(QWidget * parent = nullptr);
15 | 
16 | private:
17 |     Ui::Widget *ui;
18 |     main_form * mform;
19 | };
20 | 
21 | #endif // WIDGET_H
22 | 


--------------------------------------------------------------------------------
/cglobal.cpp:
--------------------------------------------------------------------------------
 1 | #include "cglobal.h"
 2 | 
 3 | 
 4 | CGlobal::CGlobal()
 5 | {
 6 | 
 7 | }
 8 | 
 9 | // 初始化内存互斥信号量
10 | QSemaphore* CGlobal::mSem = new QSemaphore(1);
11 | QSemaphore* CGlobal::delThreadSem = new QSemaphore(1);
12 | QSemaphore* CGlobal::genThreadSem = new QSemaphore(1);
13 | // 初始化管理器
14 | DiskManager* CGlobal::dManager = new DiskManager();
15 | FolderManager* CGlobal::fManager = new FolderManager(CGlobal::dManager);
16 | MemoryManager* CGlobal::mManager = new MemoryManager(CGlobal::dManager);
17 | 


--------------------------------------------------------------------------------
/cglobal.h:
--------------------------------------------------------------------------------
 1 | #ifndef CGLOBAL_H
 2 | #define CGLOBAL_H
 3 | 
 4 | #include "disk_manager.h"
 5 | #include "folder_manager.h"
 6 | #include "memory_manager.h"
 7 | #include <QSemaphore>
 8 | #include <QWidget>
 9 | 
10 | class CGlobal
11 | {
12 | public:
13 |     CGlobal();
14 | 
15 |     // 磁盘管理
16 |     static DiskManager* dManager;
17 |     static FolderManager* fManager;
18 | 
19 |     static QSemaphore* mSem;
20 |     // 内存管理器，其内存为互斥量
21 |     static MemoryManager* mManager;
22 | 
23 |     // 公有变量
24 |     static QSemaphore* genThreadSem;
25 |     static QSemaphore* delThreadSem;
26 | 
27 | 
28 | };
29 | 
30 | 
31 | #endif // CGLOBAL_H
32 | 


--------------------------------------------------------------------------------
/mainwindow.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAINWINDOW_H
 2 | #define MAINWINDOW_H
 3 | 
 4 | #include <QMainWindow>
 5 | #include <QTableView>
 6 | #include <QStandardItem>
 7 | #include <QStandardItemModel>
 8 | #include "systemwindow.h"
 9 | namespace Ui {
10 |     class MainWindow;
11 | }
12 | 
13 | class MainWindow : public QMainWindow
14 | {
15 |     Q_OBJECT
16 | 
17 | public:
18 |     explicit MainWindow(QWidget *parent = nullptr);
19 |     ~MainWindow();
20 | 
21 | 
22 | private slots:
23 |     void on_pushButton_clicked();
24 |     //
25 |     void showDialog(QDialog * dialog);
26 | 
27 | private:
28 |     Ui::MainWindow *ui;
29 |     SystemWindow sysWin;
30 |     CGlobal* cglobal;
31 | 
32 |     //表格属性
33 |     QStandardItemModel * model;
34 | 
35 | };
36 | 
37 | #endif // MAINWINDOW_H
38 | 


--------------------------------------------------------------------------------
/memory_monitor.h:
--------------------------------------------------------------------------------
 1 | #ifndef MEMORY_MONITOR_H
 2 | #define MEMORY_MONITOR_H
 3 | 
 4 | #include <QMainWindow>
 5 | #include <QStandardItemModel>
 6 | #include "cglobal.h"
 7 | #include <QDebug>
 8 | #include <QTableView>
 9 | 
10 | namespace Ui {
11 | class MemoryMonitor;
12 | }
13 | 
14 | class MemoryMonitor : public QMainWindow
15 | {
16 |     Q_OBJECT
17 | 
18 | public:
19 |     explicit MemoryMonitor(QWidget *parent = nullptr);
20 |     ~MemoryMonitor();
21 | 
22 |     // 表格属性
23 |     QTableView *tv_memory;
24 |     QStandardItemModel * model;
25 | 
26 | signals:
27 |     // 通知主线程更新线程
28 |     void needUpdate();
29 | 
30 | public slots:
31 |     // 刷新内存
32 |     void updateMemoryUI();
33 | 
34 | 
35 | private:
36 |     Ui::MemoryMonitor *ui;
37 | };
38 | 
39 | #endif // MEMORY_MONITOR_H
40 | 


--------------------------------------------------------------------------------
/data_define.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by Zhang Boyu on 2019/12/28.
 3 | //
 4 | 
 5 | #include "data_define.h"
 6 | 
 7 | void outputStr(string s){
 8 |     // 先用cout进行输出，后续使用QString进行输出
 9 |     std::cout<<s<<endl;
10 | }
11 | 
12 | //需要特别注意的是，年份是从1900年起至今多少年，而不是直接存储如2011年，月份从0开始的，0表示一月，星期也是从0开始的， 0表示星期日，1表示星期一。
13 | QString parseTM(tm t)
14 | {
15 |     // 年-月-日：时分秒
16 |     return QString::number(1900+t.tm_year)+"年"+QString::number(t.tm_mon+1)+"月"+QString::number(t.tm_mday)+"日("+QString::number(t.tm_hour)+"时"+QString::number(t.tm_min)+"分"+QString::number(t.tm_sec)+"秒)";
17 | }
18 | 
19 | //需要特别注意的是，年份是从1900年起至今多少年，而不是直接存储如2011年，月份从0开始的，0表示一月，星期也是从0开始的， 0表示星期日，1表示星期一。
20 | QString parseTMSimple(tm t)
21 | {
22 |     // 年-月-日：时分秒
23 |     return "("+QString::number(t.tm_hour)+"时"+QString::number(t.tm_min)+"分"+QString::number(t.tm_sec)+"秒)";
24 | }
25 | 


--------------------------------------------------------------------------------
/systemwindow.ui:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ui version="4.0">
 3 |  <class>SystemWindow</class>
 4 |  <widget class="QMainWindow" name="SystemWindow">
 5 |   <property name="geometry">
 6 |    <rect>
 7 |     <x>0</x>
 8 |     <y>0</y>
 9 |     <width>640</width>
10 |     <height>240</height>
11 |    </rect>
12 |   </property>
13 |   <property name="windowTitle">
14 |    <string>MainWindow</string>
15 |   </property>
16 |   <widget class="QWidget" name="centralwidget"/>
17 |   <widget class="QMenuBar" name="menubar">
18 |    <property name="geometry">
19 |     <rect>
20 |      <x>0</x>
21 |      <y>0</y>
22 |      <width>640</width>
23 |      <height>22</height>
24 |     </rect>
25 |    </property>
26 |   </widget>
27 |   <widget class="QStatusBar" name="statusbar"/>
28 |  </widget>
29 |  <resources/>
30 |  <connections/>
31 | </ui>
32 | 


--------------------------------------------------------------------------------
/dialog_gen_data.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOG_GEN_DATA_H
 2 | #define DIALOG_GEN_DATA_H
 3 | 
 4 | #include <QDialog>
 5 | #include <QDialogButtonBox>
 6 | #include <QVBoxLayout>
 7 | #include <QLineEdit>
 8 | #include "cglobal.h"
 9 | 
10 | namespace Ui {
11 | class dialog_gen_data;
12 | }
13 | 
14 | class dialog_gen_data : public QDialog
15 | {
16 |     Q_OBJECT
17 | 
18 | public:
19 |     explicit dialog_gen_data(QWidget *parent = nullptr);
20 |     ~dialog_gen_data();
21 | 
22 | signals:
23 |     // 数据更新了
24 |     void dataUpdated();
25 | 
26 | private:
27 |     Ui::dialog_gen_data *ui;
28 |     // 编辑框
29 |     QLineEdit* edit_fileName;
30 |     QLineEdit* edit_fileContent;
31 | 
32 |     // QWidget interface
33 | protected:
34 |     void closeEvent(QCloseEvent *event);
35 | private slots:
36 |     void on_btn_submit_clicked();
37 |     void on_message_btn_ok();
38 |     void changeInputCount(const QString &text);
39 | };
40 | 
41 | #endif // DIALOG_GEN_DATA_H
42 | 


--------------------------------------------------------------------------------
/folder_manager.h:
--------------------------------------------------------------------------------
 1 | #ifndef FOLDERMANAGER_H
 2 | #define FOLDERMANAGER_H
 3 | #include "disk_manager.h"
 4 | #include "data_define.h"
 5 | #include <time.h>
 6 | #include "user.h"
 7 | 
 8 | class FolderManager
 9 | {
10 | public:
11 |     // 暂存磁盘管理的指针变量
12 |     DiskManager * dManager;
13 |     //FCN保存的
14 |     FCB fileTable[128];
15 |     bool fileLocks[128];
16 |     //初始化
17 |     FolderManager(DiskManager * dManager);
18 |     // 添加目录项，注意：添加时记得往element里面填写tm时间数据
19 |     int generateData(string data,string fileName);
20 |     // 按照指针指向的FolderElement删除目录项
21 |     int deleteData(FCB* element);
22 |     // 读取数据
23 |     string getData(FCB* element);
24 |     // 输出信息：获取所有文件
25 |     queue<FCB*> getFiles();
26 |     //上锁
27 |     int lockFile(FCB * fcb);
28 |     //不上锁
29 |     int unlockFile(FCB * fcb);
30 | 
31 |     // 序列化函数
32 |     template<class Archive>
33 |     void serialize(Archive & ar){
34 |         ar(CEREAL_NVP(fileTable),CEREAL_NVP(fileLocks));
35 |     }
36 | 
37 | };
38 | 
39 | #endif // FOLDERMANAGER_H
40 | 


--------------------------------------------------------------------------------
/memory_monitor.ui:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ui version="4.0">
 3 |  <class>MemoryMonitor</class>
 4 |  <widget class="QMainWindow" name="MemoryMonitor">
 5 |   <property name="geometry">
 6 |    <rect>
 7 |     <x>0</x>
 8 |     <y>0</y>
 9 |     <width>640</width>
10 |     <height>615</height>
11 |    </rect>
12 |   </property>
13 |   <property name="windowTitle">
14 |    <string>MainWindow</string>
15 |   </property>
16 |   <widget class="QWidget" name="centralwidget">
17 |    <widget class="QTableView" name="tv_memory">
18 |     <property name="geometry">
19 |      <rect>
20 |       <x>30</x>
21 |       <y>10</y>
22 |       <width>581</width>
23 |       <height>551</height>
24 |      </rect>
25 |     </property>
26 |    </widget>
27 |   </widget>
28 |   <widget class="QMenuBar" name="menubar">
29 |    <property name="geometry">
30 |     <rect>
31 |      <x>0</x>
32 |      <y>0</y>
33 |      <width>640</width>
34 |      <height>22</height>
35 |     </rect>
36 |    </property>
37 |   </widget>
38 |   <widget class="QStatusBar" name="statusbar"/>
39 |  </widget>
40 |  <resources/>
41 |  <connections/>
42 | </ui>
43 | 


--------------------------------------------------------------------------------
/disk_monitor.h:
--------------------------------------------------------------------------------
 1 | #ifndef DISK_MONITOR_H
 2 | #define DISK_MONITOR_H
 3 | 
 4 | #include "data_define.h"
 5 | #include "cglobal.h"
 6 | 
 7 | #include <QDebug>
 8 | #include <QtGui>
 9 | #include <QStandardItemModel>
10 | #include <QLabel>
11 | #include <QMainWindow>
12 | #include <QTableView>
13 | 
14 | namespace Ui {
15 | class DiskMonitor;
16 | }
17 | 
18 | class DiskMonitor : public QMainWindow
19 | {
20 |     Q_OBJECT
21 | 
22 | public:
23 |     explicit DiskMonitor(QWidget *parent = nullptr);
24 |     ~DiskMonitor();
25 | 
26 | 
27 |     QTableView* tv_disk;
28 |     QStandardItemModel* model;
29 | 
30 |     QStandardItemModel* notFreeModel;
31 |     QLabel *ll_data;
32 |     QLabel *ll_status;
33 |     QLabel *ll_pos;
34 |     QLabel *ll_page;
35 |     QLabel *ll_totoal_free;
36 | 
37 | 
38 | private:
39 |     Ui::DiskMonitor *ui;
40 | 
41 |     queue<BitMapItem> qMapTemp;
42 |     BitMapItem bMItem[32][32];
43 | 
44 | signals:
45 |     // 通知主线程更新线程
46 |     void needUpdate();
47 | 
48 | public slots:
49 |     // 刷新内存
50 |     void updateDiskUI();
51 |     // 点击表格事件
52 |     void onTableClicked(const QModelIndex & mIndex);
53 | };
54 | 
55 | #endif // DISK_MONITOR_H
56 | 


--------------------------------------------------------------------------------
/dialog_delete_data.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOG_DELETE_DATA_H
 2 | #define DIALOG_DELETE_DATA_H
 3 | 
 4 | #include <QDebug>
 5 | #include <QQueue>
 6 | #include <QDialog>
 7 | #include <QListView>
 8 | #include <QList>
 9 | #include <QMessageBox>
10 | #include <QStandardItem>
11 | #include <QStandardItemModel>
12 | #include "cglobal.h"
13 | 
14 | namespace Ui {
15 | class dialog_delete_data;
16 | }
17 | 
18 | class dialog_delete_data : public QDialog
19 | {
20 |     Q_OBJECT
21 | 
22 | public:
23 |     explicit dialog_delete_data(QWidget *parent = nullptr);
24 |     ~dialog_delete_data();
25 | 
26 | private:
27 |     Ui::dialog_delete_data *ui;
28 |     QListView *lv_fileLists;
29 |     QQueue<FCB*> tmpFCB;
30 |     QStandardItemModel * model;
31 | 
32 |     // 选中的行数
33 |     int row_selected;
34 | 
35 |     // QWidget interface
36 |     QLabel* ll_owner;
37 |     QLabel* ll_fileSize;
38 | protected:
39 |     void closeEvent(QCloseEvent *event);
40 |     void getFileList();
41 | signals:
42 |     void dataUpdated();
43 | 
44 | 
45 | public slots:
46 |     void on_pushButton_clicked();
47 |     // 点击文件
48 |     void showClick(QModelIndex index);
49 |     // 刷新文件列表
50 |     void refresh();
51 | 
52 | };
53 | 
54 | #endif // DIALOG_DELETE_DATA_H
55 | 


--------------------------------------------------------------------------------
/gendatathread.h:
--------------------------------------------------------------------------------
 1 | #ifndef GENDATATHREAD_H
 2 | #define GENDATATHREAD_H
 3 | 
 4 | #include <qthread.h>
 5 | #include "data_define.h"
 6 | #include "cglobal.h"
 7 | #include <QSemaphore>
 8 | #include <QDebug>
 9 | #include <QDialog>
10 | #include <QVBoxLayout>
11 | #include <QMessageBox>
12 | 
13 | // 执行线程互斥访问信号量
14 | 
15 | class GenDataThread : public QThread
16 | {
17 |     Q_OBJECT
18 | public:
19 |     QString id = "生成数据线程";
20 |     GenDataThread();
21 | 
22 | 
23 | protected:
24 |     void run();
25 | 
26 | signals:
27 |     void showMessage(QString str);
28 |     void openUI();
29 | 
30 | };
31 | 
32 | 
33 | 
34 | class DelDataThread : public QThread
35 | {
36 |     Q_OBJECT
37 | public:
38 |     QString id = "删除线程";
39 |     DelDataThread();
40 | 
41 | 
42 | protected:
43 |     void run();
44 | 
45 | signals:
46 |     void showMessage(QString str);
47 |     void openUI();
48 | 
49 | 
50 | };
51 | 
52 | 
53 | class ExeDataThread : public QThread
54 | {
55 |     Q_OBJECT
56 | public:
57 |     QString id = "执行线程";
58 |     ExeDataThread();
59 | 
60 | protected:
61 |     void run();
62 | 
63 | signals:
64 |     void openUI(TCB* tcb);
65 |     // 通知内存有变动
66 |     void notify();
67 |     void showMessage(QString str);
68 | 
69 | public slots:
70 | 
71 | };
72 | 
73 | #endif // GENDATATHREAD_H
74 | 


--------------------------------------------------------------------------------
/disk_manager.h:
--------------------------------------------------------------------------------
 1 | #ifndef DISKMANAGER_H
 2 | #define DISKMANAGER_H
 3 | #define BLOCK_SIZE   4
 4 | #include <queue>
 5 | #include "data_define.h"
 6 | // 序列化存盘
 7 | #include "cereal/archives/json.hpp"
 8 | #include "cereal/types/unordered_map.hpp"
 9 | #include "cereal/types/memory.hpp"
10 | #include "cereal/types/string.hpp"
11 | 
12 | class DiskManager
13 | {
14 | public:
15 |     //磁盘空间
16 |     string disk[1024];
17 | 
18 |     //位示图
19 |     BitMapItem Map[1024];
20 | 
21 |     // 构造函数
22 |     DiskManager();
23 | 
24 |     //删除对换区数据
25 |     int deleteBlock(FCB *e);
26 | 
27 |     //磁盘分配
28 |     int changeBlock(FCB *e,string dt,int number);
29 | 
30 |     //释放盘块
31 |     int ReleaseBlock(FCB *e);
32 | 
33 |     // 从内存接收对换数据  换入数据
34 |     int receiveM(FCB * e,int pageNumber,string data);
35 | 
36 |     //对内存输出对换数据   换出数据
37 |     string returnM(FCB* e,int number);
38 | 
39 |     // 目录管理申请删除
40 |     int receiveF_delete(FCB * e);
41 | 
42 |     // 目录管理申请添加
43 |     int receiveF_add(FCB *e,string data);
44 | 
45 |     // 目录管理申请读取
46 |     string receiveF_read(FCB* e);
47 | 
48 |     // 输出接口，输出位示图，注意：输出当前位示图中的每一个元素，用queue传值
49 |     queue<BitMapItem> getCurrentBitMap();
50 | 
51 |     //根据文件大小分配混合索引的盘块号
52 |     Index_File indexFile(int filesize);
53 | 
54 |     // 序列化函数
55 |     template<class Archive>
56 |     void serialize(Archive & ar){
57 |         ar(CEREAL_NVP(disk),CEREAL_NVP(Map));
58 |     }
59 | 
60 | };
61 | 
62 | 
63 | 
64 | #endif // DISKMANAGER_H
65 | 


--------------------------------------------------------------------------------
/window_exe_data.h:
--------------------------------------------------------------------------------
 1 | #ifndef EXE_FORM_H
 2 | #define EXE_FORM_H
 3 | 
 4 | #include <QLabel>
 5 | #include <QListView>
 6 | #include <QMainWindow>
 7 | #include <QPushButton>
 8 | #include <QDebug>
 9 | #include <QWidget>
10 | #include <QMessageBox>
11 | #include <QStandardItem>
12 | #include <QStandardItemModel>
13 | #include <QQueue>
14 | #include <QSpinBox>
15 | #include <QTextBrowser>
16 | 
17 | #include "data_define.h"
18 | #include "cglobal.h"
19 | 
20 | namespace Ui {
21 | class window_exe_data;
22 | }
23 | 
24 | class window_exe_data : public QWidget
25 | {
26 |     Q_OBJECT
27 | 
28 | public:
29 |     explicit window_exe_data(QWidget *parent = nullptr,TCB* tcb=nullptr);
30 |     ~window_exe_data();
31 | 
32 | 
33 | 
34 | 
35 | private:
36 |     Ui::window_exe_data *ui;
37 |     QPushButton *btnRead;
38 | 
39 |     QListView* lv_fileList;
40 |     QLabel * ll_createTime;
41 |     QLabel * ll_owner;
42 |     QLabel * ll_fileSize;
43 |     QLabel * ll_fileName;
44 |     QLabel * ll_loadFile;
45 |     QStandardItemModel * model;
46 |     QSpinBox * nb_pageNumber;
47 |     QTextBrowser * tb_outputBuffer;
48 | 
49 |     QQueue<FCB*> tmpFCB;
50 |     TCB* tcb;
51 |     FCB* fileSelected;
52 |     bool isInUse;
53 | 
54 | signals:
55 |     // 做一次操作后，通知主线程更新
56 |     void notifyUpdate();
57 | 
58 | public slots:
59 |     void on_pushButton_clicked();
60 |     // 更新文件列表
61 |     void updateFiles();
62 | 
63 |     void on_btn_load_clicked();
64 |     // 选择了文件
65 |     void showClick(QModelIndex index);
66 | 
67 |     // QWidget interface
68 | protected:
69 |     void closeEvent(QCloseEvent *event);
70 | };
71 | 
72 | #endif // EXE_FORM_H
73 | 


--------------------------------------------------------------------------------
/gendatathread.cpp:
--------------------------------------------------------------------------------
 1 | #include "gendatathread.h"
 2 | #include <QLabel>
 3 | 
 4 | // 构造函数
 5 | GenDataThread::GenDataThread()
 6 | {
 7 |     // 备用
 8 | }
 9 | 
10 | ExeDataThread::ExeDataThread()
11 | {
12 |     // 备用
13 | }
14 | 
15 | DelDataThread::DelDataThread()
16 | {
17 |     // 备用
18 | }
19 | 
20 | // 多线程
21 | void GenDataThread::run()
22 | {
23 |     qDebug()<<"开始运行数据生成线程";
24 |     //等待对话框
25 |     bool status = CGlobal::genThreadSem->tryAcquire();
26 |     if (status == false){
27 |         emit showMessage("线程正在运行，但需要等待*数据生成线程*结束...");
28 |         CGlobal::genThreadSem->acquire();
29 |     }
30 |     qDebug()<<"开始运行";
31 |     // 显示等待加载框
32 |     // 打开MainWindow
33 |     emit openUI();
34 |     qDebug()<<"运行结束";
35 |     this->exec();
36 | }
37 | 
38 | 
39 | void DelDataThread::run()
40 | {
41 |     qDebug()<<"开始运行数据删除线程";
42 |     //等待对话框
43 |     bool status = CGlobal::delThreadSem->tryAcquire();
44 |     if (status == false){
45 |         emit showMessage("线程正在运行，但需要等待*数据删除线程*结束...");
46 |         CGlobal::delThreadSem->acquire();
47 |     }
48 |     qDebug()<<"开始运行";
49 |     // 通知主线程打开UI
50 |     emit openUI();
51 |     qDebug()<<"运行结束";
52 |     this->exec();
53 | }
54 | 
55 | // 执行进程，互斥访问内存
56 | void ExeDataThread::run()
57 | {
58 |     TCB* tcb = new TCB();
59 |     // 线程向内存管理器申请内存
60 | //    int status = CGlobal::mManager->allocMemory(tcb);
61 |     int status = STATUS_OK;
62 |         // 先申请4块内容
63 |     if (status == STATUS_OK){
64 |         // 通知主线程打开UI，调用tcb
65 |         emit openUI(tcb);
66 |     } else {
67 |         emit showMessage("内存不足，无法打开更多的执行线程，请关闭一些执行线程再重试");
68 |     }
69 |     emit notify();
70 |     this->exec();
71 | }
72 | 
73 | 
74 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/internal/swap.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | //
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_INTERNAL_SWAP_H_
16 | #define CEREAL_RAPIDJSON_INTERNAL_SWAP_H_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | #if defined(__clang__)
21 | CEREAL_RAPIDJSON_DIAG_PUSH
22 | CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
23 | #endif
24 | 
25 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
26 | namespace internal {
27 | 
28 | //! Custom swap() to avoid dependency on C++ <algorithm> header
29 | /*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
30 |     \note This has the same semantics as std::swap().
31 | */
32 | template <typename T>
33 | inline void Swap(T& a, T& b) CEREAL_RAPIDJSON_NOEXCEPT {
34 |     T tmp = a;
35 |         a = b;
36 |         b = tmp;
37 | }
38 | 
39 | } // namespace internal
40 | CEREAL_RAPIDJSON_NAMESPACE_END
41 | 
42 | #if defined(__clang__)
43 | CEREAL_RAPIDJSON_DIAG_POP
44 | #endif
45 | 
46 | #endif // CEREAL_RAPIDJSON_INTERNAL_SWAP_H_
47 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | #### 1、磁盘管理
 2 | 
 3 | 建立一个4KB大小的文件模拟磁盘，按逻辑将其划分为1024块，每块大小4B.其中900块用于存放普通数据，124块用于存储兑换数据.存储管理需要支持：
 4 | 
 5 | （1）数据组织：对需要存放的文件数据加以组织管理，可以采用连续组织方式、显式连接（FAT）方式、单级索引组织方式、二级索引组织方式、混合索引方式（每组要求不同，具体见“课程设计分组”部分，下同）.
 6 | 
 7 | （2）空闲块管理：能够查询并返回当前剩余的空闲块，对空闲块管理可以采用位示图法、空闲盘块表法、空闲盘块连法、成组连接法.
 8 | 
 9 | （3）兑换区管理：能够写入、读出兑换区数据.
10 | 
11 | #### 2、目录管理
12 | 
13 | 为写入模拟磁盘的数据文件建立目录，目录可以是单级文件目录、双级文件目录、树形结构目录.在目录中选择某个文件可以将其数据读入模拟内存.目录中包含文件名、文件所有者、创建时间、文件结构、在磁盘中存放的地址等信息.目录管理需要支持：
14 | 
15 | （1）新建目录：在目录中新建空目录
16 | 
17 | （2）删除目录：删除空目录
18 | 
19 | （3）为文件建立目录项：一个文件被创建后，为该文件创建目录项，并将文件相关信息写入目录中.
20 | 
21 | （4）删除文件：删除目录中某个文件，删除其在磁盘中的数据，并删除目录项.如果被删除文件已经读入内存应该阻止删除，完成基本的文件保护.
22 | 
23 | #### 3、内存管理
24 | 
25 | 申请一块64字节的内存空间模拟内存，按逻辑划分为16块，每块4B.将目录中选中的文件读入内存，显示文件中信息.内存可以同时显示多个文件信息，每个文件固定分配4个内存块，如果4个内存块不能显示文件全部信息，采用页面置换策略，将已显示完的页换出内存，可以选择的置换策略有，全局置换、局部置换、FIFO、LRU.内存管理需要支持：
26 | 
27 | （1）分配内存块：为线程分配内存块，每个线程默认分配4块.
28 | 
29 | （2）回收内存：线程结束后回收其内存.
30 | 
31 | （3）空闲内存块管理：为进入内存的数据寻找空闲内存块.没有空闲内存时，应给出提示.
32 | 
33 | （4）块时间管理：提供数据块进入模拟内存的时间、访问时间的记录和查询功能，为页面置换算法提供支持，当某个内存块被选中时，更新其访问时间.
34 | 
35 | #### 3、线程管理
36 | 
37 | 本虚拟系统以线程为基本运行单位，线程本身采用编程语言提供的线程机制，不模拟.系统主要包括的线程有：
38 | 
39 | （1）数据生成线程：该线程负责生成外存数据，给定数据大小（按字节计算）、数据信息（英文字母）、存储目录、文件名后，该线程调用磁盘管理中空闲磁盘管理功能，申请所需大小的外存块，如果盘块不够给出提示.按照要求的数据组织方式，将数据存入磁盘块（按块分配磁盘），并调用目录管理功能为其在目录中建立目录项，更改空闲盘块信息.
40 | 
41 | （2）删除数据线程：该线程调用删除目录管理中文件删除功能删除数据（内存中文件不能删除）.并回收外存空间，更新空闲盘块信息.
42 | 
43 | （3）执行线程：选择目录中的文件，执行线程将文件数据从外存调入内存，为此，首先需要调用内存管理的空闲空间管理功能，为该进程申请4块空闲内存，如果没有足够内存则给出提示，然后根据目录中文件存储信息将文件数据从外存读入内存，此间如果4块内存不够存放文件信息，需要进行换页（选择的换页策略见分组要求），欢出的页面存放到磁盘兑换区.允许同时运行多个执行线程.文件数据在内存块的分布通过线程的页表（模拟）进行记录.
44 | 
45 | （4）线程互斥：对于64B的内存，线程需要互斥访问，避免产生死锁.不能访问内存的线程阻塞，等待被唤醒.
46 | 
47 | #### 4、用户接口
48 | 
49 |    对内存块、外存块、目录信息进行可视化显示，并能够动态刷新.文件调入内存过程、以及换页过程在块与块之间加入延时，以便观察.
50 | 
51 |  


--------------------------------------------------------------------------------
/memory_manager.h:
--------------------------------------------------------------------------------
 1 | #ifndef MEMORYMANAGER_H
 2 | #define MEMORYMANAGER_H
 3 | 
 4 | #include <QString>
 5 | #include <QRandomGenerator>
 6 | #include "data_define.h"
 7 | #include "disk_manager.h"
 8 | 
 9 | typedef struct MemoryBlock{
10 |     //内存块链表
11 |     int free_length = 0;  //空闲块的数量
12 |     MemoryBlockItem block_item;
13 |     MemoryBlock* next;
14 | }MemoryBlock, *MemoryBlockList;
15 | 
16 | typedef struct BlockPage{
17 |     //线程的页块对应
18 |     int block_id;  //每个线程页对应的内存块号，-1为不在内存中
19 |     int page_id;   //线程页号
20 |     string page_data;  //每页数据
21 | }BlockPage;
22 | 
23 | typedef struct PageTable{
24 |     //存放内存页号-TCB-文件页号-数据页表的链
25 |     TCB *tcb;  //线程标识
26 |     vector<BlockPage> table;  //线程的页表中的数据结构
27 |     PageTable * next;
28 | } * TableList;
29 | 
30 | class MemoryManager
31 | {
32 | public:
33 |     //声明一个内存块链表
34 |     MemoryBlockList mem_list;
35 | 
36 |     //声明映射表
37 |     TableList tableList;
38 | 
39 |     DiskManager * dManager;
40 | 
41 |     // 构造函数
42 |     MemoryManager(DiskManager * dManager);
43 | 
44 |     // 分配内存，分配成功isAlloc <- true.
45 |     int allocMemory(TCB *t);
46 | 
47 |     // 释放TCB里面的数据
48 |     int freeBlock(TCB *t);
49 | 
50 |     // 从内存读取数据，index
51 |     ReadStat read(TCB *t,int pageIndex);
52 | 
53 | //    // 回写数据
54 | //    int writeBack(TCB* t,int pageIndex);
55 | //
56 |     // 读取换出页的数据
57 |     string loadWriteBackData(TCB* t,int pageIndex);
58 | 
59 |     // 输出当前MemoryBlock的状态
60 |     queue<MemoryBlockItem> getCurrentMemoryBlock();
61 | 
62 |     //更新内存块调用时间
63 |     static void reGetAccessTime(MemoryBlock *mb);
64 | 
65 |     //更新内存块分配时间
66 |     static void getEnterTime(MemoryBlock *mb);
67 | 
68 |     //更新页表链
69 |     void creatPageTable(TCB *t);
70 | 
71 |     //处理缺页
72 |     int loosePage(TCB *t, int pageIndex, string data);
73 | 
74 |     //页面置换算法
75 |     int LRU(TCB *t, int pageIndex, string data);
76 | 
77 |     //获取最近最久未访问的内存块号
78 |     int lruBlockId();
79 | };
80 | 
81 | #endif // MEMORYMANAGER_H
82 | 


--------------------------------------------------------------------------------
/cereal/types/map.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file map.hpp
 2 |     \brief Support for types found in \<map\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_MAP_HPP_
31 | #define CEREAL_TYPES_MAP_HPP_
32 | 
33 | #include "cereal/types/concepts/pair_associative_container.hpp"
34 | #include <map>
35 | 
36 | #endif // CEREAL_TYPES_MAP_HPP_
37 | 


--------------------------------------------------------------------------------
/cereal/types/unordered_map.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file unordered_map.hpp
 2 |     \brief Support for types found in \<unordered_map\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_UNORDERED_MAP_HPP_
31 | #define CEREAL_TYPES_UNORDERED_MAP_HPP_
32 | 
33 | #include "cereal/types/concepts/pair_associative_container.hpp"
34 | #include <unordered_map>
35 | 
36 | #endif // CEREAL_TYPES_UNORDERED_MAP_HPP_
37 | 


--------------------------------------------------------------------------------
/cereal/types/functional.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file functional.hpp
 2 |     \brief Support for types found in \<functional\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2016, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_FUNCTIONAL_HPP_
31 | #define CEREAL_TYPES_FUNCTIONAL_HPP_
32 | 
33 | #include <functional>
34 | 
35 | namespace cereal
36 | {
37 |   //! Saving for std::less
38 |   template <class Archive, class T> inline
39 |   void serialize( Archive &, std::less<T> & )
40 |   { }
41 | } // namespace cereal
42 | 
43 | #endif // CEREAL_TYPES_FUNCTIONAL_HPP_
44 | 


--------------------------------------------------------------------------------
/systemwindow.h:
--------------------------------------------------------------------------------
 1 | #ifndef SYSTEMWINDOW_H
 2 | #define SYSTEMWINDOW_H
 3 | 
 4 | #include <QMainWindow>
 5 | #include <QPushButton>
 6 | #include <QLabel>
 7 | #include <qboxlayout.h>
 8 | #include "gendatathread.h"
 9 | #include "window_exe_data.h"
10 | #include <QDebug>
11 | #include <queue>
12 | #include "data_define.h"
13 | #include "cglobal.h"
14 | #include "memory_monitor.h"
15 | #include "dialog_delete_data.h"
16 | #include "dialog_gen_data.h"
17 | #include <QMetaType>
18 | 
19 | namespace Ui {
20 | class SystemWindow;
21 | }
22 | 
23 | class SystemWindow : public QMainWindow
24 | {
25 |     Q_OBJECT
26 | 
27 | public:
28 |     explicit SystemWindow(QWidget *parent = nullptr);
29 |     ~SystemWindow();
30 | 
31 |     // 功能
32 |     QLabel * functionLabel;
33 |     QPushButton * btn_gen_data;
34 |     QPushButton * btn_del_data;
35 |     QPushButton * btn_exe_data;
36 |     QHBoxLayout * h1Layout;
37 | 
38 |     // 监视
39 |     QLabel * monitorLabel;
40 |     QPushButton * btn_memory_monitor;
41 |     QPushButton * btn_disk_monitor;
42 |     QHBoxLayout * h2Layout;
43 | 
44 |     // Window
45 |     window_exe_data * exeform;
46 |     MemoryMonitor * mMonitor;
47 | 
48 | 
49 | signals:
50 |     void onMoveToPushButton(QString btnStr);
51 | 
52 |     void updateMemoryBitMap(queue<MemoryBlockItem> items);
53 |     // 主线程发信号，通知两个监视器更新数据
54 |     void notifyUpdate();
55 | 
56 | public slots:
57 |     // 状态显示
58 |     void showMessageOnStatusBar(QString str);
59 |     void showBtnTextOnStatusBar();
60 | 
61 |     // 创建进程
62 |     void createDataGenThread();
63 |     void createDataDelThread();
64 |     void createDataExeThread();
65 | 
66 |     // 打开监视
67 |     void openDataGenUI();
68 |     void openDataDelUI();
69 |     void openDataExeUI(TCB* tcb);
70 |     void openMemoryMonitor();
71 |     void openDiskMonitor();
72 | 
73 |     // 显示等待框
74 |     void showDialog(QDialog * dialog);
75 |     void closeDialog(QDialog * dialog);
76 |     void showMessage(QString str);
77 | 
78 |     // 更新槽，通知内存和磁盘监视器进行刷新
79 |     void updateMemoryUI();
80 |     void updateDiskUI();
81 | 
82 |     // 接受数据生成、删除线程传递的槽，通知主线程数据发生变化
83 |     void updateData();
84 | 
85 | 
86 | private:
87 |     Ui::SystemWindow *ui;
88 | 
89 |     // QWidget interface
90 | protected:
91 |     void closeEvent(QCloseEvent *event);
92 | };
93 | 
94 | #endif // SYSTEMWINDOW_H
95 | 


--------------------------------------------------------------------------------
/cereal/types/utility.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file utility.hpp
 2 |     \brief Support for types found in \<utility\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_UTILITY_HPP_
31 | #define CEREAL_TYPES_UTILITY_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <utility>
35 | 
36 | namespace cereal
37 | {
38 |   //! Serializing for std::pair
39 |   template <class Archive, class T1, class T2> inline
40 |   void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::pair<T1, T2> & pair )
41 |   {
42 |     ar( CEREAL_NVP_("first",  pair.first),
43 |         CEREAL_NVP_("second", pair.second) );
44 |   }
45 | } // namespace cereal
46 | 
47 | #endif // CEREAL_TYPES_UTILITY_HPP_
48 | 


--------------------------------------------------------------------------------
/OperatingSystem.pro:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------
 2 | #
 3 | # Project created by QtCreator 2019-12-25T10:02:58
 4 | #
 5 | #-------------------------------------------------
 6 | 
 7 | QT       += core gui
 8 | 
 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
10 | 
11 | TARGET = OperatingSystem
12 | TEMPLATE = app
13 | 
14 | # The following define makes your compiler emit warnings if you use
15 | # any feature of Qt which has been marked as deprecated (the exact warnings
16 | # depend on your compiler). Please consult the documentation of the
17 | # deprecated API in order to know how to port your code away from it.
18 | DEFINES += QT_DEPRECATED_WARNINGS
19 | 
20 | # You can also make your code fail to compile if you use deprecated APIs.
21 | # In order to do so, uncomment the following line.
22 | # You can also select to disable deprecated APIs only up to a certain version of Qt.
23 | #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
24 | 
25 | CONFIG += c++11
26 | 
27 | SOURCES += \
28 |         cglobal.cpp \
29 |         data_define.cpp \
30 |         dialog_delete_data.cpp \
31 |         dialog_gen_data.cpp \
32 |         disk_manager.cpp \
33 |         disk_monitor.cpp \
34 |         folder_manager.cpp \
35 |         gendatathread.cpp \
36 |         main.cpp \
37 |         mainwindow.cpp \
38 |         memory_manager.cpp \
39 |         memory_monitor.cpp \
40 |         systemwindow.cpp \
41 |         user.cpp \
42 |         window_exe_data.cpp
43 | 
44 | HEADERS += \
45 |         cglobal.h \
46 |         data_define.h \
47 |         dialog_delete_data.h \
48 |         dialog_gen_data.h \
49 |         disk_manager.h \
50 |         disk_monitor.h \
51 |         folder_manager.h \
52 |         gendatathread.h \
53 |         memory_manager.h \
54 |         memory_monitor.h \
55 |         systemwindow.h \
56 |         user.h \
57 |         widget.h \
58 |         mainwindow.h \
59 |         window_exe_data.h
60 | 
61 | FORMS += \
62 |         dialog_delete_data.ui \
63 |         dialog_gen_data.ui \
64 |         disk_monitor.ui \
65 |         mainwindow.ui \
66 |         memory_monitor.ui \
67 |         systemwindow.ui \
68 |         window_exe_data.ui
69 | 
70 | # Default rules for deployment.
71 | qnx: target.path = /tmp/$${TARGET}/bin
72 | else: unix:!android: target.path = /opt/$${TARGET}/bin
73 | !isEmpty(target.path): INSTALLS += target
74 | 


--------------------------------------------------------------------------------
/cereal/types/atomic.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file atomic.hpp
 2 |     \brief Support for types found in \<atomic\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_ATOMIC_HPP_
31 | #define CEREAL_TYPES_ATOMIC_HPP_
32 | 
33 | #include <cereal/cereal.hpp>
34 | #include <atomic>
35 | 
36 | namespace cereal
37 | {
38 |   //! Serializing (save) for std::atomic
39 |   template <class Archive, class T> inline
40 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::atomic<T> const & a )
41 |   {
42 |     ar( CEREAL_NVP_("atomic_data", a.load()) );
43 |   }
44 | 
45 |   //! Serializing (load) for std::atomic
46 |   template <class Archive, class T> inline
47 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::atomic<T> & a )
48 |   {
49 |     T tmp;
50 |     ar( CEREAL_NVP_("atomic_data", tmp) );
51 |     a.store( tmp );
52 |   }
53 | } // namespace cereal
54 | 
55 | #endif // CEREAL_TYPES_ATOMIC_HPP_
56 | 


--------------------------------------------------------------------------------
/cereal/version.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file version.hpp
 2 |     \brief Macros to detect cereal version
 3 | 
 4 |     These macros can assist in determining the version of cereal. Be
 5 |     warned that cereal is not guaranteed to be compatible across
 6 |     different versions. For more information on releases of cereal,
 7 |     see https://github.com/USCiLab/cereal/releases.
 8 | 
 9 |     \ingroup utility */
10 | /*
11 |   Copyright (c) 2018, Shane Grant
12 |   All rights reserved.
13 | 
14 |   Redistribution and use in source and binary forms, with or without
15 |   modification, are permitted provided that the following conditions are met:
16 |       * Redistributions of source code must retain the above copyright
17 |         notice, this list of conditions and the following disclaimer.
18 |       * Redistributions in binary form must reproduce the above copyright
19 |         notice, this list of conditions and the following disclaimer in the
20 |         documentation and/or other materials provided with the distribution.
21 |       * Neither the name of cereal nor the
22 |         names of its contributors may be used to endorse or promote products
23 |         derived from this software without specific prior written permission.
24 | 
25 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
26 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
27 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
29 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
30 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
32 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 | */
36 | 
37 | #ifndef CEREAL_VERSION_HPP_
38 | #define CEREAL_VERSION_HPP_
39 | 
40 | //! The major version
41 | #define CEREAL_VERSION_MAJOR 1
42 | //! The minor version
43 | #define CEREAL_VERSION_MINOR 3
44 | //! The patch version
45 | #define CEREAL_VERSION_PATCH 0
46 | 
47 | //! The full version as a single number
48 | #define CEREAL_VERSION (CEREAL_VERSION_MAJOR * 10000 \
49 |                         + CEREAL_VERSION_MINOR * 100 \
50 |                         + CEREAL_VERSION_PATCH)
51 | 
52 | #endif // CEREAL_VERSION_HPP_
53 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/internal/strfunc.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_
16 | #define CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_
17 | 
18 | #include "../stream.h"
19 | #include <cwchar>
20 | 
21 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
22 | namespace internal {
23 | 
24 | //! Custom strlen() which works on different character types.
25 | /*! \tparam Ch Character type (e.g. char, wchar_t, short)
26 |     \param s Null-terminated input string.
27 |     \return Number of characters in the string. 
28 |     \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
29 | */
30 | template <typename Ch>
31 | inline SizeType StrLen(const Ch* s) {
32 |     CEREAL_RAPIDJSON_ASSERT(s != 0);
33 |     const Ch* p = s;
34 |     while (*p) ++p;
35 |     return SizeType(p - s);
36 | }
37 | 
38 | template <>
39 | inline SizeType StrLen(const char* s) {
40 |     return SizeType(std::strlen(s));
41 | }
42 | 
43 | template <>
44 | inline SizeType StrLen(const wchar_t* s) {
45 |     return SizeType(std::wcslen(s));
46 | }
47 | 
48 | //! Returns number of code points in a encoded string.
49 | template<typename Encoding>
50 | bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
51 |     CEREAL_RAPIDJSON_ASSERT(s != 0);
52 |     CEREAL_RAPIDJSON_ASSERT(outCount != 0);
53 |     GenericStringStream<Encoding> is(s);
54 |     const typename Encoding::Ch* end = s + length;
55 |     SizeType count = 0;
56 |     while (is.src_ < end) {
57 |         unsigned codepoint;
58 |         if (!Encoding::Decode(is, &codepoint))
59 |             return false;
60 |         count++;
61 |     }
62 |     *outCount = count;
63 |     return true;
64 | }
65 | 
66 | } // namespace internal
67 | CEREAL_RAPIDJSON_NAMESPACE_END
68 | 
69 | #endif // CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_
70 | 


--------------------------------------------------------------------------------
/cereal/types/complex.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file complex.hpp
 2 |     \brief Support for types found in \<complex\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_COMPLEX_HPP_
31 | #define CEREAL_TYPES_COMPLEX_HPP_
32 | 
33 | #include <complex>
34 | 
35 | namespace cereal
36 | {
37 |   //! Serializing (save) for std::complex
38 |   template <class Archive, class T> inline
39 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::complex<T> const & comp )
40 |   {
41 |     ar( CEREAL_NVP_("real", comp.real()),
42 |         CEREAL_NVP_("imag", comp.imag()) );
43 |   }
44 | 
45 |   //! Serializing (load) for std::complex
46 |   template <class Archive, class T> inline
47 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::complex<T> & bits )
48 |   {
49 |     T real, imag;
50 |     ar( CEREAL_NVP_("real", real),
51 |         CEREAL_NVP_("imag", imag) );
52 |     bits = {real, imag};
53 |   }
54 | } // namespace cereal
55 | 
56 | #endif // CEREAL_TYPES_COMPLEX_HPP_
57 | 


--------------------------------------------------------------------------------
/memory_monitor.cpp:
--------------------------------------------------------------------------------
 1 | #include "memory_monitor.h"
 2 | #include "ui_memory_monitor.h"
 3 | 
 4 | MemoryMonitor::MemoryMonitor(QWidget *parent) :
 5 |     QMainWindow(parent),
 6 |     ui(new Ui::MemoryMonitor)
 7 | {
 8 |     ui->setupUi(this);
 9 |     this->setWindowTitle("内存监视器");
10 |     // 关闭即销毁
11 |     this->setAttribute(Qt::WA_DeleteOnClose,true);
12 |     // 定义
13 |     tv_memory = ui->tv_memory;
14 | 
15 |     model = new QStandardItemModel(tv_memory);
16 |     // 4列，内存号，内存内容，是否空闲，最近一次访问时间
17 |     model->setColumnCount(4);
18 |     model->setHeaderData(0,Qt::Horizontal,"内存号");
19 |     model->setHeaderData(1,Qt::Horizontal,"内存内容");
20 |     model->setHeaderData(2,Qt::Horizontal,"是否空闲");
21 |     model->setHeaderData(3,Qt::Horizontal,"最近访问时间");
22 |     // 设置属性
23 |     tv_memory->setModel(model);
24 |     tv_memory->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
25 |     tv_memory->setEditTriggers(QTableView::NoEditTriggers);
26 |     tv_memory->setRowHeight(0,50);
27 |     tv_memory->setSelectionMode(QAbstractItemView::SingleSelection);
28 |     tv_memory->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
29 |     tv_memory->verticalHeader()->hide();
30 | 
31 |     // 刷新数据
32 |     updateMemoryUI();
33 | }
34 | 
35 | MemoryMonitor::~MemoryMonitor()
36 | {
37 |     delete ui;
38 | }
39 | 
40 | // 刷新UI
41 | void MemoryMonitor::updateMemoryUI()
42 | {
43 |     qDebug() << "内存监视器：更新数据";
44 |     queue<MemoryBlockItem> items = CGlobal::mManager->getCurrentMemoryBlock();
45 |     // 清空表格
46 |     //model->removeRows(0,model->rowCount());
47 | 
48 |     int cnt = 0;
49 |     while(!items.empty()){
50 |         auto qitem = items.front();
51 |         QStandardItem * id =new QStandardItem();
52 |         QStandardItem * data =new QStandardItem();
53 |         QStandardItem * isAlloc =new QStandardItem();
54 |         QStandardItem * lTime = new QStandardItem();
55 | 
56 |         id->setTextAlignment(Qt::AlignCenter);
57 |         data->setTextAlignment(Qt::AlignCenter);
58 |         isAlloc->setTextAlignment(Qt::AlignCenter);
59 |         lTime->setTextAlignment(Qt::AlignCenter);
60 | 
61 |         id->setText(QString::number(qitem.id));
62 |         data->setText(QString::fromStdString(qitem.data));
63 |         lTime->setText(parseTMSimple(qitem.time.accessTime));
64 | 
65 |         model->setItem(cnt,0,id);
66 |         model->setItem(cnt,1,data);
67 |         model->setItem(cnt,3,lTime);
68 | 
69 |         if(qitem.isFree){
70 |             isAlloc->setText("是");
71 |         }   else {
72 |             isAlloc->setText("否");
73 |         }
74 |         model->setItem(cnt,2,isAlloc);
75 |         items.pop();
76 |         cnt++;
77 |     }
78 | }
79 | 
80 | 


--------------------------------------------------------------------------------
/cereal/types/list.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file list.hpp
 2 |     \brief Support for types found in \<list\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_LIST_HPP_
31 | #define CEREAL_TYPES_LIST_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <list>
35 | 
36 | namespace cereal
37 | {
38 |   //! Saving for std::list
39 |   template <class Archive, class T, class A> inline
40 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::list<T, A> const & list )
41 |   {
42 |     ar( make_size_tag( static_cast<size_type>(list.size()) ) );
43 | 
44 |     for( auto const & i : list )
45 |       ar( i );
46 |   }
47 | 
48 |   //! Loading for std::list
49 |   template <class Archive, class T, class A> inline
50 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::list<T, A> & list )
51 |   {
52 |     size_type size;
53 |     ar( make_size_tag( size ) );
54 | 
55 |     list.resize( static_cast<size_t>( size ) );
56 | 
57 |     for( auto & i : list )
58 |       ar( i );
59 |   }
60 | } // namespace cereal
61 | 
62 | #endif // CEREAL_TYPES_LIST_HPP_
63 | 


--------------------------------------------------------------------------------
/cereal/types/deque.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file deque.hpp
 2 |     \brief Support for types found in \<deque\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_DEQUE_HPP_
31 | #define CEREAL_TYPES_DEQUE_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <deque>
35 | 
36 | namespace cereal
37 | {
38 |   //! Saving for std::deque
39 |   template <class Archive, class T, class A> inline
40 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::deque<T, A> const & deque )
41 |   {
42 |     ar( make_size_tag( static_cast<size_type>(deque.size()) ) );
43 | 
44 |     for( auto const & i : deque )
45 |       ar( i );
46 |   }
47 | 
48 |   //! Loading for std::deque
49 |   template <class Archive, class T, class A> inline
50 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::deque<T, A> & deque )
51 |   {
52 |     size_type size;
53 |     ar( make_size_tag( size ) );
54 | 
55 |     deque.resize( static_cast<size_t>( size ) );
56 | 
57 |     for( auto & i : deque )
58 |       ar( i );
59 |   }
60 | } // namespace cereal
61 | 
62 | #endif // CEREAL_TYPES_DEQUE_HPP_
63 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/cursorstreamwrapper.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | //
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
16 | #define CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
17 | 
18 | #include "stream.h"
19 | 
20 | #if defined(__GNUC__)
21 | CEREAL_RAPIDJSON_DIAG_PUSH
22 | CEREAL_RAPIDJSON_DIAG_OFF(effc++)
23 | #endif
24 | 
25 | #if defined(_MSC_VER) && _MSC_VER <= 1800
26 | CEREAL_RAPIDJSON_DIAG_PUSH
27 | CEREAL_RAPIDJSON_DIAG_OFF(4702)  // unreachable code
28 | CEREAL_RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
29 | #endif
30 | 
31 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
32 | 
33 | 
34 | //! Cursor stream wrapper for counting line and column number if error exists.
35 | /*!
36 |     \tparam InputStream     Any stream that implements Stream Concept
37 | */
38 | template <typename InputStream, typename Encoding = UTF8<> >
39 | class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding> {
40 | public:
41 |     typedef typename Encoding::Ch Ch;
42 | 
43 |     CursorStreamWrapper(InputStream& is):
44 |         GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}
45 | 
46 |     // counting line and column number
47 |     Ch Take() {
48 |         Ch ch = this->is_.Take();
49 |         if(ch == '\n') {
50 |             line_ ++;
51 |             col_ = 0;
52 |         } else {
53 |             col_ ++;
54 |         }
55 |         return ch;
56 |     }
57 | 
58 |     //! Get the error line number, if error exists.
59 |     size_t GetLine() const { return line_; }
60 |     //! Get the error column number, if error exists.
61 |     size_t GetColumn() const { return col_; }
62 | 
63 | private:
64 |     size_t line_;   //!< Current Line
65 |     size_t col_;    //!< Current Column
66 | };
67 | 
68 | #if defined(_MSC_VER) && _MSC_VER <= 1800
69 | CEREAL_RAPIDJSON_DIAG_POP
70 | #endif
71 | 
72 | #if defined(__GNUC__)
73 | CEREAL_RAPIDJSON_DIAG_POP
74 | #endif
75 | 
76 | CEREAL_RAPIDJSON_NAMESPACE_END
77 | 
78 | #endif // CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
79 | 


--------------------------------------------------------------------------------
/dialog_delete_data.cpp:
--------------------------------------------------------------------------------
 1 | #include "dialog_delete_data.h"
 2 | #include "ui_dialog_delete_data.h"
 3 | 
 4 | dialog_delete_data::dialog_delete_data(QWidget *parent) :
 5 |     QDialog(parent),
 6 |     ui(new Ui::dialog_delete_data)
 7 | {
 8 |     ui->setupUi(this);
 9 |     this->setWindowTitle("删除数据");
10 |     // 关闭即销毁
11 |     this->setAttribute  (Qt::WA_DeleteOnClose,true);
12 |     model = new QStandardItemModel(this);
13 |     row_selected = -1;
14 |     lv_fileLists = ui->lv_fileLists;
15 |     ll_owner = ui->text_owner;
16 |     ll_fileSize = ui->text_fileSize;
17 |     lv_fileLists->setModel(model);
18 |     connect(lv_fileLists,SIGNAL(clicked(QModelIndex)),this,SLOT(showClick(QModelIndex)));
19 |     getFileList();
20 | }
21 | 
22 | dialog_delete_data::~dialog_delete_data()
23 | {
24 |     delete ui;
25 | }
26 | 
27 | void dialog_delete_data::closeEvent(QCloseEvent *event)
28 | {
29 |     CGlobal::delThreadSem->release();
30 | }
31 | 
32 | // 获取文件列表
33 | void dialog_delete_data::getFileList()
34 | {
35 |     // 清空缓存数据
36 |     model->clear();
37 |     tmpFCB.clear();
38 |     row_selected = -1;
39 |     queue<FCB*> q = CGlobal::fManager->getFiles();
40 |     // 备份一份
41 |     while(!q.empty()){
42 |         FCB* fcb = q.front();
43 |         QStandardItem * item = new QStandardItem();
44 |         item->setEditable(false);
45 |         item->setText(QString::fromStdString(fcb->fileName));
46 |         model->appendRow(item);
47 |         q.pop();
48 |         tmpFCB.push_back(fcb);
49 |     }
50 | }
51 | 
52 | void dialog_delete_data::on_pushButton_clicked()
53 | {
54 |     int row = row_selected;
55 |     QMessageBox * mBox = new QMessageBox(this);
56 |     if (row != -1){
57 |         FCB* fcb = tmpFCB.at(row);
58 |         int status = CGlobal::fManager->deleteData(fcb);
59 |         switch (status) {
60 |         case STATUS_OK:
61 |             mBox->setText("删除成功");
62 |             break;
63 |         case STATUS_BUSY:
64 |             mBox->setText("文件正在使用，请稍后再试");
65 |             break;
66 |         case STATUS_ERR:
67 |             mBox->setText("删除失败");
68 |             break;
69 |         }
70 |         mBox->exec();
71 |         emit dataUpdated();
72 |         refresh();
73 |     } else {
74 |         mBox->setText("请选择要删除的文件");
75 |         mBox->exec();
76 |     }
77 | }
78 | 
79 | void dialog_delete_data::showClick(QModelIndex index)
80 | {
81 |     qDebug() << "点击了一个文件:行数"+QString::number(index.row());
82 |     row_selected = index.row();
83 |     ll_fileSize->setText(QString::number(tmpFCB.at(row_selected)->fileSize));
84 |     ll_owner->setText(QString::fromStdString(tmpFCB.at(row_selected)->owner));
85 | }
86 | 
87 | void dialog_delete_data::refresh()
88 | {
89 |     ll_owner->clear();
90 |     ll_fileSize->clear();
91 |     getFileList();
92 | }
93 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/ostreamwrapper.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_OSTREAMWRAPPER_H_
16 | #define CEREAL_RAPIDJSON_OSTREAMWRAPPER_H_
17 | 
18 | #include "stream.h"
19 | #include <iosfwd>
20 | 
21 | #ifdef __clang__
22 | CEREAL_RAPIDJSON_DIAG_PUSH
23 | CEREAL_RAPIDJSON_DIAG_OFF(padded)
24 | #endif
25 | 
26 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
27 | 
28 | //! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
29 | /*!
30 |     The classes can be wrapped including but not limited to:
31 | 
32 |     - \c std::ostringstream
33 |     - \c std::stringstream
34 |     - \c std::wpstringstream
35 |     - \c std::wstringstream
36 |     - \c std::ifstream
37 |     - \c std::fstream
38 |     - \c std::wofstream
39 |     - \c std::wfstream
40 | 
41 |     \tparam StreamType Class derived from \c std::basic_ostream.
42 | */
43 |    
44 | template <typename StreamType>
45 | class BasicOStreamWrapper {
46 | public:
47 |     typedef typename StreamType::char_type Ch;
48 |     BasicOStreamWrapper(StreamType& stream) : stream_(stream) {}
49 | 
50 |     void Put(Ch c) {
51 |         stream_.put(c);
52 |     }
53 | 
54 |     void Flush() {
55 |         stream_.flush();
56 |     }
57 | 
58 |     // Not implemented
59 |     char Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
60 |     char Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
61 |     size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
62 |     char* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
63 |     size_t PutEnd(char*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
64 | 
65 | private:
66 |     BasicOStreamWrapper(const BasicOStreamWrapper&);
67 |     BasicOStreamWrapper& operator=(const BasicOStreamWrapper&);
68 | 
69 |     StreamType& stream_;
70 | };
71 | 
72 | typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
73 | typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
74 | 
75 | #ifdef __clang__
76 | CEREAL_RAPIDJSON_DIAG_POP
77 | #endif
78 | 
79 | CEREAL_RAPIDJSON_NAMESPACE_END
80 | 
81 | #endif // CEREAL_RAPIDJSON_OSTREAMWRAPPER_H_
82 | 


--------------------------------------------------------------------------------
/cereal/types/optional.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file optional.hpp
 2 |     \brief Support for std::optional
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2017, Juan Pedro Bolivar Puente
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_STD_OPTIONAL_
31 | #define CEREAL_TYPES_STD_OPTIONAL_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <optional>
35 | 
36 | namespace cereal {
37 |   //! Saving for std::optional
38 |   template <class Archive, typename T> inline
39 |   void CEREAL_SAVE_FUNCTION_NAME(Archive& ar, const std::optional<T>& optional)
40 |   {
41 |     if(!optional) {
42 |       ar(CEREAL_NVP_("nullopt", true));
43 |     } else {
44 |       ar(CEREAL_NVP_("nullopt", false),
45 |          CEREAL_NVP_("data", *optional));
46 |     }
47 |   }
48 | 
49 |   //! Loading for std::optional
50 |   template <class Archive, typename T> inline
51 |   void CEREAL_LOAD_FUNCTION_NAME(Archive& ar, std::optional<T>& optional)
52 |   {
53 |     bool nullopt;
54 |     ar(CEREAL_NVP_("nullopt", nullopt));
55 | 
56 |     if (nullopt) {
57 |       optional = std::nullopt;
58 |     } else {
59 |       T value;
60 |       ar(CEREAL_NVP_("data", value));
61 |       optional = std::move(value);
62 |     }
63 |   }
64 | } // namespace cereal
65 | 
66 | #endif // CEREAL_TYPES_STD_OPTIONAL_
67 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/memorybuffer.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_MEMORYBUFFER_H_
16 | #define CEREAL_RAPIDJSON_MEMORYBUFFER_H_
17 | 
18 | #include "stream.h"
19 | #include "internal/stack.h"
20 | 
21 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
22 | 
23 | //! Represents an in-memory output byte stream.
24 | /*!
25 |     This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
26 | 
27 |     It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
28 | 
29 |     Differences between MemoryBuffer and StringBuffer:
30 |     1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
31 |     2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
32 | 
33 |     \tparam Allocator type for allocating memory buffer.
34 |     \note implements Stream concept
35 | */
36 | template <typename Allocator = CrtAllocator>
37 | struct GenericMemoryBuffer {
38 |     typedef char Ch; // byte
39 | 
40 |     GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
41 | 
42 |     void Put(Ch c) { *stack_.template Push<Ch>() = c; }
43 |     void Flush() {}
44 | 
45 |     void Clear() { stack_.Clear(); }
46 |     void ShrinkToFit() { stack_.ShrinkToFit(); }
47 |     Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
48 |     void Pop(size_t count) { stack_.template Pop<Ch>(count); }
49 | 
50 |     const Ch* GetBuffer() const {
51 |         return stack_.template Bottom<Ch>();
52 |     }
53 | 
54 |     size_t GetSize() const { return stack_.GetSize(); }
55 | 
56 |     static const size_t kDefaultCapacity = 256;
57 |     mutable internal::Stack<Allocator> stack_;
58 | };
59 | 
60 | typedef GenericMemoryBuffer<> MemoryBuffer;
61 | 
62 | //! Implement specialized version of PutN() with memset() for better performance.
63 | template<>
64 | inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
65 |     std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
66 | }
67 | 
68 | CEREAL_RAPIDJSON_NAMESPACE_END
69 | 
70 | #endif // CEREAL_RAPIDJSON_MEMORYBUFFER_H_
71 | 


--------------------------------------------------------------------------------
/cereal/external/rapidxml/license.txt:
--------------------------------------------------------------------------------
 1 | Use of this software is granted under one of the following two licenses,
 2 | to be chosen freely by the user.
 3 | 
 4 | 1. Boost Software License - Version 1.0 - August 17th, 2003
 5 | ===============================================================================
 6 | 
 7 | Copyright (c) 2006, 2007 Marcin Kalicinski
 8 | 
 9 | Permission is hereby granted, free of charge, to any person or organization
10 | obtaining a copy of the software and accompanying documentation covered by
11 | this license (the "Software") to use, reproduce, display, distribute,
12 | execute, and transmit the Software, and to prepare derivative works of the
13 | Software, and to permit third-parties to whom the Software is furnished to
14 | do so, all subject to the following:
15 | 
16 | The copyright notices in the Software and this entire statement, including
17 | the above license grant, this restriction and the following disclaimer,
18 | must be included in all copies of the Software, in whole or in part, and
19 | all derivative works of the Software, unless such copies or derivative
20 | works are solely in the form of machine-executable object code generated by
21 | a source language processor.
22 | 
23 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
26 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
27 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
28 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 | DEALINGS IN THE SOFTWARE.
30 | 
31 | 2. The MIT License
32 | ===============================================================================
33 | 
34 | Copyright (c) 2006, 2007 Marcin Kalicinski
35 | 
36 | Permission is hereby granted, free of charge, to any person obtaining a copy 
37 | of this software and associated documentation files (the "Software"), to deal 
38 | in the Software without restriction, including without limitation the rights 
39 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
40 | of the Software, and to permit persons to whom the Software is furnished to do so, 
41 | subject to the following conditions:
42 | 
43 | The above copyright notice and this permission notice shall be included in all 
44 | copies or substantial portions of the Software.
45 | 
46 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
47 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
48 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
49 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
50 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
51 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 
52 | IN THE SOFTWARE.
53 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/memorystream.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_MEMORYSTREAM_H_
16 | #define CEREAL_RAPIDJSON_MEMORYSTREAM_H_
17 | 
18 | #include "stream.h"
19 | 
20 | #ifdef __clang__
21 | CEREAL_RAPIDJSON_DIAG_PUSH
22 | CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
23 | CEREAL_RAPIDJSON_DIAG_OFF(missing-noreturn)
24 | #endif
25 | 
26 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
27 | 
28 | //! Represents an in-memory input byte stream.
29 | /*!
30 |     This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
31 | 
32 |     It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
33 | 
34 |     Differences between MemoryStream and StringStream:
35 |     1. StringStream has encoding but MemoryStream is a byte stream.
36 |     2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
37 |     3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
38 |     \note implements Stream concept
39 | */
40 | struct MemoryStream {
41 |     typedef char Ch; // byte
42 | 
43 |     MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
44 | 
45 |     Ch Peek() const { return CEREAL_RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; }
46 |     Ch Take() { return CEREAL_RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; }
47 |     size_t Tell() const { return static_cast<size_t>(src_ - begin_); }
48 | 
49 |     Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
50 |     void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
51 |     void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
52 |     size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
53 | 
54 |     // For encoding detection only.
55 |     const Ch* Peek4() const {
56 |         return Tell() + 4 <= size_ ? src_ : 0;
57 |     }
58 | 
59 |     const Ch* src_;     //!< Current read position.
60 |     const Ch* begin_;   //!< Original head of the string.
61 |     const Ch* end_;     //!< End of stream.
62 |     size_t size_;       //!< Size of the stream.
63 | };
64 | 
65 | CEREAL_RAPIDJSON_NAMESPACE_END
66 | 
67 | #ifdef __clang__
68 | CEREAL_RAPIDJSON_DIAG_POP
69 | #endif
70 | 
71 | #endif // CEREAL_RAPIDJSON_MEMORYBUFFER_H_
72 | 


--------------------------------------------------------------------------------
/mainwindow.cpp:
--------------------------------------------------------------------------------
 1 | #include "mainwindow.h"
 2 | #include "ui_mainwindow.h"
 3 | #include <QMessageBox>
 4 | #include <QAbstractButton>
 5 | #include <QTabWidget>
 6 | 
 7 | #include "systemwindow.h"
 8 | #include <QDebug>
 9 | 
10 | MainWindow::MainWindow(QWidget *parent) :
11 |     QMainWindow(parent),
12 |     ui(new Ui::MainWindow)
13 | {
14 |     ui->setupUi(this);
15 |     this->setWindowTitle("操作系统课程设计");
16 |     //1.设置UI界面
17 |     // 设置菜单
18 |     QMenuBar * bar = new QMenuBar();
19 |     bar->setParent(this);
20 |     setMenuBar(bar);
21 |     // 第一个菜单，
22 |     QMenu * menu1 = new QMenu();
23 |     menu1->addAction("关于",[=](){
24 |        QMessageBox  * message = new QMessageBox();
25 |        message->setText("Thread Simulator V1.0\n东北大学秦皇岛分校计科1702班小组作品：\n成员：金韬、杭功茂、王鹏、张伯羽");
26 |        message->addButton("确定",QMessageBox::AcceptRole);
27 |        message->addButton("取消",QMessageBox::DestructiveRole);
28 |        message->show();
29 |     });
30 |     menu1->addAction("退出",[=](){
31 |         // 退出功能
32 |         this->close();
33 |     });
34 |     menu1->setTitle("关于");
35 |     bar->addMenu(menu1);
36 |     // 设置要求表格
37 |     model = new QStandardItemModel();
38 |     // 4个要求
39 |     model->setColumnCount(4);
40 |     model->setRowCount(1);
41 |     model->setHeaderData(0,Qt::Horizontal,"置换策略");
42 |     model->setHeaderData(1,Qt::Horizontal,"目录结构");
43 |     model->setHeaderData(2,Qt::Horizontal,"外存组织");
44 |     model->setHeaderData(3,Qt::Horizontal,"空闲磁盘管理");
45 |     // 要求细则
46 |     QStandardItem * item0 = new QStandardItem("全局置换LRU");
47 |     QStandardItem * item1 = new QStandardItem("单级目录");
48 |     QStandardItem * item2 = new QStandardItem("混合索引");
49 |     QStandardItem * item3 = new QStandardItem("位示图");
50 |     item0->setTextAlignment(Qt::AlignCenter);
51 |     item1->setTextAlignment(Qt::AlignCenter);
52 |     item2->setTextAlignment(Qt::AlignCenter);
53 |     item3->setTextAlignment(Qt::AlignCenter);
54 |     model->setItem(0,0,item0);
55 |     model->setItem(0,1,item1);
56 |     model->setItem(0,2,item2);
57 |     model->setItem(0,3,item3);
58 | 
59 |     // 设置属性
60 |     ui->tv_class->setModel(model);
61 |     ui->tv_class->setRowHeight(0,50);
62 |     ui->tv_class->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
63 |     ui->tv_class->setEditTriggers(QTableView::NoEditTriggers);
64 |     ui->tv_class->setSelectionMode(QAbstractItemView::SingleSelection);
65 |     ui->tv_class->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
66 |     ui->tv_class->verticalHeader()->hide();
67 | 
68 |     //初始化全局变量
69 |     cglobal = new CGlobal();
70 | }
71 | 
72 | 
73 | MainWindow::~MainWindow()
74 | {
75 |     delete ui;
76 | }
77 | 
78 | 
79 | void MainWindow::on_pushButton_clicked()
80 | {
81 |     // 将用户名填入全局变量
82 |     if (ui->edit_username->text().trimmed().size() == 0){
83 |         // 不做任何操作
84 |     } else {
85 |       User::userName = ui->edit_username->text().toStdString();
86 |     }
87 |     this->hide();
88 |     sysWin.show();
89 | }
90 | 
91 | void MainWindow::showDialog(QDialog *dialog)
92 | {
93 |     if (dialog != nullptr){
94 |         dialog->exec();
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/cereal/types/forward_list.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file forward_list.hpp
 2 |     \brief Support for types found in \<forward_list\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_FORWARD_LIST_HPP_
31 | #define CEREAL_TYPES_FORWARD_LIST_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <forward_list>
35 | 
36 | namespace cereal
37 | {
38 |   //! Saving for std::forward_list all other types
39 |   template <class Archive, class T, class A> inline
40 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> const & forward_list )
41 |   {
42 |     // write the size - note that this is slow because we need to traverse
43 |     // the entire list. there are ways we could avoid this but this was chosen
44 |     // since it works in the most general fashion with any archive type
45 |     size_type const size = std::distance( forward_list.begin(), forward_list.end() );
46 | 
47 |     ar( make_size_tag( size ) );
48 | 
49 |     // write the list
50 |     for( const auto & i : forward_list )
51 |       ar( i );
52 |   }
53 | 
54 |   //! Loading for std::forward_list all other types from
55 |   template <class Archive, class T, class A>
56 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> & forward_list )
57 |   {
58 |     size_type size;
59 |     ar( make_size_tag( size ) );
60 | 
61 |     forward_list.resize( static_cast<size_t>( size ) );
62 | 
63 |     for( auto & i : forward_list )
64 |       ar( i );
65 |   }
66 | } // namespace cereal
67 | 
68 | #endif // CEREAL_TYPES_FORWARD_LIST_HPP_
69 | 


--------------------------------------------------------------------------------
/cereal/details/polymorphic_impl_fwd.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file polymorphic_impl_fwd.hpp
 2 |     \brief Internal polymorphism support forward declarations
 3 |     \ingroup Internal */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | 
31 | /* This code is heavily inspired by the boost serialization implementation by the following authors
32 | 
33 |    (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
34 |    Use, modification and distribution is subject to the Boost Software
35 |    License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)
36 | 
37 |     See http://www.boost.org for updates, documentation, and revision history.
38 | 
39 |    (C) Copyright 2006 David Abrahams - http://www.boost.org.
40 | 
41 |    See /boost/serialization/export.hpp and /boost/archive/detail/register_archive.hpp for their
42 |    implementation.
43 | */
44 | 
45 | #ifndef CEREAL_DETAILS_POLYMORPHIC_IMPL_FWD_HPP_
46 | #define CEREAL_DETAILS_POLYMORPHIC_IMPL_FWD_HPP_
47 | 
48 | namespace cereal
49 | {
50 |   namespace detail
51 |   {
52 |     //! Forward declaration, see polymorphic_impl.hpp for more information
53 |     template <class Base, class Derived>
54 |     struct RegisterPolymorphicCaster;
55 | 
56 |     //! Forward declaration, see polymorphic_impl.hpp for more information
57 |     struct PolymorphicCasters;
58 | 
59 |     //! Forward declaration, see polymorphic_impl.hpp for more information
60 |     template <class Base, class Derived>
61 |     struct PolymorphicRelation;
62 |   } // namespace detail
63 | } // namespace cereal
64 | 
65 | #endif // CEREAL_DETAILS_POLYMORPHIC_IMPL_FWD_HPP_
66 | 


--------------------------------------------------------------------------------
/cereal/types/string.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file string.hpp
 2 |     \brief Support for types found in \<string\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_STRING_HPP_
31 | #define CEREAL_TYPES_STRING_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <string>
35 | 
36 | namespace cereal
37 | {
38 |   //! Serialization for basic_string types, if binary data is supported
39 |   template<class Archive, class CharT, class Traits, class Alloc> inline
40 |   typename std::enable_if<traits::is_output_serializable<BinaryData<CharT>, Archive>::value, void>::type
41 |   CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
42 |   {
43 |     // Save number of chars + the data
44 |     ar( make_size_tag( static_cast<size_type>(str.size()) ) );
45 |     ar( binary_data( str.data(), str.size() * sizeof(CharT) ) );
46 |   }
47 | 
48 |   //! Serialization for basic_string types, if binary data is supported
49 |   template<class Archive, class CharT, class Traits, class Alloc> inline
50 |   typename std::enable_if<traits::is_input_serializable<BinaryData<CharT>, Archive>::value, void>::type
51 |   CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> & str)
52 |   {
53 |     size_type size;
54 |     ar( make_size_tag( size ) );
55 |     str.resize(static_cast<std::size_t>(size));
56 |     ar( binary_data( const_cast<CharT *>( str.data() ), static_cast<std::size_t>(size) * sizeof(CharT) ) );
57 |   }
58 | } // namespace cereal
59 | 
60 | #endif // CEREAL_TYPES_STRING_HPP_
61 | 
62 | 


--------------------------------------------------------------------------------
/cereal/types/chrono.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file chrono.hpp
 2 |     \brief Support for types found in \<chrono\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_CHRONO_HPP_
31 | #define CEREAL_TYPES_CHRONO_HPP_
32 | 
33 | #include <chrono>
34 | 
35 | namespace cereal
36 | {
37 |   //! Saving std::chrono::duration
38 |   template <class Archive, class R, class P> inline
39 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> const & dur )
40 |   {
41 |     ar( CEREAL_NVP_("count", dur.count()) );
42 |   }
43 | 
44 |   //! Loading std::chrono::duration
45 |   template <class Archive, class R, class P> inline
46 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> & dur )
47 |   {
48 |     R count;
49 |     ar( CEREAL_NVP_("count", count) );
50 | 
51 |     dur = std::chrono::duration<R, P>{count};
52 |   }
53 | 
54 |   //! Saving std::chrono::time_point
55 |   template <class Archive, class C, class D> inline
56 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> const & dur )
57 |   {
58 |     ar( CEREAL_NVP_("time_since_epoch", dur.time_since_epoch()) );
59 |   }
60 | 
61 |   //! Loading std::chrono::time_point
62 |   template <class Archive, class C, class D> inline
63 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> & dur )
64 |   {
65 |     D elapsed;
66 |     ar( CEREAL_NVP_("time_since_epoch", elapsed) );
67 | 
68 |     dur = std::chrono::time_point<C, D>{elapsed};
69 |   }
70 | } // namespace cereal
71 | 
72 | #endif // CEREAL_TYPES_CHRONO_HPP_
73 | 


--------------------------------------------------------------------------------
/cereal/types/stack.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file stack.hpp
 2 |     \brief Support for types found in \<stack\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_STACK_HPP_
31 | #define CEREAL_TYPES_STACK_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <stack>
35 | 
36 | // The default container for stack is deque, so let's include that too
37 | #include "cereal/types/deque.hpp"
38 | 
39 | namespace cereal
40 | {
41 |   namespace stack_detail
42 |   {
43 |     //! Allows access to the protected container in stack
44 |     template <class T, class C> inline
45 |     C const & container( std::stack<T, C> const & stack )
46 |     {
47 |       struct H : public std::stack<T, C>
48 |       {
49 |         static C const & get( std::stack<T, C> const & s )
50 |         {
51 |           return s.*(&H::c);
52 |         }
53 |       };
54 | 
55 |       return H::get( stack );
56 |     }
57 |   }
58 | 
59 |   //! Saving for std::stack
60 |   template <class Archive, class T, class C> inline
61 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::stack<T, C> const & stack )
62 |   {
63 |     ar( CEREAL_NVP_("container", stack_detail::container( stack )) );
64 |   }
65 | 
66 |   //! Loading for std::stack
67 |   template <class Archive, class T, class C> inline
68 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::stack<T, C> & stack )
69 |   {
70 |     C container;
71 |     ar( CEREAL_NVP_("container", container) );
72 |     stack = std::stack<T, C>( std::move( container ) );
73 |   }
74 | } // namespace cereal
75 | 
76 | #endif // CEREAL_TYPES_STACK_HPP_
77 | 


--------------------------------------------------------------------------------
/cereal/details/util.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file util.hpp
 2 |     \brief Internal misc utilities
 3 |     \ingroup Internal */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_DETAILS_UTIL_HPP_
31 | #define CEREAL_DETAILS_UTIL_HPP_
32 | 
33 | #include <typeinfo>
34 | #include <string>
35 | 
36 | #ifdef _MSC_VER
37 | namespace cereal
38 | {
39 |   namespace util
40 |   {
41 |     //! Demangles the type encoded in a string
42 |     /*! @internal */
43 |     inline std::string demangle( std::string const & name )
44 |     { return name; }
45 | 
46 |     //! Gets the demangled name of a type
47 |     /*! @internal */
48 |     template <class T> inline
49 |     std::string demangledName()
50 |     { return typeid( T ).name(); }
51 |   } // namespace util
52 | } // namespace cereal
53 | #else // clang or gcc
54 | #include <cxxabi.h>
55 | #include <cstdlib>
56 | namespace cereal
57 | {
58 |   namespace util
59 |   {
60 |     //! Demangles the type encoded in a string
61 |     /*! @internal */
62 |     inline std::string demangle(std::string mangledName)
63 |     {
64 |       int status = 0;
65 |       char *demangledName = nullptr;
66 |       std::size_t len;
67 | 
68 |       demangledName = abi::__cxa_demangle(mangledName.c_str(), 0, &len, &status);
69 | 
70 |       std::string retName(demangledName);
71 |       free(demangledName);
72 | 
73 |       return retName;
74 |     }
75 | 
76 |     //! Gets the demangled name of a type
77 |     /*! @internal */
78 |     template<class T> inline
79 |     std::string demangledName()
80 |     { return demangle(typeid(T).name()); }
81 |   }
82 | } // namespace cereal
83 | #endif // clang or gcc branch of _MSC_VER
84 | #endif // CEREAL_DETAILS_UTIL_HPP_
85 | 


--------------------------------------------------------------------------------
/dialog_delete_data.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>dialog_delete_data</class>
  4 |  <widget class="QDialog" name="dialog_delete_data">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>400</width>
 10 |     <height>327</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>Dialog</string>
 15 |   </property>
 16 |   <widget class="QLabel" name="label">
 17 |    <property name="geometry">
 18 |     <rect>
 19 |      <x>20</x>
 20 |      <y>20</y>
 21 |      <width>361</width>
 22 |      <height>16</height>
 23 |     </rect>
 24 |    </property>
 25 |    <property name="text">
 26 |     <string>请选择你要删除的目录文件或文件夹</string>
 27 |    </property>
 28 |    <property name="alignment">
 29 |     <set>Qt::AlignCenter</set>
 30 |    </property>
 31 |   </widget>
 32 |   <widget class="QListView" name="lv_fileLists">
 33 |    <property name="geometry">
 34 |     <rect>
 35 |      <x>30</x>
 36 |      <y>51</y>
 37 |      <width>341</width>
 38 |      <height>181</height>
 39 |     </rect>
 40 |    </property>
 41 |   </widget>
 42 |   <widget class="QPushButton" name="pushButton">
 43 |    <property name="geometry">
 44 |     <rect>
 45 |      <x>130</x>
 46 |      <y>290</y>
 47 |      <width>112</width>
 48 |      <height>32</height>
 49 |     </rect>
 50 |    </property>
 51 |    <property name="text">
 52 |     <string>删除</string>
 53 |    </property>
 54 |   </widget>
 55 |   <widget class="QLabel" name="label_2">
 56 |    <property name="geometry">
 57 |     <rect>
 58 |      <x>20</x>
 59 |      <y>260</y>
 60 |      <width>91</width>
 61 |      <height>21</height>
 62 |     </rect>
 63 |    </property>
 64 |    <property name="text">
 65 |     <string>文件大小(块)</string>
 66 |    </property>
 67 |    <property name="alignment">
 68 |     <set>Qt::AlignCenter</set>
 69 |    </property>
 70 |   </widget>
 71 |   <widget class="QLabel" name="label_4">
 72 |    <property name="geometry">
 73 |     <rect>
 74 |      <x>210</x>
 75 |      <y>260</y>
 76 |      <width>58</width>
 77 |      <height>21</height>
 78 |     </rect>
 79 |    </property>
 80 |    <property name="text">
 81 |     <string>所有者</string>
 82 |    </property>
 83 |    <property name="alignment">
 84 |     <set>Qt::AlignCenter</set>
 85 |    </property>
 86 |   </widget>
 87 |   <widget class="QLabel" name="text_fileSize">
 88 |    <property name="geometry">
 89 |     <rect>
 90 |      <x>110</x>
 91 |      <y>260</y>
 92 |      <width>101</width>
 93 |      <height>20</height>
 94 |     </rect>
 95 |    </property>
 96 |    <property name="text">
 97 |     <string>单击文件后显示</string>
 98 |    </property>
 99 |    <property name="alignment">
100 |     <set>Qt::AlignCenter</set>
101 |    </property>
102 |   </widget>
103 |   <widget class="QLabel" name="text_owner">
104 |    <property name="geometry">
105 |     <rect>
106 |      <x>270</x>
107 |      <y>260</y>
108 |      <width>111</width>
109 |      <height>20</height>
110 |     </rect>
111 |    </property>
112 |    <property name="text">
113 |     <string>单击文件后显示</string>
114 |    </property>
115 |    <property name="alignment">
116 |     <set>Qt::AlignCenter</set>
117 |    </property>
118 |   </widget>
119 |  </widget>
120 |  <resources/>
121 |  <connections/>
122 | </ui>
123 | 


--------------------------------------------------------------------------------
/dialog_gen_data.cpp:
--------------------------------------------------------------------------------
 1 | #include "dialog_gen_data.h"
 2 | #include "ui_dialog_gen_data.h"
 3 | 
 4 | dialog_gen_data::dialog_gen_data(QWidget *parent) :
 5 |     QDialog(parent),
 6 |     ui(new Ui::dialog_gen_data)
 7 | {
 8 |     ui->setupUi(this);
 9 |     // 初始化
10 |     changeInputCount("");
11 |     // 绑定
12 |     connect(ui->edit_fileContent,SIGNAL(textChanged(const QString &)),this,SLOT(changeInputCount(const QString &)));
13 |     this->setWindowTitle("生成数据");
14 |     // 关闭即销毁
15 |     this->setAttribute(Qt::WA_DeleteOnClose,true);
16 |     this->edit_fileName = ui->edit_fileName;
17 |     this->edit_fileContent = ui->edit_fileContent;
18 | }
19 | 
20 | dialog_gen_data::~dialog_gen_data()
21 | {
22 |     delete ui;
23 | }
24 | 
25 | void dialog_gen_data::closeEvent(QCloseEvent *event)
26 | {
27 |     CGlobal::genThreadSem->release();
28 | }
29 | 
30 | void dialog_gen_data::on_btn_submit_clicked()
31 | {
32 |     CGlobal::genThreadSem->release();
33 |     // 获取界面数据
34 |     QString fileName = edit_fileName->text();
35 |     QString fileContent = edit_fileContent->text();
36 | 
37 |     if (fileName.trimmed().size() == 0 || fileContent ==0){
38 |         QDialog * dialog = new QDialog(this);
39 |         QVBoxLayout *layout = new QVBoxLayout();
40 |         QPushButton *btn_ok = new QPushButton("确定");
41 |         btn_ok->setParent(dialog);
42 |         connect(btn_ok,SIGNAL(clicked()),this,SLOT(on_message_btn_ok()));
43 |         layout->addWidget(new QLabel("数据存盘失败,可能的原因:"));
44 |         layout->addWidget(new QLabel("1.文件名为空"));
45 |         layout->addWidget(new QLabel("2.文件内容为空"));
46 |         layout->addWidget(btn_ok);
47 |         dialog->setLayout(layout);
48 |         dialog->exec();
49 |         return;
50 |     }
51 | 
52 |     int status = CGlobal::fManager->generateData(fileContent.toStdString(),fileName.toStdString());
53 |     if(status == STATUS_ERR){
54 |         // 失败了，弹出失败框
55 |         QDialog * dialog = new QDialog(this);
56 |         QVBoxLayout *layout = new QVBoxLayout();
57 |         QPushButton *btn_ok = new QPushButton("确定");
58 |         btn_ok->setParent(dialog);
59 |         connect(btn_ok,SIGNAL(clicked()),this,SLOT(on_message_btn_ok()));
60 |         layout->addWidget(new QLabel("数据存盘失败,可能的原因有:"));
61 |         layout->addWidget(new QLabel("1.磁盘空间不足，请删除一些文件后重试"));
62 |         layout->addWidget(new QLabel("2.存在同名文件，请检查后重试"));
63 |         layout->addWidget(btn_ok);
64 |         dialog->setLayout(layout);
65 |         dialog->exec();
66 |         return;
67 |     } else {
68 |         // 发出信号给主线程
69 |         QDialog * dialog = new QDialog(this);
70 |         QVBoxLayout *layout = new QVBoxLayout();
71 |         QPushButton *btn_ok = new QPushButton("确定");
72 |         btn_ok->setParent(dialog);
73 |         connect(btn_ok,SIGNAL(clicked()),this,SLOT(on_message_btn_ok()));
74 |         layout->addWidget(new QLabel("文件写入成功"));
75 |         layout->addWidget(btn_ok);
76 |         dialog->setLayout(layout);
77 |         dialog->exec();
78 |         emit dataUpdated();
79 |         this->close();
80 |     }
81 | }
82 | 
83 | void dialog_gen_data::on_message_btn_ok()
84 | {
85 |     ((QDialog*)((QPushButton*)sender())->parent())->close();
86 | }
87 | 
88 | void dialog_gen_data::changeInputCount(const QString &text)
89 | {
90 |     ui->txt_inputNum->setText(QString::number(text.size())+"/96");
91 | }
92 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/internal/ieee754.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_IEEE754_
16 | #define CEREAL_RAPIDJSON_IEEE754_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
21 | namespace internal {
22 | 
23 | class Double {
24 | public:
25 |     Double() {}
26 |     Double(double d) : d_(d) {}
27 |     Double(uint64_t u) : u_(u) {}
28 | 
29 |     double Value() const { return d_; }
30 |     uint64_t Uint64Value() const { return u_; }
31 | 
32 |     double NextPositiveDouble() const {
33 |         CEREAL_RAPIDJSON_ASSERT(!Sign());
34 |         return Double(u_ + 1).Value();
35 |     }
36 | 
37 |     bool Sign() const { return (u_ & kSignMask) != 0; }
38 |     uint64_t Significand() const { return u_ & kSignificandMask; }
39 |     int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
40 | 
41 |     bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
42 |     bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
43 |     bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; }
44 |     bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
45 |     bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
46 | 
47 |     uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
48 |     int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
49 |     uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
50 | 
51 |     static int EffectiveSignificandSize(int order) {
52 |         if (order >= -1021)
53 |             return 53;
54 |         else if (order <= -1074)
55 |             return 0;
56 |         else
57 |             return order + 1074;
58 |     }
59 | 
60 | private:
61 |     static const int kSignificandSize = 52;
62 |     static const int kExponentBias = 0x3FF;
63 |     static const int kDenormalExponent = 1 - kExponentBias;
64 |     static const uint64_t kSignMask = CEREAL_RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
65 |     static const uint64_t kExponentMask = CEREAL_RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
66 |     static const uint64_t kSignificandMask = CEREAL_RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
67 |     static const uint64_t kHiddenBit = CEREAL_RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
68 | 
69 |     union {
70 |         double d_;
71 |         uint64_t u_;
72 |     };
73 | };
74 | 
75 | } // namespace internal
76 | CEREAL_RAPIDJSON_NAMESPACE_END
77 | 
78 | #endif // CEREAL_RAPIDJSON_IEEE754_
79 | 


--------------------------------------------------------------------------------
/cereal/types/concepts/pair_associative_container.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file pair_associative_container.hpp
 2 |     \brief Support for the PairAssociativeContainer refinement of the
 3 |     AssociativeContainer concept.
 4 |     \ingroup TypeConcepts */
 5 | /*
 6 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 7 |   All rights reserved.
 8 | 
 9 |   Redistribution and use in source and binary forms, with or without
10 |   modification, are permitted provided that the following conditions are met:
11 |       * Redistributions of source code must retain the above copyright
12 |         notice, this list of conditions and the following disclaimer.
13 |       * Redistributions in binary form must reproduce the above copyright
14 |         notice, this list of conditions and the following disclaimer in the
15 |         documentation and/or other materials provided with the distribution.
16 |       * Neither the name of cereal nor the
17 |         names of its contributors may be used to endorse or promote products
18 |         derived from this software without specific prior written permission.
19 | 
20 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
21 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
24 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | */
31 | #ifndef CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
32 | #define CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
33 | 
34 | #include "cereal/cereal.hpp"
35 | 
36 | namespace cereal
37 | {
38 |   //! Saving for std-like pair associative containers
39 |   template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
40 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, Map<Args...> const & map )
41 |   {
42 |     ar( make_size_tag( static_cast<size_type>(map.size()) ) );
43 | 
44 |     for( const auto & i : map )
45 |       ar( make_map_item(i.first, i.second) );
46 |   }
47 | 
48 |   //! Loading for std-like pair associative containers
49 |   template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
50 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, Map<Args...> & map )
51 |   {
52 |     size_type size;
53 |     ar( make_size_tag( size ) );
54 | 
55 |     map.clear();
56 | 
57 |     auto hint = map.begin();
58 |     for( size_t i = 0; i < size; ++i )
59 |     {
60 |       typename Map<Args...>::key_type key;
61 |       typename Map<Args...>::mapped_type value;
62 | 
63 |       ar( make_map_item(key, value) );
64 |       #ifdef CEREAL_OLDER_GCC
65 |       hint = map.insert( hint, std::make_pair(std::move(key), std::move(value)) );
66 |       #else // NOT CEREAL_OLDER_GCC
67 |       hint = map.emplace_hint( hint, std::move( key ), std::move( value ) );
68 |       #endif // NOT CEREAL_OLDER_GCC
69 |     }
70 |   }
71 | } // namespace cereal
72 | 
73 | #endif // CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
74 | 


--------------------------------------------------------------------------------
/folder_manager.cpp:
--------------------------------------------------------------------------------
  1 | #include "folder_manager.h"
  2 | #include "data_define.h"
  3 | #include <queue>
  4 | #include <fstream>
  5 | 
  6 | FolderManager::FolderManager(DiskManager * dManager)
  7 | {
  8 |         this->dManager = dManager;
  9 | 
 10 |         std::ifstream os("folder.json");
 11 |         if (os.is_open()){
 12 |             cereal::JSONInputArchive archieve(os);
 13 |             this->serialize(archieve);
 14 |             for(int i=0;i<128;i++){
 15 |                 fileLocks[i] = false;
 16 |             }
 17 |         } else {
 18 |             for(int i=0;i<128;i++){
 19 |                 fileTable[i].fileName = "";
 20 |                 fileTable[i].fileSize = 0;
 21 |                 fileTable[i].owner = "";
 22 |                 fileTable[i].type = 0;
 23 |                 fileLocks[i] = false;
 24 |             }
 25 |         }
 26 | 
 27 | }
 28 | 
 29 | // 按照指针指向的FolderElement删除目录项
 30 | int FolderManager::deleteData(FCB* element){
 31 |     // 删除磁盘中FCB
 32 |     for(int i=0;i<128;i++){
 33 |         if(element->fileName == fileTable[i].fileName){
 34 |             if (fileLocks[i]){
 35 |                 //上锁了
 36 |                 return STATUS_BUSY;
 37 |             } else {
 38 |                 // 删除磁盘中的文件
 39 |                 int status = this->dManager->receiveF_delete(element);
 40 |                 // 删除目录项中的文件
 41 |                 fileTable[i].fileName = "";
 42 |                 fileTable[i].fileSize = 0;
 43 |                 return status;
 44 |             }
 45 |         }
 46 |     }
 47 | }
 48 | 
 49 | // 输出信息：获取所有文件
 50 | queue<FCB*> FolderManager::getFiles(){
 51 |         queue<FCB*> q;
 52 |         for(int i=0;i<128;i++){
 53 |             if(fileTable[i].fileName != ""){
 54 |                 q.push(&fileTable[i]);
 55 |             }
 56 |             else continue;
 57 |         }
 58 |         return q;
 59 | }
 60 | 
 61 | // 创建新文件，注意：添加时记得往element里面填写tm时间数据
 62 | int FolderManager::generateData(string data,string fileName){
 63 |         for(int k=0;k<128;k++){
 64 |             if(fileTable[k].fileName == fileName){
 65 |                 return STATUS_SAME_FILE;
 66 |             }
 67 |         }
 68 |         // 获取时间
 69 |         for(int i=0;i<128;i++){
 70 |             if(fileTable[i].fileName == ""){
 71 |                 fileTable[i].fileName = fileName;
 72 |                 int a;
 73 |                 a = data.size();
 74 |                 int b;
 75 |                 if(a%4 == 0){
 76 |                     b = a/4;
 77 |                 }
 78 |                 else b = (a/4)+1;
 79 |                 fileTable[i].fileSize = b;
 80 |                 time_t t = time(nullptr);
 81 |                 fileTable[i].createTime = *localtime(&t);
 82 |                 fileTable[i].owner = User::userName;
 83 |                 return this->dManager->receiveF_add(&fileTable[i],data);
 84 |             }
 85 |         }
 86 |         // 最多存放128个块
 87 |         return STATUS_ERR;
 88 | }
 89 | 
 90 | // 读取数据
 91 | string FolderManager::getData(FCB * element){
 92 |     string data_read = this->dManager->receiveF_read(element);
 93 |     return data_read;
 94 | }
 95 | int FolderManager::lockFile(FCB * fcb){
 96 |     for(int i=0;i<128;i++){
 97 |         if(fcb->fileName == fileTable[i].fileName){
 98 |             fileLocks[i] = true;
 99 |         }
100 |     }
101 |     return STATUS_OK;
102 | }
103 | int FolderManager::unlockFile(FCB * fcb){
104 |     for(int i=0;i<128;i++){
105 |         if(fcb->fileName == fileTable[i].fileName){
106 |             fileLocks[i] = false;
107 |         }
108 |     }
109 |     return STATUS_OK;
110 | }
111 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/filereadstream.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef CEREAL_RAPIDJSON_FILEREADSTREAM_H_
 16 | #define CEREAL_RAPIDJSON_FILEREADSTREAM_H_
 17 | 
 18 | #include "stream.h"
 19 | #include <cstdio>
 20 | 
 21 | #ifdef __clang__
 22 | CEREAL_RAPIDJSON_DIAG_PUSH
 23 | CEREAL_RAPIDJSON_DIAG_OFF(padded)
 24 | CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
 25 | CEREAL_RAPIDJSON_DIAG_OFF(missing-noreturn)
 26 | #endif
 27 | 
 28 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
 29 | 
 30 | //! File byte stream for input using fread().
 31 | /*!
 32 |     \note implements Stream concept
 33 | */
 34 | class FileReadStream {
 35 | public:
 36 |     typedef char Ch;    //!< Character type (byte).
 37 | 
 38 |     //! Constructor.
 39 |     /*!
 40 |         \param fp File pointer opened for read.
 41 |         \param buffer user-supplied buffer.
 42 |         \param bufferSize size of buffer in bytes. Must >=4 bytes.
 43 |     */
 44 |     FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
 45 |         CEREAL_RAPIDJSON_ASSERT(fp_ != 0);
 46 |         CEREAL_RAPIDJSON_ASSERT(bufferSize >= 4);
 47 |         Read();
 48 |     }
 49 | 
 50 |     Ch Peek() const { return *current_; }
 51 |     Ch Take() { Ch c = *current_; Read(); return c; }
 52 |     size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
 53 | 
 54 |     // Not implemented
 55 |     void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
 56 |     void Flush() { CEREAL_RAPIDJSON_ASSERT(false); } 
 57 |     Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 58 |     size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 59 | 
 60 |     // For encoding detection only.
 61 |     const Ch* Peek4() const {
 62 |         return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
 63 |     }
 64 | 
 65 | private:
 66 |     void Read() {
 67 |         if (current_ < bufferLast_)
 68 |             ++current_;
 69 |         else if (!eof_) {
 70 |             count_ += readCount_;
 71 |             readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
 72 |             bufferLast_ = buffer_ + readCount_ - 1;
 73 |             current_ = buffer_;
 74 | 
 75 |             if (readCount_ < bufferSize_) {
 76 |                 buffer_[readCount_] = '\0';
 77 |                 ++bufferLast_;
 78 |                 eof_ = true;
 79 |             }
 80 |         }
 81 |     }
 82 | 
 83 |     std::FILE* fp_;
 84 |     Ch *buffer_;
 85 |     size_t bufferSize_;
 86 |     Ch *bufferLast_;
 87 |     Ch *current_;
 88 |     size_t readCount_;
 89 |     size_t count_;  //!< Number of characters read
 90 |     bool eof_;
 91 | };
 92 | 
 93 | CEREAL_RAPIDJSON_NAMESPACE_END
 94 | 
 95 | #ifdef __clang__
 96 | CEREAL_RAPIDJSON_DIAG_POP
 97 | #endif
 98 | 
 99 | #endif // CEREAL_RAPIDJSON_FILESTREAM_H_
100 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/filewritestream.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef CEREAL_RAPIDJSON_FILEWRITESTREAM_H_
 16 | #define CEREAL_RAPIDJSON_FILEWRITESTREAM_H_
 17 | 
 18 | #include "stream.h"
 19 | #include <cstdio>
 20 | 
 21 | #ifdef __clang__
 22 | CEREAL_RAPIDJSON_DIAG_PUSH
 23 | CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
 24 | #endif
 25 | 
 26 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
 27 | 
 28 | //! Wrapper of C file stream for output using fwrite().
 29 | /*!
 30 |     \note implements Stream concept
 31 | */
 32 | class FileWriteStream {
 33 | public:
 34 |     typedef char Ch;    //!< Character type. Only support char.
 35 | 
 36 |     FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
 37 |         CEREAL_RAPIDJSON_ASSERT(fp_ != 0);
 38 |     }
 39 | 
 40 |     void Put(char c) { 
 41 |         if (current_ >= bufferEnd_)
 42 |             Flush();
 43 | 
 44 |         *current_++ = c;
 45 |     }
 46 | 
 47 |     void PutN(char c, size_t n) {
 48 |         size_t avail = static_cast<size_t>(bufferEnd_ - current_);
 49 |         while (n > avail) {
 50 |             std::memset(current_, c, avail);
 51 |             current_ += avail;
 52 |             Flush();
 53 |             n -= avail;
 54 |             avail = static_cast<size_t>(bufferEnd_ - current_);
 55 |         }
 56 | 
 57 |         if (n > 0) {
 58 |             std::memset(current_, c, n);
 59 |             current_ += n;
 60 |         }
 61 |     }
 62 | 
 63 |     void Flush() {
 64 |         if (current_ != buffer_) {
 65 |             size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
 66 |             if (result < static_cast<size_t>(current_ - buffer_)) {
 67 |                 // failure deliberately ignored at this time
 68 |                 // added to avoid warn_unused_result build errors
 69 |             }
 70 |             current_ = buffer_;
 71 |         }
 72 |     }
 73 | 
 74 |     // Not implemented
 75 |     char Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 76 |     char Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 77 |     size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 78 |     char* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 79 |     size_t PutEnd(char*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 80 | 
 81 | private:
 82 |     // Prohibit copy constructor & assignment operator.
 83 |     FileWriteStream(const FileWriteStream&);
 84 |     FileWriteStream& operator=(const FileWriteStream&);
 85 | 
 86 |     std::FILE* fp_;
 87 |     char *buffer_;
 88 |     char *bufferEnd_;
 89 |     char *current_;
 90 | };
 91 | 
 92 | //! Implement specialized version of PutN() with memset() for better performance.
 93 | template<>
 94 | inline void PutN(FileWriteStream& stream, char c, size_t n) {
 95 |     stream.PutN(c, n);
 96 | }
 97 | 
 98 | CEREAL_RAPIDJSON_NAMESPACE_END
 99 | 
100 | #ifdef __clang__
101 | CEREAL_RAPIDJSON_DIAG_POP
102 | #endif
103 | 
104 | #endif // CEREAL_RAPIDJSON_FILESTREAM_H_
105 | 


--------------------------------------------------------------------------------
/cereal/types/array.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file array.hpp
 2 |     \brief Support for types found in \<array\>
 3 |     \ingroup STLSupport */
 4 | /*
 5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
 6 |   All rights reserved.
 7 | 
 8 |   Redistribution and use in source and binary forms, with or without
 9 |   modification, are permitted provided that the following conditions are met:
10 |       * Redistributions of source code must retain the above copyright
11 |         notice, this list of conditions and the following disclaimer.
12 |       * Redistributions in binary form must reproduce the above copyright
13 |         notice, this list of conditions and the following disclaimer in the
14 |         documentation and/or other materials provided with the distribution.
15 |       * Neither the name of cereal nor the
16 |         names of its contributors may be used to endorse or promote products
17 |         derived from this software without specific prior written permission.
18 | 
19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | */
30 | #ifndef CEREAL_TYPES_ARRAY_HPP_
31 | #define CEREAL_TYPES_ARRAY_HPP_
32 | 
33 | #include "cereal/cereal.hpp"
34 | #include <array>
35 | 
36 | namespace cereal
37 | {
38 |   //! Saving for std::array primitive types
39 |   //! using binary serialization, if supported
40 |   template <class Archive, class T, size_t N> inline
41 |   typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
42 |                           && std::is_arithmetic<T>::value, void>::type
43 |   CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::array<T, N> const & array )
44 |   {
45 |     ar( binary_data( array.data(), sizeof(array) ) );
46 |   }
47 | 
48 |   //! Loading for std::array primitive types
49 |   //! using binary serialization, if supported
50 |   template <class Archive, class T, size_t N> inline
51 |   typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
52 |                           && std::is_arithmetic<T>::value, void>::type
53 |   CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::array<T, N> & array )
54 |   {
55 |     ar( binary_data( array.data(), sizeof(array) ) );
56 |   }
57 | 
58 |   //! Saving for std::array all other types
59 |   template <class Archive, class T, size_t N> inline
60 |   typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
61 |                           || !std::is_arithmetic<T>::value, void>::type
62 |   CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::array<T, N> const & array )
63 |   {
64 |     for( auto const & i : array )
65 |       ar( i );
66 |   }
67 | 
68 |   //! Loading for std::array all other types
69 |   template <class Archive, class T, size_t N> inline
70 |   typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
71 |                           || !std::is_arithmetic<T>::value, void>::type
72 |   CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::array<T, N> & array )
73 |   {
74 |     for( auto & i : array )
75 |       ar( i );
76 |   }
77 | } // namespace cereal
78 | 
79 | #endif // CEREAL_TYPES_ARRAY_HPP_
80 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/internal/pow10.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_POW10_
16 | #define CEREAL_RAPIDJSON_POW10_
17 | 
18 | #include "../rapidjson.h"
19 | 
20 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
21 | namespace internal {
22 | 
23 | //! Computes integer powers of 10 in double (10.0^n).
24 | /*! This function uses lookup table for fast and accurate results.
25 |     \param n non-negative exponent. Must <= 308.
26 |     \return 10.0^n
27 | */
28 | inline double Pow10(int n) {
29 |     static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
30 |         1e+0,  
31 |         1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
32 |         1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
33 |         1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
34 |         1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
35 |         1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
36 |         1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
37 |         1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
38 |         1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
39 |         1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
40 |         1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
41 |         1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
42 |         1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
43 |         1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
44 |         1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
45 |         1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
46 |         1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
47 |     };
48 |     CEREAL_RAPIDJSON_ASSERT(n >= 0 && n <= 308);
49 |     return e[n];
50 | }
51 | 
52 | } // namespace internal
53 | CEREAL_RAPIDJSON_NAMESPACE_END
54 | 
55 | #endif // CEREAL_RAPIDJSON_POW10_
56 | 


--------------------------------------------------------------------------------
/cereal/external/rapidxml/rapidxml_utils.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CEREAL_RAPIDXML_UTILS_HPP_INCLUDED
  2 | #define CEREAL_RAPIDXML_UTILS_HPP_INCLUDED
  3 | 
  4 | // Copyright (C) 2006, 2009 Marcin Kalicinski
  5 | // Version 1.13
  6 | // Revision $DateTime: 2009/05/13 01:46:17 $
  7 | //! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.
  8 | 
  9 | #include "rapidxml.hpp"
 10 | #include <vector>
 11 | #include <string>
 12 | #include <fstream>
 13 | #include <stdexcept>
 14 | 
 15 | namespace cereal {
 16 | namespace rapidxml
 17 | {
 18 | 
 19 |     //! Represents data loaded from a file
 20 |     template<class Ch = char>
 21 |     class file
 22 |     {
 23 | 
 24 |     public:
 25 | 
 26 |         //! Loads file into the memory. Data will be automatically destroyed by the destructor.
 27 |         //! \param filename Filename to load.
 28 |         file(const char *filename)
 29 |         {
 30 |             using namespace std;
 31 | 
 32 |             // Open stream
 33 |             basic_ifstream<Ch> stream(filename, ios::binary);
 34 |             if (!stream)
 35 |                 throw runtime_error(string("cannot open file ") + filename);
 36 |             stream.unsetf(ios::skipws);
 37 | 
 38 |             // Determine stream size
 39 |             stream.seekg(0, ios::end);
 40 |             size_t size = stream.tellg();
 41 |             stream.seekg(0);
 42 | 
 43 |             // Load data and add terminating 0
 44 |             m_data.resize(size + 1);
 45 |             stream.read(&m_data.front(), static_cast<streamsize>(size));
 46 |             m_data[size] = 0;
 47 |         }
 48 | 
 49 |         //! Loads file into the memory. Data will be automatically destroyed by the destructor
 50 |         //! \param stream Stream to load from
 51 |         file(std::basic_istream<Ch> &stream)
 52 |         {
 53 |             using namespace std;
 54 | 
 55 |             // Load data and add terminating 0
 56 |             stream.unsetf(ios::skipws);
 57 |             m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
 58 |             if (stream.fail() || stream.bad())
 59 |                 throw runtime_error("error reading stream");
 60 |             m_data.push_back(0);
 61 |         }
 62 | 
 63 |         //! Gets file data.
 64 |         //! \return Pointer to data of file.
 65 |         Ch *data()
 66 |         {
 67 |             return &m_data.front();
 68 |         }
 69 | 
 70 |         //! Gets file data.
 71 |         //! \return Pointer to data of file.
 72 |         const Ch *data() const
 73 |         {
 74 |             return &m_data.front();
 75 |         }
 76 | 
 77 |         //! Gets file data size.
 78 |         //! \return Size of file data, in characters.
 79 |         std::size_t size() const
 80 |         {
 81 |             return m_data.size();
 82 |         }
 83 | 
 84 |     private:
 85 | 
 86 |         std::vector<Ch> m_data;   // File data
 87 | 
 88 |     };
 89 | 
 90 |     //! Counts children of node. Time complexity is O(n).
 91 |     //! \return Number of children of node
 92 |     template<class Ch>
 93 |     inline std::size_t count_children(xml_node<Ch> *node)
 94 |     {
 95 |         xml_node<Ch> *child = node->first_node();
 96 |         std::size_t count = 0;
 97 |         while (child)
 98 |         {
 99 |             ++count;
100 |             child = child->next_sibling();
101 |         }
102 |         return count;
103 |     }
104 | 
105 |     //! Counts attributes of node. Time complexity is O(n).
106 |     //! \return Number of attributes of node
107 |     template<class Ch>
108 |     inline std::size_t count_attributes(xml_node<Ch> *node)
109 |     {
110 |         xml_attribute<Ch> *attr = node->first_attribute();
111 |         std::size_t count = 0;
112 |         while (attr)
113 |         {
114 |             ++count;
115 |             attr = attr->next_attribute();
116 |         }
117 |         return count;
118 |     }
119 | 
120 | }
121 | } // namespace cereal
122 | 
123 | #endif
124 | 


--------------------------------------------------------------------------------
/disk_monitor.cpp:
--------------------------------------------------------------------------------
  1 | #include "disk_monitor.h"
  2 | #include "ui_disk_monitor.h"
  3 | 
  4 | DiskMonitor::DiskMonitor(QWidget *parent) :
  5 |     QMainWindow(parent),
  6 |     ui(new Ui::DiskMonitor)
  7 | {
  8 |     ui->setupUi(this);
  9 |     this->setWindowTitle("磁盘监视器");
 10 |     // 关闭即销毁
 11 |     this->setAttribute(Qt::WA_DeleteOnClose,true);
 12 |     // 定义
 13 |     tv_disk = ui->tv_disk;
 14 |     ll_pos = ui->text_block_pos;
 15 |     ll_data = ui->text_block_data;
 16 |     ll_page = ui->text_page;
 17 |     ll_status = ui->text_block_status;
 18 |     ll_totoal_free = ui->text_total_free_block;
 19 |     // 表格
 20 |     model = new QStandardItemModel(tv_disk);
 21 |     // 32*32
 22 |     model->setRowCount(32);
 23 |     model->setColumnCount(32);
 24 |     // 设置属性
 25 |     tv_disk->setModel(model);
 26 |     tv_disk->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
 27 |     tv_disk->setEditTriggers(QTableView::NoEditTriggers);
 28 | //    tv_disk->setRowHeight(0,50);
 29 |     tv_disk->setSelectionMode(QAbstractItemView::SingleSelection);
 30 | //    tv_disk->horizontalHeader()->hide();
 31 | //    tv_disk->verticalHeader()->hide();
 32 |     // 初始化行号从0开始
 33 |     for (int i=0;i<model->rowCount();i++) {
 34 |         model->setHeaderData(i,Qt::Vertical,i);
 35 |     }
 36 |     for (int i=0;i<model->rowCount();i++) {
 37 |         model->setHeaderData(i,Qt::Horizontal,i);
 38 |     }
 39 |     // 设置点击事件
 40 |     connect(tv_disk, SIGNAL(clicked(const QModelIndex &)), this, SLOT(onTableClicked(const QModelIndex &)));
 41 |     // 获取数据
 42 |     notFreeModel = new QStandardItemModel(ui->tv_notFree);
 43 |     ui->tv_notFree->setModel(notFreeModel);
 44 |     ui->tv_notFree->setEditTriggers(QTableView::NoEditTriggers);
 45 | 
 46 |     updateDiskUI();
 47 | }
 48 | 
 49 | DiskMonitor::~DiskMonitor()
 50 | {
 51 |     delete ui;
 52 | }
 53 | 
 54 | void DiskMonitor::updateDiskUI()
 55 | {
 56 |     qDebug() << "磁盘监视器：更新数据";
 57 |     qMapTemp = CGlobal::dManager->getCurrentBitMap();
 58 |     int freeBlockCnt = 0;
 59 |     int totalBlock = 0;
 60 |     // 清空空闲分区
 61 |     notFreeModel->clear();
 62 |     while(!qMapTemp.empty()){
 63 |         auto item = qMapTemp.front();
 64 |         if(item.isFree){
 65 |             freeBlockCnt++;
 66 |         }
 67 |         totalBlock++;
 68 |         if (item.x >=0 && item.y >=0 && item.x <32 && item.y <32){
 69 |             QStandardItem * qItem =new QStandardItem(QString::fromStdString(item.data));
 70 |             model->setItem(item.x,item.y,qItem);
 71 |             if (!item.isFree){
 72 |                 // 染色
 73 |                 model->setData(model->index(item.x,item.y),QVariant(QBrush(Qt::red)), Qt::BackgroundRole);
 74 |                 QStandardItem * it = new QStandardItem();
 75 |                 it->setText(QString::fromStdString(item.data)+"-("+QString::number(item.x)+","+QString::number(item.y)+")");
 76 |                 notFreeModel->appendRow(it);
 77 |             }
 78 |             this->bMItem[item.x][item.y] =item;
 79 |         } else {
 80 |             qDebug() << "警告：试图写入非法UI空间";
 81 |         }
 82 |         qMapTemp.pop();
 83 |     }
 84 |     ll_totoal_free->setText(QString::number(freeBlockCnt)+"/"+QString::number(totalBlock));
 85 | }
 86 | 
 87 | void DiskMonitor::onTableClicked(const QModelIndex &mIndex)
 88 | {
 89 |     auto item = bMItem[mIndex.row()][mIndex.column()];
 90 |     // 判断是否是坐标
 91 |     int index = mIndex.row()*32+mIndex.column();
 92 |     if(index >= 900){
 93 |         ll_page->setText(QString::number(index)+"(对换区)");
 94 |     } else {
 95 |         ll_page->setText(QString::number(index)+"(普通区)");
 96 |     }
 97 | 
 98 |     QString textStr = QString("(") +QString::number(item.x) + QString(",") +QString::number(item.y)+QString(")");
 99 |     ll_pos->setText(textStr);
100 | 
101 |     ll_data->setText(QString::fromStdString(item.data));
102 |     if(item.isFree){
103 |         ll_status ->setText("空闲");
104 |     } else {
105 |         ll_status ->setText("已被占用");
106 |     }
107 | 
108 | }
109 | 


--------------------------------------------------------------------------------
/cereal/types/set.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file set.hpp
  2 |     \brief Support for types found in \<set\>
  3 |     \ingroup STLSupport */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_SET_HPP_
 31 | #define CEREAL_TYPES_SET_HPP_
 32 | 
 33 | #include "cereal/cereal.hpp"
 34 | #include <set>
 35 | 
 36 | namespace cereal
 37 | {
 38 |   namespace set_detail
 39 |   {
 40 |     //! @internal
 41 |     template <class Archive, class SetT> inline
 42 |     void save( Archive & ar, SetT const & set )
 43 |     {
 44 |       ar( make_size_tag( static_cast<size_type>(set.size()) ) );
 45 | 
 46 |       for( const auto & i : set )
 47 |         ar( i );
 48 |     }
 49 | 
 50 |     //! @internal
 51 |     template <class Archive, class SetT> inline
 52 |     void load( Archive & ar, SetT & set )
 53 |     {
 54 |       size_type size;
 55 |       ar( make_size_tag( size ) );
 56 | 
 57 |       set.clear();
 58 | 
 59 |       auto hint = set.begin();
 60 |       for( size_type i = 0; i < size; ++i )
 61 |       {
 62 |         typename SetT::key_type key;
 63 | 
 64 |         ar( key );
 65 |         #ifdef CEREAL_OLDER_GCC
 66 |         hint = set.insert( hint, std::move( key ) );
 67 |         #else // NOT CEREAL_OLDER_GCC
 68 |         hint = set.emplace_hint( hint, std::move( key ) );
 69 |         #endif // NOT CEREAL_OLDER_GCC
 70 |       }
 71 |     }
 72 |   }
 73 | 
 74 |   //! Saving for std::set
 75 |   template <class Archive, class K, class C, class A> inline
 76 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::set<K, C, A> const & set )
 77 |   {
 78 |     set_detail::save( ar, set );
 79 |   }
 80 | 
 81 |   //! Loading for std::set
 82 |   template <class Archive, class K, class C, class A> inline
 83 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::set<K, C, A> & set )
 84 |   {
 85 |     set_detail::load( ar, set );
 86 |   }
 87 | 
 88 |   //! Saving for std::multiset
 89 |   template <class Archive, class K, class C, class A> inline
 90 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> const & multiset )
 91 |   {
 92 |     set_detail::save( ar, multiset );
 93 |   }
 94 | 
 95 |   //! Loading for std::multiset
 96 |   template <class Archive, class K, class C, class A> inline
 97 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> & multiset )
 98 |   {
 99 |     set_detail::load( ar, multiset );
100 |   }
101 | } // namespace cereal
102 | 
103 | #endif // CEREAL_TYPES_SET_HPP_
104 | 


--------------------------------------------------------------------------------
/mainwindow.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>MainWindow</class>
  4 |  <widget class="QMainWindow" name="MainWindow">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>494</width>
 10 |     <height>354</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>MainWindow</string>
 15 |   </property>
 16 |   <widget class="QWidget" name="centralWidget">
 17 |    <widget class="QPushButton" name="pushButton">
 18 |     <property name="geometry">
 19 |      <rect>
 20 |       <x>150</x>
 21 |       <y>270</y>
 22 |       <width>181</width>
 23 |       <height>31</height>
 24 |      </rect>
 25 |     </property>
 26 |     <property name="text">
 27 |      <string>登录</string>
 28 |     </property>
 29 |     <property name="checkable">
 30 |      <bool>true</bool>
 31 |     </property>
 32 |     <property name="checked">
 33 |      <bool>false</bool>
 34 |     </property>
 35 |    </widget>
 36 |    <widget class="QLabel" name="label">
 37 |     <property name="geometry">
 38 |      <rect>
 39 |       <x>90</x>
 40 |       <y>40</y>
 41 |       <width>301</width>
 42 |       <height>31</height>
 43 |      </rect>
 44 |     </property>
 45 |     <property name="text">
 46 |      <string>操作系统课程设计</string>
 47 |     </property>
 48 |     <property name="alignment">
 49 |      <set>Qt::AlignCenter</set>
 50 |     </property>
 51 |    </widget>
 52 |    <widget class="QLabel" name="label_2">
 53 |     <property name="geometry">
 54 |      <rect>
 55 |       <x>90</x>
 56 |       <y>110</y>
 57 |       <width>301</width>
 58 |       <height>31</height>
 59 |      </rect>
 60 |     </property>
 61 |     <property name="text">
 62 |      <string>组员：金韬、杭功茂、王鹏、张伯羽</string>
 63 |     </property>
 64 |     <property name="alignment">
 65 |      <set>Qt::AlignCenter</set>
 66 |     </property>
 67 |    </widget>
 68 |    <widget class="QLabel" name="label_3">
 69 |     <property name="geometry">
 70 |      <rect>
 71 |       <x>90</x>
 72 |       <y>70</y>
 73 |       <width>301</width>
 74 |       <height>31</height>
 75 |      </rect>
 76 |     </property>
 77 |     <property name="text">
 78 |      <string>东北大学秦皇岛分校计科1702班17-20号</string>
 79 |     </property>
 80 |     <property name="alignment">
 81 |      <set>Qt::AlignCenter</set>
 82 |     </property>
 83 |    </widget>
 84 |    <widget class="QLineEdit" name="edit_username">
 85 |     <property name="geometry">
 86 |      <rect>
 87 |       <x>210</x>
 88 |       <y>240</y>
 89 |       <width>113</width>
 90 |       <height>21</height>
 91 |      </rect>
 92 |     </property>
 93 |     <property name="text">
 94 |      <string>未命名</string>
 95 |     </property>
 96 |    </widget>
 97 |    <widget class="QLabel" name="label_4">
 98 |     <property name="geometry">
 99 |      <rect>
100 |       <x>150</x>
101 |       <y>235</y>
102 |       <width>58</width>
103 |       <height>31</height>
104 |      </rect>
105 |     </property>
106 |     <property name="text">
107 |      <string>用户名</string>
108 |     </property>
109 |     <property name="alignment">
110 |      <set>Qt::AlignCenter</set>
111 |     </property>
112 |    </widget>
113 |    <widget class="QTableView" name="tv_class">
114 |     <property name="geometry">
115 |      <rect>
116 |       <x>60</x>
117 |       <y>150</y>
118 |       <width>371</width>
119 |       <height>71</height>
120 |      </rect>
121 |     </property>
122 |    </widget>
123 |   </widget>
124 |   <widget class="QMenuBar" name="menuBar">
125 |    <property name="geometry">
126 |     <rect>
127 |      <x>0</x>
128 |      <y>0</y>
129 |      <width>494</width>
130 |      <height>22</height>
131 |     </rect>
132 |    </property>
133 |   </widget>
134 |   <widget class="QStatusBar" name="statusBar"/>
135 |   <action name="actionquit">
136 |    <property name="text">
137 |     <string>quit</string>
138 |    </property>
139 |   </action>
140 |   <action name="actionabout">
141 |    <property name="text">
142 |     <string>about</string>
143 |    </property>
144 |   </action>
145 |  </widget>
146 |  <layoutdefault spacing="6" margin="11"/>
147 |  <resources/>
148 |  <connections/>
149 | </ui>
150 | 


--------------------------------------------------------------------------------
/cereal/types/unordered_set.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file unordered_set.hpp
  2 |     \brief Support for types found in \<unordered_set\>
  3 |     \ingroup STLSupport */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_UNORDERED_SET_HPP_
 31 | #define CEREAL_TYPES_UNORDERED_SET_HPP_
 32 | 
 33 | #include "cereal/cereal.hpp"
 34 | #include <unordered_set>
 35 | 
 36 | namespace cereal
 37 | {
 38 |   namespace unordered_set_detail
 39 |   {
 40 |     //! @internal
 41 |     template <class Archive, class SetT> inline
 42 |     void save( Archive & ar, SetT const & set )
 43 |     {
 44 |       ar( make_size_tag( static_cast<size_type>(set.size()) ) );
 45 | 
 46 |       for( const auto & i : set )
 47 |         ar( i );
 48 |     }
 49 | 
 50 |     //! @internal
 51 |     template <class Archive, class SetT> inline
 52 |     void load( Archive & ar, SetT & set )
 53 |     {
 54 |       size_type size;
 55 |       ar( make_size_tag( size ) );
 56 | 
 57 |       set.clear();
 58 |       set.reserve( static_cast<std::size_t>( size ) );
 59 | 
 60 |       for( size_type i = 0; i < size; ++i )
 61 |       {
 62 |         typename SetT::key_type key;
 63 | 
 64 |         ar( key );
 65 |         set.emplace( std::move( key ) );
 66 |       }
 67 |     }
 68 |   }
 69 | 
 70 |   //! Saving for std::unordered_set
 71 |   template <class Archive, class K, class H, class KE, class A> inline
 72 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> const & unordered_set )
 73 |   {
 74 |     unordered_set_detail::save( ar, unordered_set );
 75 |   }
 76 | 
 77 |   //! Loading for std::unordered_set
 78 |   template <class Archive, class K, class H, class KE, class A> inline
 79 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> & unordered_set )
 80 |   {
 81 |     unordered_set_detail::load( ar, unordered_set );
 82 |   }
 83 | 
 84 |   //! Saving for std::unordered_multiset
 85 |   template <class Archive, class K, class H, class KE, class A> inline
 86 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> const & unordered_multiset )
 87 |   {
 88 |     unordered_set_detail::save( ar, unordered_multiset );
 89 |   }
 90 | 
 91 |   //! Loading for std::unordered_multiset
 92 |   template <class Archive, class K, class H, class KE, class A> inline
 93 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> & unordered_multiset )
 94 |   {
 95 |     unordered_set_detail::load( ar, unordered_multiset );
 96 |   }
 97 | } // namespace cereal
 98 | 
 99 | #endif // CEREAL_TYPES_UNORDERED_SET_HPP_
100 | 


--------------------------------------------------------------------------------
/cereal/types/valarray.hpp:
--------------------------------------------------------------------------------
 1 | /*! \file valarray.hpp
 2 | \brief Support for types found in \<valarray\>
 3 | \ingroup STLSupport */
 4 | 
 5 | /*
 6 | Copyright (c) 2014, Randolph Voorhies, Shane Grant
 7 | All rights reserved.
 8 | 
 9 | Redistribution and use in source and binary forms, with or without
10 | modification, are permitted provided that the following conditions are met:
11 | * Redistributions of source code must retain the above copyright
12 | notice, this list of conditions and the following disclaimer.
13 | * Redistributions in binary form must reproduce the above copyright
14 | notice, this list of conditions and the following disclaimer in the
15 | documentation and/or other materials provided with the distribution.
16 | * Neither the name of cereal nor the
17 | names of its contributors may be used to endorse or promote products
18 | derived from this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
21 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
24 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | */
31 | 
32 | #ifndef CEREAL_TYPES_VALARRAY_HPP_
33 | #define CEREAL_TYPES_VALARRAY_HPP_
34 | 
35 | #include "cereal/cereal.hpp"
36 | #include <valarray>
37 | 
38 | namespace cereal
39 | {
40 |   //! Saving for std::valarray arithmetic types, using binary serialization, if supported
41 |   template <class Archive, class T> inline
42 |   typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
43 |                           && std::is_arithmetic<T>::value, void>::type
44 |   CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
45 |   {
46 |     ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
47 |     ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous
48 |   }
49 | 
50 |   //! Loading for std::valarray arithmetic types, using binary serialization, if supported
51 |   template <class Archive, class T> inline
52 |   typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
53 |                           && std::is_arithmetic<T>::value, void>::type
54 |   CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
55 |   {
56 |     size_type valarraySize;
57 |     ar( make_size_tag( valarraySize ) );
58 | 
59 |     valarray.resize( static_cast<std::size_t>( valarraySize ) );
60 |     ar( binary_data( &valarray[0], static_cast<std::size_t>( valarraySize ) * sizeof(T) ) );
61 |   }
62 | 
63 |   //! Saving for std::valarray all other types
64 |   template <class Archive, class T> inline
65 |   typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
66 |                           || !std::is_arithmetic<T>::value, void>::type
67 |   CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
68 |   {
69 |     ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
70 |     for(auto && v : valarray)
71 |       ar(v);
72 |   }
73 | 
74 |   //! Loading for std::valarray all other types
75 |   template <class Archive, class T> inline
76 |   typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
77 |                           || !std::is_arithmetic<T>::value, void>::type
78 |   CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
79 |   {
80 |     size_type valarraySize;
81 |     ar( make_size_tag( valarraySize ) );
82 | 
83 |     valarray.resize( static_cast<size_t>( valarraySize ) );
84 |     for(auto && v : valarray)
85 |       ar(v);
86 |   }
87 | } // namespace cereal
88 | 
89 | #endif // CEREAL_TYPES_VALARRAY_HPP_
90 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/error/en.h:
--------------------------------------------------------------------------------
 1 | // Tencent is pleased to support the open source community by making RapidJSON available.
 2 | // 
 3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 4 | //
 5 | // Licensed under the MIT License (the "License"); you may not use this file except
 6 | // in compliance with the License. You may obtain a copy of the License at
 7 | //
 8 | // http://opensource.org/licenses/MIT
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software distributed 
11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
13 | // specific language governing permissions and limitations under the License.
14 | 
15 | #ifndef CEREAL_RAPIDJSON_ERROR_EN_H_
16 | #define CEREAL_RAPIDJSON_ERROR_EN_H_
17 | 
18 | #include "error.h"
19 | 
20 | #ifdef __clang__
21 | CEREAL_RAPIDJSON_DIAG_PUSH
22 | CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
23 | CEREAL_RAPIDJSON_DIAG_OFF(covered-switch-default)
24 | #endif
25 | 
26 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
27 | 
28 | //! Maps error code of parsing into error message.
29 | /*!
30 |     \ingroup CEREAL_RAPIDJSON_ERRORS
31 |     \param parseErrorCode Error code obtained in parsing.
32 |     \return the error message.
33 |     \note User can make a copy of this function for localization.
34 |         Using switch-case is safer for future modification of error codes.
35 | */
36 | inline const CEREAL_RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
37 |     switch (parseErrorCode) {
38 |         case kParseErrorNone:                           return CEREAL_RAPIDJSON_ERROR_STRING("No error.");
39 | 
40 |         case kParseErrorDocumentEmpty:                  return CEREAL_RAPIDJSON_ERROR_STRING("The document is empty.");
41 |         case kParseErrorDocumentRootNotSingular:        return CEREAL_RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
42 |     
43 |         case kParseErrorValueInvalid:                   return CEREAL_RAPIDJSON_ERROR_STRING("Invalid value.");
44 |     
45 |         case kParseErrorObjectMissName:                 return CEREAL_RAPIDJSON_ERROR_STRING("Missing a name for object member.");
46 |         case kParseErrorObjectMissColon:                return CEREAL_RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
47 |         case kParseErrorObjectMissCommaOrCurlyBracket:  return CEREAL_RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
48 |     
49 |         case kParseErrorArrayMissCommaOrSquareBracket:  return CEREAL_RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
50 | 
51 |         case kParseErrorStringUnicodeEscapeInvalidHex:  return CEREAL_RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
52 |         case kParseErrorStringUnicodeSurrogateInvalid:  return CEREAL_RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
53 |         case kParseErrorStringEscapeInvalid:            return CEREAL_RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
54 |         case kParseErrorStringMissQuotationMark:        return CEREAL_RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
55 |         case kParseErrorStringInvalidEncoding:          return CEREAL_RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
56 | 
57 |         case kParseErrorNumberTooBig:                   return CEREAL_RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
58 |         case kParseErrorNumberMissFraction:             return CEREAL_RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
59 |         case kParseErrorNumberMissExponent:             return CEREAL_RAPIDJSON_ERROR_STRING("Miss exponent in number.");
60 | 
61 |         case kParseErrorTermination:                    return CEREAL_RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
62 |         case kParseErrorUnspecificSyntaxError:          return CEREAL_RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
63 | 
64 |         default:                                        return CEREAL_RAPIDJSON_ERROR_STRING("Unknown error.");
65 |     }
66 | }
67 | 
68 | CEREAL_RAPIDJSON_NAMESPACE_END
69 | 
70 | #ifdef __clang__
71 | CEREAL_RAPIDJSON_DIAG_POP
72 | #endif
73 | 
74 | #endif // CEREAL_RAPIDJSON_ERROR_EN_H_
75 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/stringbuffer.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef CEREAL_RAPIDJSON_STRINGBUFFER_H_
 16 | #define CEREAL_RAPIDJSON_STRINGBUFFER_H_
 17 | 
 18 | #include "stream.h"
 19 | #include "internal/stack.h"
 20 | 
 21 | #if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
 22 | #include <utility> // std::move
 23 | #endif
 24 | 
 25 | #include "internal/stack.h"
 26 | 
 27 | #if defined(__clang__)
 28 | CEREAL_RAPIDJSON_DIAG_PUSH
 29 | CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
 30 | #endif
 31 | 
 32 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
 33 | 
 34 | //! Represents an in-memory output stream.
 35 | /*!
 36 |     \tparam Encoding Encoding of the stream.
 37 |     \tparam Allocator type for allocating memory buffer.
 38 |     \note implements Stream concept
 39 | */
 40 | template <typename Encoding, typename Allocator = CrtAllocator>
 41 | class GenericStringBuffer {
 42 | public:
 43 |     typedef typename Encoding::Ch Ch;
 44 | 
 45 |     GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
 46 | 
 47 | #if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
 48 |     GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
 49 |     GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
 50 |         if (&rhs != this)
 51 |             stack_ = std::move(rhs.stack_);
 52 |         return *this;
 53 |     }
 54 | #endif
 55 | 
 56 |     void Put(Ch c) { *stack_.template Push<Ch>() = c; }
 57 |     void PutUnsafe(Ch c) { *stack_.template PushUnsafe<Ch>() = c; }
 58 |     void Flush() {}
 59 | 
 60 |     void Clear() { stack_.Clear(); }
 61 |     void ShrinkToFit() {
 62 |         // Push and pop a null terminator. This is safe.
 63 |         *stack_.template Push<Ch>() = '\0';
 64 |         stack_.ShrinkToFit();
 65 |         stack_.template Pop<Ch>(1);
 66 |     }
 67 | 
 68 |     void Reserve(size_t count) { stack_.template Reserve<Ch>(count); }
 69 |     Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
 70 |     Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe<Ch>(count); }
 71 |     void Pop(size_t count) { stack_.template Pop<Ch>(count); }
 72 | 
 73 |     const Ch* GetString() const {
 74 |         // Push and pop a null terminator. This is safe.
 75 |         *stack_.template Push<Ch>() = '\0';
 76 |         stack_.template Pop<Ch>(1);
 77 | 
 78 |         return stack_.template Bottom<Ch>();
 79 |     }
 80 | 
 81 |     //! Get the size of string in bytes in the string buffer.
 82 |     size_t GetSize() const { return stack_.GetSize(); }
 83 | 
 84 |     //! Get the length of string in Ch in the string buffer.
 85 |     size_t GetLength() const { return stack_.GetSize() / sizeof(Ch); }
 86 | 
 87 |     static const size_t kDefaultCapacity = 256;
 88 |     mutable internal::Stack<Allocator> stack_;
 89 | 
 90 | private:
 91 |     // Prohibit copy constructor & assignment operator.
 92 |     GenericStringBuffer(const GenericStringBuffer&);
 93 |     GenericStringBuffer& operator=(const GenericStringBuffer&);
 94 | };
 95 | 
 96 | //! String buffer with UTF8 encoding
 97 | typedef GenericStringBuffer<UTF8<> > StringBuffer;
 98 | 
 99 | template<typename Encoding, typename Allocator>
100 | inline void PutReserve(GenericStringBuffer<Encoding, Allocator>& stream, size_t count) {
101 |     stream.Reserve(count);
102 | }
103 | 
104 | template<typename Encoding, typename Allocator>
105 | inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator>& stream, typename Encoding::Ch c) {
106 |     stream.PutUnsafe(c);
107 | }
108 | 
109 | //! Implement specialized version of PutN() with memset() for better performance.
110 | template<>
111 | inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
112 |     std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
113 | }
114 | 
115 | CEREAL_RAPIDJSON_NAMESPACE_END
116 | 
117 | #if defined(__clang__)
118 | CEREAL_RAPIDJSON_DIAG_POP
119 | #endif
120 | 
121 | #endif // CEREAL_RAPIDJSON_STRINGBUFFER_H_
122 | 


--------------------------------------------------------------------------------
/cereal/types/variant.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file variant.hpp
  2 |     \brief Support for std::variant
  3 |     \ingroup STLSupport */
  4 | /*
  5 |   Copyright (c) 2014, 2017, Randolph Voorhies, Shane Grant, Juan Pedro
  6 |   Bolivar Puente. All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_STD_VARIANT_HPP_
 31 | #define CEREAL_TYPES_STD_VARIANT_HPP_
 32 | 
 33 | #include "cereal/cereal.hpp"
 34 | #include <variant>
 35 | #include <cstdint>
 36 | 
 37 | namespace cereal
 38 | {
 39 |   namespace variant_detail
 40 |   {
 41 |     //! @internal
 42 |     template <class Archive>
 43 |     struct variant_save_visitor
 44 |     {
 45 |       variant_save_visitor(Archive & ar_) : ar(ar_) {}
 46 | 
 47 |       template<class T>
 48 |         void operator()(T const & value) const
 49 |         {
 50 |           ar( CEREAL_NVP_("data", value) );
 51 |         }
 52 | 
 53 |       Archive & ar;
 54 |     };
 55 | 
 56 |     //! @internal
 57 |     template<int N, class Variant, class ... Args, class Archive>
 58 |     typename std::enable_if<N == std::variant_size_v<Variant>, void>::type
 59 |     load_variant(Archive & /*ar*/, int /*target*/, Variant & /*variant*/)
 60 |     {
 61 |       throw ::cereal::Exception("Error traversing variant during load");
 62 |     }
 63 |     //! @internal
 64 |     template<int N, class Variant, class H, class ... T, class Archive>
 65 |     typename std::enable_if<N < std::variant_size_v<Variant>, void>::type
 66 |     load_variant(Archive & ar, int target, Variant & variant)
 67 |     {
 68 |       if(N == target)
 69 |       {
 70 |         H value;
 71 |         ar( CEREAL_NVP_("data", value) );
 72 |         variant = std::move(value);
 73 |       }
 74 |       else
 75 |         load_variant<N+1, Variant, T...>(ar, target, variant);
 76 |     }
 77 | 
 78 |   } // namespace variant_detail
 79 | 
 80 |   //! Saving for std::variant
 81 |   template <class Archive, typename VariantType1, typename... VariantTypes> inline
 82 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::variant<VariantType1, VariantTypes...> const & variant )
 83 |   {
 84 |     std::int32_t index = static_cast<std::int32_t>(variant.index());
 85 |     ar( CEREAL_NVP_("index", index) );
 86 |     variant_detail::variant_save_visitor<Archive> visitor(ar);
 87 |     std::visit(visitor, variant);
 88 |   }
 89 | 
 90 |   //! Loading for std::variant
 91 |   template <class Archive, typename... VariantTypes> inline
 92 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::variant<VariantTypes...> & variant )
 93 |   {
 94 |     using variant_t = typename std::variant<VariantTypes...>;
 95 | 
 96 |     std::int32_t index;
 97 |     ar( CEREAL_NVP_("index", index) );
 98 |     if(index >= static_cast<std::int32_t>(std::variant_size_v<variant_t>))
 99 |       throw Exception("Invalid 'index' selector when deserializing std::variant");
100 | 
101 |     variant_detail::load_variant<0, variant_t, VariantTypes...>(ar, index, variant);
102 |   }
103 | 
104 |   //! Serializing a std::monostate
105 |   template <class Archive>
106 |   void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, std::monostate const & ) {}
107 | } // namespace cereal
108 | 
109 | #endif // CEREAL_TYPES_STD_VARIANT_HPP_
110 | 


--------------------------------------------------------------------------------
/cereal/external/rapidxml/rapidxml_iterators.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CEREAL_RAPIDXML_ITERATORS_HPP_INCLUDED
  2 | #define CEREAL_RAPIDXML_ITERATORS_HPP_INCLUDED
  3 | 
  4 | // Copyright (C) 2006, 2009 Marcin Kalicinski
  5 | // Version 1.13
  6 | // Revision $DateTime: 2009/05/13 01:46:17 $
  7 | 
  8 | #include "rapidxml.hpp"
  9 | 
 10 | namespace cereal {
 11 | namespace rapidxml
 12 | {
 13 | 
 14 |     //! Iterator of child nodes of xml_node
 15 |     template<class Ch>
 16 |     class node_iterator
 17 |     {
 18 | 
 19 |     public:
 20 | 
 21 |         typedef typename xml_node<Ch> value_type;
 22 |         typedef typename xml_node<Ch> &reference;
 23 |         typedef typename xml_node<Ch> *pointer;
 24 |         typedef std::ptrdiff_t difference_type;
 25 |         typedef std::bidirectional_iterator_tag iterator_category;
 26 | 
 27 |         node_iterator()
 28 |             : m_node(0)
 29 |         {
 30 |         }
 31 | 
 32 |         node_iterator(xml_node<Ch> *node)
 33 |             : m_node(node->first_node())
 34 |         {
 35 |         }
 36 | 
 37 |         reference operator *() const
 38 |         {
 39 |             assert(m_node);
 40 |             return *m_node;
 41 |         }
 42 | 
 43 |         pointer operator->() const
 44 |         {
 45 |             assert(m_node);
 46 |             return m_node;
 47 |         }
 48 | 
 49 |         node_iterator& operator++()
 50 |         {
 51 |             assert(m_node);
 52 |             m_node = m_node->next_sibling();
 53 |             return *this;
 54 |         }
 55 | 
 56 |         node_iterator operator++(int)
 57 |         {
 58 |             node_iterator tmp = *this;
 59 |             ++this;
 60 |             return tmp;
 61 |         }
 62 | 
 63 |         node_iterator& operator--()
 64 |         {
 65 |             assert(m_node && m_node->previous_sibling());
 66 |             m_node = m_node->previous_sibling();
 67 |             return *this;
 68 |         }
 69 | 
 70 |         node_iterator operator--(int)
 71 |         {
 72 |             node_iterator tmp = *this;
 73 |             ++this;
 74 |             return tmp;
 75 |         }
 76 | 
 77 |         bool operator ==(const node_iterator<Ch> &rhs)
 78 |         {
 79 |             return m_node == rhs.m_node;
 80 |         }
 81 | 
 82 |         bool operator !=(const node_iterator<Ch> &rhs)
 83 |         {
 84 |             return m_node != rhs.m_node;
 85 |         }
 86 | 
 87 |     private:
 88 | 
 89 |         xml_node<Ch> *m_node;
 90 | 
 91 |     };
 92 | 
 93 |     //! Iterator of child attributes of xml_node
 94 |     template<class Ch>
 95 |     class attribute_iterator
 96 |     {
 97 | 
 98 |     public:
 99 | 
100 |         typedef typename xml_attribute<Ch> value_type;
101 |         typedef typename xml_attribute<Ch> &reference;
102 |         typedef typename xml_attribute<Ch> *pointer;
103 |         typedef std::ptrdiff_t difference_type;
104 |         typedef std::bidirectional_iterator_tag iterator_category;
105 | 
106 |         attribute_iterator()
107 |             : m_attribute(0)
108 |         {
109 |         }
110 | 
111 |         attribute_iterator(xml_node<Ch> *node)
112 |             : m_attribute(node->first_attribute())
113 |         {
114 |         }
115 | 
116 |         reference operator *() const
117 |         {
118 |             assert(m_attribute);
119 |             return *m_attribute;
120 |         }
121 | 
122 |         pointer operator->() const
123 |         {
124 |             assert(m_attribute);
125 |             return m_attribute;
126 |         }
127 | 
128 |         attribute_iterator& operator++()
129 |         {
130 |             assert(m_attribute);
131 |             m_attribute = m_attribute->next_attribute();
132 |             return *this;
133 |         }
134 | 
135 |         attribute_iterator operator++(int)
136 |         {
137 |             attribute_iterator tmp = *this;
138 |             ++this;
139 |             return tmp;
140 |         }
141 | 
142 |         attribute_iterator& operator--()
143 |         {
144 |             assert(m_attribute && m_attribute->previous_attribute());
145 |             m_attribute = m_attribute->previous_attribute();
146 |             return *this;
147 |         }
148 | 
149 |         attribute_iterator operator--(int)
150 |         {
151 |             attribute_iterator tmp = *this;
152 |             ++this;
153 |             return tmp;
154 |         }
155 | 
156 |         bool operator ==(const attribute_iterator<Ch> &rhs)
157 |         {
158 |             return m_attribute == rhs.m_attribute;
159 |         }
160 | 
161 |         bool operator !=(const attribute_iterator<Ch> &rhs)
162 |         {
163 |             return m_attribute != rhs.m_attribute;
164 |         }
165 | 
166 |     private:
167 | 
168 |         xml_attribute<Ch> *m_attribute;
169 | 
170 |     };
171 | 
172 | }
173 | } // namespace cereal
174 | 
175 | #endif
176 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/istreamwrapper.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_
 16 | #define CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_
 17 | 
 18 | #include "stream.h"
 19 | #include <iosfwd>
 20 | #include <ios>
 21 | 
 22 | #ifdef __clang__
 23 | CEREAL_RAPIDJSON_DIAG_PUSH
 24 | CEREAL_RAPIDJSON_DIAG_OFF(padded)
 25 | #elif defined(_MSC_VER)
 26 | CEREAL_RAPIDJSON_DIAG_PUSH
 27 | CEREAL_RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
 28 | #endif
 29 | 
 30 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
 31 | 
 32 | //! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
 33 | /*!
 34 |     The classes can be wrapped including but not limited to:
 35 | 
 36 |     - \c std::istringstream
 37 |     - \c std::stringstream
 38 |     - \c std::wistringstream
 39 |     - \c std::wstringstream
 40 |     - \c std::ifstream
 41 |     - \c std::fstream
 42 |     - \c std::wifstream
 43 |     - \c std::wfstream
 44 | 
 45 |     \tparam StreamType Class derived from \c std::basic_istream.
 46 | */
 47 |    
 48 | template <typename StreamType>
 49 | class BasicIStreamWrapper {
 50 | public:
 51 |     typedef typename StreamType::char_type Ch;
 52 | 
 53 |     //! Constructor.
 54 |     /*!
 55 |         \param stream stream opened for read.
 56 |     */
 57 |     BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
 58 |         Read();
 59 |     }
 60 | 
 61 |     //! Constructor.
 62 |     /*!
 63 |         \param stream stream opened for read.
 64 |         \param buffer user-supplied buffer.
 65 |         \param bufferSize size of buffer in bytes. Must >=4 bytes.
 66 |     */
 67 |     BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
 68 |         CEREAL_RAPIDJSON_ASSERT(bufferSize >= 4);
 69 |         Read();
 70 |     }
 71 | 
 72 |     Ch Peek() const { return *current_; }
 73 |     Ch Take() { Ch c = *current_; Read(); return c; }
 74 |     size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
 75 | 
 76 |     // Not implemented
 77 |     void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
 78 |     void Flush() { CEREAL_RAPIDJSON_ASSERT(false); } 
 79 |     Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 80 |     size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
 81 | 
 82 |     // For encoding detection only.
 83 |     const Ch* Peek4() const {
 84 |         return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
 85 |     }
 86 | 
 87 | private:
 88 |     BasicIStreamWrapper();
 89 |     BasicIStreamWrapper(const BasicIStreamWrapper&);
 90 |     BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
 91 | 
 92 |     void Read() {
 93 |         if (current_ < bufferLast_)
 94 |             ++current_;
 95 |         else if (!eof_) {
 96 |             count_ += readCount_;
 97 |             readCount_ = bufferSize_;
 98 |             bufferLast_ = buffer_ + readCount_ - 1;
 99 |             current_ = buffer_;
100 | 
101 |             if (!stream_.read(buffer_, static_cast<std::streamsize>(bufferSize_))) {
102 |                 readCount_ = static_cast<size_t>(stream_.gcount());
103 |                 *(bufferLast_ = buffer_ + readCount_) = '\0';
104 |                 eof_ = true;
105 |             }
106 |         }
107 |     }
108 | 
109 |     StreamType &stream_;
110 |     Ch peekBuffer_[4], *buffer_;
111 |     size_t bufferSize_;
112 |     Ch *bufferLast_;
113 |     Ch *current_;
114 |     size_t readCount_;
115 |     size_t count_;  //!< Number of characters read
116 |     bool eof_;
117 | };
118 | 
119 | typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
120 | typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
121 | 
122 | #if defined(__clang__) || defined(_MSC_VER)
123 | CEREAL_RAPIDJSON_DIAG_POP
124 | #endif
125 | 
126 | CEREAL_RAPIDJSON_NAMESPACE_END
127 | 
128 | #endif // CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_
129 | 


--------------------------------------------------------------------------------
/cereal/external/rapidjson/fwd.h:
--------------------------------------------------------------------------------
  1 | // Tencent is pleased to support the open source community by making RapidJSON available.
  2 | // 
  3 | // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
  4 | //
  5 | // Licensed under the MIT License (the "License"); you may not use this file except
  6 | // in compliance with the License. You may obtain a copy of the License at
  7 | //
  8 | // http://opensource.org/licenses/MIT
  9 | //
 10 | // Unless required by applicable law or agreed to in writing, software distributed 
 11 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 12 | // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 13 | // specific language governing permissions and limitations under the License.
 14 | 
 15 | #ifndef CEREAL_RAPIDJSON_FWD_H_
 16 | #define CEREAL_RAPIDJSON_FWD_H_
 17 | 
 18 | #include "rapidjson.h"
 19 | 
 20 | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
 21 | 
 22 | // encodings.h
 23 | 
 24 | template<typename CharType> struct UTF8;
 25 | template<typename CharType> struct UTF16;
 26 | template<typename CharType> struct UTF16BE;
 27 | template<typename CharType> struct UTF16LE;
 28 | template<typename CharType> struct UTF32;
 29 | template<typename CharType> struct UTF32BE;
 30 | template<typename CharType> struct UTF32LE;
 31 | template<typename CharType> struct ASCII;
 32 | template<typename CharType> struct AutoUTF;
 33 | 
 34 | template<typename SourceEncoding, typename TargetEncoding>
 35 | struct Transcoder;
 36 | 
 37 | // allocators.h
 38 | 
 39 | class CrtAllocator;
 40 | 
 41 | template <typename BaseAllocator>
 42 | class MemoryPoolAllocator;
 43 | 
 44 | // stream.h
 45 | 
 46 | template <typename Encoding>
 47 | struct GenericStringStream;
 48 | 
 49 | typedef GenericStringStream<UTF8<char> > StringStream;
 50 | 
 51 | template <typename Encoding>
 52 | struct GenericInsituStringStream;
 53 | 
 54 | typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
 55 | 
 56 | // stringbuffer.h
 57 | 
 58 | template <typename Encoding, typename Allocator>
 59 | class GenericStringBuffer;
 60 | 
 61 | typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
 62 | 
 63 | // filereadstream.h
 64 | 
 65 | class FileReadStream;
 66 | 
 67 | // filewritestream.h
 68 | 
 69 | class FileWriteStream;
 70 | 
 71 | // memorybuffer.h
 72 | 
 73 | template <typename Allocator>
 74 | struct GenericMemoryBuffer;
 75 | 
 76 | typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
 77 | 
 78 | // memorystream.h
 79 | 
 80 | struct MemoryStream;
 81 | 
 82 | // reader.h
 83 | 
 84 | template<typename Encoding, typename Derived>
 85 | struct BaseReaderHandler;
 86 | 
 87 | template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
 88 | class GenericReader;
 89 | 
 90 | typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
 91 | 
 92 | // writer.h
 93 | 
 94 | template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
 95 | class Writer;
 96 | 
 97 | // prettywriter.h
 98 | 
 99 | template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
100 | class PrettyWriter;
101 | 
102 | // document.h
103 | 
104 | template <typename Encoding, typename Allocator> 
105 | struct GenericMember;
106 | 
107 | template <bool Const, typename Encoding, typename Allocator>
108 | class GenericMemberIterator;
109 | 
110 | template<typename CharType>
111 | struct GenericStringRef;
112 | 
113 | template <typename Encoding, typename Allocator> 
114 | class GenericValue;
115 | 
116 | typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
117 | 
118 | template <typename Encoding, typename Allocator, typename StackAllocator>
119 | class GenericDocument;
120 | 
121 | typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
122 | 
123 | // pointer.h
124 | 
125 | template <typename ValueType, typename Allocator>
126 | class GenericPointer;
127 | 
128 | typedef GenericPointer<Value, CrtAllocator> Pointer;
129 | 
130 | // schema.h
131 | 
132 | template <typename SchemaDocumentType>
133 | class IGenericRemoteSchemaDocumentProvider;
134 | 
135 | template <typename ValueT, typename Allocator>
136 | class GenericSchemaDocument;
137 | 
138 | typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
139 | typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
140 | 
141 | template <
142 |     typename SchemaDocumentType,
143 |     typename OutputHandler,
144 |     typename StateAllocator>
145 | class GenericSchemaValidator;
146 | 
147 | typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
148 | 
149 | CEREAL_RAPIDJSON_NAMESPACE_END
150 | 
151 | #endif // CEREAL_RAPIDJSON_RAPIDJSONFWD_H_
152 | 


--------------------------------------------------------------------------------
/cereal/external/base64.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |    Copyright (C) 2004-2008 René Nyffenegger
  3 | 
  4 |    This source code is provided 'as-is', without any express or implied
  5 |    warranty. In no event will the author be held liable for any damages
  6 |    arising from the use of this software.
  7 | 
  8 |    Permission is granted to anyone to use this software for any purpose,
  9 |    including commercial applications, and to alter it and redistribute it
 10 |    freely, subject to the following restrictions:
 11 | 
 12 |    1. The origin of this source code must not be misrepresented; you must not
 13 |       claim that you wrote the original source code. If you use this source code
 14 |       in a product, an acknowledgment in the product documentation would be
 15 |       appreciated but is not required.
 16 | 
 17 |    2. Altered source versions must be plainly marked as such, and must not be
 18 |       misrepresented as being the original source code.
 19 | 
 20 |    3. This notice may not be removed or altered from any source distribution.
 21 | 
 22 |    René Nyffenegger rene.nyffenegger@adp-gmbh.ch
 23 | */
 24 | 
 25 | #ifndef CEREAL_EXTERNAL_BASE64_HPP_
 26 | #define CEREAL_EXTERNAL_BASE64_HPP_
 27 | 
 28 | #ifdef __GNUC__
 29 | #pragma GCC diagnostic push
 30 | #pragma GCC diagnostic ignored "-Wconversion"
 31 | #endif
 32 | 
 33 | #include <string>
 34 | 
 35 | namespace cereal
 36 | {
 37 |   namespace base64
 38 |   {
 39 |     static const std::string chars =
 40 |       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 41 |       "abcdefghijklmnopqrstuvwxyz"
 42 |       "0123456789+/";
 43 | 
 44 |     static inline bool is_base64(unsigned char c) {
 45 |       return (isalnum(c) || (c == '+') || (c == '/'));
 46 |     }
 47 | 
 48 |     inline std::string encode(unsigned char const* bytes_to_encode, size_t in_len) {
 49 |       std::string ret;
 50 |       int i = 0;
 51 |       int j = 0;
 52 |       unsigned char char_array_3[3];
 53 |       unsigned char char_array_4[4];
 54 | 
 55 |       while (in_len--) {
 56 |         char_array_3[i++] = *(bytes_to_encode++);
 57 |         if (i == 3) {
 58 |           char_array_4[0] = static_cast<unsigned char>((char_array_3[0] & 0xfc) >> 2);
 59 |           char_array_4[1] = static_cast<unsigned char>( ( ( char_array_3[0] & 0x03 ) << 4 ) + ( ( char_array_3[1] & 0xf0 ) >> 4 ) );
 60 |           char_array_4[2] = static_cast<unsigned char>( ( ( char_array_3[1] & 0x0f ) << 2 ) + ( ( char_array_3[2] & 0xc0 ) >> 6 ) );
 61 |           char_array_4[3] = static_cast<unsigned char>( char_array_3[2] & 0x3f );
 62 | 
 63 |           for(i = 0; (i <4) ; i++)
 64 |             ret += chars[char_array_4[i]];
 65 |           i = 0;
 66 |         }
 67 |       }
 68 | 
 69 |       if (i)
 70 |       {
 71 |         for(j = i; j < 3; j++)
 72 |           char_array_3[j] = '\0';
 73 | 
 74 |         char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
 75 |         char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
 76 |         char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
 77 |         char_array_4[3] = char_array_3[2] & 0x3f;
 78 | 
 79 |         for (j = 0; (j < i + 1); j++)
 80 |           ret += chars[char_array_4[j]];
 81 | 
 82 |         while((i++ < 3))
 83 |           ret += '=';
 84 |       }
 85 | 
 86 |       return ret;
 87 |     }
 88 | 
 89 |     inline std::string decode(std::string const& encoded_string) {
 90 |       size_t in_len = encoded_string.size();
 91 |       size_t i = 0;
 92 |       size_t j = 0;
 93 |       int in_ = 0;
 94 |       unsigned char char_array_4[4], char_array_3[3];
 95 |       std::string ret;
 96 | 
 97 |       while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
 98 |         char_array_4[i++] = encoded_string[in_]; in_++;
 99 |         if (i ==4) {
100 |           for (i = 0; i <4; i++)
101 |             char_array_4[i] = static_cast<unsigned char>(chars.find( char_array_4[i] ));
102 | 
103 |           char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
104 |           char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
105 |           char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
106 | 
107 |           for (i = 0; (i < 3); i++)
108 |             ret += char_array_3[i];
109 |           i = 0;
110 |         }
111 |       }
112 | 
113 |       if (i) {
114 |         for (j = i; j <4; j++)
115 |           char_array_4[j] = 0;
116 | 
117 |         for (j = 0; j <4; j++)
118 |           char_array_4[j] = static_cast<unsigned char>(chars.find( char_array_4[j] ));
119 | 
120 |         char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
121 |         char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
122 |         char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
123 | 
124 |         for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
125 |       }
126 | 
127 |       return ret;
128 |     }
129 |   } // namespace base64
130 | } // namespace cereal
131 | #ifdef __GNUC__
132 | #pragma GCC diagnostic pop
133 | #endif
134 | #endif // CEREAL_EXTERNAL_BASE64_HPP_
135 | 


--------------------------------------------------------------------------------
/cereal/types/tuple.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file tuple.hpp
  2 |     \brief Support for types found in \<tuple\>
  3 |     \ingroup STLSupport */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_TUPLE_HPP_
 31 | #define CEREAL_TYPES_TUPLE_HPP_
 32 | 
 33 | #include "cereal/cereal.hpp"
 34 | #include <tuple>
 35 | 
 36 | namespace cereal
 37 | {
 38 |   namespace tuple_detail
 39 |   {
 40 |     //! Creates a c string from a sequence of characters
 41 |     /*! The c string created will always be prefixed by "tuple_element"
 42 |         Based on code from: http://stackoverflow/a/20973438/710791
 43 |         @internal */
 44 |     template<char...Cs>
 45 |     struct char_seq_to_c_str
 46 |     {
 47 |       static const int size = 14;// Size of array for the word: tuple_element
 48 |       typedef const char (&arr_type)[sizeof...(Cs) + size];
 49 |       static const char str[sizeof...(Cs) + size];
 50 |     };
 51 | 
 52 |     // the word tuple_element plus a number
 53 |     //! @internal
 54 |     template<char...Cs>
 55 |     const char char_seq_to_c_str<Cs...>::str[sizeof...(Cs) + size] =
 56 |       {'t','u','p','l','e','_','e','l','e','m','e','n','t', Cs..., '\0'};
 57 | 
 58 |     //! Converts a number into a sequence of characters
 59 |     /*! @tparam Q The quotient of dividing the original number by 10
 60 |         @tparam R The remainder of dividing the original number by 10
 61 |         @tparam C The sequence built so far
 62 |         @internal */
 63 |     template <size_t Q, size_t R, char ... C>
 64 |     struct to_string_impl
 65 |     {
 66 |       using type = typename to_string_impl<Q/10, Q%10, static_cast<char>(R+std::size_t{'0'}), C...>::type;
 67 |     };
 68 | 
 69 |     //! Base case with no quotient
 70 |     /*! @internal */
 71 |     template <size_t R, char ... C>
 72 |     struct to_string_impl<0, R, C...>
 73 |     {
 74 |       using type = char_seq_to_c_str<static_cast<char>(R+std::size_t{'0'}), C...>;
 75 |     };
 76 | 
 77 |     //! Generates a c string for a given index of a tuple
 78 |     /*! Example use:
 79 |         @code{cpp}
 80 |         tuple_element_name<3>::c_str();// returns "tuple_element3"
 81 |         @endcode
 82 |         @internal */
 83 |     template<size_t T>
 84 |     struct tuple_element_name
 85 |     {
 86 |       using type = typename to_string_impl<T/10, T%10>::type;
 87 |       static const typename type::arr_type c_str(){ return type::str; }
 88 |     };
 89 | 
 90 |     // unwinds a tuple to save it
 91 |     //! @internal
 92 |     template <size_t Height>
 93 |     struct serialize
 94 |     {
 95 |       template <class Archive, class ... Types> inline
 96 |       static void apply( Archive & ar, std::tuple<Types...> & tuple )
 97 |       {
 98 |         serialize<Height - 1>::template apply( ar, tuple );
 99 |         ar( CEREAL_NVP_(tuple_element_name<Height - 1>::c_str(),
100 |             std::get<Height - 1>( tuple )) );
101 |       }
102 |     };
103 | 
104 |     // Zero height specialization - nothing to do here
105 |     //! @internal
106 |     template <>
107 |     struct serialize<0>
108 |     {
109 |       template <class Archive, class ... Types> inline
110 |       static void apply( Archive &, std::tuple<Types...> & )
111 |       { }
112 |     };
113 |   }
114 | 
115 |   //! Serializing for std::tuple
116 |   template <class Archive, class ... Types> inline
117 |   void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::tuple<Types...> & tuple )
118 |   {
119 |     tuple_detail::serialize<std::tuple_size<std::tuple<Types...>>::value>::template apply( ar, tuple );
120 |   }
121 | } // namespace cereal
122 | 
123 | #endif // CEREAL_TYPES_TUPLE_HPP_
124 | 


--------------------------------------------------------------------------------
/window_exe_data.cpp:
--------------------------------------------------------------------------------
  1 | #include "window_exe_data.h"
  2 | #include "ui_window_exe_data.h"
  3 | 
  4 | window_exe_data::window_exe_data(QWidget *parent,TCB* tcb) :
  5 |     QWidget(parent),
  6 |     ui(new Ui::window_exe_data)
  7 | {
  8 |     ui->setupUi(this);
  9 |     this->tcb = tcb;
 10 |     fileSelected = nullptr;
 11 |     this->setWindowTitle("数据执行");
 12 |     // 关闭即销毁
 13 |     this->setAttribute(Qt::WA_DeleteOnClose,true);
 14 |     // 定义
 15 |     lv_fileList = ui->lv_fileList;
 16 |     ll_owner = ui->text_owner;
 17 |     ll_fileName = ui->text_fileName;
 18 |     ll_fileSize = ui->text_fileSize;
 19 |     ll_createTime = ui->text_createTime;
 20 |     ll_loadFile = ui->text_loadFiles;
 21 |     nb_pageNumber = ui->nb_pageNumber;
 22 |     tb_outputBuffer = ui->tb_outputBuffer;
 23 |     // 是否已经打开文件
 24 |     isInUse = false;
 25 | 
 26 |     model = new QStandardItemModel();
 27 |     lv_fileList->setModel(model);
 28 |     connect(lv_fileList,SIGNAL(clicked(QModelIndex)),this,SLOT(showClick(QModelIndex)));
 29 | 
 30 |     updateFiles();
 31 | }
 32 | 
 33 | window_exe_data::~window_exe_data()
 34 | {
 35 |     delete ui;
 36 | }
 37 | 
 38 | // 读入按钮被按下
 39 | void window_exe_data::on_pushButton_clicked()
 40 | {
 41 |     // 加锁
 42 |     CGlobal::mSem->acquire();
 43 |     //ui->pushButton->setDisabled(true);
 44 |     // 获取页号数
 45 |     int page = nb_pageNumber->value();
 46 |     // 在内存中读取数据
 47 |     auto status = CGlobal::mManager->read(tcb,page);
 48 |     // 通过string来判断
 49 |     if (status.code == STATUS_OK){
 50 |         // 没有发生换页
 51 | 
 52 |     } else if (status.code == STATUS_MEMORY_EXIST){
 53 |         // 直接引用内存
 54 |         QMessageBox * box = new QMessageBox();
 55 |         box->setText("内存中已存在该页，内存块号为："+QString::number(status.mBlock));
 56 |         box->exec();
 57 |     }
 58 |     else if (status.code == STATUS_EXCHANGE_PAGE){
 59 |         // 发生了换页
 60 |         QMessageBox * box = new QMessageBox();
 61 |         box->setText("发生LRU全局置换，替换的内存块号为："+QString::number(status.mBlock));
 62 |         box->exec();
 63 |     }
 64 |     // 更新UI
 65 |     tb_outputBuffer->append("第"+QString::number(page)+"页数据："+QString::fromStdString(status.data));
 66 |     // 通知主线程
 67 |     emit notifyUpdate();
 68 |     // 解锁
 69 |     CGlobal::mSem->release();
 70 | }
 71 | 
 72 | // 更新文件列表
 73 | void window_exe_data::updateFiles()
 74 | {
 75 |     qDebug() << "执行线程：更新文件列表";
 76 |     model->clear();
 77 |     queue<FCB*> q = CGlobal::fManager->getFiles();
 78 |     // 备份一份
 79 |     while(!q.empty()){
 80 |         FCB* fcb = q.front();
 81 |         QStandardItem * item = new QStandardItem();
 82 |         item->setEditable(false);
 83 |         item->setText(QString::fromStdString(fcb->fileName));
 84 |         model->appendRow(item);
 85 |         q.pop();
 86 |         tmpFCB.push_back(fcb);
 87 |     }
 88 | }
 89 | 
 90 | // 锁定一个数据执行线程只能访问一个文件，要访问第二个文件需要打开多个窗口
 91 | void window_exe_data::on_btn_load_clicked()
 92 | {
 93 |     // fileSelected 指向选中文件的指针
 94 |     if(fileSelected == nullptr){
 95 |         auto box = new QMessageBox();
 96 |         box->setText("未选择文件");
 97 |         box->exec();
 98 |     } else {
 99 |         tcb->fcb = fileSelected;
100 |         // 在tcb中加入读入的数据
101 |         tcb->data = CGlobal::fManager->getData(tcb->fcb);
102 |         // 上锁，在窗口关闭的时候解锁
103 |         int status = CGlobal::mManager->allocMemory(tcb);
104 |         if (status == STATUS_OK){
105 |             CGlobal::fManager->lockFile(fileSelected);
106 |             isInUse = true;
107 |             // 在创建数据执行线程时，已经在FCB中分配了4个内存，所以直接禁用调入内存等
108 |             ((QPushButton*)sender())->setEnabled(false);
109 |             lv_fileList->setDisabled(true);
110 |             ll_loadFile->setText(QString::fromStdString(fileSelected->fileName));
111 |             // 设置页号范围
112 |             int blockSize = fileSelected->fileSize;
113 |             if (blockSize <= 0){
114 |                 nb_pageNumber->setRange(0,0);
115 |                 // 不允许读入
116 |             } else {
117 |                 nb_pageNumber->setRange(0,blockSize-1);
118 |                 ui->pushButton->setEnabled(true);
119 |             }
120 |             emit notifyUpdate();
121 |         } else {
122 |             QMessageBox *box = new QMessageBox();
123 |             box->setText("内存不足，无法打开更多的执行线程，请关闭一些执行线程再重试");
124 |             box->exec();
125 |         }
126 |     }
127 | }
128 | 
129 | void window_exe_data::showClick(QModelIndex index)
130 | {
131 |     FCB* fcb = tmpFCB.at(index.row());
132 |     ll_owner->setText(QString::fromStdString(fcb->owner));
133 |     ll_fileName->setText(QString::fromStdString(fcb->fileName));
134 |     ll_fileSize->setText(QString::number(fcb->fileSize));
135 |     ll_createTime->setText(parseTM(fcb->createTime));
136 |     fileSelected = fcb;
137 | }
138 | 
139 | void window_exe_data::closeEvent(QCloseEvent *event)
140 | {
141 |     // TODO 清除内存，先获取信号量
142 |     CGlobal::mSem->acquire();
143 |     int status = CGlobal::mManager->freeBlock(this->tcb);
144 |     if(status == STATUS_OK){
145 |         qDebug() << "内存管理器返回正常，内存已清除" ;
146 |     } else {
147 |         qDebug() << "警告！内存泄露，清除失败" ;
148 |     }
149 | 
150 |     if (isInUse && fileSelected != nullptr){
151 |         // 解锁
152 |         CGlobal::fManager->unlockFile(fileSelected);
153 |     }
154 | 
155 |     CGlobal::mSem->release();
156 |     // 发射信号
157 |     emit notifyUpdate();
158 | }
159 | 


--------------------------------------------------------------------------------
/cereal/types/vector.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file vector.hpp
  2 |     \brief Support for types found in \<vector\>
  3 |     \ingroup STLSupport */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_VECTOR_HPP_
 31 | #define CEREAL_TYPES_VECTOR_HPP_
 32 | 
 33 | #include "cereal/cereal.hpp"
 34 | #include <vector>
 35 | 
 36 | namespace cereal
 37 | {
 38 |   //! Serialization for std::vectors of arithmetic (but not bool) using binary serialization, if supported
 39 |   template <class Archive, class T, class A> inline
 40 |   typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
 41 |                           && std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, void>::type
 42 |   CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
 43 |   {
 44 |     ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
 45 |     ar( binary_data( vector.data(), vector.size() * sizeof(T) ) );
 46 |   }
 47 | 
 48 |   //! Serialization for std::vectors of arithmetic (but not bool) using binary serialization, if supported
 49 |   template <class Archive, class T, class A> inline
 50 |   typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
 51 |                           && std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, void>::type
 52 |   CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
 53 |   {
 54 |     size_type vectorSize;
 55 |     ar( make_size_tag( vectorSize ) );
 56 | 
 57 |     vector.resize( static_cast<std::size_t>( vectorSize ) );
 58 |     ar( binary_data( vector.data(), static_cast<std::size_t>( vectorSize ) * sizeof(T) ) );
 59 |   }
 60 | 
 61 |   //! Serialization for non-arithmetic vector types
 62 |   template <class Archive, class T, class A> inline
 63 |   typename std::enable_if<(!traits::is_output_serializable<BinaryData<T>, Archive>::value
 64 |                           || !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
 65 |   CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
 66 |   {
 67 |     ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
 68 |     for(auto && v : vector)
 69 |       ar( v );
 70 |   }
 71 | 
 72 |   //! Serialization for non-arithmetic vector types
 73 |   template <class Archive, class T, class A> inline
 74 |   typename std::enable_if<(!traits::is_input_serializable<BinaryData<T>, Archive>::value
 75 |                           || !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
 76 |   CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
 77 |   {
 78 |     size_type size;
 79 |     ar( make_size_tag( size ) );
 80 | 
 81 |     vector.resize( static_cast<std::size_t>( size ) );
 82 |     for(auto && v : vector)
 83 |       ar( v );
 84 |   }
 85 | 
 86 |   //! Serialization for bool vector types
 87 |   template <class Archive, class A> inline
 88 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<bool, A> const & vector )
 89 |   {
 90 |     ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
 91 |     for(const auto v : vector)
 92 |       ar( static_cast<bool>(v) );
 93 |   }
 94 | 
 95 |   //! Serialization for bool vector types
 96 |   template <class Archive, class A> inline
 97 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<bool, A> & vector )
 98 |   {
 99 |     size_type size;
100 |     ar( make_size_tag( size ) );
101 | 
102 |     vector.resize( static_cast<std::size_t>( size ) );
103 |     for(auto v : vector)
104 |     {
105 |       bool b;
106 |       ar( b );
107 |       v = b;
108 |     }
109 |   }
110 | } // namespace cereal
111 | 
112 | #endif // CEREAL_TYPES_VECTOR_HPP_
113 | 


--------------------------------------------------------------------------------
/cereal/types/queue.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file queue.hpp
  2 |     \brief Support for types found in \<queue\>
  3 |     \ingroup STLSupport */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_QUEUE_HPP_
 31 | #define CEREAL_TYPES_QUEUE_HPP_
 32 | 
 33 | #include "cereal/details/helpers.hpp"
 34 | #include <queue>
 35 | 
 36 | // The default container for queue is deque, so let's include that too
 37 | #include "cereal/types/deque.hpp"
 38 | // The default comparator for queue is less
 39 | #include "cereal/types/functional.hpp"
 40 | 
 41 | namespace cereal
 42 | {
 43 |   namespace queue_detail
 44 |   {
 45 |     //! Allows access to the protected container in queue
 46 |     /*! @internal */
 47 |     template <class T, class C> inline
 48 |     C const & container( std::queue<T, C> const & queue )
 49 |     {
 50 |       struct H : public std::queue<T, C>
 51 |       {
 52 |         static C const & get( std::queue<T, C> const & q )
 53 |         {
 54 |           return q.*(&H::c);
 55 |         }
 56 |       };
 57 | 
 58 |       return H::get( queue );
 59 |     }
 60 | 
 61 |     //! Allows access to the protected container in priority queue
 62 |     /*! @internal */
 63 |     template <class T, class C, class Comp> inline
 64 |     C const & container( std::priority_queue<T, C, Comp> const & priority_queue )
 65 |     {
 66 |       struct H : public std::priority_queue<T, C, Comp>
 67 |       {
 68 |         static C const & get( std::priority_queue<T, C, Comp> const & pq )
 69 |         {
 70 |           return pq.*(&H::c);
 71 |         }
 72 |       };
 73 | 
 74 |       return H::get( priority_queue );
 75 |     }
 76 | 
 77 |     //! Allows access to the protected comparator in priority queue
 78 |     /*! @internal */
 79 |     template <class T, class C, class Comp> inline
 80 |     Comp const & comparator( std::priority_queue<T, C, Comp> const & priority_queue )
 81 |     {
 82 |       struct H : public std::priority_queue<T, C, Comp>
 83 |       {
 84 |         static Comp const & get( std::priority_queue<T, C, Comp> const & pq )
 85 |         {
 86 |           return pq.*(&H::comp);
 87 |         }
 88 |       };
 89 | 
 90 |       return H::get( priority_queue );
 91 |     }
 92 |   }
 93 | 
 94 |   //! Saving for std::queue
 95 |   template <class Archive, class T, class C> inline
 96 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::queue<T, C> const & queue )
 97 |   {
 98 |     ar( CEREAL_NVP_("container", queue_detail::container( queue )) );
 99 |   }
100 | 
101 |   //! Loading for std::queue
102 |   template <class Archive, class T, class C> inline
103 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::queue<T, C> & queue )
104 |   {
105 |     C container;
106 |     ar( CEREAL_NVP_("container", container) );
107 |     queue = std::queue<T, C>( std::move( container ) );
108 |   }
109 | 
110 |   //! Saving for std::priority_queue
111 |   template <class Archive, class T, class C, class Comp> inline
112 |   void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> const & priority_queue )
113 |   {
114 |     ar( CEREAL_NVP_("comparator", queue_detail::comparator( priority_queue )) );
115 |     ar( CEREAL_NVP_("container", queue_detail::container( priority_queue )) );
116 |   }
117 | 
118 |   //! Loading for std::priority_queue
119 |   template <class Archive, class T, class C, class Comp> inline
120 |   void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> & priority_queue )
121 |   {
122 |     Comp comparator;
123 |     ar( CEREAL_NVP_("comparator", comparator) );
124 | 
125 |     C container;
126 |     ar( CEREAL_NVP_("container", container) );
127 | 
128 |     priority_queue = std::priority_queue<T, C, Comp>( comparator, std::move( container ) );
129 |   }
130 | } // namespace cereal
131 | 
132 | #endif // CEREAL_TYPES_QUEUE_HPP_
133 | 


--------------------------------------------------------------------------------
/cereal/details/static_object.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file static_object.hpp
  2 |     \brief Internal polymorphism static object support
  3 |     \ingroup Internal */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 |   Redistribution and use in source and binary forms, with or without
  8 |   modification, are permitted provided that the following conditions are met:
  9 |       * Redistributions of source code must retain the above copyright
 10 |         notice, this list of conditions and the following disclaimer.
 11 |       * Redistributions in binary form must reproduce the above copyright
 12 |         notice, this list of conditions and the following disclaimer in the
 13 |         documentation and/or other materials provided with the distribution.
 14 |       * Neither the name of cereal nor the
 15 |         names of its contributors may be used to endorse or promote products
 16 |         derived from this software without specific prior written permission.
 17 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 18 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 19 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 20 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 21 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 22 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 23 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 24 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 25 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 26 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27 | */
 28 | #ifndef CEREAL_DETAILS_STATIC_OBJECT_HPP_
 29 | #define CEREAL_DETAILS_STATIC_OBJECT_HPP_
 30 | 
 31 | #include "cereal/macros.hpp"
 32 | 
 33 | #if CEREAL_THREAD_SAFE
 34 | #include <mutex>
 35 | #endif
 36 | 
 37 | //! Prevent link optimization from removing non-referenced static objects
 38 | /*! Especially for polymorphic support, we create static objects which
 39 |     may not ever be explicitly referenced.  Most linkers will detect this
 40 |     and remove the code causing various unpleasant runtime errors.  These
 41 |     macros, adopted from Boost (see force_include.hpp) prevent this
 42 |     (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
 43 |     Use, modification and distribution is subject to the Boost Software
 44 |     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 45 |     http://www.boost.org/LICENSE_1_0.txt) */
 46 | 
 47 | #ifdef _MSC_VER
 48 | #   define CEREAL_DLL_EXPORT __declspec(dllexport)
 49 | #   define CEREAL_USED
 50 | #else // clang or gcc
 51 | #   define CEREAL_DLL_EXPORT __attribute__ ((visibility("default")))
 52 | #   define CEREAL_USED __attribute__ ((__used__))
 53 | #endif
 54 | 
 55 | namespace cereal
 56 | {
 57 |   namespace detail
 58 |   {
 59 |     //! A static, pre-execution object
 60 |     /*! This class will create a single copy (singleton) of some
 61 |         type and ensures that merely referencing this type will
 62 |         cause it to be instantiated and initialized pre-execution.
 63 |         For example, this is used heavily in the polymorphic pointer
 64 |         serialization mechanisms to bind various archive types with
 65 |         different polymorphic classes */
 66 |     template <class T>
 67 |     class CEREAL_DLL_EXPORT StaticObject
 68 |     {
 69 |       private:
 70 | 
 71 |         static T & create()
 72 |         {
 73 |           static T t;
 74 |           //! Forces instantiation at pre-execution time
 75 |           (void)instance;
 76 |           return t;
 77 |         }
 78 | 
 79 |         StaticObject( StaticObject const & /*other*/ ) {}
 80 | 
 81 |       public:
 82 |         static T & getInstance()
 83 |         {
 84 |           return create();
 85 |         }
 86 | 
 87 |         //! A class that acts like std::lock_guard
 88 |         class LockGuard
 89 |         {
 90 |           #if CEREAL_THREAD_SAFE
 91 |           public:
 92 |             LockGuard(std::mutex & m) : lock(m) {}
 93 |           private:
 94 |             std::unique_lock<std::mutex> lock;
 95 |           #else
 96 |           public:
 97 | 	          LockGuard(LockGuard const &) = default; // prevents implicit copy ctor warning
 98 |             ~LockGuard() CEREAL_NOEXCEPT {} // prevents variable not used
 99 |           #endif
100 |         };
101 | 
102 |         //! Attempts to lock this static object for the current scope
103 |         /*! @note This function is a no-op if cereal is not compiled with
104 |                   thread safety enabled (CEREAL_THREAD_SAFE = 1).
105 | 
106 |             This function returns an object that holds a lock for
107 |             this StaticObject that will release its lock upon destruction. This
108 |             call will block until the lock is available. */
109 |         static LockGuard lock()
110 |         {
111 |           #if CEREAL_THREAD_SAFE
112 |           static std::mutex instanceMutex;
113 |           return LockGuard{instanceMutex};
114 |           #else
115 |           return LockGuard{};
116 |           #endif
117 |         }
118 | 
119 |       private:
120 |         static T & instance;
121 |     };
122 | 
123 |     template <class T> T & StaticObject<T>::instance = StaticObject<T>::create();
124 |   } // namespace detail
125 | } // namespace cereal
126 | 
127 | #endif // CEREAL_DETAILS_STATIC_OBJECT_HPP_
128 | 


--------------------------------------------------------------------------------
/cereal/types/common.hpp:
--------------------------------------------------------------------------------
  1 | /*! \file common.hpp
  2 |     \brief Support common types - always included automatically
  3 |     \ingroup OtherTypes */
  4 | /*
  5 |   Copyright (c) 2014, Randolph Voorhies, Shane Grant
  6 |   All rights reserved.
  7 | 
  8 |   Redistribution and use in source and binary forms, with or without
  9 |   modification, are permitted provided that the following conditions are met:
 10 |       * Redistributions of source code must retain the above copyright
 11 |         notice, this list of conditions and the following disclaimer.
 12 |       * Redistributions in binary form must reproduce the above copyright
 13 |         notice, this list of conditions and the following disclaimer in the
 14 |         documentation and/or other materials provided with the distribution.
 15 |       * Neither the name of cereal nor the
 16 |         names of its contributors may be used to endorse or promote products
 17 |         derived from this software without specific prior written permission.
 18 | 
 19 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 20 |   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 21 |   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 22 |   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
 23 |   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 24 |   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 25 |   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 26 |   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 28 |   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29 | */
 30 | #ifndef CEREAL_TYPES_COMMON_HPP_
 31 | #define CEREAL_TYPES_COMMON_HPP_
 32 | 
 33 | #include "cereal/cereal.hpp"
 34 | 
 35 | namespace cereal
 36 | {
 37 |   namespace common_detail
 38 |   {
 39 |     //! Serialization for arrays if BinaryData is supported and we are arithmetic
 40 |     /*! @internal */
 41 |     template <class Archive, class T> inline
 42 |     void serializeArray( Archive & ar, T & array, std::true_type /* binary_supported */ )
 43 |     {
 44 |       ar( binary_data( array, sizeof(array) ) );
 45 |     }
 46 | 
 47 |     //! Serialization for arrays if BinaryData is not supported or we are not arithmetic
 48 |     /*! @internal */
 49 |     template <class Archive, class T> inline
 50 |     void serializeArray( Archive & ar, T & array, std::false_type /* binary_supported */ )
 51 |     {
 52 |       for( auto & i : array )
 53 |         ar( i );
 54 |     }
 55 | 
 56 |     namespace
 57 |     {
 58 |       //! Gets the underlying type of an enum
 59 |       /*! @internal */
 60 |       template <class T, bool IsEnum>
 61 |       struct enum_underlying_type : std::false_type {};
 62 | 
 63 |       //! Gets the underlying type of an enum
 64 |       /*! Specialization for when we actually have an enum
 65 |           @internal */
 66 |       template <class T>
 67 |       struct enum_underlying_type<T, true> { using type = typename std::underlying_type<T>::type; };
 68 |     } // anon namespace
 69 | 
 70 |     //! Checks if a type is an enum
 71 |     /*! This is needed over simply calling std::is_enum because the type
 72 |         traits checking at compile time will attempt to call something like
 73 |         load_minimal with a special NoConvertRef struct that wraps up the true type.
 74 | 
 75 |         This will strip away any of that and also expose the true underlying type.
 76 |         @internal */
 77 |     template <class T>
 78 |     class is_enum
 79 |     {
 80 |       private:
 81 |         using DecayedT  = typename std::decay<T>::type;
 82 |         using StrippedT = typename ::cereal::traits::strip_minimal<DecayedT>::type;
 83 | 
 84 |       public:
 85 |         static const bool value = std::is_enum<StrippedT>::value;
 86 |         using type = StrippedT;
 87 |         using base_type = typename enum_underlying_type<StrippedT, value>::type;
 88 |     };
 89 |   }
 90 | 
 91 |   //! Saving for enum types
 92 |   template <class Archive, class T> inline
 93 |   typename std::enable_if<common_detail::is_enum<T>::value,
 94 |                           typename common_detail::is_enum<T>::base_type>::type
 95 |   CEREAL_SAVE_MINIMAL_FUNCTION_NAME( Archive const &, T const & t )
 96 |   {
 97 |     return static_cast<typename common_detail::is_enum<T>::base_type>(t);
 98 |   }
 99 | 
100 |   //! Loading for enum types
101 |   template <class Archive, class T> inline
102 |   typename std::enable_if<common_detail::is_enum<T>::value, void>::type
103 |   CEREAL_LOAD_MINIMAL_FUNCTION_NAME( Archive const &, T && t,
104 |                                      typename common_detail::is_enum<T>::base_type const & value )
105 |   {
106 |     t = reinterpret_cast<typename common_detail::is_enum<T>::type const &>( value );
107 |   }
108 | 
109 |   //! Serialization for raw pointers
110 |   /*! This exists only to throw a static_assert to let users know we don't support raw pointers. */
111 |   template <class Archive, class T> inline
112 |   void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, T * & )
113 |   {
114 |     static_assert(cereal::traits::detail::delay_static_assert<T>::value,
115 |       "Cereal does not support serializing raw pointers - please use a smart pointer");
116 |   }
117 | 
118 |   //! Serialization for C style arrays
119 |   template <class Archive, class T> inline
120 |   typename std::enable_if<std::is_array<T>::value, void>::type
121 |   CEREAL_SERIALIZE_FUNCTION_NAME(Archive & ar, T & array)
122 |   {
123 |     common_detail::serializeArray( ar, array,
124 |         std::integral_constant<bool, traits::is_output_serializable<BinaryData<T>, Archive>::value &&
125 |                                      std::is_arithmetic<typename std::remove_all_extents<T>::type>::value>() );
126 |   }
127 | } // namespace cereal
128 | 
129 | #endif // CEREAL_TYPES_COMMON_HPP_
130 | 


--------------------------------------------------------------------------------
/dialog_gen_data.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>dialog_gen_data</class>
  4 |  <widget class="QDialog" name="dialog_gen_data">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>400</width>
 10 |     <height>300</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>Dialog</string>
 15 |   </property>
 16 |   <widget class="QLabel" name="label">
 17 |    <property name="geometry">
 18 |     <rect>
 19 |      <x>10</x>
 20 |      <y>30</y>
 21 |      <width>381</width>
 22 |      <height>16</height>
 23 |     </rect>
 24 |    </property>
 25 |    <property name="text">
 26 |     <string>请输入数据生成所需的以下的数据</string>
 27 |    </property>
 28 |    <property name="alignment">
 29 |     <set>Qt::AlignCenter</set>
 30 |    </property>
 31 |   </widget>
 32 |   <widget class="QLineEdit" name="edit_fileName">
 33 |    <property name="geometry">
 34 |     <rect>
 35 |      <x>90</x>
 36 |      <y>70</y>
 37 |      <width>271</width>
 38 |      <height>31</height>
 39 |     </rect>
 40 |    </property>
 41 |    <property name="sizePolicy">
 42 |     <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
 43 |      <horstretch>0</horstretch>
 44 |      <verstretch>0</verstretch>
 45 |     </sizepolicy>
 46 |    </property>
 47 |   </widget>
 48 |   <widget class="QLineEdit" name="lineEdit_2">
 49 |    <property name="enabled">
 50 |     <bool>false</bool>
 51 |    </property>
 52 |    <property name="geometry">
 53 |     <rect>
 54 |      <x>90</x>
 55 |      <y>120</y>
 56 |      <width>271</width>
 57 |      <height>31</height>
 58 |     </rect>
 59 |    </property>
 60 |    <property name="cursor">
 61 |     <cursorShape>ForbiddenCursor</cursorShape>
 62 |    </property>
 63 |    <property name="text">
 64 |     <string>根目录</string>
 65 |    </property>
 66 |   </widget>
 67 |   <widget class="QLabel" name="label_2">
 68 |    <property name="geometry">
 69 |     <rect>
 70 |      <x>10</x>
 71 |      <y>70</y>
 72 |      <width>71</width>
 73 |      <height>31</height>
 74 |     </rect>
 75 |    </property>
 76 |    <property name="text">
 77 |     <string>文件名</string>
 78 |    </property>
 79 |    <property name="alignment">
 80 |     <set>Qt::AlignCenter</set>
 81 |    </property>
 82 |   </widget>
 83 |   <widget class="QLabel" name="label_3">
 84 |    <property name="geometry">
 85 |     <rect>
 86 |      <x>10</x>
 87 |      <y>120</y>
 88 |      <width>71</width>
 89 |      <height>31</height>
 90 |     </rect>
 91 |    </property>
 92 |    <property name="text">
 93 |     <string>文件位置</string>
 94 |    </property>
 95 |    <property name="alignment">
 96 |     <set>Qt::AlignCenter</set>
 97 |    </property>
 98 |   </widget>
 99 |   <widget class="QLabel" name="label_4">
100 |    <property name="geometry">
101 |     <rect>
102 |      <x>10</x>
103 |      <y>170</y>
104 |      <width>71</width>
105 |      <height>31</height>
106 |     </rect>
107 |    </property>
108 |    <property name="text">
109 |     <string>文件内容</string>
110 |    </property>
111 |    <property name="alignment">
112 |     <set>Qt::AlignCenter</set>
113 |    </property>
114 |   </widget>
115 |   <widget class="QCheckBox" name="checkBox">
116 |    <property name="enabled">
117 |     <bool>false</bool>
118 |    </property>
119 |    <property name="geometry">
120 |     <rect>
121 |      <x>120</x>
122 |      <y>220</y>
123 |      <width>86</width>
124 |      <height>31</height>
125 |     </rect>
126 |    </property>
127 |    <property name="text">
128 |     <string>文件</string>
129 |    </property>
130 |    <property name="checkable">
131 |     <bool>true</bool>
132 |    </property>
133 |    <property name="checked">
134 |     <bool>true</bool>
135 |    </property>
136 |    <property name="tristate">
137 |     <bool>false</bool>
138 |    </property>
139 |   </widget>
140 |   <widget class="QCheckBox" name="checkBox_2">
141 |    <property name="enabled">
142 |     <bool>false</bool>
143 |    </property>
144 |    <property name="geometry">
145 |     <rect>
146 |      <x>230</x>
147 |      <y>220</y>
148 |      <width>86</width>
149 |      <height>31</height>
150 |     </rect>
151 |    </property>
152 |    <property name="text">
153 |     <string>文件夹</string>
154 |    </property>
155 |    <property name="checkable">
156 |     <bool>false</bool>
157 |    </property>
158 |   </widget>
159 |   <widget class="QLabel" name="label_5">
160 |    <property name="geometry">
161 |     <rect>
162 |      <x>10</x>
163 |      <y>220</y>
164 |      <width>71</width>
165 |      <height>31</height>
166 |     </rect>
167 |    </property>
168 |    <property name="text">
169 |     <string>文件类型</string>
170 |    </property>
171 |    <property name="alignment">
172 |     <set>Qt::AlignCenter</set>
173 |    </property>
174 |   </widget>
175 |   <widget class="QPushButton" name="btn_submit">
176 |    <property name="geometry">
177 |     <rect>
178 |      <x>150</x>
179 |      <y>260</y>
180 |      <width>112</width>
181 |      <height>32</height>
182 |     </rect>
183 |    </property>
184 |    <property name="text">
185 |     <string>提交</string>
186 |    </property>
187 |   </widget>
188 |   <widget class="QLineEdit" name="edit_fileContent">
189 |    <property name="geometry">
190 |     <rect>
191 |      <x>90</x>
192 |      <y>170</y>
193 |      <width>231</width>
194 |      <height>31</height>
195 |     </rect>
196 |    </property>
197 |    <property name="sizePolicy">
198 |     <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
199 |      <horstretch>0</horstretch>
200 |      <verstretch>0</verstretch>
201 |     </sizepolicy>
202 |    </property>
203 |    <property name="maxLength">
204 |     <number>96</number>
205 |    </property>
206 |   </widget>
207 |   <widget class="QLabel" name="txt_inputNum">
208 |    <property name="geometry">
209 |     <rect>
210 |      <x>330</x>
211 |      <y>175</y>
212 |      <width>41</width>
213 |      <height>21</height>
214 |     </rect>
215 |    </property>
216 |    <property name="text">
217 |     <string/>
218 |    </property>
219 |    <property name="alignment">
220 |     <set>Qt::AlignCenter</set>
221 |    </property>
222 |   </widget>
223 |  </widget>
224 |  <resources/>
225 |  <connections/>
226 | </ui>
227 | 


--------------------------------------------------------------------------------