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

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

Когда у вас есть указатель и объект 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. Это даст вам указатель на поле, без необходимости беспокоиться о вычислении смещений и приведении указателей к целым числам.

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

Пример:

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 мы всегда будем начинать с "корня" (экземпляр 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 использует "корневой" экземпляр, затем следующий GetValue использует экземпляр, извлеченный из результата предыдущего GetValue. Для записей мы можем использовать TValue.GetReferenceToRawData, для объектов - TValue.AsObject!

Следующий сложный момент - сделать это общим способом, чтобы вы могли реализовать двунаправленную древовидную структуру. Для этого я бы рекомендовал хранить путь от "корня" до вашего поля в виде массива TRttiMember (затем будет использовано приведение для нахождения фактического типа 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 (потому что нам нужен указатель Instance для самого последнего элемента FMember), затем мы сможем вызвать 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 может сделать не то, что вы ожидаете. Вы можете столкнуться с круговыми ссылками!