4.4. Экологическая безопасность

Поскольку работа программиста не связана с использованием природных ресурсов и в её результате нет вредных выбросов в окружающую среду, экологическая безопасность труда программиста в рассмотрении не нуждается.

4.5. Пожарная безопасность

Помещение машинного зала ПЭВМ относится к категории В (пожароопасная) пожарной опасности помещений, так как в помещении находится электрооборудование, горючие вещества (мебель, пластиковые корпуса аппаратуры и др.). В силу этого помещение должно соответствовать нормативам по огнестойкости строительных конструкций, планировке зданий, этажности, оснащенности устройствами противопожарной защиты, установленным для этой категории помещений. Помещение машинного зала должно обладать I или II степенью огнестойкости (см. СНиП 2.01.02-85 “Противопожарные нормы”), то есть самой высокой.

4.6. Выводы

В данном разделе были проанализированы основные опасности и вредности, которые необходимо учитывать при планировании рабочего места программиста, дана их качественная и, по возможности, количественная оценка, а также рекомендации по минимизации вредных последствий работы в машинном зале.

Был выполнен инженерный расчет необходимого освещения машинного зала.

Из проведенного анализа можно сделать вывод, что правильное использование компьютера, соблюдение эргономических правил и рабочей дисциплины может минимизировать практически весь спектр вредных воздействий длительной работы за компьютером.

Заключение.

Модуль, разработанный в ходе выполнения данного дипломного проекта, был успешно внедрен в трех коммерческих программных продуктах компании «МиСТ ленд – ЮГ», один из которых – «Альфа Антитеррор» - поступил в продажу в феврале 2005 года, а остальные в данный момент разрабатываются. Реализация затребованного в техническом задании функционала позволила команде разработчиков безболезненно перейти на завершающей стадии проекта к хранению ресурсов в конечной версии размещения. Вторым по значимости результатом стала возможность быстро менять ресурсы без переупаковки, перераспределения и т.п., что является вариантом пользовательской модификации ресурсов.

Модуль продолжает совершенствоваться. Разрабатывается следующая версия, основными задачами которой являются расширение функционала (программная поддержка защищенных носителей и новых видов шифрования) и увеличение скорости работы.

В специальном разделе были освещены вопросы предварительных исследований, проектирования и тестирования модуля. Большая часть уделена вопросам архитектуры. В технологическом разделе рассмотрены основные средства, которые были использованы при разработке: UML, средства STL, внешние библиотеки, методология модульного тестирования. Экономический раздел посвящен вопросам себестоимости и цены модуля; в разделе производственно-экологической безопасности рассмотрены основные вредности на рабочем месте программиста и выполнен расчет необходимой освещенности машинного зала.

Список литературы

1) Л.Г.Гагарина, Н.Н,Зубов, А.В.Стрижков, Е.Л.Федотова. Методические указания по подготовке дипломного проекта специалистов направления 654600 «Информатика и вычислительная техника». МГИЭТ, 2004.

2) Костина Г.Д., Моисеева Н.К. Маркетинговые исследования при создании и использовании программных продуктов: Методические указания длявыполнения курсовых и дипломных работ по специальности «Менеджмент». МИЭТ(ТУ),1996.

3) Константинова Л.А., Ларионов Н.М., Писеев В.М. Методические указания по выполнению раздела «Охрана труда» в дипломных проектах для студентов МИЭТ. Под ред. В.И. Каракеяна. М., МИЭТ, 1988.

4) Джефф Элджер. С++: Библиотека программиста. «Питер», 2001.

5) Бьярн Страуструп. Дизайн и эволюция С++. «ДМК Пресс», 2000

6) Эрик Дж. Брауде. Технология разработки программного обеспечения. "Питер", 2004.

7) Гради Буч. Объектно-ориентированный анализ и проектирование с примерами приложений на C++. «Невский диалект», 1998.

8) Айра Пол. Объектно-ориентированное программирование на С++. «Бином», 2001.

9) Эрих Гамма, Ричард Хелм, Ральф Джонсон, Джон Влиссидес. Приемы объектно-ориентированного проектирования. Паттерны проектирования. «Питер», 2001.

10) Чарльз Петзолд. Программирование для Windows 95. «BHV – Санкт-Петербург», 1997.

11) Герб Саттер. Решение сложных задач на С++. «Вильямс», 2002.

12) Андрей Александреску. Современное проектирование на С++. «Вильямс», 2002.

13) Бьярн Страуструп. Язык программирования С++. Специальное издание. «Бином», 2003.

14) Д. Рихтер. Windows 2000 для профессионалов. «Русская редакция», 2001.

15) Документация к библиотеке zlib - http://www.gzip.org/zlib/

16) Документация к библиотеке infozip - http://www.info-zip.org/pub/infozip/

17) Онлайн-документация по шифрованию CRC32 (CIT-forum, RSDN, flipcode)

18) Внутренняя документация MiSTland

ПРИЛОЖЕНИЕ 1

Руководство программиста.

Назначение и условия применения программы.

Модуль VFS предназначен для инкапсуляции файловых операций при получении доступа к файлам в различных типах хранилищ – каталог на диске, архив, зашифрованный файл, сетевой диск и т.п. Содержимое файлов предоставляется в виде стандартного потока С++, вне зависимости от их реального размещения. Все файлы находятся в едином пространстве имен, поэтому присутствует возможность итерирования по маске.

Модуль предназначен для работы в составе проекта, написанного на языке С++. Разработка велась с использованием компилятора из MSVS 7.1, и компиляция более слабыми в плане поддержки стандарта компиляторами не гарантируется. Для некоторого функционала необходимо наличие библиотек MS Windows не ниже версии 98. Аппаратные ограничения накладывает использующий модуль проект.

Характеристика программы.

Модуль не обладает возможностью строго гарантировать время работы своих функций. Модуль выполнен в виде статически связываемой DLL, которая должна быть в проекте в одном экземпляре. Для контроля правильности работы использован механизм исключений С++, а также класс дескриптора файла был снабжен возможностью быть проверенным в логическом выражении.

Обращение к программе.

Основной программный интерфейс модуля представлен в виде набор функций, заключенных в пространство имен. Для хранения дерева используется объект-одиночка system, который перед началом работы необходимо инициализировать. Перечень интерфейсных функций с описанием:

template <class Pred>

inline std::auto_ptr<i_file> r_open_file (

const std::string& file_name,

Pred pred,

bool seekable = true) – открыть поток на файл по имени с использованием при поиске явно указанного предиката сортировки. Параметр seekable указывает, нужно ли открывать поток с возможностью поиска по нему (сказывается на быстродействии). В случае невозможности выполнения будет сгенерировано исключение.

inline std::auto_ptr<i_file> r_open_file (

const std::string& file_name,

bool seekable = true) – то же самое с использованием предиката по умолчанию.

inline std::auto_ptr<i_file> r_open_file (

const file_id &id,

bool seekable = true) – открыть поток на файл по его дескриптору. Наиболее быстрый вариант работы, поскольку поиск не производится.

template <class Pred>

inline file_id file_exists (

const std::string& file_name,

Pred pred) – проверить существование файла по имени. Возвращаемый дескриптор можно проверить в любом логическом выражении С++. Если дескриптор правильный, по нему можно открыть поток.

inline file_id file_exists (

const std::string& file_name) – то же самое с использованием предиката по умолчанию.

template <class Pred>

inline std::auto_ptr<o_file> w_open_file (

const std::string& file_name,

Pred pred,

bool seekable = true) – открыть поток в файл на запись по имени. В случае невозможности выполнения будет сгенерировано исключение.

inline std::auto_ptr<o_file> w_open_file (

const std::string& file_name,

bool seekable = true) – то же самое с использованием предиката по умолчанию.

inline std::auto_ptr<o_file> w_open_file (

const file_id &id,

bool seekable = true,

bool app = 0) – открыть файл на запись по идентификатору. Параметр append – добавлять ли запись в конец файла.

template <class Pred>

inline void delete_file (

const std::string& file_name,

Pred pred) – удалить файл по имени, используя предикат сортировки при поиске. При невозможности выполнения будет сгенерировано исключение.

inline void delete_file (

const std::string& file_name) - то же самое с использованием предиката по умолчанию.

inline void delete_file (

const file_id &id) – удалить файл по его дескриптору.

template <class Pred>

inline fs_files<Pred> get_files (

const std::string& file_name,

Pred pred,

unsigned param) – получить контейнер с файлами в виртуальной директории по маске с использованием при поиске предиката сортировки. Параметр param позволяет задать флаги поиска аналогично функциям CRT.

inline fs_files<date_heuristic> get_files (

const std::string& file_name,

unsigned param) - то же самое с использованием предиката по умолчанию.

inline void make_dir (

const std::string& file_name) – разбор пути и создание реальных директорий по нему там, где подсистемы это позволят сделать.

inline sub_fs_id mount (

std::auto_ptr<sub_fs> what,

const std::string& path) – замонтировать подсистему в дерево. Параметр what – подсистема, параметр path – желаемый виртуальный путь до неё. Система создаст виртуальные директории в необходимом количестве. Удаление подсистемы в конце работы VFS берет на себя объект system. Возвращаемое значение – идентификатор подсистемы, позволяющий выборочно её демонтировать.

inline std::auto_ptr<sub_fs> unmount (

sub_fs_id id) – демонтировать подсистему по её идентификатору. Внимание! Осмысленность идентификаторов за всё время работы модуля не гарантируется.

Входные и выходные данные.

Входные и выходные данные полностью описаны в «обращении к программе». Ничего другого модуль не использует.

Сообщения.

Сообщения при работе модуля выводятся при помощи механизма исключений С++ в виде текстовых строк, каждая из которых соответствует некоторому типу исключений.

Типы исключений:

1) no_file – не найден файл по имени или дескриптору;

2) stream_fail – ошибка при создании потока;

3) no_mounted – поиск невозможен, нет замонтированных подсистем;

4) no_writable – нет возможности открыть поток на запись, все подсистемы помечены как read_only;

5) incorrect_path – грубая ошибка в задании имени файла;

6) zip_restrictions – неподдерживаемый формат зип-архива.

ПРИЛОЖЕНИЕ 2

Фрагменты исходных текстов.

Ниже представлены интерфейсные классы VFS. Подробности реализации в большинстве случаев опущены, поскольку код имеет большой объем.

Файл fs.h

namespace mll

{

namespace fs

{

/////////////////////////////////////////////////////////////////////////

// перечисления для передачи фуцкциям в качестве параметров

enum SearchParams

{

files = 1<<0,

dir = 1<<1,

readonly = 1<<2

};

enum WriteParams

{

append = 1

};

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// БАЗОВЫЙ ПРЕДИКАТ

// базовая эвристика, определяет файл с большей датой последнего изменения

// как "меньший". Свои предикаты нужно писать "по образу и подобию"

struct date_heuristic

{

bool operator()(const file_id& x, const file_id& y) const

{

int x_prior = x.sub_fs()->priority();

int y_prior = y.sub_fs()->priority();

if (x_prior == y_prior)

return (x.date() >= y.date());

return (x_prior > y_prior);

}

};

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// ПРОВЕРИТЬ ПУТЬ НА ПРАВИЛЬНОСТЬ

// проверить на наличие запрещенных файловой системой символов

inline bool is_path_valid(const std::string& raw_data);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// ОТКРЫТЬ ФАЙЛ НА ЧТЕНИЕ

// открыть, используя предикат сортировки

template <class Pred>

inline std::auto_ptr<i_file> r_open_file(const std::string& file_name, Pred pred,

bool seekable = true);

// открыть с использованием стандартного предиката

inline std::auto_ptr<i_file> r_open_file(const std::string& file_name, bool seekable = true);

// открыть по идентификатору

inline std::auto_ptr<i_file> r_open_file(const file_id &id, bool seekable = true);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// ПРОВЕРИТЬ ФАЙЛ НА СУЩЕСТВОВАНИЕ

// проверить, используя предикат сортировки

template <class Pred>

inline file_id file_exists(const std::string& file_name, Pred pred);

// проверить с использованием стандартного предиката

inline file_id file_exists(const std::string& file_name);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// ОТКРЫТЬ ФАЙЛ НА ЗАПИСЬ

// открыть, используя предикат сортировки

template <class Pred>

inline std::auto_ptr<o_file> w_open_file(const std::string& file_name, Pred pred,

bool seekable = true);

// открыть с использованием стандартного предиката

inline std::auto_ptr<o_file> w_open_file(const std::string& file_name, bool seekable = true);

// открыть по идетификатору, параметр - append

inline std::auto_ptr<o_file> w_open_file(const file_id &id,

bool seekable = true, bool app = 0);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// УДАЛИТЬ ФАЙЛ

// удалить, используя предикат сортировки

template <class Pred>

inline void delete_file(const std::string& file_name, Pred pred);

// удалить с использованием стандартного предиката

inline void delete_file(const std::string& file_name);

// удалить по идентификатору

inline void delete_file(const file_id &id);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// ПОЛУЧИТЬ ОБЪЕКТ ДЛЯ ИТЕРИРОВАНИЯ

// получить объект-"переборщик" файлов по маске (path - путь вместе с маской).

// Из него можно получить контейнеры file_id по всем файлам (будет использоваться

// эвристика) и по вариантам каждого отдельного файла

// создать объект, используя предикат сортировки

template <class Pred>

inline fs_files<Pred> get_files(const std::string& file_name, Pred pred, unsigned param);

// создать с использованием стандартного предиката

inline fs_files<date_heuristic> get_files(const std::string& file_name, unsigned param);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// СОЗДАТЬ ФИЗИЧЕСКИЕ ДИРЕКТОРИИ ПО ПУТИ

inline void make_dir(const std::string& file_name);

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////

// МОНТИРОВАНИЕ/ДЕМОНТИРОВАНИЕ ПОДСИСТЕМ

// замонтировать подсистему. Права на удаление будут принадлежать fs.

// Возвращается объект, который нужно передать в unmount() для принудительного

// демонтирования.

inline sub_fs_id mount(std::auto_ptr<sub_fs> what, const std::string& file_name);

// демонтировать подсистему и получить права на её удаление

inline std::auto_ptr<sub_fs> unmount(sub_fs_id id);

/////////////////////////////////////////////////////////////////////////

}

}

Файл system.h

namespace mll

{

namespace fs

{

class directory;

class sub_fs;

class cache;

class critical_section;

//=====================================================================================//

// class system //

//=====================================================================================//

class FILE_SYSTEM_EXPORT system

{

public:

protected:

static system *m_instance;

virtual ~system() {}

public:

static void make_fs();

static void destroy_fs();

static system *instance();

public:

typedef mll::utils::lcrn_tree<directory *> dir_tree;

typedef dir_tree::const_iterator const_iterator;

typedef dir_tree::iterator iterator;

public:

virtual iterator begin() = 0;

virtual iterator end() = 0;

virtual const_iterator begin() const = 0;

virtual const_iterator end() const = 0;

virtual void _create_path(const fs_path &path) = 0;

virtual iterator find_dir(const fs_path &where) const = 0;

virtual sub_fs_id mount(std::auto_ptr<sub_fs> what, const fs_path &where) = 0;

virtual std::auto_ptr<sub_fs> unmount(sub_fs_id id) = 0;

virtual mll::fs::cache* cache() = 0;

virtual critical_section *get_cs() const = 0;

};

// исключения всякого рода

typedef mll::debug::exception_template<struct fs_failure> failure;

typedef mll::debug::exception_template<struct fs_no_file,failure> no_file;

typedef mll::debug::exception_template<struct fs_stream_fail,failure> stream_fail;

typedef mll::debug::exception_template<struct fs_no_mounted,failure> no_mounted;

typedef mll::debug::exception_template<struct fs_no_writable,failure> no_writable;

typedef mll::debug::exception_template<struct fs_incorrect_path,failure> incorrect_path;

typedef mll::debug::exception_template<struct fs_zip_restrictions,failure> zip_restrictions;

}

}

Файл directory.h

namespace mll

{

namespace fs

{

//=====================================================================================//

// class directory //

//=====================================================================================//

class directory

{

private:

typedef std::list<sub_fs *> list_t;

list_t m_list;

std::string m_name;

public:

typedef list_t::iterator iterator;

typedef list_t::const_iterator const_iterator;

public:

directory(const std::string &name): m_name(name) {}

~directory();

iterator mount(sub_fs *what);

std::auto_ptr<sub_fs> unmount(iterator what);

const std::string &name() { return m_name; }

const_iterator begin() { return m_list.begin(); }

const_iterator end() { return m_list.end(); }

unsigned size() const { return m_list.size(); }

};

}

}

Файл sub_fs.h

namespace mll

{

namespace fs

{

class sub_fs_iter;

//=====================================================================================//

// class sub_fs //

//=====================================================================================//

class sub_fs

{

public:

class priority_handler;

public:

virtual ~sub_fs() = 0 {}

/// подцепить объект-приоритет системы

virtual void set_priority_handler(std::auto_ptr<priority_handler> handler) = 0;

/// Дисковый путь до объекта подсистемы (каталога, zip-файла etc), со слешем на конце

virtual const std::string& disk_path() const = 0;

/// Возможность изменять файлы внутри подсистемы

virtual bool system_readonly() const = 0;

/// Существует ли файл с указанным именем

virtual bool file_exists(const fs_path &name) const = 0;

/// Создать итератор внутри подсистемы по введенному пути

virtual std::auto_ptr<sub_fs_iter> new_iterator(const fs_path &) const = 0;

/// Размер файла с указанным именем в байтах

virtual unsigned file_size(const fs_path &name) const = 0;

/// Возможность писать в файл с указанным именем

virtual bool is_readonly(const fs_path &name) const = 0;

/// Дата последнего изменения файла с указанным именем

virtual time_t date(const fs_path &name) const = 0;

/// Является ли файл с указанным именем директорией

virtual bool is_dir(const fs_path &name) const = 0;

/// Вернуть указатель на поток istream для файла с указанным именем

virtual std::auto_ptr<std::istream> r_open_file(const fs_path &path,

bool seekable = true) const = 0;

/// Вернуть указатель на поток ostream для файла с указанным именем

/** Если указан параметр append, поток должен указывать

на конец файла.*/

virtual std::auto_ptr<std::ostream> w_open_file(const fs_path &path,

bool append, bool seekable = true) const = 0;

/// Удалить файл с указанным именем

virtual void delete_file(const fs_path &name) const = 0;

/// Создать директорию

virtual void make_dir(const fs_path &path) const = 0;

public: // up_to_subsystem_priority

virtual int priority() const = 0;

};

//=====================================================================================//

// class FILE_SYSTEM_EXPORT sub_fs::priority_handler //

//=====================================================================================//

class sub_fs::priority_handler

{

public:

virtual ~priority_handler() {}

virtual int priority() const = 0;

};

}

}

Файл sub_fs_iter.h

namespace mll

{

namespace fs

{

//=====================================================================================//

// class sub_fs_iter //

//=====================================================================================//

class sub_fs_iter

{

public:

virtual ~sub_fs_iter() = 0 {}

/// Закончились ли файлы по указанному пути

virtual bool is_done() = 0;

/// Смещение на следующий файл

virtual sub_fs_iter &operator++() = 0;

/// Формирует объект file_obj из имеющейся информации о файле

virtual file_id get_id() = 0;

};

}

}

Файл fs_files.h

namespace mll

{

namespace fs

{

//=====================================================================================//

// template<class T> class reference_container //

//=====================================================================================//

template<class T>

class reference_container

{

private:

typedef T container_type;

const container_type &m_list;

public:

reference_container(const container_type &list): m_list(list) {}

~reference_container() {}

public:

typedef typename container_type::const_iterator iterator;

public:

/// получить итератор на начало

iterator begin() { return m_list.begin(); }

/// получить итератор на конец

iterator end() { return m_list.end(); }

/// получить размер контейнера

unsigned size() const { return m_list.size(); }

};

//=====================================================================================//

// template<class T> class value_container //

//=====================================================================================//

template<class T>

class value_container

{

private:

typedef T container_type;

container_type m_list;

public:

value_container(const container_type &list): m_list(list) {}

value_container(const value_container &another): m_list(another.m_list) {}

~value_container() {}

public:

typedef typename container_type::const_iterator iterator;

public:

/// получить итератор на начало

iterator begin() { return m_list.begin(); }

/// получить итератор на конец

iterator end() { return m_list.end(); }

/// получить размер контейнера

unsigned size() const { return m_list.size(); }

};

typedef std::list<file_id> file_t;

typedef reference_container<file_t> file_container;

typedef value_container<file_t> id_container;

//=====================================================================================//

// class fs_files //

//=====================================================================================//

template <class Pred = date_heuristic>

class fs_files

{

public:

typedef file_t::const_iterator iterator;

private:

boost::shared_ptr<file_list<Pred> > m_data;

boost::shared_ptr<file_t> m_list;

public:

fs_files() {}

fs_files(const fs_path &path, unsigned param);

fs_files(const fs_files<Pred> &another);

~fs_files() {}

fs_files<Pred> &operator=(const fs_files<Pred> &);

public:

file_container get_file_container() const;

id_container get_id_container(const file_id &id) const;

public:

/// получить итератор на начало контейнера предпочтительных вариантов фалов

iterator begin() const { return m_list->begin(); }

/// получить итератор на конец

iterator end() const { return m_list->end(); }

/// получить размер контейнера

unsigned int size() const { return m_list->size(); }

};

}

}

Файл file_id.h

namespace mll

{

namespace fs

{

class sub_fs;

//=====================================================================================//

// class file_id //

//=====================================================================================//

class FILE_SYSTEM_EXPORT file_id

{

const sub_fs *m_sub_fs;

fs_path m_name;

public:

file_id(): m_sub_fs(0) {}

file_id(const sub_fs *sfs, const std::string &name);

file_id(const file_id &another);

//~file_id() {}

file_id& operator=(const file_id& another)

{

if(this != &another)

{

m_sub_fs = another.m_sub_fs;

m_name = another.m_name;

}

return *this;

}

public:

operator const void * const () const { return m_sub_fs; }

bool operator !() const { return m_sub_fs == 0; }

public:

/// Возвратит указатель на sub_fs, к которому принадлежит идентификатор

const sub_fs *sub_fs() const { return m_sub_fs; }

/// Полный виртуальный путь с именем

std::string path() const;

/// Виртуальный путь

std::string dir() const;

/// Имя файла

std::string fname() const;

/// Расширение

std::string ext() const;

/// Полное имя с расширением

std::string name() const;

/// Полный дисковый путь с именем

std::string disk_path() const;

/// Параметр "только чтение"

bool is_readonly() const;

/// Размер файла в байтах

unsigned file_size() const;

/// Время последнего изменения файла

time_t date() const;

/// Директория ли это

bool is_dir() const;

};

}

}

Файл file.h

namespace mll

{

namespace fs

{

//=====================================================================================//

// class o_file //

//=====================================================================================//

/** \class o_file

\brief Класс - "файл для записи".

*/

/** Класс, содержащий уникальный идентификатор

и указатель на поток ostream.

*/

class o_file

{

file_id m_id;

std::auto_ptr<std::ostream> m_stream;

public:

o_file(const file_id &id, std::auto_ptr<std::ostream> stream)

: m_id(id), m_stream(stream) {}

~o_file() {}

/// Возвращает ссылку на уникальный идентификатор

const file_id &id() const { return m_id; }

/// Возвращает ссылку на поток

std::ostream &stream() const { return *m_stream; }

};

//=====================================================================================//

// class i_file //

//=====================================================================================//

/** \class i_file

\brief Класс - "файл для чтения".

*/

/** Класс, содержащий уникальный идентификатор

и указатель на поток istream.

*/

class i_file

{

file_id m_id;

std::auto_ptr<std::istream> m_stream;

public:

i_file(const file_id &id, std::auto_ptr<std::istream> stream)

: m_id(id), m_stream(stream) {}

~i_file() {}

/// Возвращает ссылку на уникальный идентификатор

const file_id &id() const { return m_id; }

/// Возвращает ссылку на поток

std::istream &stream() const { return *m_stream; }

};

}

}

Файл fs_path.h

namespace mll

{

namespace fs

{

//=====================================================================================//

// class fs_path //

//=====================================================================================//

/* Служебный класс, призван заменить строку-путь.

При конструировании разбивает строку по слэшам и заносит

в список имена каталогов. Может "превращаться" обратно в строку.

*/

class FILE_SYSTEM_EXPORT fs_path

{

public:

class const_iterator;

typedef std::list<int> separators_t; ///< позиции, по которым в m_data находятся слеши (считается, чтоо в конце строки тоже есть слеш - для удобства)

typedef std::string data_t;

private:

data_t m_data;

separators_t m_separators;

public:

fs_path();

fs_path(const std::string& data);

fs_path(const char* data);

fs_path(const fs_path& another);

~fs_path() {}

public:

const_iterator begin() const;

const_iterator end() const;

std::string front() const;

std::string back() const;

void pop_front();

void pop_back();

int length() const;

void clear();

const std::string& to_str() const;

public:

fs_path& operator+=(const fs_path& another);

fs_path& operator=(const fs_path& another);

private:

void analyzeRawData();

};

//=====================================================================================//

// fs_path operator+(); //

//=====================================================================================//

fs_path operator+(const fs_path& first, const fs_path& second);

//=====================================================================================//

// class fs_path::const_iterator //

//=====================================================================================//

class FILE_SYSTEM_EXPORT

fs_path::const_iterator: public std::iterator<std::bidirectional_iterator_tag, std::string>

{

private:

friend fs_path;

std::string m_selecting;

const fs_path::data_t* m_data;

const fs_path::separators_t* m_separators;

int m_dataIndex; ///< "from" point in controlled sequence

fs_path::separators_t::const_iterator m_sepIt; ///< next separator

public:

const_iterator();

const_iterator(const const_iterator& another);

~const_iterator();

public:

bool operator==(const const_iterator& another) const

{ return ((m_dataIndex == another.m_dataIndex) && (m_sepIt == another.m_sepIt)); }

bool operator!=(const const_iterator& another) const

{ return ((m_dataIndex != another.m_dataIndex) || (m_sepIt != another.m_sepIt)); }

const_iterator& operator++();

const_iterator operator++(int);

const_iterator& operator--();

const_iterator operator--(int);

const std::string& operator*() const;

const std::string* operator->() const;

const_iterator& operator=(const const_iterator& another);

};

}

}

Файл cache.h

namespace mll

{

namespace fs

{

//=====================================================================================//

// class cache //

//=====================================================================================//

class FILE_SYSTEM_EXPORT cache

{

private:

typedef std::deque<file_id> single_query_cache_t;

single_query_cache_t m_single_query_data;

public: // кэширование данных

/// добавить данные последнего запроса на операцию с одним файлом (r_open, w_open, exists)

void add_single_query(file_id id);

/// файл удаляется, нужно сбросить его из всех кэшей

void drop_file(file_id id);

/// сбросить все кэши (например, обновилась структура подсистем)

void clear_all();

public: // получение данных

/// посмотреть наличие в кэше id, полученного ранее по такому же пути

file_id single_query_stored(const std::string& path);

};

}

}