Как правильно хранить статичный набор начальных данных в классах?

[mazzy]

Вопрос: Как правильно хранить статичный набор начальных данные в классах?

=========================
Дисклаймер 1:
хотелось бы обсудить не технические детали, а подходы к программированию в Аксапте. Обсудить плюсы и минусы.

Дисклаймер 2:
Специально возьму пример не из области учета, а из области программирования низкого уровня (чтобы не начинать обсуждение в стиле "сделай по-другому", "используй другой функционал").

Дисклаймер 3:
я специально спрашиваю про классы, а не таблицы.
с таблицами - никаких вопросов. Кроме того, что таблицы надо создавать и инициализировать отдельно.
а вот классы:
3.1. могут "жить" и на клиенте, и на сервере.
3.2. могут наследовать - первоначальные данные могут переопределяться/добавляться в потомках
3.3. живут в памяти

=========================
пусть я создаю какой-то системный класс, который обновляет Query.
в классе статически прописан Query, в потомках Query может меняться.

и есть начальные данные, которые прописывает программист (НЕ ПОЛЬЗОВАТЕЛЬ):
набор пар <таблица, поле>
именно на эти поля и накладывается фильтр классом.

Дисклаймер 4: таблиц может быть несколько, полей может быть несколько, поля могут иметь расширенный код (например, Dimension[2])

Дисклаймер 5: хотелось бы обсудить хранение не только пар, но и троек/четверок/пятерок значений. Главное, что эти пары/тройки/четверки/и.т.д. - однородны по своей структуре.

============================
В С++ я бы написал что-то вроде
struct { int64 refTable; int refField } myStruct;
set<myStruct> myStructSet = ( {Table1, Field1}, {Table2, Field2} );
и получил бы одновременно и контроль типов, и легкость инициализации.

========================
Вопрос: а как лучше хранить такие статические наборы значений?

Что можно использовать в Аксапте:
Вариант 1.1
= контейнер контейнеров:
= пример [ [table1, field1], [table2, field2] ]
=== плюсы:
======= легко инициализировать
======= легко добавлять/изменять значения в наборе в классах потомках
=== минусы:
======= никакой типизации и никакой проверки типов на этапе компиляции

Вариант 1.2
= контейнер структур (struct):
= пример
new struct1 = new Struct(Types::Int64, Types::Integer);
new struct2 = new Struct(Types::Int64, Types::Integer);
... [ struct1, struct2 ]
=== плюсы:
======= хоть какая то типизация
=== минусы:
======= инициализировать уже неудобно
======= нет проверки заполненности полей в структуре

Вариант 1.3
= контейнер собственных классов (или подходящих. В данном случе можно использовать DictField)
= пример [ new myPairClass(table1, field1), new myPairClass(table2, field2) ]
=== плюсы:
======= полный контроль над целостностью и валидностью данных
======= в потомках легко добавлять/изменять наборы
=== минусы:
======= нужно программировать свой класс - трудоемко

Вариант 2.1
set of контейнеров (множество контейнеров)

Вариант 2.2
set of struct (множество структур)

Вариант 2.3
set of myPairClass (множество собственных классов)

Вариант 3.1
list of контейнеров (множество контейнеров)

Вариант 3.2
list of struct (множество структур)

Вариант 3.3
list of myPairClass (множество собственных классов)

другие способы?
========================

Какой способ вы предпочитаете?
Почему? Какие плюсы и минусы у разных способов?
Какие примеры хранения наборов данных есть в стандартной Аксапте?

========================
Например, в Аксапте есть FieldList.
Этот класс хранит список полей в одной (!) таблице.
Этот класс хранит список полей в контейнере. (со всеми вытекающими по контролю типов)
Этот класс пытается сам предоставить интерфейс доступа через find.
Этот класс не предоставляет enumerator'а для своего содержимого
В общем, как-то не айс.

Вопрос: Как правильно хранить статичный набор начальных данные в классах?