Разработка программного модуля для компьютерной игры

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

4.2.3 Освещение рабочего места

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

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

Специфика работы за монитором ПК состоит также в том, что работать приходится с так называемым самосветящимся объектом - об этом упоминалось в разделе «Зрительное утомление».

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

1) Необходимо обеспечить достаточно равномерное распределение яркости на рабочей поверхности, а также в пределах окружающего пространства. Светлая окраска потолка, стен и производственного оборудования способствует созданию равномерного распределения яркости в поле зрения.

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

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

4) Величина освещенности должна быть постоянной во времени. Колебания освещенности, вызванные резким изменением напряжения в сети, приводят к значительному утомлению. Пульсация освещенности связана также с особенностями работы газоразрядной лампы, поэтому стоит выбирать лампы с другим принципом действия.

5) Следует выбирать оптимальную направленность светового потока. Лучше всего иметь так называемый «рассеянный» свет.

Требования к освещенности рабочего места можно сформулировать таким образом:

1) наименьшая допустимая освещенность от общего освещения должна составлять 300 люкс;

2) освещенность рабочего места не должна превышать 2/3 нормальной освещенности помещения;

3) экран монитора не должен быть ориентирован в сторону источников света (окон, настольных ламп и т.п.);

4) при размещении рабочего места рядом с окном угол между экраном монитора и плоскостью окна должен составлять не менее 90 градусов (для исключения бликов), прилегающую часть окна желательно зашторить;

5) не следует располагать дисплей непосредственно под источником освещения или вплотную с ним;

6) стена позади дисплея должна быть освещена примерно так же, как и его экран;

7) яркость для блестящих поверхностей более 0.2 кв.м не должна превышать 500 кд/кв.м;

8) показатель ослепленности не должен превышать 40 единиц;

9) коэффициент пульсаций не должен превышать 20%.

4.2.4 Электробезопасность

Согласно действующим правилам устройства электроустановок помещения для работы с ЭВМ и их внешними устройствами относятся к категории помещений без повышенной опасности (сухие, с нормальной температурой воздуха, с токоизолирующими полами), однако опасность поражения электрическим током всё же существует. При этом стандартное напряжение в 220В, хотя и представляет определенную опасность для жизни человека, является все-таки менее опасным, чем напряжения внутри ЭЛТ-монитора, которые достигают значений в десятки киловольт. Поражение электрическим током возможно в случае нарушения заземления компьютера, повреждения соединительных проводов, защитных корпусов.

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

1) сетевые розетки, от которых питается компьютер, должны соответствовать вилкам кабелей электропитания компьютера;

2) запрещается во время работы компьютера отключать и подключать разъемы соединительных кабелей;

3) запрещается снимать крышку системного блока и производить любые операции внутри корпуса до полного отключения системного блока от электропитания;

4) запрещается разбирать монитор и пытаться самостоятельно устранять неисправности (опасные для жизни высокие напряжения на элементах схемы ЭЛТ-монитора сохраняются длительное время после отключения электропитания);

5) повторное включение компьютера рекомендуется производить не ранее, чем через 20 секунд после выключения.

Однако, как показывает анализ случаев электротравматизма при эксплуатации промышленных установок, чаще всего имеет место однополюсное (однофазное) прикосновение в изолированных и глухозаземленных сетях.

ГОСТ 12.2007-75 устанавливает требования безопасности, предотвращающие или уменьшающие до допустимого уровня воздействие на человека электрического тока.

Одной из обязательных мер электробезопасности при работе с компьютером является надежное его заземление. Заземление необходимо для того, чтобы ток шел через цепь наименьшего сопротивления - чем меньше сопротивление заземлителя сопротивления человеческого тела, тем меньший ток пойдет через человека. Потребляемая компьютером мощность в последнее время постоянно растет и сейчас достигает 300-400 ватт. При напряжении в сети ~200 вольт потребляемый компьютером ток заведомо выше порогового (0,5 ампер), поэтому заземление в данном случае необходимо. Для заземления компьютера, в первую очередь, применяются естественные заземлители - любые металлические конструкции, имеющие хорошую связь с землей. Если сопротивление естественных заземлителей больше нормируемого (4 Ом), то необходимо сооружать искусственные заземлители.

4.2.5 Микроклимат

Метеорологическими условиями согласно ГОСТ 12.1.005-88 являются:

1) температура;

2) относительная влажность;

3) скорость движения воздуха;

4) атмосферное давление.

С целью обеспечения комфортных условий для работающих людей и надежной работы оборудования, необходимо поддерживать следующие метеорологические условия (согласно СН 512-78):

1) Атмосферное давление в помещении машинного зала должно быть 1013.25±266 ГПа. При пониженном давлении воздуха ухудшается отвод теплоты от аппаратуры компьютера, снижаются изоляционные свойства воздуха.

2) Воздух, используемый для вентиляции машинного зала, должен очищаться от пыли. Запыленность воздуха не должна превышать 1 мг/м?, а размеры пылинок - 3 мкм.

3) В помещении машинного зала необходимо предусмотреть систему отопления. Она должна обеспечивать достаточное, постоянное и равномерное нагревание воздуха в помещении в холодный период года, а также безопасность в отношении пожара и взрыва. При этом колебания температуры в течении суток не должны превышать 2-3 °С; в горизонтальном направлении - 2 °С на каждый метр длины; а в вертикальном - 1 °С на каждый метр высоты помещения. Для отопления помещения машинного зала рекомендуется использовать водяные или воздушные системы центрального отопления.

4) Работающие люди и включенные компьютеры являются источниками избыточного тепла в помещении машинного зала. Поэтому необходимо предусмотреть систему кондиционирования помещения.

4.2.6 Зашумленность

Шум оказывает большое влияние на человека и его работоспособность. Уже при уровнях шума выше 40 дБ ослабляется внимание, ухудшается память, появляется быстрая утомляемость, головная боль.

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

Основными источниками шума в машинном зале, помимо устаревших матричных принтеров, с недавнего времени являются системные блоки. Возросшее энергопотребление современных компьютеров вызвало возрастание требований к их системам охлаждения, вследствие чего суммарный уровень шума системного блока часто превышает 50 дБ. Кроме того, компьютеры являются источниками шумов электромагнитного происхождения (колебания элементов электромеханических устройств под влиянием переменных магнитных полей). В довершение всего, в помещениях возникает структурный шум, то есть шум, излучаемый поверхностями колеблющихся конструкций стен, перекрытий, перегородок здания в звуковом диапазоне частот. Поэтому для снижения уровня шума в помещении машинного зала рекомендуется:

1) Располагать помещение машинного зала вдали от внешних источников шума.

2) Использовать звукопоглощающие облицовочные материалы.

3) Использовать малошумящую вентиляцию.

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

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

Оптимальные показатели уровня шумов в рабочих помещениях конструкторских бюро, кабинетах расчетчиков, программистов определяются по ГОСТ 12.1.003-83 [16].

4.3 Инженерный расчет освещенности машинного зала

Рассчитаем общее освещение в машинном зале ПЭВМ методом коэффициента использования светового потока по уравнению:

Выбираем рекомендованное для машинного зала люминесцентное освещение.

(4.1)

Располагаем светильники рядами вдоль длинной стороны помещения. Будем использовать светильники типа УСП-35 с двумя лампами типа ЛБ-40. Для обеспечения наилучших условий освещения, расстояние между рядами светильников L должно соответствовать отношению:

(4.2.)

Где: h - высота подвеса светильников,

H = 3.2 м - высота помещения,

hc = 0.2 м - свес светильника,

hp = 0.75 м - высота рабочей поверхности от пола.

(4.3)

h = 3.0-0.2-0.75 = 2.25 [м] L = л*h ~= 3.2 [м]

Длина помещения А = 8 м

Ширина помещения В = 6 м

Количество рядов светильников N найдем из уравнения:

L * (0.33* 2 + N-1) = B

(4.4)

Количество рядов светильников N = 2 ряда.

Согласно нормам, нормируемая минимальная освещенность при общем освещении: Eн = 200 лк.

Так как запыленность воздуха меньше 1 мг/м?, то коэффициент запаса:

Кз = 1.5.

Площадь помещения

S = A*B = 8*6 = 48 [м?].

Так как мы предполагаем создать достаточно равномерное освещение, то коэффициент неравномерности освещения: z = 1.15.

Индекс помещения:

(4.5)

Коэффициенты отражения светового потока принимаем (c учетом наиболее распространенной окраски):

от потолка - сп = 70%,

от стен - сс = 50%,

от пола - спола = 10%.

Тогда по таблице находим коэффициент использования светового потока:

з = 0.46.

Так как мы не собираемся создавать затенение, то коэффициент затенения считаем г = 1.

Из данных производителя находим световой поток лампы ЛБ-40:

Фл = 3120 лм.

Световой поток светильника:

Фсв = 2*Фл = 6240 [лм].

Количество светильников в одном ряду:

(4.6)

Расположение светильников:

Длина светильника lсв = 1.3 м

Количество светильников в ряду М = 3 шт

Количество рядов светильников N = 2 шт

Так как А - М*lсв = 4.1<4*L = 12.8 [м]

(где L - рассчитанное минимальное расстояние между светильниками), то расстояние между светильниками в одном ряду L2 можно сделать равным расстоянию от крайнего светильника в ряду до стены. Тогда

(4.7)

Расстояние между рядами L1 при расстоянии крайнего ряда от стены 0.33*L1:

(4.8)

Итак, для нормального освещения машинного зала заданных размеров используем 6 светильников типа УСП-35 с двумя лампами типа ЛБ-40.

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

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

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

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

4.6 Выводы

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

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

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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);

};

}

}

Размещено на Allbest.ru