Анализ текстов на заимствование методом построения семантических моделей
|
Министерство образования и науки Украины Запорожский институт экономики и информационных технологий Факультет Компьютерной инженерии Кафедра Компьютерных систем К ЗАЩИТЕ ДОПУЩЕНА Зав.кафедрой ____________ ____________ МАГИСТЕРСКАЯ РАБОТА АНАЛИЗ ТЕКСТОВ НА ЗАИМСТВОВАНИЕ МЕТОДОМ ПОСТРОЕНИЯ СЕМАНТИЧЕСКИХ МОДЕЛЕЙ Выполнил ст. гр. КсиС-112М Евсеев Артур Александрович Руководитель проф. Лебедева Людмила Николаевна Нормоконтролер Акимова Елена Александровна
Запорожье 2007 |
З А Д А Н И Е
НА АТТЕСТАЦИОННУЮ РАБОТУ МАГИСТРА
Студенту гр. КсиС-112М, специальности _Компьютерные системы и сети»_
Евсееву Артуру Александровичу
(фамилия, имя, отчество)
1.Тема:
|
|
|
|
утверждена приказом по институту “ ” _____________ 200_ г. №
2.Срок сдачи студентом законченной работы _____________________
3.Перечень вопросов, подлежащих разработке ________________________
|
|
|
|
|
|
4.Объект исследования (характеристика объекта, условия исследования и др.)
|
|
|
|
|
|
|
|
5. Основные задачи исследования
|
|
|
|
|
|
|
|
Дата выдачи задания “ ” _______ 200_ г.
Руководитель дипломной работы _____________
(подпись) (фамилия и инициалы)
Задание принял к выполнению ____________
(подпись студента)(фамилия и инициалы)
РЕФЕРАТ
Объем работы: стр. 104, приложений 6, таблиц 10, рисунков 18, источников 50, формул 23.
В работе рассматриваются вопросы применения технологий семантического анализа текстов, представленных на естественном языке с целью выявления наличия заимствований.
Задача определения факта заимствования сводится к сравнению моделей, отражающих смысловую нагрузку текстов. Анализ ведется с использованием алгоритмов на графах, модифицированных и оптимизированных для применения в рамках данной задачи.
Использование схем анализа данных, предложенных в данной работе, может позволить выявлять факт заимствования даже если оригинал был определенным образом модифицирован (выполнен перевод, слова были заменены на синонимы, текст был изложен с использованием другой лексики и т.д.).
Результаты выполнения работы могут быть использованы во всех прикладных направлениях, для которых применимы методы семантического анализа текстов.
ЕСТЕСТВЕННЫЕ ЯЗЫКИ, ЗАИМСТВОВАНИЕ, ИЗОМОРФНОСТЬ, НЕЧЕТКИЙ АНАЛИЗ, ОСМЫСЛЕННЫЙ АНАЛИЗ, ПЛАГИАТ, СЕМАНТИЧЕСКАЯ МОДЕЛЬ, ТЕОРИЯ ГРАФОВ, ЦИТИРОВАНИЕ.
СОДЕРЖАНИЕ TOC \o "1-3" \h \z \u
Методы решения задачи анализа текстов на заимствование. Постановка задачи.. \h 10
1.1. Задача анализа заимствований на базе семантических технологий.. \h 11
Подходы к решению задачи анализа заимствований.. \h 14
2.1. Анализ на базе оценки релевантностей.. \h 14
2.2. Анализ на базе оценки смысловой нагрузки текста.. \h 20
2.2.1. Формирование семантического словаря. \h 20
2.2.2. Формирование семантических моделей. \h 28
2.2.3. Представление данных. \h 40
2.2.3.1. Объектная модель реализации инструмента для разбора форматов данных. \h 43
2.2.3.2. Преобразование из формата MS Word. \h 45
2.2.4. Алгоритм лексического и грамматического разбора предложений. \h 46
Алгоритмы, используемые для установления факта заимствований при семантическом анализе \h 55
3.1. Анализ изоморфности графов. \h 55
3.2. Анализ оптимальности алгоритма.. \h 73
4.1. Обоснование выбора средств разработки.. \h 78
4.2. Программный комплекс. \h 81
4.3 Система анализа текстов на заимствование. \h 85
4.4 Тестирование системы.. \h 88
4.4.1. Тестирование модулей системы (модульное тестирование) PAGEREF _Toc170623472 \h 88
4.4.2. Тестирование корректности работы логики системы.. \h 89
4.4.3. Нагрузочное тестирование. \h 89
Возможности развития проекта.. \h 91
5.1. Формальное определение объектов семантической алгебры.. \h 91
5.2. Алгоритм лексического и грамматического разбора текстов. \h 94
5.3. Алгоритмы установления факта изоморфности графов. \h 95
5.4. Оптимизация хранилищ данных.. \h 96
5.5. Параллелизация вычислительных процессов. \h 96
ПЕРЕЧЕНЬ ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ.. \h 102
ВВЕДЕНИЕ
Одной из проблем современных информационных систем является проблема систематизации и каталогизации материалов, представленных на естественном языке (ЕЯ). Необходимость этого обусловлена рядом причин:
· Не существует единых принципов оформления электронных материалов, излагаемых на ЕЯ, поэтому часто оказывается проблематичным проводить автоматизированный анализ такой информации;
· Отсутствует единая база данных, содержащая соответствия единиц электронных материалов (ЕЭМ) определенным предметным областям;
· Практически невозможно определить достоверность информации, предоставленной в публичный доступ, поскольку для ЕЭМ, как правило, не определяется индекс достоверности;
· Многие материалы, опубликованные в глобальных сетях, дублируют друг друга, или их различия очень незначительны. В таких случаях определение оригинала, который послужил основой для данной ЕЭМ – весьма трудоемкая (а иногда и вовсе не решаемая) задача;
· Объем публичной информации в глобальных компьютерных сетях – огромный, что существенно усложняет автоматизированный перебор и анализ ЕЭМ с одной стороны, и делает весьма трудоемким процесс поиска необходимой информации потенциальными пользователями информационных систем с другой стороны.
Данная проблема решается многими способами, один из которых – анализ текстов представленных на ЕЯ на основе построения семантической модели.
Под семантикой, с точки зрения информационных технологий, можно понимать принципы организаций языковых конструкций на ЕЯ.
Под семантической моделью текста, представленного на ЕЯ, можно понимать эквивалент данного текста, представленный таким образом, чтобы анализ смысловой нагрузки текста мог быть выполнен с использованием автоматизированных систем. Естественно, данная модель должна быть оформлена в соответствии с формально определенным форматом.
Развитие технологий построения семантических моделей во многом связано с развитием идеи, которая получила название “Семантическая сеть” (Semantic web). В соответствии с концепцией семантической сети для каждой опубликованной ЕЭМ должна быть построена соответствующая ей семантическая модель. Если потребуется выполнять поиск или анализ текстов на ЕЯ, то анализироваться будет не сам текст, а его семантическая модель. Это позволит решить несколько задач:
· Запросы на поиск информации в глобальной сети можно будет формировать не по ключевым словам, а на ЕЯ;
· Материалы, представленные в глобальных сетях, станет возможным сортировать “по смыслу” и принадлежности предметным областям;
· Информационные системы смогут отбирать и использовать необходимую им информацию автоматически, без участия человека.
Предполагается, что сначала будут созданы семантические модели для уже существующих ЕЭМ в глобальных сетях, а все ЕЭМ, которые будут туда помещаться вновь, будут сопровождаться соответствующими семантическими эквивалентами.
Для описания семантической модели на ЕЯ был определен специальный формат – RDF (Resource description format), который базируется на формате XML и позволяет определять соответствия вида объект – атрибут – значение. Кроме этого, ЕЭМ также предполагается присваивать информацию, определяющую уровень достоверности публикуемых материалов. Это осуществляется путем добавления цифровой подписи. Для определения онтологической информации (терминологии предметной области) используется язык OWL (Web ontology language).
Формат RDF позволяет представлять данные в виде иерархической структуры (как правило, в виде графа) в формате, который может быть разобран автоматически, с использованием, например, инструментов XML Parser. Каждый элемент документа, представленного в виде RDF, представляет собой набор фактов. Если рассматривать эти факты с точки зрения текстов на ЕЯ, то они являются предложениями, определяющими соответствие между подлежащим (объект), сказуемым (атрибут) и дополнением (значение).
Для определения объектов принято использовать формат URI (универсальный идентификатор ресурсов). В качестве синтаксиса объектов может использоваться формат, похожий на обычный WWW URL (адрес вида http://something), хотя никакого отношения к реальным URL-адресам такой объект может и не иметь. Возможно, также использовать другие варианты представления объектов в RDF. Выбор того или иного формата обычно определяется конкретной предметной областью, для элементов которой выполняется генерация семантической модели.
Для организации хранения информации, представленной в виде RDF совсем не обязательно использовать файлы .RDF. Если окажется, что такую информацию более рационально представить в виде реляционной модели, то имеет смысл хранить ее в некоторой реляционной базе данных. В таком случае может оказаться целесообразным разработать инструментарий, выполняющий преобразование из файла .RDF в структуру БД и наоборот. Это позволит использовать уже существующие утилиты, работающие с форматом .RDF.
Задача анализа текста на наличие заимствований также может решаться с использованием механизма построения семантических моделей.
В настоящий момент такая задача, в основном, решается путем анализа ключевых слов. Такой метод может оказаться эффективным для поиска полных заимствований, но если в тексте выполнялись модификации (например, была выполнена замена некоторых существительных на синонимы или текст был переведен на другой язык), то результаты такого анализа могут оказаться неудовлетворительными. В таком случае имеет смысл использовать алгоритмы, которые предполагают построение семантических моделей исходного и предполагаемых оригинальных текстов и проводить сравнения этих моделей.
Задача анализа текстов, представленных на естественном языке на предмет заимствований в разных системах решается по-разному:
1. Система “antiplagiat.ru работает по принципу анализа ключевых фраз и предназначена, в основном, для использования в учебных заведениях.Cистема собирает информацию из различных источников: загружает из Интернета и обрабатывает сайты, находящиеся в открытом доступе, базы научных статей и рефератов. Полученные материалы проходят процедуру фильтрации, в результате которой отбрасывается бесполезная с точки зрения потенциального цитирования информация.
2. Система “Лингвоанализатор”. Анализ ведется на основе стилистики предполагаемого оригинального текста – атрибутики текста.
3. Методика выявления плагиата в исходных текстах компьютерных программ, приведенная в [48].
4. Система PlagiatInform работает по аналогии с системой Антиплагиат и рассчитана на применение на базе учебных заведений.
Автор работы выполнил исследование методов анализа текстов на заимствования, предложил свои подходы к решению задачи.
РАЗДЕЛ 1
Методы решения задачи анализа текстов на заимствование. Постановка задачи
Задача анализа текстов, представленных на естественном языке, в настоящий момент решается, как правило, тремя основными методами:
1. Анализ текстов экспертом в предметной области, к которой можно отнести анализируемый текст. Данный метод не предполагает автоматизацию процесса анализа. Анализ проводит некоторое лицо, которое считается достаточно компетентным в соответствующей области знаний;
2. Анализ текстов на базе оценки релевантностей. Данный метод является достаточно хорошо сформированным, хотя применяется он, в основном, для поиска информации в глобальных сетях. На базе данного метода осуществляется поиск практически во всех поисковых системах Интернета (Google, Yahoo, Lycos, Rambler, Yandex и др.). Этот же метод может быть успешно использован для анализа текстов на наличие заимствований. По такому принципу работает достаточно популярная в данный момент система antiplagiat.ru. Метод не требует использования значительных вычислительных ресурсов. Для этих целей требуется время, соответствующее алгоритму дихотомического поиска. Однако этот метод не может быть применен в случае, если содержание текста было изменено (без изменения смысловой нагрузки текста);
3. Метод, базирующийся на анализе смысла текста.
1.1. Задача анализа заимствований на базе семантических технологий
В данной работе задачу анализа текстов, представленных на естественном языке можно разбить на несколько этапов:
1. Регистрация материалов, рассматриваемых в качество исходных. Поскольку предполагается, что объем исходных данных, а также объем вычислительной нагрузки на сервер, обслуживающий репозиторий исходных данных, могут быть значительными, для оптимизации производительности системы требуется особое внимание уделить выбору СУБД. В качестве сервера баз данных в данном случае имеет смысл использовать MS SQL server, поскольку он позволит организовать распределенное хранилище, а также обладает достаточной производительностью для выполнения поставленной задачи. Исходные документы хранить в БД не имеет смысла – достаточно хранить там только ссылку на документ, располагающийся на диске. Документ, представленный в текстовом виде, а также модели этого документа имеет смысл хранить в самой БД, так как предполагается, что эти данные будут непосредственно учувствовать в запросах при анализе текстов на заимствование.
2. Каталогизация материалов, рассматриваемых в качестве исходных. Время анализа документов на наличие заимствований можно значительно сократить, если проводить сравнение документов по близким предметным областям. Таким образом, процесс анализа документов можно значительно оптимизировать, если предварительно все исходные документы сгруппировать по соответствию некоторым предметным областям. В данной работе степень соответствия предметным областям предполагается строить на основе словаря, содержащего соответствия между следующими объектами:
a. Семантическая лексема на исходном языке (в качестве такового предлагается русский);
b. Список синонимов данной семантической лексемы;
c. Перевод семантической лексемы на другие языки
Под семантической лексемой в данном контексте понимается некоторая самостоятельная единица естественного языка, в соответствие которой возможно поставить формальное определение. В качестве источника данных для формирования такого словаря в работе предполагается использовать часть открытого проекта Wikipedia – WikiСловарь. Все элементы WikiСловаря представляют собой html-страницы, которые включают в себя все объекты, перечисленные выше.
3. Построение семантических моделей документов в формате, близком к RDF, но оптимизированном для хранения в БД. Фактически, такая семантическая модель будет представлять собой множество ссылок на данные из словаря, представленное в виде ориентированного графа, взвешенного по вершинам и ребрам. Имеет смысл также выполнять анализ полученной модели с целью выделения из нее оригинальной смысловой нагрузки, для того, чтобы анализ проводился по основному смыслу текста, а не по множествам семантических лексем, имеющих общий смысл.
4. Анализ текста на заимствование. Данная операция аналогична помещению образца в базу данных:
a. сначала требуется осуществить преобразование текста в формат простого текста (plain text);
b. Для оптимизации перебора по множеству образцов выполнить позиционирование данного текста в некоторых предметных областях – проставить индексы соответствия данного текста для каждой предметной области. Далее анализ текста вести в предметных областях, индекс которых наибольший (в порядке убывания);
c. Построить семантическую модель данного текста, представленную в виде взвешенного орграфа;
d. Выполнить выделение основного смысла из текста, убрав множества семантических лексем, имеющие общий характер. Скорректировать построенный граф;
e. Выполнить сравнения с образцами, хранящимися в БД в порядке убывания индекса соответствия предметной области. Сравнения вести на основе определения степени изоморфности двух графов – исходного и образца;
f. Сделать вывод о степени заимствования материалов, подготовить соответствующий отчет;
g. Если процент заимствования является допустимым, то считать текст оригинальным и внести его в общую базу данных образцов.
h. Если текст был признан оригинальным и внесен в общую базу данных, то должны быть установлены соответствия между всеми семантическими лексемами, относящимися к этому тексту и уникальным номером текста в БД
1.2. Выводы
Задача анализа текстов, представленных на естественных языках, может решаться различными методами. Выбор метода зависит, как правило, от характера текста.
Во многих случаях при автоматизированном анализе может быть применен метод релевантностей. Однако, если текст был некоторым образом модифицирован, то эффективным решением может оказаться применение технологий, основанных на анализе смысловой нагрузки текста.
РАЗДЕЛ 2
Подходы к решению задачи анализа заимствований
Основными автоматизированными методами решения задачи анализа заимствований текстов, представленных на естественном языке, являются:
1. Анализ на базе релевантностей;
2. Анализ на базе анализа смысловой нагрузки текста
2.1. Анализ на базе оценки релевантностей
Одним из методов анализа текстов на предмет заимствований из публичных источников является метод, основанный на анализе уровня релевантности.
Методика получения индекса релевантности для задачи анализа текстов на заимствование похожа на алгоритм получения уровня релевантности в поисковых системах.
С точки зрения поисковых систем, под релевантностью понимают меру соответствия результатов поиска запрошенным данным.
Определять факт вхождения ключевых слов, заданных в качестве запроса на поиск можно разными способами:
1. Точный поиск подстроки в строке
2. Нечеткий поиск подстроки в строке. Для выполнения такого поиска вводят понятие “расстояние между строками”. По определению Хемминга, расстоянием между 2 строками является число позиций в строке, на которых символы отличаются. При решении задачи нечеткого поиска определяется максимально допустимое число dmax – расстояние между строками. Если производится нечеткий поиск подстроки A в строке B, то считается, что A является подстрокой B, если d(A, B) <= dmax.
При анализе текстов на наличие заимствований на базе вычисления релевантности, возможно, использовать следующий алгоритм:
Предположим, что
· A – некоторый исходный текст, представленный на естественном языке;
· B = {B1, B2, … , Bn} – множество текстов, среди которых следует производить поиск.
В таком случае задача анализа текста A на заимствование из текстов множества B сводится к сортировке множества B по уровням заимствований в порядке убывания. Уровни заимствований определяются численной величиной – расстоянием Хемминга между A и Bi, где i – номер рассматриваемого текста из множества B.
Таким образом, для каждого элемента множества B определяются два подэлемента – текст и уровень заимствования из него текста A:
B = {{ B1, d1}, { B2, d2}, … , { Bn, dn}} (2.1)
Причем, множество B должно быть представлено таким образом, что
(2.2)
Имеет смысл рассматривать не все тексты из множества B, а только те, для которых di < dдоп, где dдоп – допустимый предел заимствований.
Сложность алгоритма поиска расстояния между строками очень зависит от конкретной реализации соответствующего алгоритма. Вывод о том, какой именно из алгоритмов поиска расстояний между строками следует делать исходя из анализа следующих данных:
· Максимальный и средний размеры текстов, которые анализируются на наличие заимствований;
· Максимальный и средний размеры текстов, которые рассматриваются в качестве элементов множества B;
· Величина n;
· Априорная информация о максимальном и среднем d
Наиболее распространенные алгоритмы вычисления размера между строками представлены в таблице 2.1.
Таблица 2.1
Алгоритмы вычисления расстояний между строками
|
N п/п |
Алгоритм |
Сложность по времени |
Сложность по памяти |
Особенности применения |
|
1 |
Метод динамического программирования Вагнера и Фишера |
O(n, m) = (n+1)*(m+1) |
O(n, m) = (n+1)*(m+1) |
Для вычисления всегда требует значительных затрат вычислительных ресурсов - квадратичного времени и памяти. Может быть применен для вычисления расстояний подстрок строк A и B за константное время, если было рассчитано расстояние между A и B. Позволяет, в случае необходимости, получить сами подстроки длиной d за линейное время. |
Продолжение таблицы 2.1
|
Модификация Хиршберга |
O(n, m) = n*m |
O(n, m) = m+n Требуется также стековая память для 2*max(n,m)-1 рекурсивных вызовов |
Основан на методе Вагнера-Фишера. За счет экономии памяти не позволяет быстро получить общие подстроки длины d. |
|
|
Алгоритм Ханта-Шиманского |
O(n, m) = max2(n,m)*log(max(n,m)) |
O(n, m) = m*n |
Алгоритм будет эффективен для больших по объему данных. |
Продолжение таблицы 2.1
|
Алгоритм Машека и Патерсона |
O(n, m) = max(n,m)/log(max(n,m)) |
O(n, m) = m*n |
Единственный алгоритм, для которого оценочное время работы в худшем случае меньше квадратичного. Алгоритм работает очень эффективно на больших объемах данных. Разработчики рекомендуют применять его, когда m, n > 262418 |
|
|
Алгоритм Уконнена |
O(n,m) = d * max(n,m) |
O(n, m) = m*n |
Метод эффективен, когда расстояние между строками небольшое |
Поскольку в задаче анализа текста на заимствование часто приходится иметь дело с базой данных текстов (множество B) очень большого объема, задача оптимизации поиска расстояний по этим текстам является очень актуальной. Для этого имеет смысл перед вычислением расстояний между строками собирать информацию, которая позволит сделать выбор в пользу того или иного алгоритма; эффективным может оказаться метод динамического комбинирования алгоритмов.
Алгоритмы поиска расстояния между строками, как правило, позволяют эффективно применять технологии распределенных и параллельных вычислений.
Метод анализа текстов на заимствование методом анализа релевантностей может оказаться эффективным в том случае, если исходный текст A не изменялся или выполнялись незначительные изменения. Если же выполнялись изменения исходного текста (перевод на другой язык, замена некоторых существительных синонимами), то такой метод может не дать требуемого результата.
2.2. Анализ на базе оценки смысловой нагрузки текста
Данный метод анализа принципиально отличается от того, который был изложен в разделе 2.1, схема организации процесса проверки осуществляется иным способом.
2.2.1. Формирование семантического словаря
Процесс проверки текстов, представленных на естественном языке, на базе алгоритмов анализа смысловой нагрузки опирается на заранее форматизированный банк данных – семантический словарь.
Возможно выделить 2 основных типа словарей, используемых в алгоритмах анализа семантических данных:
1. Базовый словарь. Данный словарь представляет собой совокупность независимых фактов, уровень достоверности которых является максимальным. В словарь этого уровня предполагается включать:
a. Словарь синонимов;
b. Словарь родственных семантических лексем;
c. Формальные лингвистические правила языков, которые могут быть выражены в виде фактов;
d. Список правил перевода с одного языка на другой
2. Семантический словарь. В данном словаре предполагается хранить семантические данные базы документов, которую требуется использовать в качестве исходной. При анализе текстов на заимствование потребуется выявлять наличие заимствований именно из этой базы документов.
Несмотря на то, что логически эти 2 типа словарей значительно отличаются, представление данных обоих словарей очень похоже, поэтому для них возможно применение одного и того же алгоритма.
В данной работе формирование базового словаря было решено выполнять на основе данных, находящихся на сервере открытого проекта WikiPedia – ВикиСловарь.
Для каждого слова в ВикиСловаре существует страница, представленная в виде разделов следующим образом:
1. Морфологические и синтаксические свойства
2. Семантические свойства
3. Синонимы
4. Антонимы
5. Родственные слова
6. Устойчивые словосочетания
7. Этимология
8. Перевод
Из данного списка полезными для построения семантического словаря могут оказаться данные, принадлежащие разделам:
1. Семантические свойства
2. Синонимы
3. Родственные слова
4. Устойчивые словосочетания
5. Этимология
6. Перевод
Данные из Викисловаря можно получить путем обращения к соответствующим html-страницам.
Для того чтобы получить доступ к любым WEB-страницам разработан соответствующий класс CWebData. У данного класса существует единственный (кроме конструктора) публичный метод
public string get_web_page(string url)
Данный метод принимает в качестве параметра адрес требуемой страницы и возвращает ее содержимое в виде одной нуль-терминированной строки.
Предполагается, что данный класс будет использован в качестве родительского для некоторых производных классов (но не обязательно: класс не объявлен как абстрактный, а следовательно может быть использован и без наследования).
Данный класс может быть унаследован для следующих целей:
1. Запрос к WEB-странице может занимать длительное время, которое нецелесообразно тратить на ожидание ответа WEB-сервера.
2. Маловероятно, что для задач анализа текста на наличие заимствований потребуется использовать в исходном (сыром) виде. В большинстве случаев потребуется сначала разобрать содержимое WEB-страницы, выделив из нее требуемые данные. Поэтому имеет смысл унаследовать от класса дочерний класс, который позволит выполнять parsing страницы и получать данные в структурированном виде.
Для доступа к WEB-страницам в данном классе используется средства, декларированные в пространствах имен System.Net, System.IO и System.Text.
Для выполнения анализа Викисловаря сначала потребуется получить список всех доступных слов. Адреса страниц со списками доступных слов в Викисловаре строятся по шаблону:
где <N> - номер первой буквы слов, начиная с 90, представленный в 16-ричном виде.
Список всех страниц “по буквам” хранится в файле letters.dat и приведен в приложении Д.
Для доступа к файлам используется класс CfFleReader, исходный код которого приведен в Приложении Г.
Процесс разбора данных, хранящихся в Викисловаре, разбивается на несколько этапов:
1. Получение данных по буквам и сохранение их в .php – файлах. Поскольку предполагается, что процесс разбора Викисловаря должен выполняться автоматически, то требуется исключить все факторы, которые могут повлечь за собой некорректную остановку процесса разбора. Данные факторы выявлялись экспериментально, и приведены в таблице 2.2.
Таблица 2.2.
Факторы, которые могут повлечь за собой остановку процесса разбора словаря
|
N п/п |
Фактор |
Метод решения проблемы |
|
1 |
Ошибка доступа к прокси-серверу или маршрутизатору |
Включить потенциально опасный участок кода в блок обработки исключительных ситуаций, повторять попытки получения данных до успешного окончания |
|
2 |
Ошибка доступа к серверу Викисловаря |
Как правило, ошибка может быть связана либо с сильной загруженностью канала доступа (ошибка превышения допустимого таймаута) либо с чрезмерной загрузкой сервера Викисловаря. И в том и в другом случае следует повторить попытку после некоторого временного интервала. Экспериментальным путем было установлено, что 10-секундного интервала для этих целей в большинстве случаев оказывается достаточно. |
|
3 |
Ошибка 403 Forbidden |
Данная ошибка может возникать в 2х случаях: · Если выполняется попытка обращения к несуществующей странице; · Если количество запросов с одного IP-адреса превысило допустимый предел. Требуется повторить запрос через некоторый небольшой интервал времени (использовался интервал в 2 сек). Если после значительного количества попыток получить доступ к странице так и не удалось – исключить ее из списка рассматриваемых. |
2. Разбор полученных на первом этапе html-файлов и формирование первичного словаря. Семантические связи на данном этапе не устанавливаются и не фиксируются.
3. Проход по всему словарю, получение и фиксирование базовой семантической информации. Выполняется анализ всех WEB-страниц Викисловаря, относящихся к сформированному на предыдущем этапе словарю. При организации обращений к WEB-страницам следует предусмотреть обработку исключительных ситуаций аналогично тому, как это делается в пункте 1, согласно таблице 2.2. Вся дополнительная информация, имеющая отношение к семантическим единицам должны быть внесена в словарь “на лету”.
Данные этапы должны выполняться последовательно, однако в рамках каждого этапа возможно использовать параллелизацию вычислений:
1. Большую часть времени на данном этапе занимают операции обращения к WEB-серверу. Поэтому распределение, в случае необходимости, следует вести по каналам доступа к Интернету.
2. Данный этап не представляет особой вычислительной сложности и, в большинстве случаев, не требует параллелизации.
3. Данный этап вычислительно наиболее сложный и применение технологий распределенных вычислений позволит значительно сократить время формирования словаря. На данном этапе наибольший объем времени тратится на следующие операции:
a. Получение данных с WEB-страницы. Параллелизация тут, как и на первом этапе, возможна по каналам доступа в Интернет;
b. Разбор страниц по каждому слову. Все html-страницы могут обрабатываться параллельно, однако имеет смысл сначала разбирать страницы, содержащие наибольшее количество информации (поскольку будет продолжаться процесс формирования семантического словаря). Количество модулей, выполняющих вычисления параллельно, может быть произвольным, имеет смысл задействовать для этих целей все доступные вычислительные модули;
c. Выборки из базы данных, определяющие, присутствуют ли в семантическом словаре очередные найденные семантические элементы. Параллелизация на данном этапе не имеет смысла, требуется размещать сервер БД на достаточно быстродействующем сервере и выполнять полнотекстное индексирование таблиц (full-text index), содержащих семантические словари.
В результате выполнения первого и второго этапа в базе данных было сформировано 17215 записей.
На третьем этапе требуется получить всю доступную в Викисловаре информацию о каждой записи в БД, после чего выполнить обработку данных.
Поскольку объем данных, получаемых с Викисловаря может быть очень значительным, и, соответственно, может потребовать значительных затрат времени, то этот процесс имеет смысл максимально оптимизировать. Для загрузки данных был использован инструмент WGET. Данный инструмент распространяется по лицензии GNU, что позволяет свободно использовать его как составную часть проекта. WGET может проводить закачку в многопоточном режиме, что может существенно ускорить процесс получения данных.
Для получения данных система генерирует пакетный файл, который впоследствии запускается и загружает всю требуемую информацию автономно.
Для того чтобы обратиться к Викисловарю для получения информации о некотором выражении следует послать запрос по адресу, формируемому по следующему шаблону:
http://ru.wiktionary.org/wiki/<выражение>
Выражение следует формировать в соответствии с форматом URL. Для формирования команды WGET для загрузки страницы используется следующий фрагмент кода:
string url_part = HttpUtility.UrlEncode(s);
url_part = url_part.ToUpper();
//Поскольку в пакетных файлах знак "%" является служебным, его //нужно сдублировать
string url_part_ready = "";
for (int ui = 0; ui < url_part.Length; ui++)
url_part_ready += url_part[ui] == '%'? "%%" : url_part[ui].ToString();
CFileWriter.WriteToFile("get_data.cmd", "wget -P data \"http://ru.wiktionary.org/wiki/" +
url_part_ready + "\" -O \"data/" +
url_part_ready + ".php\"");
После получения данных требуется выполнить разбор каждой страницы.
Разбор выполняется по разделам html-страницы.
Предполагается, что словарь будет формироваться динамически в процессе проверок на заимствование. Таким образом, автоматически будет реализовываться принцип поддержки словаря в актуальном состоянии.
Поскольку качество проверок с целью выявления факта заимствования является очень зависимым от связности графа, представляющего семантический словарь, следует степень его связности максимизировать. Это следует делать за счет материалов, которые имеют очень высокую степень заимствований (это может говорить о том, что там присутствуют общеизвестные факты, которые следует включить в словарь) и высокий индекс достоверности.
2.2.2. Формирование семантических моделей
Правила формирования семантических моделей для анализа текстов, представленных на естественном языке схожи с правилами построения семантической паутины.
Идея внедрения семантических сетей была предложена и сейчас курируется Тимом Берненсом-Ли в мае 2001 года и предполагает качественно новый способ хранения и обработки материалов, предоставляемых в общий доступ.
Семантическая паутина являет частью общей концепции развития Всемирной паутины и Интернет, принятой консорциумом W3. Данный факт говорит о том, что идея семантико-ориентированных систем с большой долей вероятности будет развиваться и внедрятся повсеместно.
Семантические сети предполагают, что будут организовываться в семантическом виде не только текстовые материалы на естественном языке, но и любые объекты, которые могут быть рассмотрены как ресурсы публичных сетей (например, аудио и видеоматериалы).
Для семантических сетей материалы должны быть представлены таким образом, чтобы была возможность автоматически делать выводы о характеристиках анализируемых ресурсов.
Идея семантических сетей базируется на 2х основных характеристиках:
1. Любой объект или субъект, участвующий в информационном обмене должен иметь уникальный универсальный идентификатор ресурсов. Этот идентификатор должен по общему для всех объектов или субъектов правилу обеспечивать определение элемент информационного обмена. Кроме этого, требуется разработать механизм, который позволит поддерживать базу данных уникальных идентификаторов в актуальном состоянии. Идентификатор ресурса не обязательно должен описывать некоторых цифровой материал, к которому можно получить доступ. Идентификатор ресурсов может описывать, например, некоторого пользователя, влияющего на процессы информационного обмена в сети.
2. Описание элементов информационного обмена должно также базироваться на некотором формально определенном шаблоне таким образом, чтобы оформленные таким образом были доступны для машинной обработки. Единицы информации семантического характера идентифицируются уникальным универсальным идентификатором ресурсов. Стандартом де-факто для оформления материалов семантических материалов стало семейство форматов семантических сетей (Semantic Web Family):
a. RDF;
b. RDF Schema (RDF-S);
c. OWL
Среди серьезных проектов, имеющих отношение к организации материалов семантического характера, существуют следующие:
· Проект Swoogle. Поисковая система, которая обеспечивает возможность поиска информации на базе ресурсов, оформленных в формате rdf.
·
Проект
Semantic Web Search. Поисковая система, которая обеспечивает возможность поиска
информации на базе ресурсов, имеющих семантическую природу и представленных в
различных форматах. При поиске данные семантической компоненты единиц информации расшифровываются, и по ним возможно получить характеристики рассматриваемых объектов в формате вида:
Semantic Web
Technologies in the Enterprise
[...encoded] Introduction Over the past two years, my good
friend and coworker Elias Torres has been blogging at an alarming rate about a
myriad of technology topics either directly or indirectly related to the
Semantic Web: SPARQL , Atom , Javascript, JSON , and blo...
[type] rss:item
[Title] Semantic Web Technologies in the
· Проект “Дублинское ядро”. Данный проект является одним из наиболее старых. Проект носит открытый характер, основная его цель – разработать универсальные и платформо-независимые стандарты и форматы данных, которые возможно будет использовать во всех прикладных направлениях. В настоящий момент основной задачей данного проекта является стандартизация и разработка алгоритмов формирования семантических словарей в формате rdf
· W3C. Данный консорциум занимается координированием действий по внедрению и разработке систем, основанных на базе семантически-ориентированных технологий
В рамках данной работы предлагается ввести несколько специфических для работы понятий, определений и множество допустимых операций, объединенных в единый блок – “семантическая алгебра”.
Семантическая модель рассматриваемого текста на естественном языке, не зависимо от ее фактического представления, может быть рассмотрена в виде ориентированного, взвешенного по ребрам графа. Вершиной данного графа является некоторый лексический оборот, представленный в виде множества лексем, связанных между собой согласно правилам естественного языка, на котором изложен рассматриваемый текст. Назовем этот лексический оборот семантической лексемой.
Исходный текст, представленный в виде множества лексических оборотов, будем обозначать как T, а граф, определяющий семантическую модель данного текста, будем обозначать как G.
Определим отношение:
(2.3)
Данное отношение определяет, что из данного текста T порождается описывающая его семантическая модель G.
Заметим что, если истинно (2.3), то
(2.4)
То есть, если некоторый тест T порождает семантическую модель G, то семантическая модель G порождает множество текстов R, а T является одним из элементов множества R.
Сравнение текстов следует производить только с текстами, которые, по некоторой априорной информации могут оказаться близкими по содержанию к рассматриваемому тексту. Назовем множество графов, представляющих семантические модели текстов, близкие по содержанию или описываемым объектам предметной областью и будем обозначать ее следующим образом:
,
где
A – множество, представляющее собой предметную область;
Gi – граф, представляющий собой семантическую модель некоторого текста, принадлежащего предметной области A.
Причем, верно следующее соотношение:
Если , то (2.5)
То есть, если некоторый тест T порождает семантическую модель G, принадлежащую предметной области A, то и все тексты, порождаемые семантической моделью G, будут порождать семантические модели, принадлежащие предметной области A.
При рассмотрении текста имеет смысл выделять его основную идею, а информацию общего характера – игнорировать. Назовем основной текст, определяющий смысловую нагрузку частной предметной областью. Семантическую лексему, повышающую степень соответствия модели частной предметной области будем называть семантической лексемой, принадлежащей данной частной предметной области.
В исходном представлении семантической модели текста, описывающий его граф взвешен только по ребрам – веса для вершин не проставляются. Веса вершин могут быть определены, когда требуется выделить основной смысл текста, проигнорировав информацию общего содержания. Тогда вес вершины будет представлять собой степень соответствия семантической лексемы предметной области.
Предполагается, что вес вершины определяет некоторую неотрицательную численную величину. Значение этой величины обратно пропорционально соответствию предметной области – чем меньше значение этой величины, тем больше она соответствует данной предметной области.
Соответствие семантической модели предметной области определяется следующим образом:
, (2.6)
где
S – численная величина, определяющая степень соответствия семантической модели предметной области
v – множество весов вершин графа, представляющего предметную область.
Ребра в графе определяют отношения между семантическими лексемами. Для семантических моделей определены 2 типа ребер – ориентированные и неориентированные.
Если между двумя вершинами, определяющими семантические лексемы, существует неориентированное ребро, то это означает, что эти две семантические лексемы эквивалентны. Кроме этого, определятся также степень эквивалентности, которая определяется весом ребра. В качестве вершин, связанных неориентированным ребром могут выступать, например, синонимы.
Если две вершины связаны ориентированным ребром, то это указывается на некоторую зависимость одной семантической лексемы от другой. В качестве такой зависимости могут выступать, например:
· Следствия вида: “если <семантическая лексема 1>, то <семантическая лексема 2>”. В таком случае будет определена зависимость, выражаемая ориентированным ребром объекта <семантическая лексема 2> от объекта <семантическая лексема 1>. Схематически данная модель представлена на рис. 2.1.
SHAPE \* MERGEFORMAT <Семантическая
лексема 1> <Семантическая
лексема 2>
Рис. 2.1. Зависимость одной семантической
лексемы от другой
· Вывод частного из общего
Степень зависимости между связями, определяемыми ребрами определяется весами соответствующих ребер.
В соответствии с вышеизложенными правилами, например, выражение:
“Язык программирования C++ – это универсальный язык программирования, который позволяет разрабатывать программы в соответствии с разными парадигмами: процедурным программированием, объектно-ориентированным, параметрическим”
в виде семантической графовой модели может быть представлено так, как это показано на рис. 2.2. Данная структура представляет собой совокупность элементов – вершин и ребер, составляющих граф, представляющий семантическую модель текста.
SHAPE \* MERGEFORMAT Параметрическое
программирование Универсальный
язык программирования Разработка программ Разработка программного обеспечения Язык
программирования C++ Парадигмы
программирования Процедурное
программирование Объектно-ориентированное
программирование
Рис. 2.2. Семантическое представление высказывания на естественном языке
Формирование семантической модели на базе текста, представленного на естественном языке, выполняется на нескольких этапах:
1. Получение информации о частной предметной области и выделение основного смысла текста. Определение соответствия предметной области предполагается проводить по правилу итеративного анализа величины соответствия предметной области согласно (2.4). Выполнение этого анализа будет выполняться на основе сформированного заранее словаря. Для этого предварительно будет построен граф, вершины которого имеют отношение к лексическим оборотам в анализируемом тексте. Таким образом, будет сформирован граф, соответствующий частной предметной области первой итерации.
2. Задачу выделение основного смысла можно свести к определению связности данного графа и выделение связной компоненты графа. Для решения данной задачи можно использовать следующий алгоритм: Предположим, что существует некоторый граф G, заданный таблицей связности так, как это показано в примере на рис 2.3
|
SHAPE \* MERGEFORMAT
|
|
Рис. 2.3(а). Пример графа Рис. 2.3(б). Матрица связности для графа Значение элемента матрицы связности определяется следующим образом:
Для определения максимальной связной компоненты графа, представленного матрицей связности A[n*n] требуется выполнить следующее:
Шаг 1: Заполнить массив индексов idx[n] значениями -1
Шаг 2: Присвоить переменной x значение 0
Шаг 3: Найти idx[i] такое, что idx[i] = -1. Если не найдено – перейти к шагу 7
Шаг 4: Присвоить idx[i] значение x.
Шаг 5: Используя алгоритм поиска в ширину, получить список вершин, к которым
существует путь из вершины i. Для каждой такой вершины установить значение
соответствующего индекса в массиве idx равным x
Шаг 6: Увеличить x на единицу и перейти к шагу 3
Шаг 7: Получить для чисел от 0 до x количество вхождений в массив idx. Результат поместить в массив C таким образом, что в C[1] будет находиться количество
вхождений в idx чисел 1, в C[2] – чисел 2 и так далее
Шаг 8: Вычислить Cnmax – номер максимального значения в массиве C
Шаг 9: Удалить из графа все вершины, значение idx[i] которых не равно Cnmax.
Полученный граф будет являться подграфом исходного графа, представляющий собой
его максимальную связную компоненту.
Например, для графа, представленного на рисунке 2.4 процесс выделения
максимальной связной компоненты графа выглядит так, как это показано на рис. 2.
4
SHAPE \* MERGEFORMAT 1 7 2 3 8 9 4 6 5 10
Рис. 2. 4. Пример графа
Построим таблицу связности для данного графа – таблица 2.3
Таблица 2.3
Таблица связности графа
|
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
|
|
1 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
|
2 |
1 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
|
3 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
|
4 |
0 |
0 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
|
5 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
0 |
0 |
0 |
|
6 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
0 |
0 |
1 |
|
7 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
|
8 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
|
9 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
|
10 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
1 |
Выполнение шагов от 1 до 6 включительно представлено в таблице 2.4
Таблица 2.4
Выполнение алгоритма поиска максимальной связной компоненты на шагах 1-6 (Массив idx)
|
Итерация |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
|
0 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
|
1 |
0 |
0 |
0 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
-1 |
|
2 |
0 |
0 |
0 |
1 |
1 |
1 |
-1 |
-1 |
-1 |
1 |
|
3 |
0 |
0 |
0 |
1 |
1 |
1 |
2 |
-1 |
-1 |
1 |
|
4 |
0 |
0 |
0 |
1 |
1 |
1 |
2 |
3 |
3 |
1 |
На следующем шаге формируется матрица C, представленная в таблице 2.5
Таблица 2.5
Матрица C
|
C[0] |
C[1] |
C[2] |
C[3] |
|
3 |
4 |
1 |
2 |
Найдем номер максимального значения: Cnmax = 1
Удалим из графа все вершины, индекс которых не равен 1. В результате получим подграф, являющийся максимальной компонентой графа (см. рис. 2. 5)
SHAPE \* MERGEFORMAT
|
4 |
|
6 |
|
5 |
|
10 |
Рис. 2.5. Максимальная компонента графа
На данном этапе построение семантической модели текста будет завершено.
2.2.3. Представление данных
Тексты, которые предполагается рассматривать на наличие заимствований должны быть определенным формальным образом представлены.
Для оформления данных, имеющих некоторою смысловую нагрузку, в семантических сетях принято использовать ряд форматов, основанных, как правило, на XML.
Элементарная единица данных в таких форматах обычно формируется по правилу объект – атрибут – значение.
Самым распространенным форматом, позволяющим описывать данные семантического характера, является формат RDF (Resource description framework).
Любой факт, который представляет семантическую ценность, может быть выражен отдельным блоком в структуре, оформленной согласно правилам RDF.
Например, ряд фактов может быть выражен следующим образом:
:john :a :Person .
:john :hasMother :susan .
:john :hasFather :richard .
:richard :hasBrother :luke .
Каждый логический элемент в этой структуре начинается со знака “:”. Описание факта завершается терминирующим символом “.”.
Стандарт RDF изначально разрабатывался таким образом, чтобы обеспечить возможность распределенного хранения семантической информации. Обращение к тому или иному блоку выполняется тогда, когда требуется построить логическую цепочку фактов.
На основе данных, представленных в формате RDF можно формировать новые, производные факты, которые будут являться соотнесенными между собой простыми фактами. Таким образом строятся высказывания на машинном семантическом языке.
Правила построения RDF очень простые:
1. Факт выражается тройкой элементов, похожих на обычное предложение на естественном языке в виде: (Подлежащее, Сказуемое, Дополнение)
2. Подлежащее, сказуемое и дополнение представляют собой сущности, определенные в области информационного обмена. В качестве этих сущностей может выступать как ссылка на реальный материал в электронном виде (как семантический, так и на естественном языке), так и характеристика некого абстрактного объекта; В качестве такого абстрактного объекта может выступать, например, персона, участвующая в информационном обмене. Сама персона не может быть получена пользователем семантической сети или некоторой системы семантического характера, однако ее действия могут вносить корректировки в смысловую нагрузку оцениваемого материала, а значит пренебрегать этим нельзя;
Выделяют два типа имен при описании смысловой информации в RDF – локальные и глобальные.
При использовании локальных имен предполагают, что они будут использоваться исключительно в контексте данного RDF-блока, глобальные – наоборот, доступны везде.
Обычно разделение на глобальные и локальные имена выполняется в рамках выделения предметных областей. Тогда локальные имена – это семантические понятия, принадлежащие конкретной предметной области, а глобальные обеспечивают межпредметную связь, выступая в качестве шлюза.
Формат RDF является универсальным для оформления семантических моделей и используется, как правило, для представления внешнего результата и входных данных в систему. Внутри системы оформление данных обычно несколько модифицируется таким образом, чтобы необходимые действия над семантическими данными выполнялись максимально оптимальнее и эффективнее.
Несмотря на то, что некоторую семантическую информацию о тексте можно получить, проанализировав особенности его оформления, в данной работе предполагается проводить только анализ текстовой информации, а значит, требуется разработать средства, позволяющие преобразовывать тексты из различных рассматриваемых форматов данных в единый текстовый формат.
Для доступа к данным в работе предполагается использовать технологию COM/DCOM (OLE). Использование данной технологии не позволит очень быстро получать текст из документов, однако он позволит организовать единый интерфейс для доступа к данным, представленных в различных форматах.
2.2.3.1. Объектная модель реализации инструмента для разбора форматов данных
Для того чтобы регламентировать правила доступа к данным разных форматов можно использовать абстрактный класс, от которого будут унаследованы все классы, в которых будет выполнена реализация алгоритмов разбора форматов файлов. Схематически такая объектная модель представлена на рис. 2.6. На схеме показаны реализованные классы с модификаторами и иерархической структурой.
|
|||
|
|||
|
|
|
|
|
|
………… ………… ………… ………… |
|
Промежуточные классы |
|
………… ………… ………… ………… |
Рис. 2.6. Схематическое представление объектной модели
В классе CDocumentParser (см. Приложение А) объявлены 3 метода и одно поле:
- is_format_compatible(…) – метод, который должен производить проверку совместимости разбираемого файла заявленному формату. Поскольку предполагается, что процесс разбора будет выполняться автоматизировано, то вызывать этот метод следует перед каждой новой операцией разбора, иначе ошибка при разборе может привести к остановке процесса парсинга целиком.
- parse_file(…) – выполняет разбор файла. Результат разбора помещает в публичное поле “text”.
- generate_sql_script() – формирует sql-скрипт для вставки данных о документе в БД.
2.2.3.2. Преобразование из формата MS Word
Стандартом де-факто при оформлении работ студентами учебных заведений стало использованием для этих целей текстового процессора Microsoft Word.
Для того чтобы было возможно использовать OLE-объект, привязанный к некоторому .doc-файлу потребуется включить в проект соответствующие сборки:
· Microsoft Office 10.0 Object Library;
· Microsoft Office Runtime 1.0 Type Library;
· Microsoft Word 10.0 Object Library
Реализация алгоритма получения текста из .doc – файла посредством технологии OLE выглядит следующим образом:
· Создается OLE – объект – экземпляр MS Word. Для этих елей создается экземпляр класса Word.Application
· В рамках этого объекта производится открытие требуемого .doc файла. Для этих елей создается экземпляр класса Word.Document, унаследованный от класса Word.Application
· Производится получение текстовой информации из этого файла
· Выполняется закрытие OLE объекта
Полный исходный код класса, реализующего разбор MSWord – документов приведен в приложении Б.
2.2.4. Алгоритм лексического и грамматического разбора предложений
Одной из основных проблем, возникающих в процессе автоматизированного анализа текста на естественном языке, является проблема формализации. Данная проблема решается различными способами и выбор методики формализации материалов, представленных на естественном языке, обычно зависит от характера текстов, которые предполагается обрабатывать и характера задачи, для которой требуются данные, представленные в формальном виде.
При анализе текстов на естественном языке с целью построения семантических моделей задача формализации сводится к выделению объектов и отношений между объектами.
Если предположить, что текст, представленный на естественном языке оформлен согласно правилам языка, то можно сформулировать несколько утверждений, которые будут использоваться при анализе текста. Данные утверждения приведены в таблице 2.6.
Таблица 2.6
Утверждения, используемые при разборе текстов на естественных языках славянского происхождения
|
N п/п |
Суть утверждения |
Описание утверждения |
Пример и примечания |
|
1 |
Использование разделителей |
Логические элементы высказываний на естественном языке принято отделять специальными разделителями. Эти разделители получили название “знаки препинания” и могут использоваться для выделения логически независимых блоков в высказываниях. |
Высказывание вида “Мобильный телефон является средством связи, Однако он может использоваться для других целей” может быть разделено на 2 семантически независимых блока: “Мобильный телефон является средством связи” и “Мобильный телефон может быть использован не как средство связи”. При разборе выражений может возникнуть ряд проблем, связанных с применением данного правила: знаки препинания далеко не всегда выделяют логически и семантически законченные блоки, они могут служить и для других целей. Например, в русском языке вводные слова также могут выделяться запятыми, хотя они определенно не являются объектом, влияющим на характер семантического высказывания. Более того, часто имеет смысл такие вводные слова вообще не принимать во внимание при построении семантической модели, либо учитывать только при определении веса соответствующего ребра графа. |
Продолжение таблицы 2.6
|
2. |
Правило “тройки” |
Суть представления семантических данных заключается в том, что выделяется одна пара семантических лексем, а затем устанавливается некоторая связь между ними. При разборе текстов на естественном языке следует придерживаться этого правила. В семантически обособленном блоке высказывания следует выделить два объекта, а затем попытаться определить между ним степень и характер связи. |
Высказывание “цифровая музыка представляется последовательностью двоичных чисел” может быть разобрана следующим образом. Сначала потребуется выделить два объекта, которые присутствуют в высказывании. Очевидно, что эти два объекта: “цифровая музыка” и “последовательность двоичных чисел”. Отношением между ними является элемент “представляется”. Таким образом, формируется связь, состоящая из тройки, представленной в виде схемы “Объект-связь-объект”. Для данного примера будет построена модель, которую можно представить в виде графа: SHAPE \* MERGEFORMAT
|
Продолжение таблицы 2.6
|
3. |
“Прилагательное – существительное” |
Если в предложении обнаруживается блок, составленный из пары “Прилагательное – существительное”, то эту пару можно рассматривать как отдельную семантическую лексему. Т.е. не следует производить деление этой пары, прилагательное всегда будет выступать характеристикой существительного, а значит, будет являться его составной частью. |
В высказывании “Вычислительная техника позволяет значительно упростить рутинные процессы за счет их автоматизации” Может быть выделена семантическая лексема “вычислительная техника” согласно изложенному правилу. Следует отметить, что пара “прилагательное-существительное”, рассматриваемое как семантическая лексема может быть расширена в процессе анализа высказывания. |
Продолжение таблицы 2.6
|
4. |
Использование глаголов |
Если в высказывании обнаружен глагол, то в семантической модели он должен быть рассмотрен как отношение между объектами. |
В выражении “SQL является стандартом запросов для баз данных” можно выделить глагол “является” и рассматривать его как связь между двумя объектами. После того, как обнаружен объект-глагол, требуется выполнить поиск объектов, которые можно выделить в семантически независимые блоки. Кроме этого, данное отношение нельзя считать окончательно определенным. В процессе анализа высказывания возможна ситуация, когда данное отношение возможно будет расширить или изменить и скорректировать вес соответствующего отношения. |
|
5. |
Главные и зависимые слова |
Если в высказывании существует некоторая пара слов, имеющих определенную связь, то в этой паре обязательно будет присутствовать главное и зависимое слово |
Продолжение таблицы 2.6
|
6. |
Средства согласования слов |
Для согласования главного и зависимого слова могут применяться ряд механизмов, которые обычно определяют в рамках контекстно-независимых численных кодов, направленных на анализ данных грамматического характера |
|
|
7. |
Цепочки зависимости |
Для главного слова в грамматической модели предложения могут быть определены не только зависимые от него слова. Это слово само может зависеть от других. Таким образом, для грамматической модели возможно составления цепочек зависимости |
Продолжение таблицы 2.6
|
8. |
Правила согласований |
Согласование пар “прилагательное-существительное” возможно лишь в том случае, когда они имеют одинаковый род, число и падеж |
|
|
9. |
Единство согласований |
Если для двух слов в предложении уже определено правило согласование, то все другие правила можно не рассматривать. Т.е. Между любыми двумя словами в предложении может быть установлено не более чем одно соответствие. |
Если сформулировать это утверждение с точки зрения теории построения семантических моделей, то это значит, что между любыми двумя вершинами в графе, представляющем семантическую модель или ее фрагмент может существовать не более одного ребра |
В результате выполнения синтаксически-грамматического анализа строится дерево зависимостей согласно правилу (2.7).
В корне такого дерева располагается сказуемое, а в ветвях – синтаксические выражению, имеющие определенное отношение со сказуемым. Данное дерево имеет рекурсивно-ориентированную структуру.
На заключающем этапе работы данного алгоритма выполняется рекурсивный анализ полученного дерева, и выделяются условно-формализованные элементы, которые могут быть использованы при построении семантических моделей с использованием алгоритмов, изложенных в данной работе.
В большинстве случаев для лексического и синтаксического разбора может быть применена оптимизация, основанная на данных справочников в базах данных.
Для применения данного подхода предварительно должны быть сформированы словари частей речи языка, на котором представлен текст и для каждого элемента установлено соответствие с частью и ролью речи.
При анализе текстов на естественном языке, если удастся получить соответствующие элементу текста данных их БД, то необходимость в синтаксическом и лексическом разборе отсутствует, что позволит существенно сократить расходы процессорного времени и памяти.
Оптимизация на базе словаря должна всегда использоваться вместе с классическим лексическим и синтаксическим анализом, выявленные части речи естественного языка с достаточно высоким уровнем достоверности должны помещаться в словарь. Таким образом, возможно будет реализовать механизм самообучения системы лексического и синтаксического анализа. При получении новой информации в результате обучения системы должно обязательно включать этап привязки: должны быть установлены связи с объектами, полученными в результате разбора. В качестве таких связей следует использовать семантические связи между семантическими лексемами.
2.2.5 Выводы
Перед тем, как выполнять анализ семантических моделей необходимо предварительно их формально представить.
Для того чтобы получить условно формальное отображение текста, представленного на естественном языке на дискретное множество, предлагается использовать алгоритмы синтаксического и лексического анализа. Оптимизация алгоритма возможна за счет применения словарей.
После выполнения формализации материалов, представленных на естественном языке, их возможно представить в виде некоторого составного семантического объекта. Алгоритмы для выполнения этой операции представлены в данном разделе.
Для того чтобы выполнять анализ семантических моделей текстов, требуется предварительно выделить основной смысл текстов. Для этого в работе предлагается использовать алгоритм, основанный на алгоритме выделения компонент графа.
РАЗДЕЛ 3
Алгоритмы, используемые для установления факта заимствований при семантическом анализе
В данной работе семантический анализ базируется на ряде алгоритмов, имеющих классическую природу, но адаптированных и оптимизированных для решения задачи семантического анализа текстов, представленных на естественных языках и установления факта заимствования текстов из публичных источников.
3.1. Анализ изоморфности графов
Для того, чтобы устанавливать факт наличия заимствования материалов из публичных источников, может оказаться эффективным метод анализа семантических моделей текстов, представленных на естественном языке.
Задача сравнения семантических моделей близка по характеру к задаче установления изоморфности графов, но имеет ряд специфических особенностей.
В классической теории графов задача установления изоморфности является NP-полной, то есть, не может быть выполнена за полиномиальное время, хотя строгого доказательства того, что задача не может быть решена полиноминальным алгоритмом, не существует. Решение данной проблемы является весьма перспективным направлением, поскольку задача установления изоморфности может очень широко использоваться во многих прикладных направлениях.
Формально изоморфность графов определяется следующим образом:
Если существует 2 различных графа и возможно изменить нумерацию вершин таким образом, чтобы эти графы стали эквивалентными, то эти два графа называются изоморфными.
Некоторым образом оптимизировать алгоритм установления изоморфности возможно за счет применения механизма поиска с возвратом.
Суть алгоритма состоит в последовательном наложении (установлении соответствия) вершин одного графа на вершины другого таким образом, чтобы формируемые подмножества вершин в одном и другом графах имели одинаковые отношения смежности.
Оригинальный алгоритм позволяет установить факт изоморфности графов путем последовательного рекурсивного перебора вершин одного графа и попыток установить соответствие с вершинами другого графа.
Такой алгоритм является очень требовательным к вычислительным характеристикам компьютера, а именно – производительности процессора и объема оперативной памяти. Как правило, требуется выполнять проблемно-ориентированную оптимизацию вычислений. В исследованиях [11], посвященных алгоритмам установления изоморфности графов, приводятся аргументы в пользу того, что существенный выигрыш в производительности алгоритма в общем виде возможно получить только в случае применения оптимизации по следующим направлениям:
· Максимально избавиться от рекурсивных вызовов, так как такие вызовы потребляют значительную часть процессорного времени и не позволяют оптимизировать алгоритм по объему используемой оперативной памяти
· Использовать механизм “back tracking” (рекурсия с возвратом). Однако данный подход должен быть адаптирован для решения с использованием динамического программирования (в данном случае его основная цель – избавиться от рекурсии).
В данной работе при оптимизации алгоритма можно учитывать тот факт, что каждой вершине графа обязательно будет поставлено в соответствие определенное значение – семантическая лексема.
Однако, следует учитывать, что при использовании данного метода установление полного соответствия графа, представляющего связи между семантическими лексемами недостаточно, так как может оказаться допустимым использование родственных семантических понятий (например, использование синонимов или переводов).
Таким образом, в данной работе предполагается использовать следующий алгоритм установления степени изоморфности семантических моделей.
Обозначим графы как G1 и G2:
, (3.1)
представляющие собой множества вершин соответствующих графов.
Определим функцию
(3.2)
которая задает вес ребра между двумя вершинами из одного из множеств (1) с номерами i и j. Если между соответствующими вершинами ребро отсутствует (или присутствует по иному ориентированное ребро), то значение этой функции будет равно
Определим также функцию
(3.3)
которая задает длину кратчайшего пути между двумя вершинами из одного из множеств (3.1) с номерами i и j. Если между соответствующими вершинами путь отсутствует, то значение этой функции будет равно
Под кратчайшим путем в данном контексте понимается такое множество вершин
Определим функцию изоморфности двух подграфов PG1 и PG2, составленных из вершин, количество которых составляет |PG1| и |PG2| соответственно:
(3.4)
Шаг 1. Получить два графа, соответствующие семантическим моделям анализируемых текстов. Предполагается, что уже выполнено выделение основного смысла текстов, и семантические модели отражают именно основную смысловую нагрузку.
Шаг 2. Определить максимально допустимое время работы алгоритма (с).
Шаг 3. Определить предметную область в семантическом словаре по алгоритму выделения максимальной компоненты.
Шаг 4. Выделить из графа, представляющего собой семантическую модель исходного текста вершину, имеющую наибольший вес и максимальную степень (количество исходящих ребер). Рассчитать ее индексное значение, исходя из определения (3.5), по формуле:
, (3.5)
где
- степень значимости веса вершины,
- степень значимости связности графа
Степени значимости определяются исходя из того насколько семантический словарь и модель являются полными и связными. Если семантический словарь содержит достаточный объем материалов, позволяющих определить степень заимствования с высокой долей вероятности, и, как следствие, в семантическом словаре присутствует большое количество связей, то и в исходном тексте необходимо определять в качестве исходной такую вершину, которая связана с наибольшим количеством семантических лексем. Это означает, что значение должно быть достаточно большим.
Самым идеальным вариантом (когда следует принимать значение
В общем случае для их анализа потребуется применять механизмы длинной арифметики, однако в данной работе предполагается, что все значения весов ребер будут находиться в диапазонах стандартных типов данных. В данной работе рекомендуется для этих целей применять вычислительную технику с 64-разрядной архитектурой.
Если для определения типа связи ребра будет использоваться тип данных
unsigned __int64,
то это позволит закодировать до 2^64 – 1 типов ребер, что достаточно для задачи анализа заимствований.
Если существует семантический словарь, который представлен графом с высоким значением связности, то вероятность успешного определения факта заимствования материалов достаточно высока, но сложность алгоритма установления изоморфности двух графов прямопропорциональна показателю степени связности графа. Например, если будут рассматриваться два полных графа, то задача определения изоморфности будет сведена к задаче полного перебора, что составил сложность соответствующего алгоритма
O(n) = n!
При том объеме данных, которые будут участвовать в процессе определения факта заимствования, данная сложность алгоритма не может считаться приемлемой. В таком случае подграф графа словаря семантической модели будет ограничиваться не только предметной областью, но и объемами, которые следует определять исходя из значения, определенного на Шаге 2.
Если объем данных в семантическом словаре незначительный, то имеет смысл наиболее точно определять степень согласованности предметных областей, т.е. максимизировать параметр
В случае, если никакой дополнительной информации о характере графа, представляющего собой семантическую модель словаря и семантической модели рассматриваемого текста на естественном языке нет, то эти коэффициенты следует брать одинаковыми. В данной работе предлагается использовать коэффициент 0.5
Шаг 5. Найти вершину в графе, представляющем семантическую модель словаря, которая будет максимально похожа на ту, которая была определена на Шаге 4.
Схожесть вершин следует определять, сравнивая соответствующие индексы вершин, которые определяются согласно формуле (3.5)
Шаг 6. Вычислить степень изоморфности графов по формуле (3.4).
Пример.
Предположим, что существует некоторый семантический словарь, который представлен графом, изображенным на рис. 3.1
SHAPE \* MERGEFORMAT
|
Стол |
|
Стул |
|
Мебель |
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Красный цвет |
|
Red color |
|
Системы счисления |
|
Двоичная |
|
Восьмеричная |
|
Шестнадцатеричная |
|
bin |
|
hex |
|
oct |
Рис. 3.1. Пример семантического словаря
Предположим, что для анализа предоставлен следующий текст, представленный на естественном языке:
“Одним из типов звуковой аппаратуры являются усилители звуковых сигналов. В настоящий момент распространены два типа усилителей: транзисторные и ламповые”.
Соответствующая модель данного текста может быть представлена на рис. 3.1
|
Звуковая аппаратура |
|
Транзисторные |
|
Ламповые |
|
Усилители звуковых сигналов |
Рис. 3.2. Пример семантической модели текста
На этапе определения предметных областей будут определены компоненты исходного графа, представляющего собой семантический словарь. В соответствии с алгоритмом определения компонент графа, каждой вершине будет присвоено некоторое индексное значение.
Количество данных индексных значений будет соответствовать количеству компонент графа. Для всех вершин одной компоненты графа все значения индексов вершин будут одинаковыми.
Схематическое представление графа с проставленными компонентными индексами представлено на рис. 3.3
SHAPE \* MERGEFORMAT
|
Стол |
|
Стул |
|
Мебель |
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Красный цвет |
|
Red color |
|
Системы счисления |
|
Двоичная |
|
Восьмеричная |
|
Шестнадцатиричная |
|
bin |
|
hex |
|
oct |
|
1 |
|
1 |
|
1 |
|
2 |
|
2 |
|
2 |
|
3 |
|
3 |
|
4 |
|
4 |
|
4 |
|
4 |
|
4 |
|
4 |
|
4 |
|
4 |
Рис. 3.3 Разделение графа на компоненты
Таким образом, граф, представляющий семантическую модель словаря, был разделен на 4 компоненты. Каждая компонента представляет собой информацию одной предметной области.
Далее следует определить предметную область, к которой можно отнести исходный текст на естественном языке. В качестве такой предметной области в данном случае следует использовать подграф с вершинами, пронумерованными индексом 2.
Таким образом, задача определения заимствования в данном случае может быть сведена к задаче установления семантической изоморфности двух графов, представленных на рис 3.4
SHAPE \* MERGEFORMAT
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Звуковая аппаратура |
Рис. 3.4. Графы, изоморфность которых следует установить
Для установления факта и степени изоморфности данных графов можно использовать алгоритм, суть которого изложена в данном разделе.
На Шаге 4 этого алгоритма требуется выделить стартовую вершину в каждом из графов согласно формуле (3.5). Для этого расчета потребуется определить два коэффициента и
Согласно рекомендациям, определим их значения равными 0,5.
Расчетная формула для данных графов будет выглядеть следующим образом:
(3.6)
Для удобства вершины в графах нумеруются, однако эти номера не являются весами соответствующих вершин.
Вершины приведенных графов можно пронумеровать так, как это показано на рис. 3.5
SHAPE \* MERGEFORMAT
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Звуковая аппаратура |
|
1 |
|
2 |
|
3 |
|
1 |
|
2 |
|
3 |
|
4 |
Рис. 3.5. Нумерация вершин графа
Расчет индексных вершин следует вести согласно формуле (3.6). Результаты этого расчета для приведенных графов указаны в таблицах 3.1 и 3.2.
Таблица 3.1
Расчет индексов вершин графа, представляющего семантическую модель исходного текста
|
Номер вершины |
Расчет |
Результат |
|
1 |
0.5 + 2/2 |
1.5 |
|
2 |
0.5 + 0/2 |
0.5 |
|
3 |
0.5 + 0/2 |
0.5 |
Таблица 3.2
Расчет индексов вершин графа, представляющего семантическую модель исходного текста
|
Номер вершины |
Расчет |
Результат |
|
1 |
0.5 + ½ |
1 |
|
2 |
0.5 + 2/2 |
1.5 |
|
3 |
0.5 + 0/2 |
0.5 |
|
4 |
0.5 + 0/2 |
0.5 |
Согласно проведенным расчетам стартовыми точками на первом шаге следует выбирать в графе, представляющем семантическую модель исходного текста, вершину, номер которой равен единице. Для графа, представляющего семантическую модель словаря, стартовой вершиной будет вершина с номером 2.
Задача следующего этапа целиком ориентированна на установление изоморфности этих графов и определение степени их соответствия.
Вычисление этих показателей следует вести, используя формулу (3.4) и максимизируя соответствующий параметр.
Предположим, что на первой итерации будет осуществлена попытка установки соответствия графов так, как это показано на рисунке 3. 6
SHAPE \* MERGEFORMAT
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Звуковая аппаратура |
|
1 |
|
2 |
|
3 |
|
1 |
|
2 |
|
3 |
|
4 |
Рис. 3.6. Первая итерация установления соответствия
На рисунке предполагаемые соответствия обозначены пунктиром.
В данном случае степень соответствия составит 1/3, поскольку совпала только одна вершина из трех (та, которая была выбрана в качестве стартовой). Анализируя текущий уровень соответствия можно существенно оптимизировать алгоритм таким образом, чтобы осуществлялся возврат на уровень вверх тогда, когда текущий уровень соответствия меньше заданного значения. С точки зрения реализации данный подход можно рассматривать как перебор с возвратом.
На второй итерации будет выполнена попытка установить соответствие графов таким образом, как это показано на рис. 3.7.
SHAPE \* MERGEFORMAT
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Усилители звуковых сигналов |
|
Ламповые |
|
Транзисторные |
|
Звуковая аппаратура |
|
1 |
|
2 |
|
3 |
|
1 |
|
2 |
|
3 |
|
4 |
Рис. 3.7. Вторая итерация установления соответствия
В результате выполнения данной итерации будет установлено, что значение уровня соответствия составляет 3/3 (совпали все вершины).
Решение задачи завершается расчетом максимального значения уровня соответствия по итерациям:
Z = max(1/3, 3/3) = 3/3 = 1
Таким образом установлено, что степень соответствия графов составляет 1, что говорит о том, что графы абсолютно семантически изоморфны, а значит имеет место абсолютное заимствование текста. Процент заимствования составит
Z*100 = 100%.
Данный пример не претендует на полноценную иллюстрацию работы алгоритма, он всего лишь показывает логику работы алгоритма. Одной из существенных деталей, которая в данном примере не рассматривалась, является то, что для ребер графов обязательно должно быть проставлено значение их весов. В примере было принято значение весов ребер равными 1, на практике же значение обычно определяется некоторым дробным числом, причем, чем точнее будет определено это значение, тем точнее будет определен результат степени соответствия, и тем эффективнее и оптимальнее будет работать алгоритм перебора с возвратом.
Кроме этого, следует обратить внимание на то, что степень соответствия будет зависеть не только от значения веса текущего ребра графа, а и от удаленности от стартовой вершины. Такой подход имеет две полезные особенности:
· Он более логично позволяет описать логику работы семантических моделей;
· Используя нити графа с весом, определяемым таким образом, возможно существенно оптимизировать работу алгоритма.
Если для графа
Определена функция весов ребер согласно (3.2)
определена исходная вершина и такие, что
|
(3.7) |
Функция и
Данное ограничение (3.7) определяет, что между вершинами и отсутствует прямое ребро (то есть они не являются инцидентными), но между ними существует конечный путь.
Предположим, что вершины и удовлетворяют ограничению (3.7) и существует множество
(3.8)
такое, что (3.8) представляет собой множество вершин, составляющих кратчайший путь.
Нить между вершинами и будет представлять собой некоторое абстрактное ребро, определяющее наличие непрямой связи между семантическими лексемами.
Весом нити между вершинами и будет являться значение, определяемое следующей формулой:
(3.9)
Пример.
Предположим, что существует некоторая семантическая модель, представленная графом, изображенным на рисунке 3.8.
Следует обратить внимание, что данная семантическая модель не отражает истинного смысла предметной области, это всего лишь пример, на котором возможно продемонстрировать использование оптимизации установления факта изоморфности графа с использованием нитей.
SHAPE \* MERGEFORMAT
|
Средства взаимодействия между вычислительными узлами |
|
Компьютерные сети |
|
Интернет |
|
Чаты и форумы |
|
0.8 |
|
0.765 |
|
0.3 |
Рис. 3.8. Семантическая модель, для которой предполагается использовать нити
Предположим, что требуется построить нить таким образом, как это показано на рисунке 3.9 (нить обозначена пунктиром)
SHAPE \* MERGEFORMAT
|
Средства взаимодействия между вычислительными узлами |
|
Компьютерные сети |
|
Интернет |
|
Чаты и форумы |
|
0.8 |
|
0.765 |
|
0.3 |
Рис. 3.9. Построение нити в семантической модели.
Вычисление веса нити следует вести согласно формуле (3.9), предварительно определив кратчайший путь.
Согласно формуле (3.9) вес нити будет определен следующим образом:
Таким образом, семантическая лексема «Чаты и форумы» имеет отношение к семантической лексеме «Средства взаимодействия между вычислительными узлами”. Степень этого отношения определяется уровнем 0.1836.
Использование нитей может оказаться очень эффективным инструментом при установлении факта изоморфности графов, однако перед их использованием следует выполнить ряд подготовительных действий.
Основная проблема при использовании нитей заключается в том, что возможна ситуация, когда в путь, являющийся промежуточным для данной нити, может попасть вершина, которая может быть сопоставлена другой вершине в сравниваемом графе, и тогда алгоритм установления факта изоморфности графов не будет работать корректно.
Таким образом, выделению в путь, который будет заменен нитью, подлежат только те вершины, индекс соответствия которых меньше предельно допустимого.
3.2. Анализ оптимальности алгоритма
В настоящий момент не существует формального алгоритма установления факта изоморфности графов, оценка которого имеет полиномиальный характер. Более того, гарантированное время, за которое анализ изоморфности будет выполнен составляет
O(n) = n!
Предположим, что имеется некоторая база документов в виде семантических моделей, объем которой:
· 18000 записей базового семантического словаря;
· 300000 документов, каждый их которых содержит 10000 семантических лексем
Эти численные данные взяты исходя из предварительного анализа базы документов referat.ru.
Объем данных в таком случае составит:
Вычислим приближенное значение факториала данного числа по формуле Стирлинга:
Вычисление значения выражения, соответствующего формуле Стирлинга в рамках данной работы вести не обязательно, достаточно отметить, что это значение будет значительно превосходить число
Если предположить, что процессор может выполнять 10000 миллионов операций в секунду, то процесс анализа будет соответствовать величине:
Безусловно, данное время не может считаться приемлемым для данной задачи, потому требуется выполнять ее оптимизацию.
В данной работе выделяются следующее методы повышения быстродействия алгоритма:
1. использование индексов глубины рекурсивного просмотра. Если индекс превышает максимально допустимый, то выполняется шаг назад;
2. Использование перебора с возвратом. Если на определенном этапе возможна на основе мультипликативного значения величин ребер установить, что в данном направлении просмотра установить факт изоморфности невозможно, то выполняется шаг назад;
3. Использование алгоритма выбора ключевых вершин, с которых будет выполняться просмотр;
4. Использование технологий внедрения нитей в граф.
Первый метод оптимизации позволить получить любое указанное разработчиком время работы алгоритма, однако качество результата прямопропорционально времени, которое выделяется для работы алгоритма. Под качеством работы алгоритма понимается соответствие полученных выводов о наличие заимствований истине. В данном методе индекс глубины просмотра определяется согласно вычислительным возможностям техники, на котором будет проводиться анализ.
Второй метод позволяет очень существенно оптимизировать время работы и память, необходимые для работы алгоритма: скорость работы может возрастать в десятки раз, а если исходный граф имеет слаборегулярную структуру, то может потребоваться объем времени, в сотни раз меньше, чем у оригинального алгоритма.
Данный подход может также использоваться при переходе к алгоритму, основанному на методах динамического программирования (с целью снятия проблем, возникающих при рекурсивных вызовах).
Очевидным недостатком данного метода является то, что невозможно предсказать реальное время работы алгоритма, то есть невозможно предугадать сколько раз будет выполнен шаг назад. Это не позволяет формально описать время работы алгоритма выражением, меньшим чем
O(n) = n!
Использование алгоритма выбора ключевых вершин позволяет (при комбинировании с алгоритмом поиска с возвратом) сократить сложность алгоритма в количество раз, соответствующему количеству ребер, исходящих из этой вершины.
Еще уменьшить время, требуемое на работу алгоритма возможно, если на каждом рекурсивном вызове формировать очередную ключевую вершину. В таком случае время работы будет уменьшаться по обратному экспоненциальному закону.
Технология внедрения нитей в граф может очень значительно оптимизировать алгоритм, приблизив его сложность к такой, какая является приемлемой для вычислительных способностей техники, на которой будет вестись анализ без существенной потери качества анализа текстов на наличие заимствований.
Оптимизация базируется на том, что некоторые вершины на определенном этапе анализа при просмотре графа игнорируются. Создается некоторое фиктивное ребро, вес которого рассчитывается согласно значениям весов между вершинами, которые предполагается извлечь из списка рассматриваемых.
Существенной проблемой при реализации алгоритма внедрения нитей в графы является сложность задачи построения списка вершин, которые возможно убрать из рассмотрения.
Предполагается, что данный алгоритм будет иметь реализацию элементов динамического программирования на динамической таблице, которая должна строиться на этапе формирования семантических моделей.
Значительного выигрыша в производительности возможно достичь, если использовать метод динамического комбинирования алгоритмов, т.е. выбор алгоритма, который на определенном этапе должен проводить просмотр графа исходя из анализа данных, полученных на предыдущих этапах.
Для обеспечения возможности динамического переключения между алгоритмами придется использовать дополнительные блоки памяти:
· Память для хранения данных по каждой вершине. Эти данные возможно сохранять в таблицах, описывающих графы. В качестве данных таблиц используются кубы, каждое измерение которых определяет тип данных. В качестве одного из измерений предлагается использовать данных, которые были получены при выполнении определенного алгоритма и каким-либо образом характеризуют вершину или связь с точки зрения этого алгоритма;
· Блок данных, являющихся результирующими для одного алгоритма и входными для другого
3.3. Выводы
Ключевым алгоритмом анализа текстов, представленных на естественном языке, на наличие заимствований является алгоритм сравнения семантических моделей.
В данной работе этот алгоритм реализован на базе классического алгоритма установления изоморфности графов, но использовалась проблемно-ориентированная модификация алгоритма.
При рассмотрении алгоритма было предложено использовать несколько вариантов оптимизаций, применимых в контексте данной работы.
РАЗДЕЛ 4
Реализация приложения
4.1. Обоснование выбора средств разработки
В качестве основного средства разработки проекта использовался язык программирования C# в среде разработки Microsoft Visual Studio 2005.
На выбор данного языка повлиял ряд факторов, среди которых:
· Поддержка Объектно-ориентированной парадигмы программирования. C# полноценно поддерживает данную парадигму и позволяет применять все характерные особенности данной технологии:
o Абстракция данных;
o Механизмы наследования;
o Средства обеспечения полиморфизма;
o Парадигма инкапсуляции
Механизмы объектно-ориентированных технологий позволяют создать логическую связь между разрабатываемыми объектами и обеспечить их взаимодействие между собой.
В данной работе присутствует множество логически-независимых и обособленных частей, при реализации которых потребуется организовать взаимодействие и организацию данных и инструкций согласно правилам объектно-ориентированного программирования.
· C# поддерживает ряд средств в рамках технологий объектно-ориентированного программирования, которые позволяют увеличить качество разрабатываемых продуктов и максимально эффективно использовать время, отведенное на разработку программного обеспечения. Среди них:
o Технология внешних псевдонимов (external aliases). Данная технология позволяет использовать различные сборки с одинаковыми пространствами имен как различные пространства имен. Это достигается за счет использования механизмов выделения глобальных пространств имен для сборок. Для этих целей объявляются внешние псевдонимы для каждой сборки. Далее эти псевдонимы возможно использовать как пространства имен высоко уровня;
o Возможность использования общих типов (Generics). Данный подход позволяет не указывать тип используемого параметра в процессе разработки, тем самым обеспечив возможность универсализировать процесс разработки. Данный механизм несколько схож с механизмом шаблонного программирования в C++;
o Возможность использования статических классов. Данные и инструкции статического класса загружаются один раз, а создать экземпляр данного класса невозможно;
o Разделение классов. Язык программирования C# позволяет разбить класс на несколько частей, используя идентификатор partial. Данный подход позволяет оптимальным образом структурировать исходный код приложения;
o Итераторы. Механизм итераторов позволяет удобно и эффективно выполнять обход элементов коллекций, что положительно сказывается на качестве исходного кода и производительности разрабатываемого приложения. Механизм итераторов позволяет максимально оптимизировать операции итеративного характера, что является весьма востребованным в данной работе, поскольку вычислительная сложность используемых алгоритмов очень высокая, а значит, следует искать пути максимально оптимизировать работу системы с точки зрения использования процессорного времени и системной памяти;
o Безымянные методы. Этот подход позволяет разработчику не указывать имена методов, а разрешить компилятору сгенерировать их автоматически. Такой подход позволяет сократить объем исходного кода приложения, тем самым повысив его читабельность и логическую упорядоченность;
o Документирование исходного кода в стандарте XML. C# позволяет каждый блок кода комментировать и документировать по правилам, принятым согласно стандарту оформления XML-кода. Такой подход позволяет разрабатывать структурную документацию по приложению прямо в процессе его разработки. Это позволит получать автоматически техническую документацию по коду в любом виде;
o В C# присутствует сборщик мусора (garbage collector), характерный для всех .NET – языков. C# также позволяет писать и неуправляемый код, в рамках блока небезопасного блока;
o В C# все объекты являются классами, что позволяет универсализировать и упростить процесс разработки;
o C# позволяет использовать очень удобный механизм – сериализацию классов, упаковывая и распаковывая классы в различных участках разрабатываемого приложения. На базе этой возможности возможно очень удобно строить распределенные вычисления, что также является актуальным для данной работы;
o В C# представлена концепция пространств имен, что позволяет иерархически структурировать исходный код приложения и избежать проблем с именованием;
· C# является полноценным .NET-языком, что позволяет использовать все достоинства данной технологии, среди которых:
o Технология компиляции “на лету” – Just in time (JIT). Данная технология позволяет разрабатывать код для виртуальной машины, а выполняться он будет с производительностью, близкой к выполнению native-кода;
o Данная технология позволяет использовать прозрачную связь между .NET-языками программирования;
o .NET является кроссплатформенной технологией, несмотря на то, что в настоящее время существует официальная реализация только для платформ Windows.
· Для C# существуют стандарты языка – ECMA-334 и ISO (ISO/IEC 23270:2003). Разрабатывая приложения, используя данные стандарты можно быть уверенным за то, что не возникнет проблем при компиляции и исполнении приложения;
В качестве хранилища данных в данной работе используется СУБД MS SQL Server 2005, поскольку эта СУБД оптимальным образом может использоваться совместно со средствами разработки Microsoft, а также позволяет работать с базами данных очень большого объема.
Также, одним из аргументов в пользу MS SQL Server 2005 в рамках данной работы является то, что данная СУБД поддерживает использование XML-схем данных, а значит, информация, представленная в виде RDF (формат RDF базируется на XML) может быть успешно интерпретирована средствами СУБД MS SQL Server 2005.
4.2. Программный комплекс
Информационная система представляет собой набор приложений, предназначенных для выполнения анализа текстов на заимствование, а также схем хранение об обработки данных.
4.2.1. Хранение данных.
Данные, представляющие собой семантические модели, хранятся в базе данных adb на базе сервера MS SQL Server 2005.
Схема данных представлена на рис. 4.1
Рис. 4.1. Схема хранения базы данных adb
Информация хранится в 5 таблицах, назначение которых приведено в таблице 4.1
Таблица 4.1
Назначение таблиц и полей в БД
|
N п/п |
Таблица |
Назначение таблицы |
Поля |
Назначение полей |
|
1. |
texts |
Хранение информации о проанализированных текстах |
text_id |
Уникальный идентификатор текста в таблице |
|
text |
Либо текст (если его объем не слишком большой), либо ссылка на место хранения текста |
|||
|
text_caption |
Заголовок текста |
|||
|
2. |
identities |
Сущности – семантические лексемы |
identity_id |
Уникальный номер семантической лексемы |
|
identity_name |
Семантическая лексема |
|||
|
identity_weight |
Вес лексемы |
|||
|
3. |
link_types |
Типы связей между семантическими лексемами |
link_id |
Уникальный номер типа семантической связи |
|
link_name |
Имя семантической связи |
Продолжение таблицы 4.1
|
4. |
links |
Семантические связи |
link_from |
Исходная семантическая лексема |
|
link_to |
Связанная семантическая лексема |
|||
|
link_weight |
Вес связи между двумя семантическими лексемами |
|||
|
link_type |
Тип семантической связи |
|||
|
5. |
text_identities |
Связи между текстами и семантическими лексемами |
text_id |
Ссылка на текст |
|
identity_id |
Ссылка на семантическую лексему |
В базе данных проставлены индексы по всем ключевым полям.
Предполагается, что сами тексты, анализ которых уже был выполнен, будут сохранены в отдельные файлы, а на эти файлы будут установлены связи со всеми семантическими лексемами, что позволит потом определить – из какого именно текста было выполнено заимствование.
Сама программная система состоит из нескольких независимых блоков:
· Система сбора информации с сервера Википедии с целью формирования стартового семантического словаря. Предполагается, что операция пополнения словаря будет выполняться регулярно. Это возможно сделать с использованием планировщика задач (например, Microsoft Scheduler) путем планирования запуска системы сбора информации. Система спроектирована в виде консольного приложения, что позволит пользоваться ей в автоматическом режиме;
· Система построения, анализа и редактирования семантических моделей. Данная система выполнена в виде приложения, позволяющего выполнять следующие действия:
o Выполнять анализ характеристик графа: связности, регулярности, средним величинам по весам из куба, характеризующим граф;
o Выполнять изменение характеристик семантических лексем – изменять показатели, поставленные в соответствие лексеме, изменять веса показателей, изменять значение семантических лексем;
o Создавать новые семантические лексемы, указав соответствующие характеристики;
o Выполнять изменение характеристик семантических связей – изменять показатели, поставленные в соответствие семантической связи, изменять веса и т.д.;
o Создавать новые семантические связи, определяя отношения между семантическими лексемами.
· Система анализа текстов на заимствование, позволяющая выполнять анализ на базе семантических технологий.
4.3 Система анализа текстов на заимствование
Данная система выполнена в виде набора классов, диаграмма которых представлена на рис. 4.2.
Рис. 4.2. Диаграмма классов системы анализа на заимствование
Описание классов системы представлено в таблице 4.2.
Таблица 4.2.
Описание классов системы выявления заимствований
|
N п/п |
Имя класса |
Назначение |
|
1. |
adbDataSet |
Средство для доступа к базе данных adb. |
|
2. |
CfileReader |
Класс для выполнения чтения данных из текстовых файлов |
|
3. |
CfileWriter |
Класс для выполнения записи данных в текстовые файлы |
|
4. |
Fmain |
Класс, в котором описаны характеристики и поведение элементов интерфейса, а также прописана логика работы системы |
Продолжение таблицы 4.2
|
5. |
identitiesTableAdapter |
Средство типа TableAdapter для доступа данным семантических лексем |
|
6. |
linksTableAdapter |
Средство типа TableAdapter для доступа к данным семантических связей |
|
7. |
Program |
Элемент, с которого начинается выполнение приложение. Содержит инструкции по созданию элементов интерфейса и инициализации системы |
|
8. |
QueriesTableAdapter |
Средство типа TableAdapter, позволяющее выполнять запросы к данным семантических моделей |
|
9. |
Resources |
Класс, содержащий идентификацию ресурсов, используемых в системе |
|
10. |
Settings |
Класс, содержащий информацию о конфигурации системы |
|
11. |
Text_identitiesTableAdapter |
Средство типа TableAdapter для доступа к данным связей тестов и принадлежащих им семантическим лексемам |
|
12. |
TextsTableAdapter |
Средство типа TableAdapter для доступа к данным о проанализированных текстах |
Продолжение таблицы 4.2
|
13. |
Link_typesTableAdapter |
Средство типа TableAdapter для доступа к данным о типах семантических связей |
|
14. |
CStatistics |
Класс содержит только публичные поля (фактически является структурой), которые хранят данные о статистике ведения вычислений |
Все классы объявлены в рамках пространства имен app.
Классы CfileReader и CfileWriter являются статическими.
4.4 Тестирование системы
Тестирование системы выполнялось в соответствии с двумя подходами:
· Тестирование корректности работы логики работы системы;
· Нагрузочное тестирование;
· Тестирование модулей системы
4.4.1. Тестирование модулей системы (модульное тестирование)
Тестирование модулей системы выполнялось следующим образом:
· Для каждого метода класса, который потенциально может иметь блоки, работающее некорректно либо не соответствующие логике работы системы, формировался набор тестов, имеющих характер наиболее вероятных значений параметров, при которых будет работать система, а также набор граничных тестовых данных.
· Создавался экземпляр класса в рамках параллельно объявленного пространства имен;
· Выполнялось тестирование на данных, подготовленных на предыдущих шагах. Если выявлялось несоответствие, то модуль дорабатывался либо корректировались формальные ограничения на характер данных
4.4.2. Тестирование корректности работы логики системы
Тестирование корректности работы логики системы производилось в соотвествии с небольшим объемом данных, результат анализа которых в соотвествии в приведенными в работе алгоритмами заранее известен.
Тестировалась логика работы на текстах которые:
· целиком эквивалентны образцам;
· являются переводом на иностранный язык (предварительно заполнялся словарь соответствующими данными о правилах перевода конкретных выражений);
· некоторые слова заменены на синонимы
4.4.3. Нагрузочное тестирование
Нагрузочное тестирование проводилось на базе документов сервера referat.ru.
Тестирование представляло собой проверку корректности работы на больших объемах даннях.
В результате тестирование было выявлено, что:
· Вывод, полученный в результате анализа обычно соотвествовал реальному, однако степень заимствования не всегда соответствовала реальной. Это объясняется тем, что синтаксический и лексический разбор на сложных языковых конструкциях не всегда позволяет точно определить основное и зависимое слово в предложении
· Скорость работы системы не всегда была приемлемой. Это является еще одним аргументом в пользу того, что следует исследовать возможности оптимизации алгоритма установления изоморфности графов;
РАЗДЕЛ 5
Возможности развития проекта
Качество анализа текста с использованием механизмов семантических технологий, а также объем вычислительных ресурсов, затрачиваемых для выполнения анализа, в значительной степени зависит от алгоритмической базы, используемой в проекте. Соответственно, в качестве направления развития проекта в данной работе предполагается максимально оптимизировать алгоритмы, для выполнения которых требуется наибольший объем вычислительных ресурсов.
5.1. Формальное определение объектов семантической алгебры
В настоящий момент механизмы, предполагающие повсеместное использование технологий, реализующих механизмы нечеткого анализа материалов, представляемых человеком естественным для него образом, являются очень перспективными.
Подходы, предложенные в рамках теории анализа естественных объектов на базе семантических технологий, могут быть использованы практически во всех прикладных направлениях.
В настоящий момент наиболее развитым в этом плане процессом является попытка внедрения семантических сетей.
Для хранения данных, имеющих характер семантических моделей, существуют формально определенные правила и форматы, однако четкого формального набора правил, который позволил бы аналитически описывать поведение объектов семантического характера (в данной работе было принято решение называть эти правила и определения семантической алгеброй) на данный момент не существует, хотя при использовании семантических моделей в различных предметных областях и их связях формальные аналитические правила могут оказаться полезными.
Алгебра семантических объектов в основном основывается на элементах дискретной математики, преимущественно на теории графов, но имеет ряд существенных особенностей:
1. Задача анализа любых объектов естественной природы является, как правило, задачей нечеткого анализа. Для того чтобы обеспечить анализ моделей таких объектов потребуется во все элементы объектов включать дополнительные данные – предположительная степень соответствия оригиналу. Во всех алгоритмах и правилах, позволяющих делать определенные выводы, обязательно должны использоваться эти величины. Данный подход требует, чтобы классическая теория графов, которая предполагает, что ее объектам могут быть сопоставлены определенные значения – веса, была некоторым образом модифицирована.
2. В соответствии с классической теорией графов, представление объектов, имеющих графовую структуру, в вычислительной технике принято выполнять в виде:
a. матрицы смежности;
b. таблицы инцидентности
Оба этих представления строятся в виде матрицы, элементами которой являются веса вершин. Для представления структур семантического характера потребуется использовать более сложные структуры с большим числом измерений. В данной работе предлагается использовать для определения семантических моделей 3х-мерные кубы, которые строятся так, как это показано на рис. 5.1
|
|
|
Рис. 5.1. Многомерное представление графа
Если граф задан в виде матрицы A:
(5.1)
Тогда величина x характеризует k-ый вес ребра от вершины i к вершине j.
Если между вершинами i и j ребра не существует, то значение x принимается равным бесконечности.
В качестве измерений j могут использоваться различные показатели, например:
· Уровень соответствия значения вершины оригиналу;
· Уровень достоверности информации, представляемой связью;
· Уровень соответствия предметной области;
· Значения, вычисляемые на этапах работы алгоритмов – отдаленность от ключевой вершины, глубина рекурсии и др.
В данной работе величина k=2. Измерения определяют следующие параметры:
· Степень соответствия вершины оригиналу (для i=j);
· Степень соответствия связи оригиналу (для i<>j)
Следует отметить, что в случае использования данной схемы будут доступны дополнительные возможности анализа данных, представляющих семантическую модель на базе многомерного анализа, например, на базе технологии OLAP.
3. Алгоритмы классической теории графов могут быть применены, однако требуется их модификация с целью оптимизации объема требуемых вычислительных ресурсов.
5.2. Алгоритм лексического и грамматического разбора текстов
Задача корректной формализации является очень важной подзадачей при анализе текстов на наличие заимствований, поскольку если окажется, что текст формализован не корректно - то все выводы, сделанные на основе формальной модели нельзя считать достоверными.
Задача формализации текстов, представленных на естественном языке, решается на базе алгоритмов лексического и синтаксического анализа. Целью данного анализа является выявление пар выражений, представляющих собой зависящее и основное выражение. На основе выявления этих пар и степени связи между ними формируется формальная модель текстов.
Технически алгоритмы лексического и синтаксического разбора очень похожи на те, которые используются в системах автоматизированного перевода.
В данной работе основа лексического и синтаксического разбора базируется на элементах теории разбора славянских языков Карпова.
Оптимизация работы алгоритма, а также улучшение качества его работы возможно за счет использования значительно большего количества правил разбора текстов согласно теории Карпова.
Для улучшения качества разбора возможно также привлечение базы научной информации, имеющей отношение к филологическим наукам.
Функциональность системы может быть существенно расширена за счет применения механизмов разбора нескольких языковых групп.
5.3. Алгоритмы установления факта изоморфности графов
Задача оптимизации работы алгоритмов, имеющих характер, схожий с задачей анализа изоморфности является актуальной не только для задачи автоматизированного осмысленного анализа текстов, представленных на естественных языках. Результаты оптимизации могут быть использованы также в очень большом количестве прикладных направлений.
С точки зрения алгоритмов семантического анализа текстов, представленных на естественном языке, наиболее критичным ресурсом является процессорное время.
Классическое алгоритмы анализа изоморфности имеют оценку алгоритма, представленную в виде очень быстрорастущих функций, что в значительной степени ограничивает возможность их применения при анализе данных большого объема.
Существуют определенные улучшения данного алгоритма, которые позволят оптимизировать его, если заранее известен характер анализируемых данных, однако в общем случае сложность алгоритма все равно эквивалентна сложности алгоритмов полного перебора.
В рамках данной работы существенно уменьшить время, требуемое на выполнения анализа возможно путем реализации проблемно-ориентированных оптимизаций, описанных в разделе, посвященном анализу изоморфности графов данной работы.
Наиболее оптимальный выигрыш в производительности возможно получить на базе алгоритма внедрения нитей в граф, однако разработка и реализация данного алгоритма представляет собой составной процесс и может рассматриваться в рамках отдельного исследования.
5.4. Оптимизация хранилищ данных
Поскольку работа предполагает использование достаточно больших объемов данных, то возможно выполнить значительную оптимизацию, если эффективно организовать процессы обмена данными между СУБД и приложением.
Одним из перспективных направлений в рамках данной работы может считаться использование средств XML-схем на базе системы управления базами данных Microsoft SQL Server 2005.
5.5. Параллелизация вычислительных процессов
Под параллелизаций в данной работе понимается возможность распределения ряда наиболее требовательных алгоритмов на несколько вычислительных узлов таким образом, чтобы процесс вычислений выполнялся одновременно на нескольких вычислительных узлах.
Среди основных вычислительных процессов, которые могут поддаваться эффективной параллелизации, можно выделить следующие:
1. Параллелизация хранилищ данных и средств их обработки. Предполагается, что информация, представленная в виде семантических моделей, и представляющая собой образцы предположительно оригинальных источников может быть разделена в рамках предметных областей. Информация, соответствующая определенной предметной области должна помещаться и обрабатываться на базе отдельного вычислительного узла;
2. Алгоритмы нечеткого выделения компонент графа могут быть рекурсивно распределены на несколько вычислительных узлов поблочно. Если одно из измерений куба, представляющего собой модель семантического характера, будет выделено для хранения информации о достижимости других узлов, то в таком случае процессы выделения максимальных компонент возможно запускать независимо друг от друга от вершин, имеющих разное значение индекса связности.
3. Алгоритмы определения изоморфности графов. Параллелизация данных алгоритмов возможна путем разделения вычислительных поток на несколько логических блоков:
a. Вычислительные блоки;
b. Блоки опережающего анализа
Вычислительные блоки разделяются по применяемым алгоритмам и выполняются, по возможности, параллельно на нескольких вычислительных узлах, а блоки опережающего анализа выполняют анализ характеристик фрагментов графов, которые должны быть рассмотрены в ближайшее время, выполняют их анализ с целью определения наиболее подходящей для данного фрагмента оптимизации алгоритма.
4. Формирование оптимальных схем анализа характеристик графа и выделения информации, используемой для выбора наиболее подходящих оптимизаций алгоритма.
5. Алгоритмы синтаксического и лексического разбора. Данная задача является очень хорошо параллезируемой, поскольку может быть разбита на несколько независимых блоков, анализ которых может выполняться параллельно на нескольких вычислительных узлах. В качестве таких блоков могут использоваться, например, предложения или абзацы исходного текста.
5.6. Выводы
В качестве основных возможностей развития проекта в данной работе выделяются исследования, направленные на оптимизацию алгоритмов, требующих наибольшее количество вычислительных ресурсов, а также расширение функциональности системы
ВЫВОДЫ
В ходе выполнения аттестационной работы магистра была исследована различные подходы к решению задачи анализа текстов на наличие заимствований, цитирований и плагиата. средства, позволяющие вести рассмотрение текста на базе моделей, представляющих собой форматизированные представления исходных текстов.
Среди рассмотренных методов были выделены:
1. Анализ экспертом в предметной области;
2. Анализ на базе релевантностей;
3. Анализ на базе систем семантического анализа
Было установлено, что метод поиска ключевых слов (метод релевантностей) является весьма эффективным, если предполагается, что текст, представленный на естественном языке, содержит фрагменты полного заимствования (т.е. элементы, которые были целиком скопированы из публичных источников).
Однако, если предполагается, что текст содержит элементы заимствования, но оригинал был модифицирован некоторым образом, и при этом смысловая нагрузка текста осталась неизменной или менялась незначительно, то в таком случае качество результатов, полученных после анализа на базе релевантностей, может оказаться неудовлетворительным.
В таком случае в данной работе предлагается использовать технологии, основанные на базе систем осмысленного анализа.
В системах осмысленного анализа предлагается перед выполнением анализа текстов предварительно формировать некоторую формальную модель этих текстов, отражающую их смысловую нагрузку, затем выделять основной смысл текстов, а затем выполнять сравнение этих моделей.
Для формализации текстов, представленных на естественном языке, используется лексический и синтаксический разбор по набору правил из теории разбора славянских языков Карпова.
Для получения основного смысла текста, представленного на естественном языке, используется механизм нечеткого выделения компонент графа, модифицированный с учетом особенностей решаемой проблемы.
Для установления факта заимствований используется модифицированный алгоритм установления изоморфности графов, для которого предполагается выполнять проблемно-ориентированные оптимизации.
В процессе выполнения работы был определен ряд правил и определений, применимых для оперирования с семантическими моделями. Совокупность этих правил и определений в данной работе было предложено назвать элементами семантической алгебры.
РЕКОМЕНДАЦИИ
Данная работа может быть использована везде, где задача осмысленного анализа текстов, представленных на естественном языке, с целью выявления заимствований является актуальной.
Элементы работы могут быть использованы при разработках и исследованиях направлений, имеющих отношение к анализу естественных сущностей на базе метода построения семантических моделей.
ПЕРЕЧЕНЬ ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ
1. Лебедев И. С. Принципы обработки естественно-языковых запросов в системах лингвистического обеспечения //Электронный журнал «Исследовано в России» http://zhurnal.ape.relarn.ru/articles/2004/157.pdf , 2005
2. Семантическая паутина http://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%BC%D0%B0%D0%BD%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BF%D0%B0%D1%83%D1%82%D0%B8%D0%BD%D0%B0
3. Бобровский С. Семантическая сеть и автономные агенты http://kis.pcweek.ru/Year2004/N24/CP1251/Strategy/chapt1.php
4. Тим Бернерс-Ли, Джеймс Хендлер и Ора Лассила. Семантическая Сеть. http://ezolin.pisem.net/logic/semantic_web_rus.php
5. Статья “Перспективы формирования Семантической Сети” http://www.semantictools.ru/conception/two_approach.shtml
6. Extensible Markup Language (XML) http://www.w3c.org/XML
7. Статья “Для нерадивых студентов настали тяжелые дни” http://www.mynews-in.net/news/society/2006/05/31/1033801.php
8. Краткое введение в RDF http://xmlhack.ru/texts/06/rdf-quickintro/rdf-quickintro.php
9. Козлов Д. Д. Информационно-поисковые системы в Internet: текущее состояние и пути развития. http://lvk.cs.msu.su/~ddk/ir_and_ia_review.pdf
10. Поиск в строках, массивах, последовательностях http://algolist.manual.ru/search/index.php
11. Пинчук В.П. Распознавание изоморфности графов: ПНВ-алгоритм
12. Типовая машина осмысленного поиска информации на основе модуля элементарного смысла http://www.intelpart.com/cip/cip-part1.php
13. Крысин Л. П. Автоматический перевод http://www.una-translations.ru/library/krysin.php
14. C Sharp http://ru.wikipedia.org/wiki/C_sharp
16. Углубление в C# http://www.gotdotnet.ru/LearnDotNet/CSharp/731.aspx
17. dev.net.ua: Українська Спільнота Розробникiв http://www.uneta.org/article.aspx?article=719A4A69-8390-483A-8478-A55F53AD1380
18. Статья “Факториал” http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D0%B0%D0%BB
19. Статья “Семантическая сеть сделает жизнь осмысленнее”. http://www.webplanet.ru/news/technology/2004/5/17/www2004_org.php
20. Статья “Что такое Semantic Web (SW)?” http://www.semantictools.ru/conception/about.shtml
21. Макаров В. В., Идентификация дублирования и плагиата в исходном тексте. –М.: Институт проблем управления РАН, 1999. – 456 с.
22. Манцивода А. В. Система метаописаний Dublin Core. http://teacode.com/concept/eor/dc.php
23. Технология автоматического анализа текстов http://www.analyst.ru/index.php?lang=eng&dir=content/tech/&id=wp&subid=1
24. Изоморфизм графов http://ric.uni-altai.ru/Fundamental/pascal3/lab7/teor7-4.php
25. Изоморфизм http://khpi-iip.mipk.kharkiv.edu/library/datastr/book_sod/kgsu/din_0117.php
26. Методы доказательства изоморфности и неизоморфности графов http://mathmod.bmstu.ru/Docs/Eduwork/dm_iu4_s4.pdf
27. Кристофидес Н. Теория графов. Алгоритмический подход. –М.:Мир, 1978. – 432 с.
28. Ахо А., Хопкрофт Дж., Ульман Дж. Построение и анализ вычислительных алгоритмов. М.:Мир 1979, –536 с.
29. Свами М., Тхуласираман К. Графы, сети и алгоритмы. М.:Мир 1984, –454 с.
30. Березина Л. Ю. Графы и их применение. – М.: Прсвещение, 1979, –154 с.
31. Берж К. Теория графов и ее применения. –М.: ИЛ. 1962, –412 c.
32. Оре О. Теория графовю. –М.: Наука, 1980, –200 с.
33. Уилсон Р. Введение в теорию графов. –М.: Мир, 1977, -212 с.
34. Харари Ф. Теория графов. – М.:Мир, 1973, –312 с.
35. Ху Т. Целочисленное программирование и потоки в сетях. – М.:Мир, 1974, –301 с.
36. Цой С., Цхай С. М. Прикладная теория графов. – Алма-Ата: Наука, 1971, –234 с.
37. Вычисление компонент связности http://khpi-iip.mipk.kharkiv.edu/library/datastr/book_sod/kgsu/din_0105.php
38. Связность. Достижимость в графах. http://infolimp.h15.ru/_g4.php
39. Описание алгоритма визуализатора "Поиск сильно связных компонент в ориентированном графе" http://rain.ifmo.ru/~orybak/scc/doc/SearchScc-Algorithm.php
40. Асанов М. О., Баранский В. А., Расин В. В. Дискретная математика: графы, матроиды, алгоритмы. – М.: Просвещение, 1995, –413 с.
41. Седжвик Р. Фундаментальные алгоритмы на C++. Часть 5: Алгоритмы на графах.
42. Павловская Т. А.. C#. Программирование на языке высокого уровня. - Питер, 2007, 463 с.
43. Jon Jagger, John Sharp "Microsoft Visual C# .NET Step by Step--Version 2003"
44. Каленик А. Использование новых возможностей Microsoft SQL Server 2005. - Питер, 2006, 344 с.
45. Жилинский А. А. Самоучитель Microsoft SQL Server 2005. BHV, 2007 http://e-books.com/index.php?entry=721&code=136&lang=ru
46. Rick Sawtell, Joseph Jorden, Lance Mortensen "MCSA / MCSE / MCDBA: SQL Server 2000 Administration: Study Guide, - SYBEX Inc, 2003, 415 c.
47. От Нестора до Фонвизина. Новые методы определения авторства. М.: Издат. группа "Прогресс", 1994, 142 с.
48. Фукс В. По всем правилам искусства (точные методы в исследованиях литературы, музыки и изобразительного искусства). Искусство и ЭВМ. М.:"Мир", 1975, 201 с.
49. Иванчегло C. “Методы выявления плагиата в программировании” http://www.kv.by/index2000491105.php
50. Colin J. Neill, Ganesh Shanmuganthan. A Web-Enabled Plagiarism Detection Tool. IEEE IT Pro, September/October 2004. перевод: Колин Нейл, Ганеш Шанмагантан. Web-инструмент для выявления плагиата. // Открытые системы, – № 1, –2005, –с.40-44.
ПРИЛОЖЕНИЯ
ПРИЛОЖЕНИЕ А
Исходный текст CDocumentParser.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace parser
{
abstract class CDocumentParser
{
/// <summary>
/// Определяет, совместим ли формат данного файла
/// для разбора данным парсером
/// </summary>
/// <param name="filename">Имя проверяемого файла</param>
/// <returns></returns>
public abstract bool is_format_compatible(string filename);
/// <summary>
/// Разобранный текст
/// </summary>
public string text = null;
/// <summary>
/// Выполняет разбор файла. Результат помещает в this.text
/// </summary>
/// <param name="filename">Имя файла для разбора</param>
public abstract void parse_file(string filename);
/// <summary>
/// Готовит sql-скрипт для вставки разобранной информации в БД
/// </summary>
/// <returns>SQL-скрипт</returns>
public abstract string generate_sql_script();
}
}
Приложение Б
Исходный текст CWordDocumentParser.cs
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office;
using System.IO;
using System.Reflection;
namespace parser
{
class CWordDocumentParser : CDocumentParser
{
public override void parse_file(string filename)
{
//проверяем, существует ли файл и соотвевтвует ли он формату
FileInfo fi = new FileInfo(filename);
if (!fi.Exists || !is_format_compatible(filename))
{
text = null;
return;
}
try
{
//Создаем приложение
Word.Application wa = new Word.ApplicationClass();
object FileNmae = filename;
object def_value = Missing.Value;
//Открываем документ
Word.Document wd = wa.Documents.Open(ref FileNmae, ref def_value,
ref def_value, ref def_value, ref def_value, ref def_value,
ref def_value, ref def_value, ref def_value, ref def_value,
ref def_value, ref def_value, ref def_value, ref def_value,
ref def_value);
//Получаем текст
this.text = wd.Content.Text;
//Закрываем приложение
wa.Quit(ref def_value, ref def_value, ref def_value);
}//try
catch
{
//Произошла какая-то ошибка
text = null;
return;
}
}//public override void parse_file(..)
public override bool is_format_compatible(string filename)
{
filename = filename.ToLower();
//Проверим расширение
if (filename.IndexOf(".doc") < 0) return false;
return true;
}
public override string generate_sql_script()
{
return null;
}
}
}
Приложение В
Исходный текст CWebDocument.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.IO;
namespace dictionary
{
class CWebData
{
private HttpWebRequest request;
private HttpWebResponse response;
private Stream inet_stream;
public string get_web_page(string url)
{
//Отправляем запрос
request = (HttpWebRequest)WebRequest.Create(url);
//Получаем ответи от WEB-сервера
response = (HttpWebResponse)request.GetResponse();
//Получаем поток из ответа сервера
inet_stream = response.GetResponseStream();
//Тут будем хранить результат, полученный со страницы
string result = "";
//Получаем данные из потока
int c = 0;
while ((c = inet_stream.ReadByte()) != -1)
result += (char)c;
return result;
}//get_web_page
}//class
}
Приложение Г
Исходный код CFileReader.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace dictionary
{
static class CFileReader
{
/// <summary>
/// Чиатет весь файл в строку
/// </summary>
/// <param name="filename">Имя файла</param>
/// <returns>Строка, содержащая данные из файла</returns>
static public string ReadFile(string filename)
{
StreamReader Reader = new StreamReader(filename);
string result = "";
string tmp = "";
while ((tmp = Reader.ReadLine()) != null)
result += (tmp + '\n');
Reader.Close();
return result;
}
/// <summary>
/// Чиатает в строку нужную линию из файла
/// </summary>
/// <param name="filename">Имя файла</param>
/// <param name="lineNo">Номер строки, начиная с 0</param>
/// <returns>Прочитанную строку или null, если строка не найдена</returns>
static public string ReadFile(string filename, int lineNo)
{
StreamReader Reader = new StreamReader(filename);
string result = "";
string tmp;
//Добираемся до нужной строчки
for (int i = 0; i < lineNo; i++)
{
tmp = Reader.ReadLine();
if (tmp == null) //Нет больше строчек
{
Reader.Close();
return null;
}
}//for
result = Reader.ReadLine();
Reader.Close();
return result;
}
}
}
Приложение Д
Список ссылок “по буквам” Викисловаря
Приложение E
Исходные коды приложений семантичсекого анализа
app.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
</configSections>
<connectionStrings>
<add name="app.Properties.Settings.adbConnectionString" connectionString="Data Source=E-ART-LAPTOP\SQLEXPRESS;Initial Catalog=adb;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>
adbDataDesigner.Designer
#pragma warning disable 1591
namespace app {
using System;
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[Serializable()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedDataSetSchema")]
[System.Xml.Serialization.XmlRootAttribute("adbDataSet")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.DataSet")]
public partial class adbDataSet : System.Data.DataSet {
private identitiesDataTable tableidentities;
private link_typesDataTable tablelink_types;
private linksDataTable tablelinks;
private text_identitiesDataTable tabletext_identities;
private textsDataTable tabletexts;
private System.Data.DataRelation relationlinks_link_types;
private System.Data.DataRelation relationlinks_link_types1;
private System.Data.SchemaSerializationMode _schemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public adbDataSet() {
this.BeginInit();
this.InitClass();
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
base.Tables.CollectionChanged += schemaChangedHandler;
base.Relations.CollectionChanged += schemaChangedHandler;
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected adbDataSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context, false) {
if ((this.IsBinarySerialized(info, context) == true)) {
this.InitVars(false);
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
this.Tables.CollectionChanged += schemaChangedHandler1;
this.Relations.CollectionChanged += schemaChangedHandler1;
return;
}
string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
if ((this.DetermineSchemaSerializationMode(info, context) == System.Data.SchemaSerializationMode.IncludeSchema)) {
System.Data.DataSet ds = new System.Data.DataSet();
ds.ReadXmlSchema(new System.Xml.XmlTextReader(new System.IO.StringReader(strSchema)));
if ((ds.Tables["identities"] != null)) {
base.Tables.Add(new identitiesDataTable(ds.Tables["identities"]));
}
if ((ds.Tables["link_types"] != null)) {
base.Tables.Add(new link_typesDataTable(ds.Tables["link_types"]));
}
if ((ds.Tables["links"] != null)) {
base.Tables.Add(new linksDataTable(ds.Tables["links"]));
}
if ((ds.Tables["text_identities"] != null)) {
base.Tables.Add(new text_identitiesDataTable(ds.Tables["text_identities"]));
}
if ((ds.Tables["texts"] != null)) {
base.Tables.Add(new textsDataTable(ds.Tables["texts"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
else {
this.ReadXmlSchema(new System.Xml.XmlTextReader(new System.IO.StringReader(strSchema)));
}
this.GetSerializationData(info, context);
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
base.Tables.CollectionChanged += schemaChangedHandler;
this.Relations.CollectionChanged += schemaChangedHandler;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public identitiesDataTable identities {
get {
return this.tableidentities;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public link_typesDataTable link_types {
get {
return this.tablelink_types;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public linksDataTable links {
get {
return this.tablelinks;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public text_identitiesDataTable text_identities {
get {
return this.tabletext_identities;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public textsDataTable texts {
get {
return this.tabletexts;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.BrowsableAttribute(true)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Visible)]
public override System.Data.SchemaSerializationMode SchemaSerializationMode {
get {
return this._schemaSerializationMode;
}
set {
this._schemaSerializationMode = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
public new System.Data.DataTableCollection Tables {
get {
return base.Tables;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
public new System.Data.DataRelationCollection Relations {
get {
return base.Relations;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void InitializeDerivedDataSet() {
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataSet Clone() {
adbDataSet cln = ((adbDataSet)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override bool ShouldSerializeTables() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override bool ShouldSerializeRelations() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void ReadXmlSerializable(System.Xml.XmlReader reader) {
if ((this.DetermineSchemaSerializationMode(reader) == System.Data.SchemaSerializationMode.IncludeSchema)) {
this.Reset();
System.Data.DataSet ds = new System.Data.DataSet();
ds.ReadXml(reader);
if ((ds.Tables["identities"] != null)) {
base.Tables.Add(new identitiesDataTable(ds.Tables["identities"]));
}
if ((ds.Tables["link_types"] != null)) {
base.Tables.Add(new link_typesDataTable(ds.Tables["link_types"]));
}
if ((ds.Tables["links"] != null)) {
base.Tables.Add(new linksDataTable(ds.Tables["links"]));
}
if ((ds.Tables["text_identities"] != null)) {
base.Tables.Add(new text_identitiesDataTable(ds.Tables["text_identities"]));
}
if ((ds.Tables["texts"] != null)) {
base.Tables.Add(new textsDataTable(ds.Tables["texts"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
else {
this.ReadXml(reader);
this.InitVars();
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
System.IO.MemoryStream stream = new System.IO.MemoryStream();
this.WriteXmlSchema(new System.Xml.XmlTextWriter(stream, null));
stream.Position = 0;
return System.Xml.Schema.XmlSchema.Read(new System.Xml.XmlTextReader(stream), null);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.InitVars(true);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars(bool initTable) {
this.tableidentities = ((identitiesDataTable)(base.Tables["identities"]));
if ((initTable == true)) {
if ((this.tableidentities != null)) {
this.tableidentities.InitVars();
}
}
this.tablelink_types = ((link_typesDataTable)(base.Tables["link_types"]));
if ((initTable == true)) {
if ((this.tablelink_types != null)) {
this.tablelink_types.InitVars();
}
}
this.tablelinks = ((linksDataTable)(base.Tables["links"]));
if ((initTable == true)) {
if ((this.tablelinks != null)) {
this.tablelinks.InitVars();
}
}
this.tabletext_identities = ((text_identitiesDataTable)(base.Tables["text_identities"]));
if ((initTable == true)) {
if ((this.tabletext_identities != null)) {
this.tabletext_identities.InitVars();
}
}
this.tabletexts = ((textsDataTable)(base.Tables["texts"]));
if ((initTable == true)) {
if ((this.tabletexts != null)) {
this.tabletexts.InitVars();
}
}
this.relationlinks_link_types = this.Relations["links_link_types"];
this.relationlinks_link_types1 = this.Relations["links_link_types1"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.DataSetName = "adbDataSet";
this.Prefix = "";
this.Namespace = "http://tempuri.org/adbDataSet.xsd";
this.EnforceConstraints = true;
this.SchemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
this.tableidentities = new identitiesDataTable();
base.Tables.Add(this.tableidentities);
this.tablelink_types = new link_typesDataTable();
base.Tables.Add(this.tablelink_types);
this.tablelinks = new linksDataTable();
base.Tables.Add(this.tablelinks);
this.tabletext_identities = new text_identitiesDataTable();
base.Tables.Add(this.tabletext_identities);
this.tabletexts = new textsDataTable();
base.Tables.Add(this.tabletexts);
this.relationlinks_link_types = new System.Data.DataRelation("links_link_types", new System.Data.DataColumn[] {
this.tablelinks.link_fromColumn}, new System.Data.DataColumn[] {
this.tablelink_types.link_idColumn}, false);
this.Relations.Add(this.relationlinks_link_types);
this.relationlinks_link_types1 = new System.Data.DataRelation("links_link_types1", new System.Data.DataColumn[] {
this.tablelinks.link_toColumn}, new System.Data.DataColumn[] {
this.tablelink_types.link_idColumn}, false);
this.Relations.Add(this.relationlinks_link_types1);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializeidentities() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializelink_types() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializelinks() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializetext_identities() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializetexts() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
this.InitVars();
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs) {
adbDataSet ds = new adbDataSet();
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
return type;
}
public delegate void identitiesRowChangeEventHandler(object sender, identitiesRowChangeEvent e);
public delegate void link_typesRowChangeEventHandler(object sender, link_typesRowChangeEvent e);
public delegate void linksRowChangeEventHandler(object sender, linksRowChangeEvent e);
public delegate void text_identitiesRowChangeEventHandler(object sender, text_identitiesRowChangeEvent e);
public delegate void textsRowChangeEventHandler(object sender, textsRowChangeEvent e);
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class identitiesDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columnidentity_id;
private System.Data.DataColumn columnidentity_name;
private System.Data.DataColumn columnidentity_weight;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesDataTable() {
this.TableName = "identities";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal identitiesDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected identitiesDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_idColumn {
get {
return this.columnidentity_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_nameColumn {
get {
return this.columnidentity_name;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_weightColumn {
get {
return this.columnidentity_weight;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow this[int index] {
get {
return ((identitiesRow)(this.Rows[index]));
}
}
public event identitiesRowChangeEventHandler identitiesRowChanging;
public event identitiesRowChangeEventHandler identitiesRowChanged;
public event identitiesRowChangeEventHandler identitiesRowDeleting;
public event identitiesRowChangeEventHandler identitiesRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void AddidentitiesRow(identitiesRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow AddidentitiesRow(string identity_name, double identity_weight) {
identitiesRow rowidentitiesRow = ((identitiesRow)(this.NewRow()));
rowidentitiesRow.ItemArray = new object[] {
null,
identity_name,
identity_weight};
this.Rows.Add(rowidentitiesRow);
return rowidentitiesRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
identitiesDataTable cln = ((identitiesDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new identitiesDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columnidentity_id = base.Columns["identity_id"];
this.columnidentity_name = base.Columns["identity_name"];
this.columnidentity_weight = base.Columns["identity_weight"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columnidentity_id = new System.Data.DataColumn("identity_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_id);
this.columnidentity_name = new System.Data.DataColumn("identity_name", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_name);
this.columnidentity_weight = new System.Data.DataColumn("identity_weight", typeof(double), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_weight);
this.columnidentity_id.AutoIncrement = true;
this.columnidentity_id.AllowDBNull = false;
this.columnidentity_id.ReadOnly = true;
this.columnidentity_name.MaxLength = 2048;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow NewidentitiesRow() {
return ((identitiesRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new identitiesRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(identitiesRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.identitiesRowChanged != null)) {
this.identitiesRowChanged(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.identitiesRowChanging != null)) {
this.identitiesRowChanging(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.identitiesRowDeleted != null)) {
this.identitiesRowDeleted(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.identitiesRowDeleting != null)) {
this.identitiesRowDeleting(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void RemoveidentitiesRow(identitiesRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "identitiesDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class link_typesDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columnlink_id;
private System.Data.DataColumn columnlink_name;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesDataTable() {
this.TableName = "link_types";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal link_typesDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected link_typesDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_idColumn {
get {
return this.columnlink_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_nameColumn {
get {
return this.columnlink_name;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow this[int index] {
get {
return ((link_typesRow)(this.Rows[index]));
}
}
public event link_typesRowChangeEventHandler link_typesRowChanging;
public event link_typesRowChangeEventHandler link_typesRowChanged;
public event link_typesRowChangeEventHandler link_typesRowDeleting;
public event link_typesRowChangeEventHandler link_typesRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Addlink_typesRow(link_typesRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow Addlink_typesRow(string link_name) {
link_typesRow rowlink_typesRow = ((link_typesRow)(this.NewRow()));
rowlink_typesRow.ItemArray = new object[] {
null,
link_name};
this.Rows.Add(rowlink_typesRow);
return rowlink_typesRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
link_typesDataTable cln = ((link_typesDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new link_typesDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columnlink_id = base.Columns["link_id"];
this.columnlink_name = base.Columns["link_name"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columnlink_id = new System.Data.DataColumn("link_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_id);
this.columnlink_name = new System.Data.DataColumn("link_name", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_name);
this.columnlink_id.AutoIncrement = true;
this.columnlink_id.AllowDBNull = false;
this.columnlink_id.ReadOnly = true;
this.columnlink_name.AllowDBNull = false;
this.columnlink_name.MaxLength = 1024;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow Newlink_typesRow() {
return ((link_typesRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new link_typesRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(link_typesRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.link_typesRowChanged != null)) {
this.link_typesRowChanged(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.link_typesRowChanging != null)) {
this.link_typesRowChanging(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.link_typesRowDeleted != null)) {
this.link_typesRowDeleted(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.link_typesRowDeleting != null)) {
this.link_typesRowDeleting(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Removelink_typesRow(link_typesRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "link_typesDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class linksDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columnlink_from;
private System.Data.DataColumn columnlink_to;
private System.Data.DataColumn columnlink_weight;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksDataTable() {
this.TableName = "links";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal linksDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected linksDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_fromColumn {
get {
return this.columnlink_from;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_toColumn {
get {
return this.columnlink_to;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_weightColumn {
get {
return this.columnlink_weight;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow this[int index] {
get {
return ((linksRow)(this.Rows[index]));
}
}
public event linksRowChangeEventHandler linksRowChanging;
public event linksRowChangeEventHandler linksRowChanged;
public event linksRowChangeEventHandler linksRowDeleting;
public event linksRowChangeEventHandler linksRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void AddlinksRow(linksRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow AddlinksRow(int link_from, int link_to, double link_weight) {
linksRow rowlinksRow = ((linksRow)(this.NewRow()));
rowlinksRow.ItemArray = new object[] {
link_from,
link_to,
link_weight};
this.Rows.Add(rowlinksRow);
return rowlinksRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
linksDataTable cln = ((linksDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new linksDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columnlink_from = base.Columns["link_from"];
this.columnlink_to = base.Columns["link_to"];
this.columnlink_weight = base.Columns["link_weight"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columnlink_from = new System.Data.DataColumn("link_from", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_from);
this.columnlink_to = new System.Data.DataColumn("link_to", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_to);
this.columnlink_weight = new System.Data.DataColumn("link_weight", typeof(double), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_weight);
this.columnlink_from.AllowDBNull = false;
this.columnlink_to.AllowDBNull = false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow NewlinksRow() {
return ((linksRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new linksRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(linksRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.linksRowChanged != null)) {
this.linksRowChanged(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.linksRowChanging != null)) {
this.linksRowChanging(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.linksRowDeleted != null)) {
this.linksRowDeleted(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.linksRowDeleting != null)) {
this.linksRowDeleting(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void RemovelinksRow(linksRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "linksDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class text_identitiesDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columntext_id;
private System.Data.DataColumn columnidentity_id;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesDataTable() {
this.TableName = "text_identities";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal text_identitiesDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected text_identitiesDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn text_idColumn {
get {
return this.columntext_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_idColumn {
get {
return this.columnidentity_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow this[int index] {
get {
return ((text_identitiesRow)(this.Rows[index]));
}
}
public event text_identitiesRowChangeEventHandler text_identitiesRowChanging;
public event text_identitiesRowChangeEventHandler text_identitiesRowChanged;
public event text_identitiesRowChangeEventHandler text_identitiesRowDeleting;
public event text_identitiesRowChangeEventHandler text_identitiesRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Addtext_identitiesRow(text_identitiesRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow Addtext_identitiesRow(int text_id, int identity_id) {
text_identitiesRow rowtext_identitiesRow = ((text_identitiesRow)(this.NewRow()));
rowtext_identitiesRow.ItemArray = new object[] {
text_id,
identity_id};
this.Rows.Add(rowtext_identitiesRow);
return rowtext_identitiesRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
text_identitiesDataTable cln = ((text_identitiesDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new text_identitiesDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columntext_id = base.Columns["text_id"];
this.columnidentity_id = base.Columns["identity_id"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columntext_id = new System.Data.DataColumn("text_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext_id);
this.columnidentity_id = new System.Data.DataColumn("identity_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_id);
this.columntext_id.AllowDBNull = false;
this.columnidentity_id.AllowDBNull = false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow Newtext_identitiesRow() {
return ((text_identitiesRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new text_identitiesRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(text_identitiesRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.text_identitiesRowChanged != null)) {
this.text_identitiesRowChanged(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.text_identitiesRowChanging != null)) {
this.text_identitiesRowChanging(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.text_identitiesRowDeleted != null)) {
this.text_identitiesRowDeleted(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.text_identitiesRowDeleting != null)) {
this.text_identitiesRowDeleting(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Removetext_identitiesRow(text_identitiesRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "text_identitiesDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class textsDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columntext_id;
private System.Data.DataColumn columntext;
private System.Data.DataColumn columntext_caption;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsDataTable() {
this.TableName = "texts";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal textsDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected textsDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn text_idColumn {
get {
return this.columntext_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn textColumn {
get {
return this.columntext;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn text_captionColumn {
get {
return this.columntext_caption;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow this[int index] {
get {
return ((textsRow)(this.Rows[index]));
}
}
public event textsRowChangeEventHandler textsRowChanging;
public event textsRowChangeEventHandler textsRowChanged;
public event textsRowChangeEventHandler textsRowDeleting;
public event textsRowChangeEventHandler textsRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void AddtextsRow(textsRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow AddtextsRow(string text, string text_caption) {
textsRow rowtextsRow = ((textsRow)(this.NewRow()));
rowtextsRow.ItemArray = new object[] {
null,
text,
text_caption};
this.Rows.Add(rowtextsRow);
return rowtextsRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
textsDataTable cln = ((textsDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new textsDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columntext_id = base.Columns["text_id"];
this.columntext = base.Columns["text"];
this.columntext_caption = base.Columns["text_caption"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columntext_id = new System.Data.DataColumn("text_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext_id);
this.columntext = new System.Data.DataColumn("text", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext);
this.columntext_caption = new System.Data.DataColumn("text_caption", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext_caption);
this.columntext_id.AutoIncrement = true;
this.columntext_id.AllowDBNull = false;
this.columntext_id.ReadOnly = true;
this.columntext.MaxLength = 1073741823;
this.columntext_caption.MaxLength = 1024;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow NewtextsRow() {
return ((textsRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new textsRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(textsRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.textsRowChanged != null)) {
this.textsRowChanged(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.textsRowChanging != null)) {
this.textsRowChanging(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.textsRowDeleted != null)) {
this.textsRowDeleted(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.textsRowDeleting != null)) {
this.textsRowDeleting(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void RemovetextsRow(textsRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "textsDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class identitiesRow : System.Data.DataRow {
private identitiesDataTable tableidentities;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal identitiesRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tableidentities = ((identitiesDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int identity_id {
get {
return ((int)(this[this.tableidentities.identity_idColumn]));
}
set {
this[this.tableidentities.identity_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string identity_name {
get {
try {
return ((string)(this[this.tableidentities.identity_nameColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'identity_name\' in table \'identities\' is DBNull.", e);
}
}
set {
this[this.tableidentities.identity_nameColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public double identity_weight {
get {
try {
return ((double)(this[this.tableidentities.identity_weightColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'identity_weight\' in table \'identities\' is DBNull.", e);
}
}
set {
this[this.tableidentities.identity_weightColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Isidentity_nameNull() {
return this.IsNull(this.tableidentities.identity_nameColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Setidentity_nameNull() {
this[this.tableidentities.identity_nameColumn] = System.Convert.DBNull;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Isidentity_weightNull() {
return this.IsNull(this.tableidentities.identity_weightColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Setidentity_weightNull() {
this[this.tableidentities.identity_weightColumn] = System.Convert.DBNull;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class link_typesRow : System.Data.DataRow {
private link_typesDataTable tablelink_types;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal link_typesRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tablelink_types = ((link_typesDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int link_id {
get {
return ((int)(this[this.tablelink_types.link_idColumn]));
}
set {
this[this.tablelink_types.link_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string link_name {
get {
return ((string)(this[this.tablelink_types.link_nameColumn]));
}
set {
this[this.tablelink_types.link_nameColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow linksRow {
get {
return ((linksRow)(this.GetParentRow(this.Table.ParentRelations["links_link_types"])));
}
set {
this.SetParentRow(value, this.Table.ParentRelations["links_link_types"]);
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow linksRowBylinks_link_types1 {
get {
return ((linksRow)(this.GetParentRow(this.Table.ParentRelations["links_link_types1"])));
}
set {
this.SetParentRow(value, this.Table.ParentRelations["links_link_types1"]);
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class linksRow : System.Data.DataRow {
private linksDataTable tablelinks;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal linksRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tablelinks = ((linksDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int link_from {
get {
return ((int)(this[this.tablelinks.link_fromColumn]));
}
set {
this[this.tablelinks.link_fromColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int link_to {
get {
return ((int)(this[this.tablelinks.link_toColumn]));
}
set {
this[this.tablelinks.link_toColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public double link_weight {
get {
try {
return ((double)(this[this.tablelinks.link_weightColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'link_weight\' in table \'links\' is DBNull.", e);
}
}
set {
this[this.tablelinks.link_weightColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Islink_weightNull() {
return this.IsNull(this.tablelinks.link_weightColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Setlink_weightNull() {
this[this.tablelinks.link_weightColumn] = System.Convert.DBNull;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow[] Getlink_typesRows() {
return ((link_typesRow[])(base.GetChildRows(this.Table.ChildRelations["links_link_types"])));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow[] Getlink_typesRowsBylinks_link_types1() {
return ((link_typesRow[])(base.GetChildRows(this.Table.ChildRelations["links_link_types1"])));
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class text_identitiesRow : System.Data.DataRow {
private text_identitiesDataTable tabletext_identities;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal text_identitiesRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tabletext_identities = ((text_identitiesDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int text_id {
get {
return ((int)(this[this.tabletext_identities.text_idColumn]));
}
set {
this[this.tabletext_identities.text_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int identity_id {
get {
return ((int)(this[this.tabletext_identities.identity_idColumn]));
}
set {
this[this.tabletext_identities.identity_idColumn] = value;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class textsRow : System.Data.DataRow {
private textsDataTable tabletexts;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal textsRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tabletexts = ((textsDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int text_id {
get {
return ((int)(this[this.tabletexts.text_idColumn]));
}
set {
this[this.tabletexts.text_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string text {
get {
try {
return ((string)(this[this.tabletexts.textColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'text\' in table \'texts\' is DBNull.", e);
}
}
set {
this[this.tabletexts.textColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string text_caption {
get {
try {
return ((string)(this[this.tabletexts.text_captionColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'text_caption\' in table \'texts\' is DBNull.", e);
}
}
set {
this[this.tabletexts.text_captionColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool IstextNull() {
return this.IsNull(this.tabletexts.textColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void SettextNull() {
this[this.tabletexts.textColumn] = System.Convert.DBNull;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Istext_captionNull() {
return this.IsNull(this.tabletexts.text_captionColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Settext_captionNull() {
this[this.tabletexts.text_captionColumn] = System.Convert.DBNull;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class identitiesRowChangeEvent : System.EventArgs {
private identitiesRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRowChangeEvent(identitiesRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class link_typesRowChangeEvent : System.EventArgs {
private link_typesRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRowChangeEvent(link_typesRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class linksRowChangeEvent : System.EventArgs {
private linksRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRowChangeEvent(linksRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class text_identitiesRowChangeEvent : System.EventArgs {
private text_identitiesRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRowChangeEvent(text_identitiesRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class textsRowChangeEvent : System.EventArgs {
private textsRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRowChangeEvent(textsRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
}
}
namespace app.adbDataSetTableAdapters {
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.ComponentModel.DataObjectAttribute(true)]
[System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class identitiesTableAdapter : System.ComponentModel.Component {
private System.Data.SqlClient.SqlDataAdapter _adapter;
private System.Data.SqlClient.SqlConnection _connection;
private System.Data.SqlClient.SqlCommand[] _commandCollection;
private bool _clearBeforeFill;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesTableAdapter() {
this.ClearBeforeFill = true;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private System.Data.SqlClient.SqlDataAdapter Adapter {
get {
if ((this._adapter == null)) {
this.InitAdapter();
}
return this._adapter;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal System.Data.SqlClient.SqlConnection Connection {
get {
if ((this._connection == null)) {
this.InitConnection();
}
return this._connection;
}
set {
this._connection = value;
if ((this.Adapter.InsertCommand != null)) {
this.Adapter.InsertCommand.Connection = value;
}
if ((this.Adapter.DeleteCommand != null)) {
this.Adapter.DeleteCommand.Connection = value;
}
if ((this.Adapter.UpdateCommand != null)) {
this.Adapter.UpdateCommand.Connection = value;
}
for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
if ((this.CommandCollection[i] != null)) {
((System.Data.SqlClient.SqlCommand)(this.CommandCollection[i])).Connection = value;
}
}
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected System.Data.SqlClient.SqlCommand[] CommandCollection {
get {
if ((this._commandCollection == null)) {
this.InitCommandCollection();
}
return this._commandCollection;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool ClearBeforeFill {
get {
return this._clearBeforeFill;
}
set {
this._clearBeforeFill = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitAdapter() {
this._adapter = new System.Data.SqlClient.SqlDataAdapter();
System.Data.Common.DataTableMapping tableMapping = new System.Data.Common.DataTableMapping();
tableMapping.SourceTable = "Table";
tableMapping.DataSetTable = "identities";
tableMapping.ColumnMappings.Add("identity_id", "identity_id");
tableMapping.ColumnMappings.Add("identity_name", "identity_name");
tableMapping.ColumnMappings.Add("identity_weight", "identity_weight");
this._adapter.TableMappings.Add(tableMapping);
this._adapter.InsertCommand = new System.Data.SqlClient.SqlCommand();
this._adapter.InsertCommand.Connection = this.Connection;
this._adapter.InsertCommand.CommandText = "INSERT INTO [dbo].[identities] ([identity_name], [identity_weight]) VALUES (@iden" +
"tity_name, @identity_weight)";
this._adapter.InsertCommand.CommandType = System.Data.CommandType.Text;
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@identity_name", System.Data.SqlDbType.NChar, 0, System.Data.ParameterDirection.Input, 0, 0, "identity_name", System.Data.DataRowVersion.Current, false, null, "", "", ""));
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@identity_weight", System.Data.SqlDbType.Float, 0, System.Data.ParameterDirection.Input, 0, 0, "identity_weight", System.Data.DataRowVersion.Current, false, null, "", "", ""));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitConnection() {
this._connection = new System.Data.SqlClient.SqlConnection();
this._connection.ConnectionString = global::app.Properties.Settings.Default.adbConnectionString;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitCommandCollection() {
this._commandCollection = new System.Data.SqlClient.SqlCommand[1];
this._commandCollection[0] = new System.Data.SqlClient.SqlCommand();
this._commandCollection[0].Connection = this.Connection;
this._commandCollection[0].CommandText = "SELECT identity_id, identity_name, identity_weight FROM dbo.identities";
this._commandCollection[0].CommandType = System.Data.CommandType.Text;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Fill, true)]
public virtual int Fill(adbDataSet.identitiesDataTable dataTable) {
this.Adapter.SelectCommand = this.CommandCollection[0];
if ((this.ClearBeforeFill == true)) {
dataTable.Clear();
}
int returnValue = this.Adapter.Fill(dataTable);
return returnValue;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
public virtual adbDataSet.identitiesDataTable GetData() {
this.Adapter.SelectCommand = this.CommandCollection[0];
adbDataSet.identitiesDataTable dataTable = new adbDataSet.identitiesDataTable();
this.Adapter.Fill(dataTable);
return dataTable;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet.identitiesDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet dataSet) {
return this.Adapter.Update(dataSet, "identities");
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow dataRow) {
return this.Adapter.Update(new System.Data.DataRow[] {
dataRow});
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow[] dataRows) {
return this.Adapter.Update(dataRows);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Insert, true)]
public virtual int Insert(string identity_name, System.Nullable<double> identity_weight) {
if ((identity_name == null)) {
this.Adapter.InsertCommand.Parameters[0].Value = System.DBNull.Value;
}
else {
this.Adapter.InsertCommand.Parameters[0].Value = ((string)(identity_name));
}
if ((identity_weight.HasValue == true)) {
this.Adapter.InsertCommand.Parameters[1].Value = ((double)(identity_weight.Value));
}
else {
this.Adapter.InsertCommand.Parameters[1].Value = System.DBNull.Value;
}
System.Data.ConnectionState previousConnectionState = this.Adapter.InsertCommand.Connection.State;
if (((this.Adapter.InsertCommand.Connection.State & System.Data.ConnectionState.Open)
!= System.Data.ConnectionState.Open)) {
this.Adapter.InsertCommand.Connection.Open();
}
try {
int returnValue = this.Adapter.InsertCommand.ExecuteNonQuery();
return returnValue;
}
finally {
if ((previousConnectionState == System.Data.ConnectionState.Closed)) {
this.Adapter.InsertCommand.Connection.Close();
}
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.ComponentModel.DataObjectAttribute(true)]
[System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class link_typesTableAdapter : System.ComponentModel.Component {
private System.Data.SqlClient.SqlDataAdapter _adapter;
private System.Data.SqlClient.SqlConnection _connection;
private System.Data.SqlClient.SqlCommand[] _commandCollection;
private bool _clearBeforeFill;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesTableAdapter() {
this.ClearBeforeFill = true;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private System.Data.SqlClient.SqlDataAdapter Adapter {
get {
if ((this._adapter == null)) {
this.InitAdapter();
}
return this._adapter;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal System.Data.SqlClient.SqlConnection Connection {
get {
if ((this._connection == null)) {
this.InitConnection();
}
return this._connection;
}
set {
this._connection = value;
if ((this.Adapter.InsertCommand != null)) {
this.Adapter.InsertCommand.Connection = value;
}
if ((this.Adapter.DeleteCommand != null)) {
this.Adapter.DeleteCommand.Connection = value;
}
if ((this.Adapter.UpdateCommand != null)) {
this.Adapter.UpdateCommand.Connection = value;
}
for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
if ((this.CommandCollection[i] != null)) {
((System.Data.SqlClient.SqlCommand)(this.CommandCollection[i])).Connection = value;
}
}
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected System.Data.SqlClient.SqlCommand[] CommandCollection {
get {
if ((this._commandCollection == null)) {
this.InitCommandCollection();
}
return this._commandCollection;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool ClearBeforeFill {
get {
return this._clearBeforeFill;
}
set {
this._clearBeforeFill = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitAdapter() {
this._adapter = new System.Data.SqlClient.SqlDataAdapter();
System.Data.Common.DataTableMapping tableMapping = new System.Data.Common.DataTableMapping();
tableMapping.SourceTable = "Table";
tableMapping.DataSetTable = "link_types";
tableMapping.ColumnMappings.Add("link_id", "link_id");
tableMapping.ColumnMappings.Add("link_name", "link_name");
this._adapter.TableMappings.Add(tableMapping);
this._adapter.InsertCommand = new System.Data.SqlClient.SqlCommand();
this._adapter.InsertCommand.Connection = this.Connection;
this._adapter.InsertCommand.CommandText = "INSERT INTO [dbo].[link_types] ([link_name]) VALUES (@link_name)";
this._adapter.InsertCommand.CommandType = System.Data.CommandType.Text;
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@link_name", System.Data.SqlDbType.NChar, 0, System.Data.ParameterDirection.Input, 0, 0, "link_name", System.Data.DataRowVersion.Current, false, null, "", "", ""));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitConnection() {
this._connection = new System.Data.SqlClient.SqlConnection();
this._connection.ConnectionString = global::app.Properties.Settings.Default.adbConnectionString;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitCommandCollection() {
this._commandCollection = new System.Data.SqlClient.SqlCommand[1];
this._commandCollection[0] = new System.Data.SqlClient.SqlCommand();
this._commandCollection[0].Connection = this.Connection;
this._commandCollection[0].CommandText = "SELECT link_id, link_name FROM dbo.link_types";
this._commandCollection[0].CommandType = System.Data.CommandType.Text;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Fill, true)]
public virtual int Fill(adbDataSet.link_typesDataTable dataTable) {
this.Adapter.SelectCommand = this.CommandCollection[0];
if ((this.ClearBeforeFill == true)) {
dataTable.Clear();
}
int returnValue = this.Adapter.Fill(dataTable);
return returnValue;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
public virtual adbDataSet.link_typesDataTable GetData() {
this.Adapter.SelectCommand = this.CommandCollection[0];
adbDataSet.link_typesDataTable dataTable = new adbDataSet.link_typesDataTable();
this.Adapter.Fill(dataTable);
return dataTable;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet.link_typesDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet dataSet) {
return this.Adapter.Update(dataSet, "link_types");
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow dataRow) {
return this.Adapter.Update(new System.Data.DataRow[] {
dataRow});
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow[] dataRows) {
return this.Adapter.Update(dataRows);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Insert, true)]
public virtual int Insert(string link_name) {
if ((link_name == null)) {
throw new System.ArgumentNullException("link_name");
}
else {
this.Adapter.InsertCommand.Parameters[0].Value = ((string)(link_name));
}
System.Data.ConnectionState previousConnectionState = this.Adapter.InsertCommand.Connection.State;
if (((this.Adapter.InsertCommand.Connection.State & System.Data.ConnectionState.Open)
!= System.Data.ConnectionState.Open)) {
this.Adapter.InsertCommand.Connection.Open();
}
try {
int returnValue = this.Adapter.InsertCommand.ExecuteNonQuery();
return returnValue;
}
finally {
if ((previousConnectionState == System.Data.ConnectionState.Closed)) {
this.Adapter.InsertCommand.Connection.Close();
}
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.ComponentModel.DataObjectAttribute(true)]
[System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class linksTableAdapter : System.ComponentModel.Component {
private System.Data.SqlClient.SqlDataAdapter _adapter;
private System.Data.SqlClient.SqlConnection _connection;
private System.Data.SqlClient.SqlCommand[] _commandCollection;
private bool _clearBeforeFill;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksTableAdapter() {
this.ClearBeforeFill = true;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private System.Data.SqlClient.SqlDataAdapter Adapter {
get {
if ((this._adapter == null)) {
this.InitAdapter();
}
return this._adapter;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal System.Data.SqlClient.SqlConnection Connection {
get {
if ((this._connection == null)) {
this.InitConnection();
}
return this._connection;
}
set {
this._connection = value;
if ((this.Adapter.InsertCommand != null)) {
this.Adapter.InsertCommand.Connection = value;
}
if ((this.Adapter.DeleteCommand != null)) {
this.Adapter.DeleteCommand.Connection = value;
}
if ((this.Adapter.UpdateCommand != null)) {
this.Adapter.UpdateCommand.Connection = value;
}
for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
if ((this.CommandCollection[i] != null)) {
((System.Data.SqlClient.SqlCommand)(this.CommandCollection[i])).Connection = value;
}
}
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected System.Data.SqlClient.SqlCommand[] CommandCollection {
get {
if ((this._commandCollection == null)) {
this.InitCommandCollection();
}
return this._commandCollection;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool ClearBeforeFill {
get {
return this._clearBeforeFill;
}
set {
this._clearBeforeFill = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitAdapter() {
this._adapter = new System.Data.SqlClient.SqlDataAdapter();
System.Data.Common.DataTableMapping tableMapping = new System.Data.Common.DataTableMapping();
tableMapping.SourceTable = "Table";
tableMapping.DataSetTable = "links";
tableMapping.ColumnMappings.Add("link_from", "link_from");
tableMapping.ColumnMappings.Add("link_to", "link_to");
tableMapping.ColumnMappings.Add("link_weight", "link_weight");
this._adapter.TableMappings.Add(tableMapping);
this._adapter.InsertCommand = new System.Data.SqlClient.SqlCommand();
this._adapter.InsertCommand.Connection = this.Connection;
this._adapter.InsertCommand.CommandText = "INSERT INTO [dbo].[links] ([link_from], [link_to], [link_weight]) VALUES (@link_f" +
"rom, @link_to, @link_weight)";
this._adapter.InsertCommand.CommandType = System.Data.CommandType.Text;
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@link_from", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, 0, 0, "link_from", System.Data.DataRowVersion.Current, false, null, "", "", ""));
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@link_to", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, 0, 0, "link_to", System.Data.DataRowVersion.Current, false, null, "", "", ""));
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@link_weight", System.Data.SqlDbType.Float, 0, System.Data.ParameterDirection.Input, 0, 0, "link_weight", System.Data.DataRowVersion.Current, false, null, "", "", ""));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitConnection() {
this._connection = new System.Data.SqlClient.SqlConnection();
this._connection.ConnectionString = global::app.Properties.Settings.Default.adbConnectionString;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitCommandCollection() {
this._commandCollection = new System.Data.SqlClient.SqlCommand[1];
this._commandCollection[0] = new System.Data.SqlClient.SqlCommand();
this._commandCollection[0].Connection = this.Connection;
this._commandCollection[0].CommandText = "SELECT link_from, link_to, link_weight FROM dbo.links";
this._commandCollection[0].CommandType = System.Data.CommandType.Text;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Fill, true)]
public virtual int Fill(adbDataSet.linksDataTable dataTable) {
this.Adapter.SelectCommand = this.CommandCollection[0];
if ((this.ClearBeforeFill == true)) {
dataTable.Clear();
}
int returnValue = this.Adapter.Fill(dataTable);
return returnValue;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
public virtual adbDataSet.linksDataTable GetData() {
this.Adapter.SelectCommand = this.CommandCollection[0];
adbDataSet.linksDataTable dataTable = new adbDataSet.linksDataTable();
this.Adapter.Fill(dataTable);
return dataTable;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet.linksDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet dataSet) {
return this.Adapter.Update(dataSet, "links");
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow dataRow) {
return this.Adapter.Update(new System.Data.DataRow[] {
dataRow});
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow[] dataRows) {
return this.Adapter.Update(dataRows);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Insert, true)]
public virtual int Insert(int link_from, int link_to, System.Nullable<double> link_weight) {
this.Adapter.InsertCommand.Parameters[0].Value = ((int)(link_from));
this.Adapter.InsertCommand.Parameters[1].Value = ((int)(link_to));
if ((link_weight.HasValue == true)) {
this.Adapter.InsertCommand.Parameters[2].Value = ((double)(link_weight.Value));
}
else {
this.Adapter.InsertCommand.Parameters[2].Value = System.DBNull.Value;
}
System.Data.ConnectionState previousConnectionState = this.Adapter.InsertCommand.Connection.State;
if (((this.Adapter.InsertCommand.Connection.State & System.Data.ConnectionState.Open)
!= System.Data.ConnectionState.Open)) {
this.Adapter.InsertCommand.Connection.Open();
}
try {
int returnValue = this.Adapter.InsertCommand.ExecuteNonQuery();
return returnValue;
}
finally {
if ((previousConnectionState == System.Data.ConnectionState.Closed)) {
this.Adapter.InsertCommand.Connection.Close();
}
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.ComponentModel.DataObjectAttribute(true)]
[System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class text_identitiesTableAdapter : System.ComponentModel.Component {
private System.Data.SqlClient.SqlDataAdapter _adapter;
private System.Data.SqlClient.SqlConnection _connection;
private System.Data.SqlClient.SqlCommand[] _commandCollection;
private bool _clearBeforeFill;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesTableAdapter() {
this.ClearBeforeFill = true;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private System.Data.SqlClient.SqlDataAdapter Adapter {
get {
if ((this._adapter == null)) {
this.InitAdapter();
}
return this._adapter;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal System.Data.SqlClient.SqlConnection Connection {
get {
if ((this._connection == null)) {
this.InitConnection();
}
return this._connection;
}
set {
this._connection = value;
if ((this.Adapter.InsertCommand != null)) {
this.Adapter.InsertCommand.Connection = value;
}
if ((this.Adapter.DeleteCommand != null)) {
this.Adapter.DeleteCommand.Connection = value;
}
if ((this.Adapter.UpdateCommand != null)) {
this.Adapter.UpdateCommand.Connection = value;
}
for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
if ((this.CommandCollection[i] != null)) {
((System.Data.SqlClient.SqlCommand)(this.CommandCollection[i])).Connection = value;
}
}
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected System.Data.SqlClient.SqlCommand[] CommandCollection {
get {
if ((this._commandCollection == null)) {
this.InitCommandCollection();
}
return this._commandCollection;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool ClearBeforeFill {
get {
return this._clearBeforeFill;
}
set {
this._clearBeforeFill = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitAdapter() {
this._adapter = new System.Data.SqlClient.SqlDataAdapter();
System.Data.Common.DataTableMapping tableMapping = new System.Data.Common.DataTableMapping();
tableMapping.SourceTable = "Table";
tableMapping.DataSetTable = "text_identities";
tableMapping.ColumnMappings.Add("text_id", "text_id");
tableMapping.ColumnMappings.Add("identity_id", "identity_id");
this._adapter.TableMappings.Add(tableMapping);
this._adapter.InsertCommand = new System.Data.SqlClient.SqlCommand();
this._adapter.InsertCommand.Connection = this.Connection;
this._adapter.InsertCommand.CommandText = "INSERT INTO [dbo].[text_identities] ([text_id], [identity_id]) VALUES (@text_id, " +
"@identity_id)";
this._adapter.InsertCommand.CommandType = System.Data.CommandType.Text;
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@text_id", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, 0, 0, "text_id", System.Data.DataRowVersion.Current, false, null, "", "", ""));
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@identity_id", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, 0, 0, "identity_id", System.Data.DataRowVersion.Current, false, null, "", "", ""));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitConnection() {
this._connection = new System.Data.SqlClient.SqlConnection();
this._connection.ConnectionString = global::app.Properties.Settings.Default.adbConnectionString;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitCommandCollection() {
this._commandCollection = new System.Data.SqlClient.SqlCommand[1];
this._commandCollection[0] = new System.Data.SqlClient.SqlCommand();
this._commandCollection[0].Connection = this.Connection;
this._commandCollection[0].CommandText = "SELECT text_id, identity_id FROM dbo.text_identities";
this._commandCollection[0].CommandType = System.Data.CommandType.Text;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Fill, true)]
public virtual int Fill(adbDataSet.text_identitiesDataTable dataTable) {
this.Adapter.SelectCommand = this.CommandCollection[0];
if ((this.ClearBeforeFill == true)) {
dataTable.Clear();
}
int returnValue = this.Adapter.Fill(dataTable);
return returnValue;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
public virtual adbDataSet.text_identitiesDataTable GetData() {
this.Adapter.SelectCommand = this.CommandCollection[0];
adbDataSet.text_identitiesDataTable dataTable = new adbDataSet.text_identitiesDataTable();
this.Adapter.Fill(dataTable);
return dataTable;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet.text_identitiesDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet dataSet) {
return this.Adapter.Update(dataSet, "text_identities");
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow dataRow) {
return this.Adapter.Update(new System.Data.DataRow[] {
dataRow});
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow[] dataRows) {
return this.Adapter.Update(dataRows);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Insert, true)]
public virtual int Insert(int text_id, int identity_id) {
this.Adapter.InsertCommand.Parameters[0].Value = ((int)(text_id));
this.Adapter.InsertCommand.Parameters[1].Value = ((int)(identity_id));
System.Data.ConnectionState previousConnectionState = this.Adapter.InsertCommand.Connection.State;
if (((this.Adapter.InsertCommand.Connection.State & System.Data.ConnectionState.Open)
!= System.Data.ConnectionState.Open)) {
this.Adapter.InsertCommand.Connection.Open();
}
try {
int returnValue = this.Adapter.InsertCommand.ExecuteNonQuery();
return returnValue;
}
finally {
if ((previousConnectionState == System.Data.ConnectionState.Closed)) {
this.Adapter.InsertCommand.Connection.Close();
}
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.ComponentModel.DataObjectAttribute(true)]
[System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class textsTableAdapter : System.ComponentModel.Component {
private System.Data.SqlClient.SqlDataAdapter _adapter;
private System.Data.SqlClient.SqlConnection _connection;
private System.Data.SqlClient.SqlCommand[] _commandCollection;
private bool _clearBeforeFill;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsTableAdapter() {
this.ClearBeforeFill = true;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private System.Data.SqlClient.SqlDataAdapter Adapter {
get {
if ((this._adapter == null)) {
this.InitAdapter();
}
return this._adapter;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal System.Data.SqlClient.SqlConnection Connection {
get {
if ((this._connection == null)) {
this.InitConnection();
}
return this._connection;
}
set {
this._connection = value;
if ((this.Adapter.InsertCommand != null)) {
this.Adapter.InsertCommand.Connection = value;
}
if ((this.Adapter.DeleteCommand != null)) {
this.Adapter.DeleteCommand.Connection = value;
}
if ((this.Adapter.UpdateCommand != null)) {
this.Adapter.UpdateCommand.Connection = value;
}
for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
if ((this.CommandCollection[i] != null)) {
((System.Data.SqlClient.SqlCommand)(this.CommandCollection[i])).Connection = value;
}
}
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected System.Data.SqlClient.SqlCommand[] CommandCollection {
get {
if ((this._commandCollection == null)) {
this.InitCommandCollection();
}
return this._commandCollection;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool ClearBeforeFill {
get {
return this._clearBeforeFill;
}
set {
this._clearBeforeFill = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitAdapter() {
this._adapter = new System.Data.SqlClient.SqlDataAdapter();
System.Data.Common.DataTableMapping tableMapping = new System.Data.Common.DataTableMapping();
tableMapping.SourceTable = "Table";
tableMapping.DataSetTable = "texts";
tableMapping.ColumnMappings.Add("text_id", "text_id");
tableMapping.ColumnMappings.Add("text", "text");
tableMapping.ColumnMappings.Add("text_caption", "text_caption");
this._adapter.TableMappings.Add(tableMapping);
this._adapter.InsertCommand = new System.Data.SqlClient.SqlCommand();
this._adapter.InsertCommand.Connection = this.Connection;
this._adapter.InsertCommand.CommandText = "INSERT INTO [dbo].[texts] ([text], [text_caption]) VALUES (@text, @text_caption)";
this._adapter.InsertCommand.CommandType = System.Data.CommandType.Text;
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@text", System.Data.SqlDbType.NText, 0, System.Data.ParameterDirection.Input, 0, 0, "text", System.Data.DataRowVersion.Current, false, null, "", "", ""));
this._adapter.InsertCommand.Parameters.Add(new System.Data.SqlClient.SqlParameter("@text_caption", System.Data.SqlDbType.NChar, 0, System.Data.ParameterDirection.Input, 0, 0, "text_caption", System.Data.DataRowVersion.Current, false, null, "", "", ""));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitConnection() {
this._connection = new System.Data.SqlClient.SqlConnection();
this._connection.ConnectionString = global::app.Properties.Settings.Default.adbConnectionString;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitCommandCollection() {
this._commandCollection = new System.Data.SqlClient.SqlCommand[1];
this._commandCollection[0] = new System.Data.SqlClient.SqlCommand();
this._commandCollection[0].Connection = this.Connection;
this._commandCollection[0].CommandText = "SELECT text_id, text, text_caption FROM dbo.texts";
this._commandCollection[0].CommandType = System.Data.CommandType.Text;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Fill, true)]
public virtual int Fill(adbDataSet.textsDataTable dataTable) {
this.Adapter.SelectCommand = this.CommandCollection[0];
if ((this.ClearBeforeFill == true)) {
dataTable.Clear();
}
int returnValue = this.Adapter.Fill(dataTable);
return returnValue;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
public virtual adbDataSet.textsDataTable GetData() {
this.Adapter.SelectCommand = this.CommandCollection[0];
adbDataSet.textsDataTable dataTable = new adbDataSet.textsDataTable();
this.Adapter.Fill(dataTable);
return dataTable;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet.textsDataTable dataTable) {
return this.Adapter.Update(dataTable);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(adbDataSet dataSet) {
return this.Adapter.Update(dataSet, "texts");
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow dataRow) {
return this.Adapter.Update(new System.Data.DataRow[] {
dataRow});
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public virtual int Update(System.Data.DataRow[] dataRows) {
return this.Adapter.Update(dataRows);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Insert, true)]
public virtual int Insert(string text, string text_caption) {
if ((text == null)) {
this.Adapter.InsertCommand.Parameters[0].Value = System.DBNull.Value;
}
else {
this.Adapter.InsertCommand.Parameters[0].Value = ((string)(text));
}
if ((text_caption == null)) {
this.Adapter.InsertCommand.Parameters[1].Value = System.DBNull.Value;
}
else {
this.Adapter.InsertCommand.Parameters[1].Value = ((string)(text_caption));
}
System.Data.ConnectionState previousConnectionState = this.Adapter.InsertCommand.Connection.State;
if (((this.Adapter.InsertCommand.Connection.State & System.Data.ConnectionState.Open)
!= System.Data.ConnectionState.Open)) {
this.Adapter.InsertCommand.Connection.Open();
}
try {
int returnValue = this.Adapter.InsertCommand.ExecuteNonQuery();
return returnValue;
}
finally {
if ((previousConnectionState == System.Data.ConnectionState.Closed)) {
this.Adapter.InsertCommand.Connection.Close();
}
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.ComponentModel.DataObjectAttribute(true)]
[System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class QueriesTableAdapter : System.ComponentModel.Component {
private System.Data.IDbCommand[] _commandCollection;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected System.Data.IDbCommand[] CommandCollection {
get {
if ((this._commandCollection == null)) {
this.InitCommandCollection();
}
return this._commandCollection;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitCommandCollection() {
this._commandCollection = new System.Data.IDbCommand[1];
this._commandCollection[0] = new System.Data.SqlClient.SqlCommand();
((System.Data.SqlClient.SqlCommand)(this._commandCollection[0])).Connection = new System.Data.SqlClient.SqlConnection(global::app.Properties.Settings.Default.adbConnectionString);
((System.Data.SqlClient.SqlCommand)(this._commandCollection[0])).CommandText = "INSERT into texts(text, text_caption) values (:text, :text_caption)";
((System.Data.SqlClient.SqlCommand)(this._commandCollection[0])).CommandType = System.Data.CommandType.Text;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Insert, false)]
public virtual int SQLInsText() {
System.Data.SqlClient.SqlCommand command = ((System.Data.SqlClient.SqlCommand)(this.CommandCollection[0]));
System.Data.ConnectionState previousConnectionState = command.Connection.State;
if (((command.Connection.State & System.Data.ConnectionState.Open)
!= System.Data.ConnectionState.Open)) {
command.Connection.Open();
}
int returnValue;
try {
returnValue = command.ExecuteNonQuery();
}
finally {
if ((previousConnectionState == System.Data.ConnectionState.Closed)) {
command.Connection.Close();
}
}
return returnValue;
}
}
}
#pragma warning restore 1591
CFileReader
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace app
{
static class CFileReader
{
/// <summary>
/// ب᳥𡣥᪫ ࡱ /// </summary>
/// <param name="filename">ɬ��param>
/// <returns>Ҳ, ὠ塭 饠��returns>
static public string ReadFile(string filename)
{
StreamReader Reader = new StreamReader(filename);
string result = "";
string tmp = "";
while ((tmp = Reader.ReadLine()) != null)
result += (tmp + '\n');
Reader.Close();
return result;
}
/// <summary>
/// ب᳠氠ࡱ箳��᪫� /// </summary>
/// <param name="filename">ɬ��param>
/// <param name="lineNo">ή� 리 鮠�/param>
/// <returns>а︨�柮ull, 沫桱�㡭᪤殠</returns>
static public string ReadFile(string filename, int lineNo)
{
StreamReader Reader = new StreamReader(filename);
string result = "";
string tmp;
//Ů⩰졭�硱릍
for (int i = 0; i < lineNo; i++)
{
tmp = Reader.ReadLine();
if (tmp == null) //Υ𡢮콸㡱樍
{
Reader.Close();
return null;
}
}//for
result = Reader.ReadLine();
Reader.Close();
return result;
}
}
}
CFileWriter
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace app
{
static class CFileWriter
{
public static bool WriteToFile(string filename, string text)
{
StreamWriter f;
if (!File.Exists(filename))
{
try
{
f = File.CreateText(filename);
}
catch
{
return false;
}
}//if
else
{
try
{
f = new StreamWriter(filename, true);
}
catch
{
return false;
}
}//else
try
{
f.WriteLine(text);
}
catch
{
return false;
}
f.Close();
return true;
}
}
}
FMainDesigner.cs
namespace app
{
partial class FMain
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.richTextBox1 = new System.Windows.Forms.RichTextBox();
this.button1 = new System.Windows.Forms.Button();
this.label1 = new System.Windows.Forms.Label();
this.textBox1 = new System.Windows.Forms.TextBox();
this.SuspendLayout();
//
// richTextBox1
//
this.richTextBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.richTextBox1.Location = new System.Drawing.Point(1, 52);
this.richTextBox1.Name = "richTextBox1";
this.richTextBox1.Size = new System.Drawing.Size(576, 209);
this.richTextBox1.TabIndex = 0;
this.richTextBox1.Text = "";
//
// button1
//
this.button1.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
this.button1.Location = new System.Drawing.Point(184, 273);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(210, 25);
this.button1.TabIndex = 1;
this.button1.Text = "û�饢;
this.button1.UseVisualStyleBackColor = true;
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(-2, 4);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(98, 13);
this.label1.TabIndex = 2;
this.label1.Text = "Ƞ䯫衲櫱
//
// textBox1
//
this.textBox1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.textBox1.Location = new System.Drawing.Point(1, 20);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(576, 20);
this.textBox1.TabIndex = 3;
//
// FMain
//
this.AutoScaleDimensions = new
System.Drawing.SizeF(
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(578, 302);
this.Controls.Add(this.textBox1);
this.Controls.Add(this.label1);
this.Controls.Add(this.button1);
this.Controls.Add(this.richTextBox1);
this.Name = "FMain";
this.Text = "Text analizer";
this.ResumeLayout(false);
this.PerformLayout();
}
#endregion
private System.Windows.Forms.RichTextBox richTextBox1;
private System.Windows.Forms.Button button1;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.TextBox textBox1;
}
}
FResult.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.OleDb;
using System.Threading;
using System.IO;
namespace app
{
public partial class FResult : Form
{
/// <summary>
/// Ƞ䯫衲櫱 /// </summary>
public string caption;
/// <summary>
/// Ҡꡲ櫱눠 /// </summary>
public string source;
/// <summary>
/// ӳ𡢳崲 �鳼鮲鸥衪﮷殭�步
/// </summary>
private List<string> syntax_list = new List<string>();
/// <summary>
/// ӳ𡢳崲 �鳼歠�桧㡽즬殲� /// </summary>
private List<string> semantic_list = new List<string>();
/// <summary>
/// Ҩ�칬 믲ﱻ㡰ᨤ欿�鸥 ⬮릠ࡲ櫱 /// </summary>
private string separators = ".,:-()!?\"';";
/// <summary>
/// ު覬𐬿�Ჱ�拊 /// </summary>
private CStatistics statistics = new CStatistics();
public FResult()
{
InitializeComponent();
}
/// <summary>
/// Callback-
/// 嬿 , ���館吝ﲲ���ﳮ랠衽즬殲᪠鮲汴檱� /// </summary>
/// <param name="text"></param>
delegate void SetTextCallback(string text);
/// <summary>
/// Callback-
/// 嬿 , ���館吝ﲲ���ﳮ랠衽즬殲᪠鮲汴檱� /// </summary>
/// <param name="text"></param>
delegate void SetProgressRangeCallBack(int min, int max);
/// <summary>
/// Callback-
/// 嬿 , ���館吝ﲲ���ﳮ랠衽즬殲᪠鮲汴檱� /// </summary>
/// <param name="text"></param>
delegate void SetProgressIncCallBack(int value);
/// <summary>
/// Callback-
/// 嬿 , ���館吝ﲲ���ﳮ랠衽즬殲᪠鮲汴檱� /// </summary>
/// <param name="text"></param>
delegate void SetLogCallBack(string text);
/// <summary>
/// û𡨠𐩱�� � /// </summary>
/// <param name="text"></param>
private void WriteIntoText(string text)
{
if (this.TextOperation.InvokeRequired)
{
SetTextCallback d = new SetTextCallback(WriteIntoText);
this.Invoke(d, new object[] { text });
}
else
{
TextOperation.Text = text;
WriteIntoLog(text);
}//else
}
/// <summary>
/// û�ᰨ櫱 쯣
/// </summary>
/// <param name="text"></param>
private void WriteIntoLog(string text)
{
if (this.ProgressLog.InvokeRequired)
{
SetLogCallBack d = new SetLogCallBack(WriteIntoLog);
this.Invoke(d, new object[] { text });
}
else
{
ProgressLog.Text += text;
ProgressLog.Text += '\n';
}//else
}
/// <summary>
/// Ա㬨㡥𡤰ᮨ�콠progress
/// </summary>
/// <param name="min"></param>
/// <param name="max"></param>
private void SetProgressRange(int min, int max)
{
if (this.progress.InvokeRequired)
{
SetProgressRangeCallBack d = new SetProgressRangeCallBack(SetProgressRange);
this.Invoke(d, new object[] { min, max });
}
else
{
this.progress.Minimum = min;
this.progress.Maximum = max;
}//else
}
/// <summary>
/// Ԣ欨�氠讠�㟰rogress 1
/// </summary>
/// <param name="value"></param>
private void ProgressInc(int value)
{
if (this.progress.InvokeRequired)
{
SetProgressIncCallBack d = new SetProgressIncCallBack(ProgressInc);
this.Invoke(d, new object[] { value });
}
else
progress.Increment(value);
}
/// <summary>
/// Į𡲲 衯דּ���易�欨
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
private string prepare_string(string source)
{
string tmp = source;
//Ҩ�칬 믲ﱻ㡭� 㼰樿 ᬥ 桪﮶㋊ string symbols = " .,()!@#$%^&*_-\\|/";
bool flag = true;
while (flag)
{
flag = false;
for (int i = 0; i < symbols.Length; i++)
{
//û檠쩸 כּ Ḡ죍
while (tmp.IndexOf(symbols[i]) == 0)
{
tmp = tmp.Remove(0, 1);
flag = true;
}//while ' '
//û檠쩸 כּ ࡪ﮶㋊ while (tmp.IndexOf(symbols[i]) == tmp.Length)
{
tmp = tmp.Remove(tmp.Length, 1);
flag = true;
}//while ' '
}//for
}//while flag
//û檠壮ꮻ㡯칍
while (tmp.IndexOf(" ") >= 0)
{
tmp = tmp.Remove(tmp.IndexOf(" "), 1);
}//while " "
return tmp;
}
/// <summary>
/// û𡲨벨�駠ﮠ /// </summary>
/// <param name="source"></param>
/// <returns></returns>
private void parse_syntax(string source)
{
//Ҿ垠ⴤ檠㲥
//�猪㲥 㭥㯧㱠
List<string> tmp = new List<string>();
string s = "";
SetProgressRange(0, source.Length);
for (int i = 0; i < source.Length; i++)
{
ProgressInc(1);
statistics.syntax_bytes++;
//Ʊ즠�魢褐- 欨
if (separators.IndexOf(source[i]) >= 0)
{
s = prepare_string(s);
//Ʊ즠랠𐴱- 渥䬠棠� if (s == "") continue;
//Ʊ즠宨릠��, 痢 㱿⮫桢館吝졡�
//Ю촷鳼 롪�颮 ��鼍
if (s.Length < 2)
{
s = "";
continue;
}
//ɱ묾� 뱠饠ﳰ�沫桮全 ��ꡨ塮宮䬠� if (s.IndexOf(' ') < 0)
{
s = "";
continue;
}
syntax_list.Add(s);
s = "";
statistics.syntax_count++;
continue;
}
//Ʊ즠︥易褐�渠�졭㡢묾� 椮 ࡰᨡﮍ
if ((int)source[i] < 32) continue;
s += source[i];
//ū�, �鮲汴檱 졢�
Thread.Sleep(1);
}//for
}
/// <summary>
/// û𡲥� ᮠ쩧 /// </summary>
public void AnalizeText()
{
WriteIntoText("Ю央�櫱;
/*
//Ԥᬿ檠饠 衣אַ㫠 㲥 泌 桤㯩 롢�
while (caption.IndexOf("'") >= 0)
caption = caption.Remove(caption.IndexOf("'"), 1);
while (caption.IndexOf("\"") >= 0)
caption = caption.Remove(caption.IndexOf("\""), 1);
while (source.IndexOf("'") >= 0)
source = source.Remove(source.IndexOf("'"), 1);
while (source.IndexOf("\"") >= 0)
source = source.Remove(source.IndexOf("\""), 1);
*/
WriteIntoText("û묾�㡪 „");
// string connection_string = "Provider=SQLOLEDB.1;Source=E-ART-LAPTOP\\SQLEXPRESS;Initial Catalog=adb;Integrated Security=SSPI";
string connection_string = "Provider=SQLOLEDB;Data Source=e-art-laptop\\sqlexpress;Integrated Security=SSPI;Initial Catalog=adb";
OleDbConnection connection = new OleDbConnection(connection_string);
WriteIntoText("û㮥㡲櫱 „");
CFileWriter.WriteToFile("texts\\" + caption + ".txt", source);
string SQLInsertText = "insert into texts(text, text_caption) values ('files/" + caption + ".txt', '" + caption + "');";
OleDbCommand command = new OleDbCommand(SQLInsertText, connection);
connection.Open();
command.ExecuteNonQuery();
//Ƞ𐴱롥ꡱ⯰ 鲲髨
timer_statistics.Enabled = true;
WriteIntoText("û鸥 ﮠ;
parse_syntax(source);
if (File.Exists("syntax.txt")) File.Delete("syntax.txt");
foreach (string s in syntax_list)
{
CFileWriter.WriteToFile("syntax.txt", s + '\n');
}//foreach
}
private void TextOperation_Click(object sender, EventArgs e)
{
}
private void FResult_FormClosing(object sender, FormClosingEventArgs e)
{
Application.Exit();
}
/// <summary>
/// ϡ퀥𡲲᳨ /// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void timer1_Tick(object sender, EventArgs e)
{
l_syntax_bytes.Text = statistics.syntax_bytes.ToString();
l_syntax_count.Text = statistics.syntax_count.ToString();
}
}
}
FResult.Designer
namespace app
{
partial class FResult
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.tabControl1 = new System.Windows.Forms.TabControl();
this.tabPage1 = new System.Windows.Forms.TabPage();
this.progress = new System.Windows.Forms.ProgressBar();
this.TextOperation = new System.Windows.Forms.Label();
this.ProgressLog = new System.Windows.Forms.RichTextBox();
this.tabPage3 = new System.Windows.Forms.TabPage();
this.tabPage2 = new System.Windows.Forms.TabPage();
this.groupBox1 = new System.Windows.Forms.GroupBox();
this.label4 = new System.Windows.Forms.Label();
this.label3 = new System.Windows.Forms.Label();
this.label2 = new System.Windows.Forms.Label();
this.label1 = new System.Windows.Forms.Label();
this.label5 = new System.Windows.Forms.Label();
this.label6 = new System.Windows.Forms.Label();
this.timer_statistics = new System.Windows.Forms.Timer(this.components);
this.l_syntax_count = new System.Windows.Forms.Label();
this.l_syntax_bytes = new System.Windows.Forms.Label();
this.tabControl1.SuspendLayout();
this.tabPage1.SuspendLayout();
this.tabPage2.SuspendLayout();
this.groupBox1.SuspendLayout();
this.SuspendLayout();
//
// tabControl1
//
this.tabControl1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.tabControl1.Controls.Add(this.tabPage1);
this.tabControl1.Controls.Add(this.tabPage2);
this.tabControl1.Controls.Add(this.tabPage3);
this.tabControl1.Location = new System.Drawing.Point(2, 0);
this.tabControl1.Name = "tabControl1";
this.tabControl1.SelectedIndex = 0;
this.tabControl1.Size = new System.Drawing.Size(442, 295);
this.tabControl1.TabIndex = 0;
//
// tabPage1
//
this.tabPage1.Controls.Add(this.progress);
this.tabPage1.Controls.Add(this.TextOperation);
this.tabPage1.Controls.Add(this.ProgressLog);
this.tabPage1.Location = new System.Drawing.Point(4, 22);
this.tabPage1.Name = "tabPage1";
this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
this.tabPage1.Size = new System.Drawing.Size(434, 269);
this.tabPage1.TabIndex = 0;
this.tabPage1.Text = "а擄沱";
this.tabPage1.UseVisualStyleBackColor = true;
//
// progress
//
this.progress.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.progress.Location = new System.Drawing.Point(9, 239);
this.progress.Name = "progress";
this.progress.Size = new System.Drawing.Size(416, 23);
this.progress.Style = System.Windows.Forms.ProgressBarStyle.Continuous;
this.progress.TabIndex = 2;
//
// TextOperation
//
this.TextOperation.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
this.TextOperation.AutoSize = true;
this.TextOperation.Location = new System.Drawing.Point(6, 220);
this.TextOperation.Name = "TextOperation";
this.TextOperation.Size = new System.Drawing.Size(74, 13);
this.TextOperation.TabIndex = 1;
this.TextOperation.Text = "TextOperation";
this.TextOperation.Click += new System.EventHandler(this.TextOperation_Click);
//
// ProgressLog
//
this.ProgressLog.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.ProgressLog.Location = new System.Drawing.Point(3, 3);
this.ProgressLog.Name = "ProgressLog";
this.ProgressLog.ScrollBars = System.Windows.Forms.RichTextBoxScrollBars.ForcedVertical;
this.ProgressLog.Size = new System.Drawing.Size(427, 206);
this.ProgressLog.TabIndex = 0;
this.ProgressLog.Text = "";
//
// tabPage3
//
this.tabPage3.Location = new System.Drawing.Point(4, 22);
this.tabPage3.Name = "tabPage3";
this.tabPage3.Padding = new System.Windows.Forms.Padding(3);
this.tabPage3.Size = new System.Drawing.Size(434, 269);
this.tabPage3.TabIndex = 2;
this.tabPage3.Text = "ѥ贫�;
this.tabPage3.UseVisualStyleBackColor = true;
//
// tabPage2
//
this.tabPage2.Controls.Add(this.groupBox1);
this.tabPage2.Location = new System.Drawing.Point(4, 22);
this.tabPage2.Name = "tabPage2";
this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
this.tabPage2.Size = new System.Drawing.Size(434, 269);
this.tabPage2.TabIndex = 1;
this.tabPage2.Text = "ͮ妫�髠)";
this.tabPage2.UseVisualStyleBackColor = true;
//
// groupBox1
//
this.groupBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.groupBox1.Controls.Add(this.l_syntax_bytes);
this.groupBox1.Controls.Add(this.l_syntax_count);
this.groupBox1.Controls.Add(this.label6);
this.groupBox1.Controls.Add(this.label5);
this.groupBox1.Controls.Add(this.label4);
this.groupBox1.Controls.Add(this.label3);
this.groupBox1.Controls.Add(this.label2);
this.groupBox1.Controls.Add(this.label1);
this.groupBox1.Location = new System.Drawing.Point(6, 3);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Size = new System.Drawing.Size(425, 263);
this.groupBox1.TabIndex = 0;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "Ҳ᳨�騠";
//
// label4
//
this.label4.AutoSize = true;
this.label4.Location = new System.Drawing.Point(16, 69);
this.label4.Name = "label4";
this.label4.Size = new System.Drawing.Size(177, 13);
this.label4.TabIndex = 7;
this.label4.Text = "Ю촷殮 �鳠槺";
//
// label3
//
this.label3.AutoSize = true;
this.label3.Location = new System.Drawing.Point(16, 56);
this.label3.Name = "label3";
this.label3.Size = new System.Drawing.Size(179, 13);
this.label3.TabIndex = 6;
this.label3.Text = "Ю촷殮 �鳠즪";
//
// label2
//
this.label2.AutoSize = true;
this.label2.Location = new System.Drawing.Point(16, 43);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(297, 13);
this.label2.TabIndex = 5;
this.label2.Text = "ϡ ⡩𡳥벲�鮲鸥 ᮠ쩧ᳮ";
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(16, 30);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(183, 13);
this.label1.TabIndex = 4;
this.label1.Text = "Ю촷殮 鸥 즪";
//
// label5
//
this.label5.AutoSize = true;
this.label5.Location = new System.Drawing.Point(16, 82);
this.label5.Name = "label5";
this.label5.Size = new System.Drawing.Size(186, 13);
this.label5.TabIndex = 8;
this.label5.Text = "ˮ�殲 퀰:";
//
// label6
//
this.label6.AutoSize = true;
this.label6.Location = new System.Drawing.Point(16, 95);
this.label6.Name = "label6";
this.label6.Size = new System.Drawing.Size(146, 13);
this.label6.TabIndex = 9;
this.label6.Text = "Ұ業�𐦭�鮻:";
//
// timer_statistics
//
this.timer_statistics.Enabled = true;
this.timer_statistics.Tick += new System.EventHandler(this.timer1_Tick);
//
// l_syntax_count
//
this.l_syntax_count.AutoSize = true;
this.l_syntax_count.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
this.l_syntax_count.ForeColor = System.Drawing.Color.Black;
this.l_syntax_count.Location = new System.Drawing.Point(319, 30);
this.l_syntax_count.Name = "l_syntax_count";
this.l_syntax_count.Size = new System.Drawing.Size(14, 13);
this.l_syntax_count.TabIndex = 10;
this.l_syntax_count.Text = "0";
this.l_syntax_count.TextAlign = System.Drawing.ContentAlignment.TopRight;
//
// l_syntax_bytes
//
this.l_syntax_bytes.AutoSize = true;
this.l_syntax_bytes.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
this.l_syntax_bytes.ForeColor = System.Drawing.Color.Black;
this.l_syntax_bytes.Location = new System.Drawing.Point(319, 43);
this.l_syntax_bytes.Name = "l_syntax_bytes";
this.l_syntax_bytes.Size = new System.Drawing.Size(14, 13);
this.l_syntax_bytes.TabIndex = 11;
this.l_syntax_bytes.Text = "0";
this.l_syntax_bytes.TextAlign = System.Drawing.ContentAlignment.TopRight;
//
// FResult
//
this.AutoScaleDimensions = new
System.Drawing.SizeF(
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(443, 295);
this.Controls.Add(this.tabControl1);
this.Name = "FResult";
this.Text = "ҥ� ᮠ쩧";
this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FResult_FormClosing);
this.tabControl1.ResumeLayout(false);
this.tabPage1.ResumeLayout(false);
this.tabPage1.PerformLayout();
this.tabPage2.ResumeLayout(false);
this.groupBox1.ResumeLayout(false);
this.groupBox1.PerformLayout();
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.TabControl tabControl1;
private System.Windows.Forms.TabPage tabPage1;
private System.Windows.Forms.Label TextOperation;
private System.Windows.Forms.RichTextBox ProgressLog;
private System.Windows.Forms.ProgressBar progress;
private System.Windows.Forms.TabPage tabPage3;
private System.Windows.Forms.TabPage tabPage2;
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.Label label4;
private System.Windows.Forms.Label label3;
private System.Windows.Forms.Label label2;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.Label label5;
private System.Windows.Forms.Label label6;
private System.Windows.Forms.Timer timer_statistics;
private System.Windows.Forms.Label l_syntax_count;
private System.Windows.Forms.Label l_syntax_bytes;
}
}
app.csproj
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5D349DC0-9BF0-4A59-B0E5-F619AE1CA587}</ProjectGuid>
<OutputType>WinExe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>app</RootNamespace>
<AssemblyName>app</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Data" />
<Reference Include="System.Deployment" />
<Reference Include="System.Drawing" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="adbDataSet.cs">
<DependentUpon>adbDataSet.xsd</DependentUpon>
</Compile>
<Compile Include="adbDataSet.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>adbDataSet.xsd</DependentUpon>
</Compile>
<Compile Include="CFileReader.cs" />
<Compile Include="CFileWiter.cs" />
<Compile Include="CStatistics.cs" />
<Compile Include="FMain.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="FMain.Designer.cs">
<DependentUpon>FMain.cs</DependentUpon>
</Compile>
<Compile Include="FResult.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="FResult.Designer.cs">
<DependentUpon>FResult.cs</DependentUpon>
</Compile>
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<EmbeddedResource Include="FMain.resx">
<SubType>Designer</SubType>
<DependentUpon>FMain.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="FResult.resx">
<SubType>Designer</SubType>
<DependentUpon>FResult.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
<SubType>Designer</SubType>
</EmbeddedResource>
<Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
<None Include="adbDataSet.xsc">
<DependentUpon>adbDataSet.xsd</DependentUpon>
</None>
<None Include="adbDataSet.xsd">
<Generator>MSDataSetGenerator</Generator>
<LastGenOutput>adbDataSet.Designer.cs</LastGenOutput>
<SubType>Designer</SubType>
</None>
<None Include="adbDataSet.xss">
<DependentUpon>adbDataSet.xsd</DependentUpon>
</None>
<None Include="app.config" />
<None Include="ClassDiagram1.cd" />
<None Include="Properties\Settings.settings">
<Generator>SettingsSingleFileGenerator</Generator>
<LastGenOutput>Settings.Designer.cs</LastGenOutput>
</None>
<Compile Include="Properties\Settings.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Settings.settings</DependentUpon>
<DesignTimeSharedInput>True</DesignTimeSharedInput>
</Compile>
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
adbDataSet.xsd
<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="adbDataSet" targetNamespace="http://tempuri.org/adbDataSet.xsd" xmlns:mstns="http://tempuri.org/adbDataSet.xsd" xmlns="http://tempuri.org/adbDataSet.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" xmlns:msprop="urn:schemas-microsoft-com:xml-msprop" attributeFormDefault="qualified" elementFormDefault="qualified">
<xs:annotation>
<xs:appinfo source="urn:schemas-microsoft-com:xml-msdatasource">
<DataSource DefaultConnectionIndex="0" FunctionsComponentName="QueriesTableAdapter" GeneratorFunctionsComponentClassName="QueriesTableAdapter" Modifier="AutoLayout, AnsiClass, Class, Public" SchemaSerializationMode="IncludeSchema" UserFunctionsComponentName="QueriesTableAdapter" xmlns="urn:schemas-microsoft-com:xml-msdatasource">
<Connections>
<Connection AppSettingsObjectName="Settings" AppSettingsPropertyName="adbConnectionString" ConnectionStringObject="" IsAppSettingsProperty="True" Modifier="Assembly" Name="adbConnectionString (Settings)" ParameterPrefix="@" PropertyReference="ApplicationSettings.app.Properties.Settings.GlobalReference.Default.adbConnectionString" Provider="System.Data.SqlClient">
</Connection>
</Connections>
<Tables>
<TableAdapter BaseClass="System.ComponentModel.Component" DataAccessorModifier="AutoLayout, AnsiClass, Class, Public" DataAccessorName="identitiesTableAdapter" GeneratorDataComponentClassName="identitiesTableAdapter" Name="identities" UserDataComponentName="identitiesTableAdapter">
<MainSource>
<DbSource ConnectionRef="adbConnectionString (Settings)" DbObjectName="adb.dbo.identities" DbObjectType="Table" FillMethodModifier="Public" FillMethodName="Fill" GenerateMethods="Both" GenerateShortCommands="True" GeneratorGetMethodName="GetData" GeneratorSourceName="Fill" GetMethodModifier="Public" GetMethodName="GetData" QueryType="Rowset" ScalarCallRetval="System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" UseOptimisticConcurrency="True" UserGetMethodName="GetData" UserSourceName="Fill">
<InsertCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>INSERT INTO [dbo].[identities] ([identity_name], [identity_weight]) VALUES (@identity_name, @identity_weight)</CommandText>
<Parameters>
<Parameter AllowDbNull="True" AutogeneratedName="" DataSourceName="" DbType="StringFixedLength" Direction="Input" ParameterName="@identity_name" Precision="0" ProviderType="NChar" Scale="0" Size="0" SourceColumn="identity_name" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
<Parameter AllowDbNull="True" AutogeneratedName="" DataSourceName="" DbType="Double" Direction="Input" ParameterName="@identity_weight" Precision="0" ProviderType="Float" Scale="0" Size="0" SourceColumn="identity_weight" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
</Parameters>
</DbCommand>
</InsertCommand>
<SelectCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>SELECT identity_id, identity_name, identity_weight FROM dbo.identities</CommandText>
<Parameters>
</Parameters>
</DbCommand>
</SelectCommand>
</DbSource>
</MainSource>
<Mappings>
<Mapping SourceColumn="identity_id" DataSetColumn="identity_id" />
<Mapping SourceColumn="identity_name" DataSetColumn="identity_name" />
<Mapping SourceColumn="identity_weight" DataSetColumn="identity_weight" />
</Mappings>
<Sources>
</Sources>
</TableAdapter>
<TableAdapter BaseClass="System.ComponentModel.Component" DataAccessorModifier="AutoLayout, AnsiClass, Class, Public" DataAccessorName="link_typesTableAdapter" GeneratorDataComponentClassName="link_typesTableAdapter" Name="link_types" UserDataComponentName="link_typesTableAdapter">
<MainSource>
<DbSource ConnectionRef="adbConnectionString (Settings)" DbObjectName="adb.dbo.link_types" DbObjectType="Table" FillMethodModifier="Public" FillMethodName="Fill" GenerateMethods="Both" GenerateShortCommands="True" GeneratorGetMethodName="GetData" GeneratorSourceName="Fill" GetMethodModifier="Public" GetMethodName="GetData" QueryType="Rowset" ScalarCallRetval="System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" UseOptimisticConcurrency="True" UserGetMethodName="GetData" UserSourceName="Fill">
<InsertCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>INSERT INTO [dbo].[link_types] ([link_name]) VALUES (@link_name)</CommandText>
<Parameters>
<Parameter AllowDbNull="False" AutogeneratedName="" DataSourceName="" DbType="StringFixedLength" Direction="Input" ParameterName="@link_name" Precision="0" ProviderType="NChar" Scale="0" Size="0" SourceColumn="link_name" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
</Parameters>
</DbCommand>
</InsertCommand>
<SelectCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>SELECT link_id, link_name FROM dbo.link_types</CommandText>
<Parameters>
</Parameters>
</DbCommand>
</SelectCommand>
</DbSource>
</MainSource>
<Mappings>
<Mapping SourceColumn="link_id" DataSetColumn="link_id" />
<Mapping SourceColumn="link_name" DataSetColumn="link_name" />
</Mappings>
<Sources>
</Sources>
</TableAdapter>
<TableAdapter BaseClass="System.ComponentModel.Component" DataAccessorModifier="AutoLayout, AnsiClass, Class, Public" DataAccessorName="linksTableAdapter" GeneratorDataComponentClassName="linksTableAdapter" Name="links" UserDataComponentName="linksTableAdapter">
<MainSource>
<DbSource ConnectionRef="adbConnectionString (Settings)" DbObjectName="adb.dbo.links" DbObjectType="Table" FillMethodModifier="Public" FillMethodName="Fill" GenerateMethods="Both" GenerateShortCommands="True" GeneratorGetMethodName="GetData" GeneratorSourceName="Fill" GetMethodModifier="Public" GetMethodName="GetData" QueryType="Rowset" ScalarCallRetval="System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" UseOptimisticConcurrency="True" UserGetMethodName="GetData" UserSourceName="Fill">
<InsertCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>INSERT INTO [dbo].[links] ([link_from], [link_to], [link_weight]) VALUES (@link_from, @link_to, @link_weight)</CommandText>
<Parameters>
<Parameter AllowDbNull="False" AutogeneratedName="" DataSourceName="" DbType="Int32" Direction="Input" ParameterName="@link_from" Precision="0" ProviderType="Int" Scale="0" Size="0" SourceColumn="link_from" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
<Parameter AllowDbNull="False" AutogeneratedName="" DataSourceName="" DbType="Int32" Direction="Input" ParameterName="@link_to" Precision="0" ProviderType="Int" Scale="0" Size="0" SourceColumn="link_to" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
<Parameter AllowDbNull="True" AutogeneratedName="" DataSourceName="" DbType="Double" Direction="Input" ParameterName="@link_weight" Precision="0" ProviderType="Float" Scale="0" Size="0" SourceColumn="link_weight" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
</Parameters>
</DbCommand>
</InsertCommand>
<SelectCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>SELECT link_from, link_to, link_weight FROM dbo.links</CommandText>
<Parameters>
</Parameters>
</DbCommand>
</SelectCommand>
</DbSource>
</MainSource>
<Mappings>
<Mapping SourceColumn="link_from" DataSetColumn="link_from" />
<Mapping SourceColumn="link_to" DataSetColumn="link_to" />
<Mapping SourceColumn="link_weight" DataSetColumn="link_weight" />
</Mappings>
<Sources>
</Sources>
</TableAdapter>
<TableAdapter BaseClass="System.ComponentModel.Component" DataAccessorModifier="AutoLayout, AnsiClass, Class, Public" DataAccessorName="text_identitiesTableAdapter" GeneratorDataComponentClassName="text_identitiesTableAdapter" Name="text_identities" UserDataComponentName="text_identitiesTableAdapter">
<MainSource>
<DbSource ConnectionRef="adbConnectionString (Settings)" DbObjectName="adb.dbo.text_identities" DbObjectType="Table" FillMethodModifier="Public" FillMethodName="Fill" GenerateMethods="Both" GenerateShortCommands="True" GeneratorGetMethodName="GetData" GeneratorSourceName="Fill" GetMethodModifier="Public" GetMethodName="GetData" QueryType="Rowset" ScalarCallRetval="System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" UseOptimisticConcurrency="True" UserGetMethodName="GetData" UserSourceName="Fill">
<InsertCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>INSERT INTO [dbo].[text_identities] ([text_id], [identity_id]) VALUES (@text_id, @identity_id)</CommandText>
<Parameters>
<Parameter AllowDbNull="False" AutogeneratedName="" DataSourceName="" DbType="Int32" Direction="Input" ParameterName="@text_id" Precision="0" ProviderType="Int" Scale="0" Size="0" SourceColumn="text_id" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
<Parameter AllowDbNull="False" AutogeneratedName="" DataSourceName="" DbType="Int32" Direction="Input" ParameterName="@identity_id" Precision="0" ProviderType="Int" Scale="0" Size="0" SourceColumn="identity_id" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
</Parameters>
</DbCommand>
</InsertCommand>
<SelectCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>SELECT text_id, identity_id FROM dbo.text_identities</CommandText>
<Parameters>
</Parameters>
</DbCommand>
</SelectCommand>
</DbSource>
</MainSource>
<Mappings>
<Mapping SourceColumn="text_id" DataSetColumn="text_id" />
<Mapping SourceColumn="identity_id" DataSetColumn="identity_id" />
</Mappings>
<Sources>
</Sources>
</TableAdapter>
<TableAdapter BaseClass="System.ComponentModel.Component" DataAccessorModifier="AutoLayout, AnsiClass, Class, Public" DataAccessorName="textsTableAdapter" GeneratorDataComponentClassName="textsTableAdapter" Name="texts" UserDataComponentName="textsTableAdapter">
<MainSource>
<DbSource ConnectionRef="adbConnectionString (Settings)" DbObjectName="adb.dbo.texts" DbObjectType="Table" FillMethodModifier="Public" FillMethodName="Fill" GenerateMethods="Both" GenerateShortCommands="True" GeneratorGetMethodName="GetData" GeneratorSourceName="Fill" GetMethodModifier="Public" GetMethodName="GetData" QueryType="Rowset" ScalarCallRetval="System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" UseOptimisticConcurrency="True" UserGetMethodName="GetData" UserSourceName="Fill">
<InsertCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>INSERT INTO [dbo].[texts] ([text], [text_caption]) VALUES (@text, @text_caption)</CommandText>
<Parameters>
<Parameter AllowDbNull="True" AutogeneratedName="" DataSourceName="" DbType="String" Direction="Input" ParameterName="@text" Precision="0" ProviderType="NText" Scale="0" Size="0" SourceColumn="text" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
<Parameter AllowDbNull="True" AutogeneratedName="" DataSourceName="" DbType="StringFixedLength" Direction="Input" ParameterName="@text_caption" Precision="0" ProviderType="NChar" Scale="0" Size="0" SourceColumn="text_caption" SourceColumnNullMapping="False" SourceVersion="Current">
</Parameter>
</Parameters>
</DbCommand>
</InsertCommand>
<SelectCommand>
<DbCommand CommandType="Text" ModifiedByUser="False">
<CommandText>SELECT text_id, text, text_caption FROM dbo.texts</CommandText>
<Parameters>
</Parameters>
</DbCommand>
</SelectCommand>
</DbSource>
</MainSource>
<Mappings>
<Mapping SourceColumn="text_id" DataSetColumn="text_id" />
<Mapping SourceColumn="text" DataSetColumn="text" />
<Mapping SourceColumn="text_caption" DataSetColumn="text_caption" />
</Mappings>
<Sources>
</Sources>
</TableAdapter>
</Tables>
<Sources>
<DbSource ConnectionRef="adbConnectionString (Settings)" DbObjectName="" DbObjectType="Unknown" GenerateShortCommands="True" GeneratorSourceName="SQLInsText" MethodsParameterType="CLR" Modifier="Public" Name="SQLInsText" QueryType="NoData" ScalarCallRetval="System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" UseOptimisticConcurrency="True" UserGetMethodName="GetDataBy" UserSourceName="SQLInsText">
<InsertCommand>
<DbCommand CommandType="Text" ModifiedByUser="True">
<CommandText>INSERT into texts(text, text_caption) values (:text, :text_caption)</CommandText>
<Parameters>
</Parameters>
</DbCommand>
</InsertCommand>
</DbSource>
</Sources>
</DataSource>
</xs:appinfo>
</xs:annotation>
<xs:element name="adbDataSet" msdata:IsDataSet="true" msdata:UseCurrentLocale="true" msprop:Generator_UserDSName="adbDataSet" msprop:Generator_DataSetName="adbDataSet">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="identities" msprop:Generator_UserTableName="identities" msprop:Generator_RowDeletedName="identitiesRowDeleted" msprop:Generator_RowChangedName="identitiesRowChanged" msprop:Generator_RowClassName="identitiesRow" msprop:Generator_RowChangingName="identitiesRowChanging" msprop:Generator_RowEvArgName="identitiesRowChangeEvent" msprop:Generator_RowEvHandlerName="identitiesRowChangeEventHandler" msprop:Generator_TableClassName="identitiesDataTable" msprop:Generator_TableVarName="tableidentities" msprop:Generator_RowDeletingName="identitiesRowDeleting" msprop:Generator_TablePropName="identities">
<xs:complexType>
<xs:sequence>
<xs:element name="identity_id" msdata:ReadOnly="true" msdata:AutoIncrement="true" msprop:Generator_UserColumnName="identity_id" msprop:Generator_ColumnVarNameInTable="columnidentity_id" msprop:Generator_ColumnPropNameInRow="identity_id" msprop:Generator_ColumnPropNameInTable="identity_idColumn" type="xs:int" />
<xs:element name="identity_name" msprop:Generator_UserColumnName="identity_name" msprop:Generator_ColumnVarNameInTable="columnidentity_name" msprop:Generator_ColumnPropNameInRow="identity_name" msprop:Generator_ColumnPropNameInTable="identity_nameColumn" minOccurs="0">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:maxLength value="2048" />
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="identity_weight" msprop:Generator_UserColumnName="identity_weight" msprop:Generator_ColumnVarNameInTable="columnidentity_weight" msprop:Generator_ColumnPropNameInRow="identity_weight" msprop:Generator_ColumnPropNameInTable="identity_weightColumn" type="xs:double" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="link_types" msprop:Generator_UserTableName="link_types" msprop:Generator_RowDeletedName="link_typesRowDeleted" msprop:Generator_RowChangedName="link_typesRowChanged" msprop:Generator_RowClassName="link_typesRow" msprop:Generator_RowChangingName="link_typesRowChanging" msprop:Generator_RowEvArgName="link_typesRowChangeEvent" msprop:Generator_RowEvHandlerName="link_typesRowChangeEventHandler" msprop:Generator_TableClassName="link_typesDataTable" msprop:Generator_TableVarName="tablelink_types" msprop:Generator_RowDeletingName="link_typesRowDeleting" msprop:Generator_TablePropName="link_types">
<xs:complexType>
<xs:sequence>
<xs:element name="link_id" msdata:ReadOnly="true" msdata:AutoIncrement="true" msprop:Generator_UserColumnName="link_id" msprop:Generator_ColumnVarNameInTable="columnlink_id" msprop:Generator_ColumnPropNameInRow="link_id" msprop:Generator_ColumnPropNameInTable="link_idColumn" type="xs:int" />
<xs:element name="link_name" msprop:Generator_UserColumnName="link_name" msprop:Generator_ColumnVarNameInTable="columnlink_name" msprop:Generator_ColumnPropNameInRow="link_name" msprop:Generator_ColumnPropNameInTable="link_nameColumn">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:maxLength value="1024" />
</xs:restriction>
</xs:simpleType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="links" msprop:Generator_UserTableName="links" msprop:Generator_RowDeletedName="linksRowDeleted" msprop:Generator_RowChangedName="linksRowChanged" msprop:Generator_RowClassName="linksRow" msprop:Generator_RowChangingName="linksRowChanging" msprop:Generator_RowEvArgName="linksRowChangeEvent" msprop:Generator_RowEvHandlerName="linksRowChangeEventHandler" msprop:Generator_TableClassName="linksDataTable" msprop:Generator_TableVarName="tablelinks" msprop:Generator_RowDeletingName="linksRowDeleting" msprop:Generator_TablePropName="links">
<xs:complexType>
<xs:sequence>
<xs:element name="link_from" msprop:Generator_UserColumnName="link_from" msprop:Generator_ColumnVarNameInTable="columnlink_from" msprop:Generator_ColumnPropNameInRow="link_from" msprop:Generator_ColumnPropNameInTable="link_fromColumn" type="xs:int" />
<xs:element name="link_to" msprop:Generator_UserColumnName="link_to" msprop:Generator_ColumnVarNameInTable="columnlink_to" msprop:Generator_ColumnPropNameInRow="link_to" msprop:Generator_ColumnPropNameInTable="link_toColumn" type="xs:int" />
<xs:element name="link_weight" msprop:Generator_UserColumnName="link_weight" msprop:Generator_ColumnVarNameInTable="columnlink_weight" msprop:Generator_ColumnPropNameInRow="link_weight" msprop:Generator_ColumnPropNameInTable="link_weightColumn" type="xs:double" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="text_identities" msprop:Generator_UserTableName="text_identities" msprop:Generator_RowDeletedName="text_identitiesRowDeleted" msprop:Generator_RowChangedName="text_identitiesRowChanged" msprop:Generator_RowClassName="text_identitiesRow" msprop:Generator_RowChangingName="text_identitiesRowChanging" msprop:Generator_RowEvArgName="text_identitiesRowChangeEvent" msprop:Generator_RowEvHandlerName="text_identitiesRowChangeEventHandler" msprop:Generator_TableClassName="text_identitiesDataTable" msprop:Generator_TableVarName="tabletext_identities" msprop:Generator_RowDeletingName="text_identitiesRowDeleting" msprop:Generator_TablePropName="text_identities">
<xs:complexType>
<xs:sequence>
<xs:element name="text_id" msprop:Generator_UserColumnName="text_id" msprop:Generator_ColumnVarNameInTable="columntext_id" msprop:Generator_ColumnPropNameInRow="text_id" msprop:Generator_ColumnPropNameInTable="text_idColumn" type="xs:int" />
<xs:element name="identity_id" msprop:Generator_UserColumnName="identity_id" msprop:Generator_ColumnVarNameInTable="columnidentity_id" msprop:Generator_ColumnPropNameInRow="identity_id" msprop:Generator_ColumnPropNameInTable="identity_idColumn" type="xs:int" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="texts" msprop:Generator_UserTableName="texts" msprop:Generator_RowDeletedName="textsRowDeleted" msprop:Generator_RowChangedName="textsRowChanged" msprop:Generator_RowClassName="textsRow" msprop:Generator_RowChangingName="textsRowChanging" msprop:Generator_RowEvArgName="textsRowChangeEvent" msprop:Generator_RowEvHandlerName="textsRowChangeEventHandler" msprop:Generator_TableClassName="textsDataTable" msprop:Generator_TableVarName="tabletexts" msprop:Generator_RowDeletingName="textsRowDeleting" msprop:Generator_TablePropName="texts">
<xs:complexType>
<xs:sequence>
<xs:element name="text_id" msdata:ReadOnly="true" msdata:AutoIncrement="true" msprop:Generator_UserColumnName="text_id" msprop:Generator_ColumnVarNameInTable="columntext_id" msprop:Generator_ColumnPropNameInRow="text_id" msprop:Generator_ColumnPropNameInTable="text_idColumn" type="xs:int" />
<xs:element name="text" msprop:Generator_UserColumnName="text" msprop:Generator_ColumnVarNameInTable="columntext" msprop:Generator_ColumnPropNameInRow="text" msprop:Generator_ColumnPropNameInTable="textColumn" minOccurs="0">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:maxLength value="1073741823" />
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="text_caption" msprop:Generator_UserColumnName="text_caption" msprop:Generator_ColumnVarNameInTable="columntext_caption" msprop:Generator_ColumnPropNameInRow="text_caption" msprop:Generator_ColumnPropNameInTable="text_captionColumn" minOccurs="0">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:maxLength value="1024" />
</xs:restriction>
</xs:simpleType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
<xs:annotation>
<xs:appinfo>
<msdata:Relationship name="links_link_types" msdata:parent="links" msdata:child="link_types" msdata:parentkey="link_from" msdata:childkey="link_id" msprop:Generator_UserRelationName="links_link_types" msprop:Generator_RelationVarName="relationlinks_link_types" msprop:Generator_UserChildTable="link_types" msprop:Generator_UserParentTable="links" msprop:Generator_ParentPropName="linksRow" msprop:Generator_ChildPropName="Getlink_typesRows" />
<msdata:Relationship name="links_link_types1" msdata:parent="links" msdata:child="link_types" msdata:parentkey="link_to" msdata:childkey="link_id" msprop:Generator_UserRelationName="links_link_types1" msprop:Generator_RelationVarName="relationlinks_link_types1" msprop:Generator_UserChildTable="link_types" msprop:Generator_UserParentTable="links" msprop:Generator_ParentPropName="linksRowBylinks_link_types1" msprop:Generator_ChildPropName="Getlink_typesRowsBylinks_link_types1" />
</xs:appinfo>
</xs:annotation>
</xs:schema>
MODEL_BUILDER
adbDataSet.Designer
#pragma warning disable 1591
namespace model_builder {
using System;
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[Serializable()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.ComponentModel.ToolboxItem(true)]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedDataSetSchema")]
[System.Xml.Serialization.XmlRootAttribute("adbDataSet")]
[System.ComponentModel.Design.HelpKeywordAttribute("vs.data.DataSet")]
public partial class adbDataSet : System.Data.DataSet {
private identitiesDataTable tableidentities;
private link_typesDataTable tablelink_types;
private linksDataTable tablelinks;
private text_identitiesDataTable tabletext_identities;
private textsDataTable tabletexts;
private System.Data.SchemaSerializationMode _schemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public adbDataSet() {
this.BeginInit();
this.InitClass();
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
base.Tables.CollectionChanged += schemaChangedHandler;
base.Relations.CollectionChanged += schemaChangedHandler;
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected adbDataSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context, false) {
if ((this.IsBinarySerialized(info, context) == true)) {
this.InitVars(false);
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
this.Tables.CollectionChanged += schemaChangedHandler1;
this.Relations.CollectionChanged += schemaChangedHandler1;
return;
}
string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
if ((this.DetermineSchemaSerializationMode(info, context) == System.Data.SchemaSerializationMode.IncludeSchema)) {
System.Data.DataSet ds = new System.Data.DataSet();
ds.ReadXmlSchema(new System.Xml.XmlTextReader(new System.IO.StringReader(strSchema)));
if ((ds.Tables["identities"] != null)) {
base.Tables.Add(new identitiesDataTable(ds.Tables["identities"]));
}
if ((ds.Tables["link_types"] != null)) {
base.Tables.Add(new link_typesDataTable(ds.Tables["link_types"]));
}
if ((ds.Tables["links"] != null)) {
base.Tables.Add(new linksDataTable(ds.Tables["links"]));
}
if ((ds.Tables["text_identities"] != null)) {
base.Tables.Add(new text_identitiesDataTable(ds.Tables["text_identities"]));
}
if ((ds.Tables["texts"] != null)) {
base.Tables.Add(new textsDataTable(ds.Tables["texts"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
else {
this.ReadXmlSchema(new System.Xml.XmlTextReader(new System.IO.StringReader(strSchema)));
}
this.GetSerializationData(info, context);
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
base.Tables.CollectionChanged += schemaChangedHandler;
this.Relations.CollectionChanged += schemaChangedHandler;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public identitiesDataTable identities {
get {
return this.tableidentities;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public link_typesDataTable link_types {
get {
return this.tablelink_types;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public linksDataTable links {
get {
return this.tablelinks;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public text_identitiesDataTable text_identities {
get {
return this.tabletext_identities;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
public textsDataTable texts {
get {
return this.tabletexts;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.BrowsableAttribute(true)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Visible)]
public override System.Data.SchemaSerializationMode SchemaSerializationMode {
get {
return this._schemaSerializationMode;
}
set {
this._schemaSerializationMode = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
public new System.Data.DataTableCollection Tables {
get {
return base.Tables;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
public new System.Data.DataRelationCollection Relations {
get {
return base.Relations;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void InitializeDerivedDataSet() {
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataSet Clone() {
adbDataSet cln = ((adbDataSet)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override bool ShouldSerializeTables() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override bool ShouldSerializeRelations() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void ReadXmlSerializable(System.Xml.XmlReader reader) {
if ((this.DetermineSchemaSerializationMode(reader) == System.Data.SchemaSerializationMode.IncludeSchema)) {
this.Reset();
System.Data.DataSet ds = new System.Data.DataSet();
ds.ReadXml(reader);
if ((ds.Tables["identities"] != null)) {
base.Tables.Add(new identitiesDataTable(ds.Tables["identities"]));
}
if ((ds.Tables["link_types"] != null)) {
base.Tables.Add(new link_typesDataTable(ds.Tables["link_types"]));
}
if ((ds.Tables["links"] != null)) {
base.Tables.Add(new linksDataTable(ds.Tables["links"]));
}
if ((ds.Tables["text_identities"] != null)) {
base.Tables.Add(new text_identitiesDataTable(ds.Tables["text_identities"]));
}
if ((ds.Tables["texts"] != null)) {
base.Tables.Add(new textsDataTable(ds.Tables["texts"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
else {
this.ReadXml(reader);
this.InitVars();
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
System.IO.MemoryStream stream = new System.IO.MemoryStream();
this.WriteXmlSchema(new System.Xml.XmlTextWriter(stream, null));
stream.Position = 0;
return System.Xml.Schema.XmlSchema.Read(new System.Xml.XmlTextReader(stream), null);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.InitVars(true);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars(bool initTable) {
this.tableidentities = ((identitiesDataTable)(base.Tables["identities"]));
if ((initTable == true)) {
if ((this.tableidentities != null)) {
this.tableidentities.InitVars();
}
}
this.tablelink_types = ((link_typesDataTable)(base.Tables["link_types"]));
if ((initTable == true)) {
if ((this.tablelink_types != null)) {
this.tablelink_types.InitVars();
}
}
this.tablelinks = ((linksDataTable)(base.Tables["links"]));
if ((initTable == true)) {
if ((this.tablelinks != null)) {
this.tablelinks.InitVars();
}
}
this.tabletext_identities = ((text_identitiesDataTable)(base.Tables["text_identities"]));
if ((initTable == true)) {
if ((this.tabletext_identities != null)) {
this.tabletext_identities.InitVars();
}
}
this.tabletexts = ((textsDataTable)(base.Tables["texts"]));
if ((initTable == true)) {
if ((this.tabletexts != null)) {
this.tabletexts.InitVars();
}
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.DataSetName = "adbDataSet";
this.Prefix = "";
this.Namespace = "http://tempuri.org/adbDataSet.xsd";
this.EnforceConstraints = true;
this.SchemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
this.tableidentities = new identitiesDataTable();
base.Tables.Add(this.tableidentities);
this.tablelink_types = new link_typesDataTable();
base.Tables.Add(this.tablelink_types);
this.tablelinks = new linksDataTable();
base.Tables.Add(this.tablelinks);
this.tabletext_identities = new text_identitiesDataTable();
base.Tables.Add(this.tabletext_identities);
this.tabletexts = new textsDataTable();
base.Tables.Add(this.tabletexts);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializeidentities() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializelink_types() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializelinks() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializetext_identities() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private bool ShouldSerializetexts() {
return false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
this.InitVars();
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs) {
adbDataSet ds = new adbDataSet();
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
return type;
}
public delegate void identitiesRowChangeEventHandler(object sender, identitiesRowChangeEvent e);
public delegate void link_typesRowChangeEventHandler(object sender, link_typesRowChangeEvent e);
public delegate void linksRowChangeEventHandler(object sender, linksRowChangeEvent e);
public delegate void text_identitiesRowChangeEventHandler(object sender, text_identitiesRowChangeEvent e);
public delegate void textsRowChangeEventHandler(object sender, textsRowChangeEvent e);
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class identitiesDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columnidentity_id;
private System.Data.DataColumn columnidentity_name;
private System.Data.DataColumn columnidentity_weight;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesDataTable() {
this.TableName = "identities";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal identitiesDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected identitiesDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_idColumn {
get {
return this.columnidentity_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_nameColumn {
get {
return this.columnidentity_name;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_weightColumn {
get {
return this.columnidentity_weight;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow this[int index] {
get {
return ((identitiesRow)(this.Rows[index]));
}
}
public event identitiesRowChangeEventHandler identitiesRowChanging;
public event identitiesRowChangeEventHandler identitiesRowChanged;
public event identitiesRowChangeEventHandler identitiesRowDeleting;
public event identitiesRowChangeEventHandler identitiesRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void AddidentitiesRow(identitiesRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow AddidentitiesRow(string identity_name, double identity_weight) {
identitiesRow rowidentitiesRow = ((identitiesRow)(this.NewRow()));
rowidentitiesRow.ItemArray = new object[] {
null,
identity_name,
identity_weight};
this.Rows.Add(rowidentitiesRow);
return rowidentitiesRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
identitiesDataTable cln = ((identitiesDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new identitiesDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columnidentity_id = base.Columns["identity_id"];
this.columnidentity_name = base.Columns["identity_name"];
this.columnidentity_weight = base.Columns["identity_weight"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columnidentity_id = new System.Data.DataColumn("identity_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_id);
this.columnidentity_name = new System.Data.DataColumn("identity_name", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_name);
this.columnidentity_weight = new System.Data.DataColumn("identity_weight", typeof(double), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_weight);
this.columnidentity_id.AutoIncrement = true;
this.columnidentity_id.AllowDBNull = false;
this.columnidentity_id.ReadOnly = true;
this.columnidentity_name.MaxLength = 2048;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow NewidentitiesRow() {
return ((identitiesRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new identitiesRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(identitiesRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.identitiesRowChanged != null)) {
this.identitiesRowChanged(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.identitiesRowChanging != null)) {
this.identitiesRowChanging(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.identitiesRowDeleted != null)) {
this.identitiesRowDeleted(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.identitiesRowDeleting != null)) {
this.identitiesRowDeleting(this, new identitiesRowChangeEvent(((identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void RemoveidentitiesRow(identitiesRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "identitiesDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class link_typesDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columnlink_id;
private System.Data.DataColumn columnlink_name;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesDataTable() {
this.TableName = "link_types";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal link_typesDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected link_typesDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_idColumn {
get {
return this.columnlink_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_nameColumn {
get {
return this.columnlink_name;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow this[int index] {
get {
return ((link_typesRow)(this.Rows[index]));
}
}
public event link_typesRowChangeEventHandler link_typesRowChanging;
public event link_typesRowChangeEventHandler link_typesRowChanged;
public event link_typesRowChangeEventHandler link_typesRowDeleting;
public event link_typesRowChangeEventHandler link_typesRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Addlink_typesRow(link_typesRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow Addlink_typesRow(string link_name) {
link_typesRow rowlink_typesRow = ((link_typesRow)(this.NewRow()));
rowlink_typesRow.ItemArray = new object[] {
null,
link_name};
this.Rows.Add(rowlink_typesRow);
return rowlink_typesRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
link_typesDataTable cln = ((link_typesDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new link_typesDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columnlink_id = base.Columns["link_id"];
this.columnlink_name = base.Columns["link_name"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columnlink_id = new System.Data.DataColumn("link_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_id);
this.columnlink_name = new System.Data.DataColumn("link_name", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_name);
this.columnlink_id.AutoIncrement = true;
this.columnlink_id.AllowDBNull = false;
this.columnlink_id.ReadOnly = true;
this.columnlink_name.AllowDBNull = false;
this.columnlink_name.MaxLength = 1024;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow Newlink_typesRow() {
return ((link_typesRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new link_typesRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(link_typesRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.link_typesRowChanged != null)) {
this.link_typesRowChanged(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.link_typesRowChanging != null)) {
this.link_typesRowChanging(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.link_typesRowDeleted != null)) {
this.link_typesRowDeleted(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.link_typesRowDeleting != null)) {
this.link_typesRowDeleting(this, new link_typesRowChangeEvent(((link_typesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Removelink_typesRow(link_typesRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "link_typesDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class linksDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columnlink_from;
private System.Data.DataColumn columnlink_to;
private System.Data.DataColumn columnlink_weight;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksDataTable() {
this.TableName = "links";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal linksDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected linksDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_fromColumn {
get {
return this.columnlink_from;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_toColumn {
get {
return this.columnlink_to;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn link_weightColumn {
get {
return this.columnlink_weight;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow this[int index] {
get {
return ((linksRow)(this.Rows[index]));
}
}
public event linksRowChangeEventHandler linksRowChanging;
public event linksRowChangeEventHandler linksRowChanged;
public event linksRowChangeEventHandler linksRowDeleting;
public event linksRowChangeEventHandler linksRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void AddlinksRow(linksRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow AddlinksRow(int link_from, int link_to, double link_weight) {
linksRow rowlinksRow = ((linksRow)(this.NewRow()));
rowlinksRow.ItemArray = new object[] {
link_from,
link_to,
link_weight};
this.Rows.Add(rowlinksRow);
return rowlinksRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
linksDataTable cln = ((linksDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new linksDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columnlink_from = base.Columns["link_from"];
this.columnlink_to = base.Columns["link_to"];
this.columnlink_weight = base.Columns["link_weight"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columnlink_from = new System.Data.DataColumn("link_from", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_from);
this.columnlink_to = new System.Data.DataColumn("link_to", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_to);
this.columnlink_weight = new System.Data.DataColumn("link_weight", typeof(double), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnlink_weight);
this.columnlink_from.AllowDBNull = false;
this.columnlink_to.AllowDBNull = false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow NewlinksRow() {
return ((linksRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new linksRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(linksRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.linksRowChanged != null)) {
this.linksRowChanged(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.linksRowChanging != null)) {
this.linksRowChanging(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.linksRowDeleted != null)) {
this.linksRowDeleted(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.linksRowDeleting != null)) {
this.linksRowDeleting(this, new linksRowChangeEvent(((linksRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void RemovelinksRow(linksRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "linksDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class text_identitiesDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columntext_id;
private System.Data.DataColumn columnidentity_id;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesDataTable() {
this.TableName = "text_identities";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal text_identitiesDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected text_identitiesDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn text_idColumn {
get {
return this.columntext_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn identity_idColumn {
get {
return this.columnidentity_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow this[int index] {
get {
return ((text_identitiesRow)(this.Rows[index]));
}
}
public event text_identitiesRowChangeEventHandler text_identitiesRowChanging;
public event text_identitiesRowChangeEventHandler text_identitiesRowChanged;
public event text_identitiesRowChangeEventHandler text_identitiesRowDeleting;
public event text_identitiesRowChangeEventHandler text_identitiesRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Addtext_identitiesRow(text_identitiesRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow Addtext_identitiesRow(int text_id, int identity_id) {
text_identitiesRow rowtext_identitiesRow = ((text_identitiesRow)(this.NewRow()));
rowtext_identitiesRow.ItemArray = new object[] {
text_id,
identity_id};
this.Rows.Add(rowtext_identitiesRow);
return rowtext_identitiesRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
text_identitiesDataTable cln = ((text_identitiesDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new text_identitiesDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columntext_id = base.Columns["text_id"];
this.columnidentity_id = base.Columns["identity_id"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columntext_id = new System.Data.DataColumn("text_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext_id);
this.columnidentity_id = new System.Data.DataColumn("identity_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columnidentity_id);
this.columntext_id.AllowDBNull = false;
this.columnidentity_id.AllowDBNull = false;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow Newtext_identitiesRow() {
return ((text_identitiesRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new text_identitiesRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(text_identitiesRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.text_identitiesRowChanged != null)) {
this.text_identitiesRowChanged(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.text_identitiesRowChanging != null)) {
this.text_identitiesRowChanging(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.text_identitiesRowDeleted != null)) {
this.text_identitiesRowDeleted(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.text_identitiesRowDeleting != null)) {
this.text_identitiesRowDeleting(this, new text_identitiesRowChangeEvent(((text_identitiesRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Removetext_identitiesRow(text_identitiesRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "text_identitiesDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[System.Serializable()]
[System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedTableSchema")]
public partial class textsDataTable : System.Data.DataTable, System.Collections.IEnumerable {
private System.Data.DataColumn columntext_id;
private System.Data.DataColumn columntext;
private System.Data.DataColumn columntext_caption;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsDataTable() {
this.TableName = "texts";
this.BeginInit();
this.InitClass();
this.EndInit();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal textsDataTable(System.Data.DataTable table) {
this.TableName = table.TableName;
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected textsDataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
base(info, context) {
this.InitVars();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn text_idColumn {
get {
return this.columntext_id;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn textColumn {
get {
return this.columntext;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataColumn text_captionColumn {
get {
return this.columntext_caption;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow this[int index] {
get {
return ((textsRow)(this.Rows[index]));
}
}
public event textsRowChangeEventHandler textsRowChanging;
public event textsRowChangeEventHandler textsRowChanged;
public event textsRowChangeEventHandler textsRowDeleting;
public event textsRowChangeEventHandler textsRowDeleted;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void AddtextsRow(textsRow row) {
this.Rows.Add(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow AddtextsRow(string text, string text_caption) {
textsRow rowtextsRow = ((textsRow)(this.NewRow()));
rowtextsRow.ItemArray = new object[] {
null,
text,
text_caption};
this.Rows.Add(rowtextsRow);
return rowtextsRow;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public virtual System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public override System.Data.DataTable Clone() {
textsDataTable cln = ((textsDataTable)(base.Clone()));
cln.InitVars();
return cln;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataTable CreateInstance() {
return new textsDataTable();
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal void InitVars() {
this.columntext_id = base.Columns["text_id"];
this.columntext = base.Columns["text"];
this.columntext_caption = base.Columns["text_caption"];
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
private void InitClass() {
this.columntext_id = new System.Data.DataColumn("text_id", typeof(int), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext_id);
this.columntext = new System.Data.DataColumn("text", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext);
this.columntext_caption = new System.Data.DataColumn("text_caption", typeof(string), null, System.Data.MappingType.Element);
base.Columns.Add(this.columntext_caption);
this.columntext_id.AutoIncrement = true;
this.columntext_id.AllowDBNull = false;
this.columntext_id.ReadOnly = true;
this.columntext.MaxLength = 1073741823;
this.columntext_caption.MaxLength = 1024;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public textsRow NewtextsRow() {
return ((textsRow)(this.NewRow()));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Data.DataRow NewRowFromBuilder(System.Data.DataRowBuilder builder) {
return new textsRow(builder);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override System.Type GetRowType() {
return typeof(textsRow);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanged(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.textsRowChanged != null)) {
this.textsRowChanged(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowChanging(System.Data.DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.textsRowChanging != null)) {
this.textsRowChanging(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleted(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.textsRowDeleted != null)) {
this.textsRowDeleted(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void OnRowDeleting(System.Data.DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.textsRowDeleting != null)) {
this.textsRowDeleting(this, new textsRowChangeEvent(((textsRow)(e.Row)), e.Action));
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void RemovetextsRow(textsRow row) {
this.Rows.Remove(row);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) {
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
adbDataSet ds = new adbDataSet();
xs.Add(ds.GetSchemaSerializable());
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "textsDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
return type;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class identitiesRow : System.Data.DataRow {
private identitiesDataTable tableidentities;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal identitiesRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tableidentities = ((identitiesDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int identity_id {
get {
return ((int)(this[this.tableidentities.identity_idColumn]));
}
set {
this[this.tableidentities.identity_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string identity_name {
get {
try {
return ((string)(this[this.tableidentities.identity_nameColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'identity_name\' in table \'identities\' is DBNull.", e);
}
}
set {
this[this.tableidentities.identity_nameColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public double identity_weight {
get {
try {
return ((double)(this[this.tableidentities.identity_weightColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'identity_weight\' in table \'identities\' is DBNull.", e);
}
}
set {
this[this.tableidentities.identity_weightColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Isidentity_nameNull() {
return this.IsNull(this.tableidentities.identity_nameColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Setidentity_nameNull() {
this[this.tableidentities.identity_nameColumn] = System.Convert.DBNull;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Isidentity_weightNull() {
return this.IsNull(this.tableidentities.identity_weightColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Setidentity_weightNull() {
this[this.tableidentities.identity_weightColumn] = System.Convert.DBNull;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class link_typesRow : System.Data.DataRow {
private link_typesDataTable tablelink_types;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal link_typesRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tablelink_types = ((link_typesDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int link_id {
get {
return ((int)(this[this.tablelink_types.link_idColumn]));
}
set {
this[this.tablelink_types.link_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string link_name {
get {
return ((string)(this[this.tablelink_types.link_nameColumn]));
}
set {
this[this.tablelink_types.link_nameColumn] = value;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class linksRow : System.Data.DataRow {
private linksDataTable tablelinks;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal linksRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tablelinks = ((linksDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int link_from {
get {
return ((int)(this[this.tablelinks.link_fromColumn]));
}
set {
this[this.tablelinks.link_fromColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int link_to {
get {
return ((int)(this[this.tablelinks.link_toColumn]));
}
set {
this[this.tablelinks.link_toColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public double link_weight {
get {
try {
return ((double)(this[this.tablelinks.link_weightColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'link_weight\' in table \'links\' is DBNull.", e);
}
}
set {
this[this.tablelinks.link_weightColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Islink_weightNull() {
return this.IsNull(this.tablelinks.link_weightColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Setlink_weightNull() {
this[this.tablelinks.link_weightColumn] = System.Convert.DBNull;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class text_identitiesRow : System.Data.DataRow {
private text_identitiesDataTable tabletext_identities;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal text_identitiesRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tabletext_identities = ((text_identitiesDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int text_id {
get {
return ((int)(this[this.tabletext_identities.text_idColumn]));
}
set {
this[this.tabletext_identities.text_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int identity_id {
get {
return ((int)(this[this.tabletext_identities.identity_idColumn]));
}
set {
this[this.tabletext_identities.identity_idColumn] = value;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public partial class textsRow : System.Data.DataRow {
private textsDataTable tabletexts;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
internal textsRow(System.Data.DataRowBuilder rb) :
base(rb) {
this.tabletexts = ((textsDataTable)(this.Table));
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public int text_id {
get {
return ((int)(this[this.tabletexts.text_idColumn]));
}
set {
this[this.tabletexts.text_idColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string text {
get {
try {
return ((string)(this[this.tabletexts.textColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'text\' in table \'texts\' is DBNull.", e);
}
}
set {
this[this.tabletexts.textColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public string text_caption {
get {
try {
return ((string)(this[this.tabletexts.text_captionColumn]));
}
catch (System.InvalidCastException e) {
throw new System.Data.StrongTypingException("The value for column \'text_caption\' in table \'texts\' is DBNull.", e);
}
}
set {
this[this.tabletexts.text_captionColumn] = value;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool IstextNull() {
return this.IsNull(this.tabletexts.textColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void SettextNull() {
this[this.tabletexts.textColumn] = System.Convert.DBNull;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public bool Istext_captionNull() {
return this.IsNull(this.tabletexts.text_captionColumn);
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public void Settext_captionNull() {
this[this.tabletexts.text_captionColumn] = System.Convert.DBNull;
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class identitiesRowChangeEvent : System.EventArgs {
private identitiesRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRowChangeEvent(identitiesRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public identitiesRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class link_typesRowChangeEvent : System.EventArgs {
private link_typesRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRowChangeEvent(link_typesRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public link_typesRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class linksRowChangeEvent : System.EventArgs {
private linksRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRowChangeEvent(linksRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public linksRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
public class text_identitiesRowChangeEvent : System.EventArgs {
private text_identitiesRow eventRow;
private System.Data.DataRowAction eventAction;
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRowChangeEvent(text_identitiesRow row, System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public text_identitiesRow Row {
get {
return this.eventRow;
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public System.Data.DataRowAction Action {
get {
return this.eventAction;
}
}
}