ezexpressions.pas

很管用的GIS控件

              TheRecno := FPrimaryLayer.Recno;
              FRecordList[TheRecno] := true;
              FMinRecno := IMin( FMinRecno, TheRecno );
              FMaxRecno := IMax( FMaxRecno, TheRecno );
            End;
          Finally
            EntityToQuery.free;
          End;
        Finally
          FPrimaryLayer.Next;
        End;
      End;
    Finally
      FPrimaryLayer.CancelFilter;
    End;
  End;

Begin
  Inherited Create( ParameterList );
  ErrorFound:=false;
  If ParameterList <> Nil Then
  Begin
    If ( ParameterList.Count = 3 ) And
      ( ParameterList.Param[0] Is TEntExpr ) And
      ( ParameterList.Param[1] Is TEzGraphicOperatorExpr ) And
      ( ( ParameterList.ExprType[2] = ttString ) Or
        ( ParameterList.Param[2] Is TEntExpr ) Or
        ( ParameterList.Param[2] Is TEzQueryVectorExpr ) Or
        ( ParameterList.Param[2] Is TEzQueryLayerExpr ) Or
        ( ParameterList.Param[2] Is TEzQueryScopeExpr ) ) Then
    Begin
      // all is right
    End
    Else If ParameterList.Count > 3 Then  // a list of records
    Begin
      For I := 3 To ParameterList.Count - 1 Do
      Begin
        If Not ( ParameterList.ExprType[I] = ttInteger ) Then
        Begin
          ErrorFound := true;
          Break;
        End;
      End;
    End
    Else
      ErrorFound := true;
  End
  Else
    ErrorFound := true;

  if ErrorFound then
    Raise EExpression.Create( Format(SWrongParameters, ['QUERY_LAYER']) );

  FMainExpr := MainExpr;
  FRecordList := TBits.Create;
  { determines the type of query }
  QueryLayerKind := Low( TEzQueryLayerKind );
  TestLayer := Nil;
  TheRecordList := Nil;
  If ParameterList.Count > 3 Then
  Begin
    If ( ParameterList.Count = 4 ) And ( ParameterList.ExprType[2] = ttBoolean ) And
      ( ParameterList.ExprType[3] = ttString ) Then
      QueryLayerKind := qlkComplexExpression
    Else
      QueryLayerKind := qlkFixedRecords;
  End
  Else If ParameterList.Count = 3 Then
  Begin
    If Param[2] Is TEntExpr Then
      QueryLayerKind := qlkAllRecords
    Else If Param[2] Is TEzQueryVectorExpr Then
      QueryLayerKind := qlkQueryVector
    Else If Param[2] Is TEzQueryScopeExpr Then
      QueryLayerKind := qlkQueryScope
    Else If Param[2] Is TEzQueryLayerExpr Then
      QueryLayerKind := qlkQueryLayer
    Else
      Raise EExpression.Create( 'Third parameter is wrong' );
  End;
  FMinRecno := System.MaxInt;
  FMaxRecno := -System.MaxInt;
  { get the test layer}
  FPrimaryLayer:= ( Param[0] As TEntExpr ).FLayer;
  { get the graphic operator }
  Operator := TEzGraphicOperator( Param[1].AsInteger );
  Case QueryLayerKind Of
    qlkFixedRecords:
      Begin
        { get the layer whose records will be used to query to FPrimaryLayer. }
        TestLayer := ( Param[2] As TEntExpr ).FLayer;
        { query to specific records }
        For I := 3 To ParameterCount - 1 Do
        Begin
          TestEntity := TestLayer.LoadEntityWithRecno( Param[I].AsInteger );
          If TestEntity = Nil Then
            Continue;
          Try
            DoQuery;
          Finally
            TestEntity.free;
          End;
        End;
      End;
    qlkAllRecords:
      Begin
        { get the layer whose records will be used to query to FPrimaryLayer. }
        TestLayer := ( Param[2] As TEntExpr ).FLayer;
        { use all the records in SourceLayer}
        TestLayer.First;
        TestLayer.StartBuffering;
        Try
          While Not TestLayer.eof Do
          Begin
            Try
              If TestLayer.RecIsDeleted Then
                continue;
              TestEntity := TestLayer.RecLoadEntity;
              If TestEntity = Nil Then
                Continue;
              Try
                DoQuery;
              Finally
                TestEntity.free;
              End;
            Finally
              TestLayer.Next;
            End;
          End;
        Finally
          TestLayer.EndBuffering;
        End;
      End;
    qlkQueryVector, qlkQueryScope, qlkQueryLayer, qlkComplexExpression:
      Begin
        If QueryLayerKind = qlkQueryVector Then
        Begin
          TestLayer := TEzQueryVectorExpr( Param[2] ).FPrimaryLayer;
          TheRecordList := TEzQueryVectorExpr( Param[2] ).FRecordList;
          MinRec := TEzQueryVectorExpr( Param[2] ).FMinRecno;
          MaxRec := TEzQueryVectorExpr( Param[2] ).FMaxRecno;
        End
        Else If QueryLayerKind = qlkQueryScope Then
        Begin
          TestLayer := TEzQueryScopeExpr( Param[2] ).FPrimaryLayer;
          TheRecordList := TEzQueryScopeExpr( Param[2] ).FRecordList;
          MinRec := TEzQueryScopeExpr( Param[2] ).FMinRecno;
          MaxRec := TEzQueryScopeExpr( Param[2] ).FMaxRecno;
        End
        Else If QueryLayerKind in [qlkQueryLayer, qlkComplexExpression] Then
        Begin
          TestLayer := TEzQueryLayerExpr( Param[2] ).FPrimaryLayer;
          TheRecordList := TEzQueryLayerExpr( Param[2] ).FRecordList;
          MinRec := TEzQueryLayerExpr( Param[2] ).FMinRecno;
          MaxRec := TEzQueryLayerExpr( Param[2] ).FMaxRecno;
        End
        Else
        Begin
          MinRec := 0;
          MaxRec := -1;
        End;
        For I := MinRec To MaxRec Do
        Begin
          If TheRecordList[I] Then
          Begin
            TestEntity := TestLayer.LoadEntityWithRecno( I );
            If TestEntity = Nil Then
              Continue;
            Try
              DoQuery;
            Finally
              TestEntity.free;
            End;
          End;
        End;
      End;
  End;

End;

Destructor TEzQueryLayerExpr.Destroy;
Begin
  FRecordList.free;
  Inherited Destroy;
End;

{$IFDEF BCB}
function TEzQueryLayerExpr.GetPrimaryLayer: TEzBaseLayer;
begin
  Result := FPrimaryLayer;
end;
{$ENDIF}

Function TEzQueryLayerExpr.GetAsBoolean: Boolean;
Var
  TheRecno: Integer;
Begin
  TheRecno := FPrimaryLayer.Recno;
  If TheRecno <= FMaxRecno Then
    Result := FRecordList[TheRecno]
  Else
    Result := false;
End;

Function TEzQueryLayerExpr.GetExprType: TExprType;
Begin
  result := ttBoolean;
End;

{$IFDEF BCB}
function TEzVectorExpr.GetVector: TEzVector;
begin
  Result := FVector;
end;
{$ENDIF}

{ TEzQueryVectorExpr }

Constructor TEzQueryVectorExpr.Create( ParameterList: TParameterList;
  MainExpr: TEzMainExpr );
Var
  TestEntity: TEzEntity;
  Operator: TEzGraphicOperator;
  Vector: TEzVector;
  EntityToQuery: TEzEntity;
  Passed: Boolean;
  TheRecno: Integer;
  VectorType: TEzVectorType;
  BufferWidth: Double;
  TempEntity: TEzEntity;
Begin
  Inherited Create( ParameterList );
  If ( ParameterList <> Nil ) And ( ParameterList.Count = 3 ) And
     ( ParameterList.Param[0] Is TEntExpr ) And
     ( ParameterList.Param[1] Is TEzGraphicOperatorExpr ) And
     ( ParameterList.Param[2] Is TEzVectorExpr ) Then
  Begin
    // all is right here
  End Else
  Begin
    Raise EExpression.Create( Format(SWrongParameters, ['QUERY_VECTOR']) );
  End;

  FMainExpr := MainExpr;
  FRecordList := TBits.Create;
  FMinRecno := System.MaxInt;
  FMaxRecno := -System.MaxInt;

  { get the test layer}
  FPrimaryLayer := ( Param[0] As TEntExpr ).FLayer;
  { get the graphic operator }
  Operator := TEzGraphicOperator( Param[1].AsInteger );
  { get the vector }
  Vector := ( Param[2] As TEzVectorExpr ).FVector;
  VectorType:= ( Param[2] As TEzVectorExpr ).FVectorType;
  BufferWidth:= ( Param[2] As TEzVectorExpr ).FBufferWidth;
  if VectorType = vtPolygon then
  begin
    if not EqualPoint2d( Vector[0], Vector[Vector.Count - 1] ) Then
      Vector.Add( Vector[0] );
    TestEntity := TEzPolygon.Create( Vector.Count );
    TestEntity.Points.Assign( Vector );
  end else if VectorType = vtBuffer then
  begin
    TempEntity := TEzPolyline.Create( Vector.Count );
    try
      TempEntity.Points.Assign( Vector );
      TestEntity:= CreateBufferFromEntity( TempEntity, 50, BufferWidth );
    finally
      TempEntity.Free;
    end;
  end else  { assumed a simple polyline if VectorType in [ vtPolyline, vtBuffer ] }
  begin
    TestEntity := TEzPolyline.Create( Vector.Count );
    TestEntity.Points.Assign( Vector );
  end;
  { now query against this entity TestEntity }
  { Set filter for the source layer and for this entity in order to optimize speed }
  FPrimaryLayer.SetGraphicFilter( stOverlap, TestEntity.FBox );
  FPrimaryLayer.First;
  Try
    While Not FPrimaryLayer.eof Do
    Begin
      Try
        If FPrimaryLayer.RecIsDeleted Then
          Continue;
        EntityToQuery := FPrimaryLayer.RecLoadEntity;
        If EntityToQuery = Nil Then
          Continue;
        Try
          Passed := EntityToQuery.CompareAgainst( TestEntity, Operator );
          If Passed Then
          Begin
            TheRecno := FPrimaryLayer.Recno;
            FRecordList[TheRecno] := true;
            FMinRecno := IMin( FMinRecno, TheRecno );
            FMaxRecno := IMax( FMaxRecno, TheRecno );
          End;
        Finally
          EntityToQuery.free;
        End;
      Finally
        FPrimaryLayer.Next;
      End;
    End;
  Finally
    FPrimaryLayer.CancelFilter;
    TestEntity.Free;
  End;
End;

Destructor TEzQueryVectorExpr.Destroy;
Begin
  FRecordList.free;
  Inherited Destroy;
End;

Function TEzQueryVectorExpr.GetAsBoolean: Boolean;
Var
  TheRecno: Integer;
Begin
  TheRecno := FPrimaryLayer.Recno;
  If TheRecno <= FMaxRecno Then
    Result := FRecordList[TheRecno]
  Else
    Result := false;
End;

Function TEzQueryVectorExpr.GetExprType: TExprType;
Begin
  result := ttBoolean;
End;

{$IFDEF BCB}
function TEzQueryVectorExpr.GetPrimaryLayer: TEzBaseLayer;
begin
  Result := FPrimaryLayer;
end;
{$ENDIF}

{ TEzQueryScopeExpr }

Constructor TEzQueryScopeExpr.Create( ParameterList: TParameterList;
  MainExpr: TEzMainExpr );
Var
  //Resolver: TEzMainExpr;
  TheRecno: Integer;
Begin
  Inherited Create( ParameterList );

  If ( ParameterList <> Nil ) And ( ParameterList.Count = 2 ) And
     ( ParameterList.Param[0] Is TEntExpr ) And
     ( ParameterList.ExprType[1] = ttBoolean ) Then
  Begin
    // all is right
  End
  Else
    Raise EExpression.Create( Format(SWrongParameters, ['QUERY_SCOPE']) );

  FMainExpr := MainExpr;
  FRecordList := TBits.create;
  FMinRecno := System.MaxInt;
  FMaxRecno := -System.MaxInt;

  { get the test layer}
  FPrimaryLayer := ( Param[0] As TEntExpr ).FLayer;
  { create the expression }
  {Resolver := Nil;
  if no resolver is defined, then all records are included }
  {If Length( Param[1].AsString ) > 0 Then
  Begin
    Resolver := TEzMainExpr.Create( FMainExpr.Gis, FPrimaryLayer );
    Resolver.ParseExpression( Param[1].AsString );
    If Resolver.Expression.ExprType <> ttBoolean Then
      FreeAndNil( Resolver ); // all records will be included on wrong expression type !!!
  End; }
  FPrimaryLayer.First;
  FPrimaryLayer.StartBuffering;
  Try
    While Not FPrimaryLayer.Eof Do
    Begin
      Try
        If FPrimaryLayer.RecIsDeleted Then
          Continue;
        //If Resolver <> Nil Then
        //Begin
          If FPrimaryLayer.DBTable <> Nil Then
            FPrimaryLayer.Synchronize;
          If Param[1].AsBoolean Then
          Begin
            TheRecno := FPrimaryLayer.Recno;
            FRecordList[TheRecno] := true;
            FMinRecno := IMin( FMinRecno, TheRecno );
            FMaxRecno := IMax( FMaxRecno, TheRecno );
          End;
        //End
        //Else
        //Begin
          //TheRecno := FPrimaryLayer.Recno;
          //FRecordList[TheRecno] := true;
          //FMinRecno := IMin( FMinRecno, TheRecno );
          //FMaxRecno := IMax( FMaxRecno, TheRecno );
        //End;
      Finally
        FPrimaryLayer.Next;
      End;
    End;
  Finally
    FPrimaryLayer.EndBuffering;
  End;

End;

Destructor TEzQueryScopeExpr.destroy;
Begin
  FRecordList.free;
  Inherited destroy;
End;

Function TEzQueryScopeExpr.GetAsBoolean: Boolean;
Var
  TheRecno: Integer;
Begin
  TheRecno := FPrimaryLayer.Recno;
  If TheRecno <= FMaxRecno Then
    Result := FRecordList[TheRecno]
  Else
    Result := false;
End;

Function TEzQueryScopeExpr.GetExprType: TExprType;
Begin
  result := ttBoolean;
End;

{ TUDFExpr - class implementation}

Constructor TUDFExpr.Create( ParameterList: TParameterList;
  GIS: TEzBaseGIS; Layer: TEzBaseLayer; Const Identifier: String;
  DataType: TExprType; MaxLen: Integer );
Begin
  Inherited Create( ParameterList );
  FLayer := Layer;
  FGIS := GIS;
  FIdentifier := Identifier;
  FDataType := DataType;
  FMaxLen:= MaxLen;
End;

Function TUDFExpr.GetExprType: TExprType;
Begin
  Result := FDataType;
End;

Function TUDFExpr.GetMaxString: String;
Var
  Mx: Integer;
Begin
  Result:= '';
  if Not (FDatatype = ttString) then Exit;
  Mx:= FMaxLen;