Rtti доступ к полям и свойствам в сложных структурах данных

вы касаетесь нескольких концепций и проблем с этим вопросом. Прежде всего, вы смешали некоторые типы записей и некоторые свойства, и я хотел бы сначала разобраться с этим. Затем я дам вам краткую информацию о том, как читать "левые" и "Верхние" поля записи, когда эта запись является частью поля в классе... Тогда я дам вам советы о том, как сделать эту работу в общем. Я, наверное, объясню немного больше, чем требуется, но сейчас полночь, и я не могу. спать!

пример:

TPoint = record
  Top: Integer;
  Left: Integer;
end;

TMyClass = class
protected
  function GetMyPoint: TPoint;
  procedure SetMyPoint(Value:TPoint);
public
  AnPoint: TPoint;           
  property MyPoint: TPoint read GetMyPoint write SetMyPoint;
end;

function TMyClass.GetMyPoint:Tpoint;
begin
  Result := AnPoint;
end;

procedure TMyClass.SetMyPoint(Value:TPoint);
begin
  AnPoint := Value;
end;

вот в чем дело. Если вы напишете этот код, во время выполнения он будет делать то, что он делает:

var X:TMyClass;
x.AnPoint.Left := 7;

но этот код не будет работать так же:

var X:TMyClass;
x.MyPoint.Left := 7;

потому что этот код эквивалентен:

var X:TMyClass;
var tmp:TPoint;

tmp := X.GetMyPoint;
tmp.Left := 7;

способ исправить это-сделать что-то вроде этого:

var X:TMyClass;
var P:TPoint;

P := X.MyPoint;
P.Left := 7;
X.MyPoint := P;

двигаясь дальше, вы хотите сделать то же самое с RTTI. Вы можете получить RTTI для поля "AnPoint:TPoint" и для поля" MyPoint:TPoint". Поскольку с помощью RTTI вы по существу используете функцию для получения значения, вам нужно будет использовать метод "сделать локальную копию, изменить, записать обратно" с обоими (тот же код, что и для примера X. MyPoint).

при выполнении этого с RTTI мы всегда будем начинать с "root" (экземпляр TExampleClass или экземпляр TMyClass) и использовать ничего, кроме серии методов Rtti GetValue и SetValue, чтобы получить значение глубокого поля или установить значение такое же глубокое поле.

предположим, что у нас есть следующее:

AnPointFieldRtti: TRttiField; // This is RTTI for the AnPoint field in the TMyClass class
LeftFieldRtti: TRttiField; // This is RTTI for the Left field of the TPoint record

мы хотим подражать это:

var X:TMyClass;
begin
  X.AnPoint.Left := 7;
end;

мы будем тормозить, что в шаги, мы стремимся к этому:

var X:TMyClass;
    V:TPoint;
begin
  V := X.AnPoint;
  V.Left := 7;
  X.AnPoint := V;
end;

потому что мы хотим сделать это с RTTI, и мы хотим, чтобы он работал с чем угодно, мы не будем использовать тип "TPoint". Итак, как и ожидалось, мы сначала сделаем это:

var X:TMyClass;
    V:TValue; // This will hide a TPoint value, but we'll pretend we don't know
begin
  V := AnPointFieldRtti.GetValue(X);
end;

для следующего шага мы будем использовать GetReferenceToRawData, чтобы получить указатель на запись TPoint скрытый в V: TValue (вы знаете, тот, о котором мы притворяемся, что ничего не знаем, кроме того факта, что это запись). Как только мы получим указатель на эту запись, мы можем вызвать метод SetValue для перемещения этого "7" внутри записи.

LeftFieldRtti.SetValue(V.GetReferenceToRawData, 7);

это все. Теперь нам просто нужно переместить TValue обратно в X: TMyClass:

AnPointFieldRtti.SetValue(X, V)

С головы до хвоста это будет выглядеть так:

var X:TMyClass;
    V:TPoint;
begin
  V := AnPointFieldRtti.GetValue(X);
  LeftFieldRtti.SetValue(V.GetReferenceToRawData, 7);
  AnPointFieldRtti.SetValue(X, V);
end;

это, очевидно, может быть расширено для обработки структур любой глубины. Просто помните, что вам нужно сделать это шаг за шагом: первый GetValue использует экземпляр "root", затем следующий GetValue использует экземпляр, извлеченный из предыдущего результата GetValue. Для записи мы можем использовать TValue.GetReferenceToRawData, для объектов мы можем использовать TValue.AsObject!

следующий сложный бит делает это общим способом, поэтому вы можете реализовать свою двунаправленную древовидную структуру. Для этого я бы рекомендовал сохранить путь от "root" до вашего поля в виде Trttimember array (затем литье будет использоваться для поиска фактического типа runtype, поэтому мы можем вызвать GetValue и SetValue). Узел будет выглядеть примерно так:

TMemberNode = class
  private
    FMember : array of TRttiMember; // path from root
    RootInstance:Pointer;
  public
    function GetValue:TValue;
    procedure SetValue(Value:TValue);
end;

реализация GetValue очень проста:

function TMemberNode.GetValue:TValue;
var i:Integer;    
begin
  Result := FMember[0].GetValue(RootInstance);
  for i:=1 to High(FMember) do
    if FMember[i-1].FieldType.IsRecord then
      Result := FMember[i].GetValue(Result.GetReferenceToRawData)
    else
      Result := FMember[i].GetValue(Result.AsObject);
end;

реализация SetValue будет немного более вовлечена. Из-за этих (надоедливых?) записи нам нужно будет сделать все процедура GetValue делает (потому что нам нужен указатель экземпляра для самого последнего Fmember element), тогда мы сможем вызвать SetValue, но нам может потребоваться вызвать SetValue для его родителя, а затем для его родителя и так далее... Это, очевидно, означает, что мы должны сохранить все промежуточные TValue нетронутыми, просто на случай, если они нам нужны. Итак, мы идем:

procedure TMemberNode.SetValue(Value:TValue);
var Values:array of TValue;
    i:Integer;
begin
  if Length(FMember) = 1 then
    FMember[0].SetValue(RootInstance, Value) // this is the trivial case
  else
    begin
      // We've got an strucutred case! Let the fun begin.
      SetLength(Values, Length(FMember)-1); // We don't need space for the last FMember

      // Initialization. The first is being read from the RootInstance
      Values[0] := FMember[0].GetValue(RootInstance);

      // Starting from the second path element, but stoping short of the last
      // path element, we read the next value
      for i:=1 to Length(FMember)-2 do // we'll stop before the last FMember element
        if FMember[i-1].FieldType.IsRecord then
          Values[i] := FMember[i].GetValue(Values[i-1].GetReferenceToRawData)
        else
          Values[i] := FMember[i].GetValue(Values[i-1].AsObject);

      // We now know the instance to use for the last element in the path
      // so we can start calling SetValue.
      if FMember[High(FMember)-1].FieldType.IsRecord then
        FMember[High(FMember)].SetValue(Values[High(FMember)-1].GetReferenceToRawData, Value)
      else
        FMember[High(FMember)].SetValue(Values[High(FMember)-1].AsObject, Value);

      // Any records along the way? Since we're dealing with classes or records, if
      // something is not a record then it's a instance. If we reach a "instance" then
      // we can stop processing.
      i := High(FMember)-1;
      while (i >= 0) and FMember[i].FieldType.IsRecord do
      begin
        if i = 0 then
          FMember[0].SetValue(RootInstance, Values[0])
        else
          if FMember[i-1].FieldType.IsRecord then
            FMember[i].SetValue(FMember[i-1].GetReferenceToRawData, Values[i])
          else
            FMember[i].SetValue(FMember[i-1].AsObject, Values[i]);
        // Up one level (closer to the root):
        Dec(i)
      end;
    end;
end;

... И это должно быть оно. Теперь некоторые предупреждения:

• не ожидайте, что это будет компилироваться! Я фактически написал каждый бит кода в этом сообщении в веб-браузере. Для технических причины, по которым у меня был доступ к Rtti.исходный файл pas для поиска имен методов и полей, но у меня нет доступа к компилятору.
• я был бы очень осторожен с этим кодом, особенно если речь идет о свойствах. Свойство может быть реализовано без резервного поля, процедура setter может не делать то, что вы ожидаете. Вы можете столкнуться с циклическими ссылками!

вы, похоже, неправильно понимаете, как работает указатель экземпляра. Вы не храните указатель на поле, вы храните указатель на класс или запись, что это поле. Ссылки на объекты уже являются указателями, поэтому там не требуется кастинг. Для записей необходимо получить указатель на них с символом@.

как только у вас есть указатель и объект TRttiField, который ссылается на это поле, вы можете вызвать SetValue или GetValue на TRttiField и передать указатель экземпляра, и он заботится обо всех вычислениях смещения для вас.

в конкретном случае массивов GetValue он даст вам TValue, который представляет массив. Вы можете проверить это, позвонив TValue.IsArray Если вы хотите. Когда у вас есть TValue, представляющий массив, вы можете получить длину массива с помощью TValue.GetArrayLength и получить отдельные элементы с TValue.GetArrayElement.

EDIT: вот как обращаться с членами записи в класс.

записи тоже являются типами, и у них есть RTTI. Вы можете изменить их, не делая "GetValue, modify, SetValue" следующим образом:

procedure ModifyPoint(example: TExampleClass; newXValue, newYValue: integer);
var
  context: TRttiContext;
  value: TValue;
  field: TRttiField;
  instance: pointer;
  recordType: TRttiRecordType;
begin
  field := context.GetType(TExampleClass).GetField('FPoint');
  //TValue that references the TPoint
  value := field.GetValue(example);
  //Extract the instance pointer to the TPoint within your object
  instance := value.GetReferenceToRawData;
  //RTTI for the TPoint type
  recordType := context.GetType(value.TypeInfo) as TRttiRecordType;
  //Access the individual members of the TPoint
  recordType.GetField('X').SetValue(instance, newXValue);
  recordType.GetField('Y').SetValue(instance, newYValue);
end;

похоже, что часть, о которой вы не знали, - это TValue.GetReferenceToRawData. Это даст вам указатель на поле, без необходимости беспокоиться о вычислении смещений и указателей на целые числа.