Owl's perspective

2017年7月19日

[書籍][ebook]Expert Delphi

Packt Publishingで注文した

Expert Delphi (amazon US, amazon JP)/Paweł Głowacki著/Packt Publishing/ISBN9781786460165/49.99USD(Print+eBook)

が配送されてきました(今回の配送もDHL/佐川急便で、インドはチェンナイ(旧マドラス)からの発送でした)。2017/07/11に注文して8日目の到着、49.99USDから20% discountで40.00USD=4,576JPY(暫定、1USD=114.40JPY)でした。

2017年7月12日

Microsoft Monthly Update 2017/07

今日はMicrosoftのセキュリティアップデートの日です。
リリースノート 2017 年 7 月のセキュリティ更新プログラム
2017 年 7 月のセキュリティ更新プログラム (月例) – 日本のセキュリティチーム

2017年7月7日

[書籍]現場で役立つシステム設計の原則

啓文堂書店渋谷店で

現場で役立つシステム設計の原則 (amazon)/増田亨著/技術評論社/3,175円/ISBN978-4-7741-9087-7

を購入。

2017年7月1日

2017/07開催のセミナー

Web Seminar
Live Seminar
- 2017/07/06 16:00-18:00(JST) セミナー「モバイル、クラウド、IoT時代にどう立ち向かう？これからのDBアプリケーション開発」
- 2017/07/28 10:00-18:00(JST) 第34回エンバカデロ・デベロッパーキャンプ・イン東京

2017年6月23日

[書籍]Effective Debugging

紀伊國屋書店新宿本店でEffective Debugging (amazon US)の翻訳である

Effective Debugging (amazon)/Diomidis Spinellis著/黒川利明訳/大岩尚宏技術監修/オライリージャパン/3,456円/ISBN978-4-87311-799-7

を購入。

[書籍]改訂新版 C#ポケットリファレンス

紀伊國屋書店新宿本店で

[改訂新版]C#ポケットリファレンス (amazon)/WINGSプロジェクト、土井毅、髙江賢、飯島聡著/山田祥寛監修/技術評論社/2,851円/ISBN978-4-7741-9030-3

を購入。

RAD Studio/Delphi/C++Builder 10.2 Tokyo Android Compatibility Pack

RAD Studio/Delphi/C++Builder 10.2 TokyoのHotfixがリリースされています。以下の新しいバージョンのAndroid上でのテキストの入力の問題(10.1 Berlinでも発生)とレンダリングや性能上の問題(10.2 Tokyoで発生)を修正するとのことです。

30781 FireMonkey Android Compatibility Patch for RAD Studio 10.2
30782 Source code for FireMonkey Android Compatibility Patch

RAD Studio 10.2 向け FireMonkey の Android互換性パッチ [JAPAN]

なおこのHotfixよりも先に30764 April 2017 RAD Studio 10.2 Hotfix for Toolchain Issuesをインストールする必要があるとのことです(30781を適用後に30764を適用した場合、再度30781を適用しなければならない)。

2017年6月14日

Microsoft Monthly Update 2017/06

今日はMicrosoftのセキュリティアップデートの日です。
リリースノート 2017 年 6 月のセキュリティリリース
2017 年 6 月のセキュリティ更新プログラム (月例) – 日本のセキュリティチーム

2017年6月1日

[書籍]Windows Sysinternals徹底解説改訂新版

紀伊國屋書店新宿本店でWindows Sysinternals徹底解説の改訂版でTroubleshooting with the Windows Sysinternals Tools, 2nd Edition (amazon US)の翻訳である

Windows Sysinternals徹底解説改訂新版 (amazon)/Mark Russinovich、Aaron Margosis著/山内和朗訳/日経BP/5,940円/ISBN978-4-82229-896-8

を購入。

2017/06開催のセミナー

Web Seminar
Live Seminar

2017年5月31日

[書籍]Delphi in Depth: FireDAC

Amazon (US)で注文した

Delphi in Depth: FireDAC (CreateSpace, amazon US)/Cary Jensen著/CreateSpace/ISBN978-1546391272/49.99USD

が配送されてきました(今回の発送地はアメリカ合衆国デラウェア州、配送はUPS i-parcel/佐川急便でした)。2017/05/19に注文して12日目の到着、Dependency Injection In Delphiと合わせてShipping & Handlingが10.97USDで計60.96USD=~~6,787JPY~~6,979JPY(~~暫定、1USD=111.33JPY~~1USD=114.479JPY)でした。

2017年5月12日

RAD Studio ロードマップ 2017/05

RAD Studioのロードマップの2017/05版が公開されています。

RAD Studio Roadmap May 2017
May 2017 Roadmap Commentary from Product Management

日本語訳もそのうち公開されると思われますが、注目点をいくつかピックアップしておきます。

RAD Studio 10.2.1 Tokyoは今年(2017年)半ばくらいにリリース、C++BuilderのLinux Serverサポートを追加
RAD Studio 10.2.2 Tokyoは2017年末くらいにリリース、AndroidのZ-オーダサポートとWindows 10/WinRT関係の更新、C++のリファクタリングでリネーム機能のサポートとコード補完、コードインサイトの強化といったあたり
RAD Studio 10.3 コードネーム "Carnival"は2018年で、FMXでAndroidのネイティブコントロールのサポート、LLDBの統合、C++17サポート、Delphiで64bit macOSのサポートの追加、DelphiでNullable型サポートや文法面の強化など

2017/05/19追記: 日本語訳が公開されました。

RAD Studioロードマップ（2017年5月付）

2017/05/22追記: コメントについても日本語訳が公開されています。

製品マネージャからの2017年5月付け製品ロードマップに関するコメント

2017年5月10日

Microsoft Monthly Update 2017/05

今日はMicrosoftのセキュリティアップデートの日です。
リリースノート 2017 年 5 月のセキュリティ更新プログラム (en)
2017 年 5 月のセキュリティ更新プログラム (月例) – 日本のセキュリティチーム

2017年5月4日

RAD Studio/Delphi/C++Builder 10.2 Tokyo April 2017 Hotfix for Toolchain Issues

RAD Studio/Delphi/C++Builder 10.2 TokyoのHotfixがリリースされています。デバッガ、C++ RTL、Delphiコンパイラの以下の問題を修正するとのことです。

デバッガ
- Android/Linuxで関数を評価するときに例外を投げたりaccess violationが起きるとデバッグ中のアプリケーションが終了してしまうことがある
- AndroidでDelphi文字列に関係するいくつかの問題
- Linuxでほかのユニットで定義されているインライン関数を展開したときに行番号情報がないためにデバッグできない
- iOSとAndroidでレコード型の動的配列を評価しようとするとデバッガがクラッシュする(iOS)またはnilが表示される(Android)
- Linuxでクラスデストラクタをデバッグしようとすると2つのブレークポイントが必要になることがある
C++ RTL
- [RSP-16394] AV on exit after FreeLibrary: WindowsアプリケーションでLoadLibraryを使用して動的にライブラリをロードしていると終了時にaccess violationが発生することがある
- scanfと関係するメソッド(_sのようなセキュリティ強化版を含む)の不具合で、出力バッファのサイズを超えて入力データで上書きされる
Delphiコンパイラ
- C++ Windows x64アプリケーションにDelphiユニットを静的にリンクするとリソース文字列が破損する
- [RSP-17138] Win64 compilation stuck at linking: Delphi Windows x64コンパイラが応答しなくなりCPUを100%使用した状態になることがある

30764 April 2017 RAD Studio 10.2 Hotfix for Toolchain Issues

April 2017 RAD Studio 10.2 Hotfix for Toolchain Issues
RAD Studio 10.2 Hotfix for Toolchain Issues リリース [JAPAN]

InterBase XE7 Update 7

InterBase XE7 Update 7がリリースされています。バージョンは12.0.7.384となっています。

30768 InterBase XE7 Update 7 (12.0.7.384) for Windows
30769 InterBase XE7 Update 7 (12.0.7.384) for Linux
30770 InterBase XE7 ToGo Edition (12.0.7.384), Win/OSX/iOS/Android

InterBase XE7 Update 7 Readme (en)
解決された不具合 (en)

InterBase XE7 Update 7 – now available

2017年5月1日

2017/05開催のセミナー

2017年4月17日

[書籍][ebook]プロフェッショナルSSL/TLS

Bulletproof SSL and TLS (amazon US)の翻訳である

プロフェッショナルSSL/TLS/Ivan Ristic著/齋藤孝道監訳/ラムダノート/ISBN978-4-908686-00-9/5,399円(紙書籍+電子書籍(PDF))、4,860円(電子書籍(PDF)のみ)

を購入。PDFは購入後すぐにダウンロード可能、紙書籍は別途2017/05/10前後に配送(配送費別、540円)とのこと。

2017/05/11追記: 書籍版が配送されてきました(配送は佐川急便でした)。

2017年4月12日

Microsoft Monthly Update 2017/04

今日はMicrosoftのセキュリティアップデートの日です。
リリースノート 2017 年 4 月のセキュリティ更新プログラム (en)
2017 年 4 月のセキュリティ更新プログラム (月例) – 日本のセキュリティチーム

今月からセキュリティ情報の公開は廃止されています。またWindows Vistaの延長サポートが終了となっています。

2017年4月10日

IDE Fix Pack 5.96/DDevExtensions 2.84 for RAD Studio/Delphi/C++Builder 10.2 Tokyo

Andreas HausladenさんのIDE Fix PackがアップデートされてVersion 5.96となっています。RAD Studio/Delphi/C++Builder 10.2 Tokyo対応といくつかの修正が行われています。またDDevExtensions Version 2.84もRAD Studio/Delphi/C++Builder 10.2 Tokyo対応が行われています。

IDE Fix Pack 5.96, DDevExtensions, DFMCheck for Delphi 10.2 | Andy's Blog and Tools

2017年4月1日

2017/04開催のセミナー

Web Seminar
Live Seminar
- 2017/04/14 14:00-17:00(JST) セミナー「Delphi / C++ Builder 業務アプリケーション刷新実践法」
  - BDEを使った業務アプリを移行ツールで最新化 (2017年4月14日実施セミナーサマリー）[JAPAN]

2017年3月23日

RAD Studio/Delphi/C++Builder 10.2 Tokyoリリース

Firebird 3.0.2

Firebird 3.0.2がリリースされています。

Firebird: Firebird 3.0.2
Firebird 3.0.2 Release Notes (PDF)

2017年3月22日

ジェネリックスのリストをアルゴリズムを指定してソートする

Delphi 2009で導入されたジェネリックスのコンテナの一つであるTList<T>にはSortメソッドがあり、比較関数としてデフォルト以外のComparer(コンペアラ)も渡すことができるのですが、ソートアルゴリズムそのものはクイックソートしかありません。一般的には平均して性能が出るとされるクイックソートですが、安定ではないこと、苦手な状況が存在することなど、決して万能というわけではありません。ところがTList<T>.Sortは内部で保持しているTArray.Sortにソートを丸投げしており、ソートアルゴリズムを変更することができません。そこでアルゴリズムを指定してTList<T>(およびTObjectList<T: class>)をソートする方法を考えてみました。ただしDelphi 2009のTList<T>にはExchangeメソッドもMoveメソッドも存在していないため、Delphi 2010以降の対応になります。

まずソートを行うためのレコード型と、ソートアルゴリズムを実装するクラスの継承元クラスの宣言です。

{$IF RTLVersion <= 20.00}
{$MESSAGE ERROR 'Need Delphi 2010 or later'}
{$IFEND}

uses
{$IF RTLVersion >= 23.00}
  System.Rtti, System.Generics.Defaults, System.Generics.Collections;
{$ELSE}
  Rtti, Generics.Defaults, Generics.Collections;
{$IFEND}

type
  { Forward declarations }
  TSortAlgorithm<T> = class;

  { TGenericListSorter }
  TGenericListSorter = record
  private
    class function  GetComparer<T>(List: TList<T>; const AComparer: IComparer<T>): IComparer<T>; static;
  public
    class procedure Sort<T: record>(List: TList<T>; Algorithm: TSortAlgorithm<T>;
                                    const AComparer: IComparer<T>{$IF CompilerVersion >= 24.00} = nil{$IFEND}); overload; static;
{$IF CompilerVersion < 24.00}
    class procedure Sort<T: record>(List: TList<T>; Algorithm: TSortAlgorithm<T>); overload; static;
{$IFEND}
    class procedure Sort<T: class>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>;
                                   const AComparer: IComparer<T>{$IF CompilerVersion >= 24.00} = nil{$IFEND}); overload; static;
{$IF CompilerVersion < 24.00}
    class procedure Sort<T: class>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>); overload; static;
{$IFEND}
    class procedure Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>;
                         const AComparer: IComparer<String>{$IF CompilerVersion >= 24.00} = nil{$IFEND}); overload; static;
{$IF CompilerVersion < 24.00}
    class procedure Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>); overload; static;
{$IFEND}
  end;

  { TSortAlgorithm (abstract) }
  TSortAlgorithm<T> = class(TObject)
  public
    class function  Instance: TSortAlgorithm<T>; virtual; abstract;
    class procedure Sort(List: TList<T>; const AComparer: IComparer<T>); virtual; abstract;
  end;

TGenericListSorterはソートを行うためのレコード型で、overloadされたpublicな3つ(XE2およびそれ以前は6つ、後述)のSortメソッドと、比較を行うコンペアラを決定するためのprivateなGetComparerメソッドを持ちます。Sortメソッドの1つめは値型用(レコード制約)、2つめはクラス型用(クラス制約)、3つめはこのどちらにも含まれない文字列型用です。IComparer<T>にデフォルトパラメータを指定できるのはDelphi XE3以降のため、それ以前のバージョンではコンペアラを指定しないオーバロードをさらに3つ用意しました。またTSortAlgorithm<T>はソートアルゴリズムを実装するためのクラスの継承元になります。実際にソートを行うSortメソッドと、シングルトンなインスタンスを取得するためのInstanceメソッドを持ちます。TGenericListSorterの実装は次のようになります。

class procedure TGenericListSorter.Sort<T>(List: TList<T>; Algorithm: TSortAlgorithm<T>;
                                           const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,AComparer);

  Algorithm.Sort(List,Comparer);

end;

{$IF CompilerVersion < 24.00}
class procedure TGenericListSorter.Sort<T>(List: TList<T>; Algorithm: TSortAlgorithm<T>);
var
  Comparer: IComparer<T>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,nil);

  Algorithm.Sort(List,Comparer);

end;
{$IFEND}

class procedure TGenericListSorter.Sort<T>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>;
                                           const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
  OwnsObjects: Boolean;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,AComparer);

  OwnsObjects := List.OwnsObjects;
  try
    List.OwnsObjects := False;
    Algorithm.Sort(List,Comparer);

  finally
    List.OwnsObjects := OwnsObjects;
  end;

end;

{$IF CompilerVersion < 24.00}
class procedure TGenericListSorter.Sort<T>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>);
var
  Comparer: IComparer<T>;
  OwnsObjects: Boolean;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,nil);

  OwnsObjects := List.OwnsObjects;
  try
    List.OwnsObjects := False;
    Algorithm.Sort(List,Comparer);

  finally
    List.OwnsObjects := OwnsObjects;
  end;

end;
{$IFEND}

class procedure TGenericListSorter.Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>;
                                        const AComparer: IComparer<String>);
var
  Comparer: IComparer<String>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<String>(List,AComparer);

  Algorithm.Sort(List,Comparer);

end;

{$IF CompilerVersion < 24.00}
class procedure TGenericListSorter.Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>);
var
  Comparer: IComparer<String>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<String>(List,nil);

  Algorithm.Sort(List,Comparer);

end;
{$IFEND}

class function TGenericListSorter.GetComparer<T>(List: TList<T>; const AComparer: IComparer<T>): IComparer<T>;
var
  ctx: TRttiContext;
begin

  Result := AComparer;
  if Result = nil then
  begin
    Result := ctx.GetType(List.ClassType).GetField('FComparer').GetValue(List).AsType<IComparer<T>>;
  end;

end;

Sortメソッドはいずれもコンペアラを確定し、指定されたソートアルゴリズムのインスタンスのSortメソッドを呼び出しています。ただしTObjectList<T>用のオーバロードはソートを行っている間、一時的にOwnsObjectsをFalseに変更しています。これはOwnsObjectsがTrueだと(以下の例のマージソートのように)Items[]に代入を行ったときに、もともと格納されているTのインスタンスを解放してしまうためで、ソートアルゴリズムのクラスで直接ソートを行うのではなく、レコード型TGenericListSorterの3つのオーバロードに処理を分けて、そこから間接的に呼び出すようになっているのはこれが理由です。またGetComparerメソッドはコンペアラが指定されていない(=nil)ときに、TList<T>の持つデフォルトのコンペアラを(RTTIを使って)取得します。次に実際のソートアルゴリズムを実装したクラスですが、まずコムソートを実装してみます。

type
  TCombSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TCombSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TCombSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TCombSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
const
  SHRINK_FACTOR = 1.247330950103979;
var
  Index: Integer;
  Gap: Integer;
  Swapped: Boolean;
begin

  Gap := List.Count;
  Swapped := True;

  while (Gap > 1) or (Swapped = True) do
  begin
    if Gap > 1 then
    begin
      Gap := Trunc(Gap / SHRINK_FACTOR);
    end;

    if Gap < 1 then
    begin
      Gap := 1;
    end;

    Swapped := False;
    Index := 0;

    while (Gap + Index) < List.Count do
    begin
      if AComparer.Compare(List.Items[Index],List.Items[Index + Gap]) > 0 then
      begin
        List.Exchange(Index,Index + Gap);
        Swapped := True;
      end;
      Index := Index + 1;
    end;
  end;

end;

前述の通り(TGenericListSorterとは異なり)1種類の<T>に対してのみSortを実装すればよいようになっています。またSortメソッド以外にシングルトンなインスタンスを取得するためのInstanceメソッドと、そのインスタンスを解放するためのクラスデストラクタを用意します。これで例えばInteger型のリストに対しては

var
  I: Integer;
  Value: Integer;
  List: TList<Integer>;
begin
  List := TList<Integer>.Create;
  try
    for I := 0 to 999 do
    begin
      List.Add(Random(100000));
    end;

    TGenericListSorter.Sort<Integer>(List,TCombSort<Integer>.Instance,TComparer<Integer>.Construct(
      function(const Left, Right: Integer): Integer
      begin
        Result := Left - Right;
      end));

    for Value in List do
    begin
      Memo1.Lines.Add(IntToStr(Value));
    end;

  finally
    List.Free;
  end
end;

このような形でソートを呼び出すことができます。同じようにその他のソートアルゴリズムを実装していきます。ノームソートです。

type
  TGnomeSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TGnomeSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TGnomeSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TGnomeSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Index: Integer;
begin

  Index := 0;
  while Index < List.Count do
  begin
    if (Index = 0) or (AComparer.Compare(List.Items[Index],List.Items[Index - 1]) >= 0) then
    begin
      Index := Index + 1;
    end
    else
    begin
      List.Exchange(Index,Index - 1);
      Index := Index - 1;
    end;
  end;

end;

選択ソートです。

type
  TSelectionSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TSelectionSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TSelectionSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TSelectionSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Index1: Integer;
  Index2: Integer;
  MinIndex: Integer;
  Temp: T;
begin

  for Index1 := 0 to List.Count - 2 do
  begin
    MinIndex := Index1;
    Temp := List.Items[MinIndex];

    for Index2 := Index1 + 1 to List.Count - 1 do
    begin
      if AComparer.Compare(List.Items[Index2],Temp) < 0 then
      begin
        MinIndex := Index2;
        Temp := List.Items[MinIndex];
      end;
    end;

    if MinIndex <> Index1 then
    begin
      List.Move(MinIndex,Index1);
    end;
  end;

end;

挿入ソートです。

type
  TInsertionSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TInsertionSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TInsertionSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TInsertionSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
  Index1: Integer;
  Index2: Integer;
  Temp: T;
begin

  for Index1 := 1 to List.Count - 1 do
  begin
    Temp := List.Items[Index1];
    Index2 := Index1 - 1;

    while (Index2 >= 0) and (AComparer.Compare(List.Items[Index2],Temp) > 0) do
    begin
      Index2 := Index2 - 1;
    end;

    List.Move(Index1,Index2 + 1);
  end;

end;

クイックソートです。

type
  TQuickSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  InternalSort(List: TList<T>; Left: Integer; Right: Integer;
                                  const AComparer: IComparer<T>);
    class function   Partition(List: TList<T>; Left: Integer; Right: Integer;
                               const AComparer: IComparer<T>): Integer;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TQuickSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TQuickSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TQuickSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
begin

  InternalSort(List,0,List.Count - 1,AComparer);

end;

class procedure TQuickSort<T>.InternalSort(List: TList<T>; Left: Integer; Right: Integer;
                                           const AComparer: IComparer<T>);
var
  Pivot: Integer;
begin

  if Left < Right then
  begin
    Pivot := Partition(List,Left,Right,AComparer);

    InternalSort(List,Left,     Pivot,AComparer);
    InternalSort(List,Pivot + 1,Right,AComparer);
  end;

end;

class function TQuickSort<T>.Partition(List: TList<T>; Left: Integer; Right: Integer;
                                       const AComparer: IComparer<T>): Integer;
var
  Index1: Integer;
  Index2: Integer;
  Pivot: T;
begin

  Pivot := List.Items[(Left + Right) div 2];
  Index1 := Left  - 1;
  Index2 := Right + 1;

  while True do
  begin
    repeat
      Index1 := Index1 + 1;
    until (AComparer.Compare(List.Items[Index1],Pivot) >= 0);

    repeat
      Index2 := Index2 - 1;
    until (AComparer.Compare(List.Items[Index2],Pivot) <= 0);

    if Index1 >= Index2 then
    begin
      Result := Index2;
      Exit;
    end;

    List.Exchange(Index1,Index2);
  end;

end;

ヒープソートです。

type
  THeapSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  BuildHeap(List: TList<T>; const AComparer: IComparer<T>);
    class procedure  Heapify(List: TList<T>; Index: Integer; Max: Integer;
                             const AComparer: IComparer<T>);
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor THeapSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function THeapSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure THeapSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Index: Integer;
begin

  BuildHeap(List,AComparer);

  for Index := List.Count - 1 downto 1 do
  begin
    List.Exchange(0,Index);

    Heapify(List,0,Index,AComparer);
  end;

end;

class procedure THeapSort<T>.BuildHeap(List: TList<T>; const AComparer: IComparer<T>);
var
  Index: Integer;
begin

  for Index := (List.Count div 2) - 1 downto 0 do
  begin
    Heapify(List,Index,List.Count,AComparer);
  end;

end;

class procedure THeapSort<T>.Heapify(List: TList<T>; Index: Integer; Max: Integer;
                                     const AComparer: IComparer<T>);
var
  Left: Integer;
  Right: Integer;
  Largest: Integer;
begin

  Left  := Index * 2 + 1;
  Right := Index * 2 + 2;

  if (Left < Max) and (AComparer.Compare(List.Items[Left],List.Items[Index]) > 0) then
  begin
    Largest := Left;
  end
  else
  begin
    Largest := Index;
  end;

  if (Right < Max) and (AComparer.Compare(List.Items[Right],List.Items[Largest]) > 0) then
  begin
    Largest := Right;
  end;

  if Largest <> Index then
  begin
    List.Exchange(Index,Largest);

    Heapify(List,Largest,Max,AComparer);
  end;

end;

マージソートです。

type
  TMergeSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  InternalSort(List: TList<T>; var Work: array of T;
                                  Left: Integer; Right: Integer;
                                  const AComparer: IComparer<T>);
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TMergeSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TMergeSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TMergeSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  WorkArea: array of T;
begin

  SetLength(WorkArea,List.Count);
  try
    InternalSort(List,WorkArea,0,List.Count - 1,AComparer);

  finally
    SetLength(WorkArea,0);
  end;

end;

class procedure TMergeSort<T>.InternalSort(List: TList<T>; var Work: array of T;
                                           Left: Integer; Right: Integer;
                                           const AComparer: IComparer<T>);
var
  Index1: Integer;
  Index2: Integer;
  Index3: Integer;
  Mid: Integer;
begin

  if Left >= Right then
  begin
    Exit;
  end;

  Mid := (Left + Right) div 2;
  InternalSort(List,Work,Left,   Mid,  AComparer);
  InternalSort(List,Work,Mid + 1,Right,AComparer);

  for Index1 := Left to Mid do
  begin
    Work[Index1] := List.Items[Index1];
  end;

  Index2 := Right;
  for Index1 := Mid + 1 to Right do
  begin
    Work[Index1] := List.Items[Index2];
    Index2 := Index2 - 1;
  end;

  Index1 := Left;
  Index2 := Right;
  for Index3 := Left to Right do
  begin
    if AComparer.Compare(Work[Index1],Work[Index2]) > 0 then
    begin
      List.Items[Index3] := Work[Index2];
      Index2 := Index2 - 1;
    end
    else
    begin
      List.Items[Index3] := Work[Index1];
      Index1 := Index1 + 1;
    end;
  end;

end;

シェルソートです。

type
  TShellSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  InternalSort(List: TList<T>; Gap: Integer;
                                  const AComparer: IComparer<T>);
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TShellSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TShellSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TShellSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Gap: Integer;
begin

  Gap := List.Count div 2;
  while Gap > 0 do
  begin
    InternalSort(List,Gap,AComparer);

    Gap := Gap div 2;
  end;

end;

class procedure TShellSort<T>.InternalSort(List: TList<T>; Gap: Integer;
                                           const AComparer: IComparer<T>);
var
  Index1: Integer;
  Index2: Integer;
begin

  for Index1 := Gap to List.Count - 1 do
  begin
    Index2 := Index1 - Gap;
    while Index2 >= 0 do
    begin
      if AComparer.Compare(List.Items[Index2 + Gap],List.Items[Index2]) > 0 then
      begin
        Break;
      end;

      List.Exchange(Index2,Index2 + Gap);
      Index2 := Index2 - Gap;
    end;
  end;

end;

Instanceメソッドとクラスデストラクタを毎回書かなければならないことを除けば、ソートのコードを1つ書くだけで値型に対するTList<T>(TList<String>を含む)、クラスに対するTObjectList<T>のどちらであってもソートを行うことができます。

→ジェネリックスのリストをアルゴリズムを指定してソートする(Gist)

2017年3月15日

DELPHI / C++BUILDER 0315 IN TOKYO

本日13:30から次期RAD Studio/Delphi/C++Builder(10.2 Tokyo)のお披露目となるDELPHI / C++BUILDER 0315 IN TOKYOが東京ミッドタウン・カンファレンスで行われます。UStreamによる中継も行われます。

レセプションも含め終了しました。参加者、関係者の皆さん、お疲れさまでした。

今日のアバウトなまとめ

RAD Studio/Delphi/C++Builderの次期バージョンは"10.2 Tokyo"で、2017/03/28販売開始予定
主な新機能はLinux(Intel x64)サポート(C++Builderは次のアップデートにあたる"10.2.1"でサポート)
LinuxサポートはEnt SKU以上が必要(Add-on Packなどは今のところなし)
勉強会やりましょう

Microsoft Monthly Update 2017/03

今日はMicrosoftのセキュリティアップデートの日です。
2017年03月のマイクロソフトセキュリティ情報の概要
MS17-006
MS17-007
MS17-008
MS17-009
MS17-010
MS17-011
MS17-012
MS17-013
MS17-014
MS17-015
MS17-016
MS17-017
MS17-018
MS17-019
MS17-020
MS17-021
MS17-022
MS17-023

2017年3月9日

InterBase 2017リリース

InterBase 2017(13.0.0.129)がリリースされています。~~現時点(2017/03/09)でDeveloper EditionとServer Edition(トライアル版)のみダウンロード可能です。~~ODSは17になっています。

30748 InterBase 2017 Server Ed., Windows/Linux (13.0.0.129, Japanese)
30749 InterBase 2017 Server Ed., Windows/Linux (13.0.0.129, English)
30736 InterBase 2017 (13.0.0.129) Developer Edition, Japanese
30738 InterBase 2017 (13.0.0.129) Developer Edition, English

30756 InterBase 2017 ToGo Ed., Windows/Linux/macOS/iOS/Android

Readme - InterBase (en)
InterBase 2017 の新機能 - InterBase(en)

InterBase 2017 - Now available • DelphiABall

2017/03/10追記: Server Editionもダウンロードできるようになっています。

2017/03/24追記: ToGo Editionもダウンロードできるようになっています。

2017年3月7日

Adobe Reader(X以降)で指定したファイルの指定したページを開く

以前Adobe Acrobat/Readerで指定したPDFファイルの指定したページを開く方法について書きましたが、コメントでおかぽんさんからAdobe Reader X以降ではこの方法が使えなくなっているとの指摘をいただきました。

...DDEを使った方法ですが、Acrobat X から、DDEのサービス名が変更されています。...

調べてみると、Actobat/ReaderのVersion 10(X)以降で、DDEのサービス名が Acroview + [A|R] + <MajorVersion> に変更されたことが原因とのことです。というわけでこれに対応してみました。

uses
{$IF RTLVersion >= 23.00}
  Winapi.Windows, System.SysUtils, System.Win.Registry, System.AnsiStrings,
  Vcl.DdeMan;
{$ELSE}
  Windows, SysUtils, Registry, {$IFDEF UNICODE}AnsiStrings, {$ENDIF}DdeMan;
{$IFEND}

function GetAcrobatPathname: String;
begin

  with TRegistry.Create do
  begin
    try
      RootKey := HKEY_CLASSES_ROOT;
      OpenKeyReadOnly('Software\Adobe\Acrobat\Exe');
      try
        Result := AnsiDequotedStr(ReadString(''),'"');

      finally
        CloseKey;
      end;

    finally
      Free;
    end;
  end;

end;

procedure OpenPDF(const Filename: String; Page: Integer);
const
  CDdeCommand: AnsiString = '[DocOpen("%s")][DocGoTo(NULL,%d)]';
var
  Macro: AnsiString;
  Pathname: String;
  ServiceName: String;
  MajorVersion: Integer;
  AcrobatType: String;
begin

  Macro := {$IFDEF UNICODE}{$IF RTLVersion >= 23.00}System.{$IFEND}AnsiStrings.{$ENDIF}
           Format(CDdeCommand,[Filename,Page - 1]);

  Pathname := GetAcrobatPathname;

  ServiceName := 'Acroview';
  MajorVersion := GetFileVersion(Pathname) shr 16;
  if MajorVersion >= 10 then
  begin
    if CompareText(ExtractFileName(Pathname),'AcroRd32.exe') = 0 then
    begin
      AcrobatType := 'R';
    end
    else
    begin
      AcrobatType := 'A';
    end;

    ServiceName := ServiceName + Format('%s%d',[AcrobatType,MajorVersion]);
  end;

  with TDdeClientConv.Create(nil) do
  begin
    try
      ConnectMode := ddeManual;
      ServiceApplication := ChangeFileExt(Pathname,'');
      SetLink(ServiceName,'Control');
      if (OpenLink or ((MajorVersion >= 15) and OpenLink)) = True then
      begin
        ExecuteMacro(PAnsiChar(Macro),False);
        CloseLink;
      end;

    finally
      Free;
    end;
  end;

end;

Acrobat/Readerの実行ファイルの場所をレジストリの"HKEY_CLASSES_ROOT\Software\Adobe\Acrobat\Exe"から取得し、SysUtils.GetFileVersionで問い合わせたバージョン情報の上位16ビット(メジャーバージョン)とファイル名からサービス名を組み立て、DDEをTDdeClientConv.OpenLinkで呼び出してTDdeClientConv.ExecuteMacroでマクロ実行することでファイルを開きページを移動する、という手順になります。またAcrobat/Reader DCの場合TDdeClientConv.OpenLinkの内部でWinExec(en)を使用して起動した直後にDdeConnect(en)を呼び出すと失敗するようなので、リトライするようにしています。

おかぽんさん、情報ありがとうございました。

→Adobe Reader(X以降)で指定したファイルの指定したページを開く(Gist)

2017年3月5日

[書籍][ebook]Dependency Injection In Delphi

Leanpubで

Dependency Injection In Delphi (amazon US)/Nick Hodges著/Leanpub/ISBN978-1941266229(printed), ISBN978-1-941266-19-9(ebook)/29.99USD(printed), 29.99USD(ebook)

を購入(LearnpubのebookはPDF/EPUB/MOBI形式をダウンロード可能)。

2017/05/31追記: Amazon (US)で書籍版が購入可能になっています。ということでDelphi in Depth: FireDACと一緒に注文したDependency Injection In Delphiの書籍版が配送されてきました。29.99USD=3,433JPY(1USD=114.479JOY、配送料は含まず)ということになりました。

2017年3月1日

2017/03開催のセミナー

Web Seminar
- 2017/03/06 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第7回 Delphi「オブジェクト指向」/C++「オブジェクト指向」
- 2017/03/13 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第8回 Delphi「作ってみよう Delphiの部」
  - 【DELPHI STARTER チュートリアルシリーズ】シーズン2 第8回 ‟作ってみよう„ Delphiの部[JAPAN]
- 2017/03/27 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第9回 C++「作ってみよう C++の部」
  - 【C++Builder Starter チュートリアルシリーズ】シーズン2 第9回 ‟作ってみよう„ [JAPAN]
  - 【Delphi / C++Builder Starter Edition チュートリアルシリーズ】シーズン2 完結！[JAPAN]
Live Seminar
- 2017/03/15 13:30-20:00(JST) DELPHI / C++BUILDER 0315 IN TOKYO
- 2017/03/28 17:00-19:00(JST) 「RAD Studioで始めるマルチデバイス・クロスプラットフォーム開発ワークショップ」
  - 3月28日開催　RAD Studioで始めるマルチデバイス・クロスプラットフォーム開発ワークショップ - ハンズオンセッション [JAPAN]

2017年2月24日

[書籍]Optimized C++

紀伊國屋書店新宿本店でOptimized C++ (amazon US)の翻訳である

Optimized C++ (amazon)/Kurt Guntheroth著/黒川利明訳/島敏博技術監修/オライリージャパン/4,320円/ISBN978-4-87311-792-8

を購入。

2017年2月22日

Microsoft OOB Update 2017/02

Microsoftの定例外のセキュリティアップデートがリリースされています。
MS17-005

2017年2月18日

Firebird 2.5.7

Firebird Ver2.5.7がリリースされています。

Firebird: Firebird 2.5.7
Firebird 2.5 Release Notes (PDF)

2017年2月17日

[書籍]C#プログラミングのイディオム/定石&パターン

紀伊國屋書店新宿本店で

C#プログラミングのイディオム/定石&パターン (amazon)/出井秀行著/技術評論社/3,218円/ISBN978-4-7741-8758-7

を購入。

[書籍]改訂第4版 SQLポケットリファレンス

紀伊國屋書店新宿本店で

改訂第4版 SQLポケットリファレンス (amazon)/朝井淳著/技術評論社/2,138円/ISBN978-4-7741-8732-7

を購入。

2017年2月15日

Microsoft Monthly Update 2017/02 is canceled

今日はMicrosoftのセキュリティアップデートの日、の予定だったのですが、

we discovered a last minute issue that could impact some customers and was not resolved in time for our planned updates today.
After considering all options, we made the decision to delay this month’s updates.

とのことで、更新プログラムのリリースは延期になっています。~~この後のリリーススケジュールは現時点(2017/02/15)で未定とのことです。~~

2017/02/16追記: 2017/02のセキュリティ更新プログラムはキャンセルとなった模様です。

3 月の月例セキュリティ更新プログラム公開 (2017 年 3 月 14 日 (米国日付)) の一部として更新プログラムを配信する予定です。

Adobe Flash Playerには既知のセキュリティホールが存在していますので、Windows 8.1/10、Windows Server 2012/2012R2/2016、Windows RT 8.1上のInternet ExplorerおよびEdgeではFlash Playerを無効化するか、代替のwebブラウザを使用することを強くお勧めします。

2017/02/22追記: IE/EdgeのAdobe Flash Playerの更新プログラムがリリースされています。

Adobe Flash Player の脆弱性を修正するセキュリティ更新プログラムを定例外で公開 – 日本のセキュリティチーム
マイクロソフトセキュリティ情報 MS17-005 - 緊急 Adobe Flash Player のセキュリティ更新プログラム (4010250)

Web Seminar
- 2017/02/06 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第3回 Delphi「条件とループ」/C++「条件とループ」
  - 【DELPHI STARTER チュートリアルシリーズ】シーズン2 第3回 ‟条件とループ„ [JAPAN]
  - 【C++Builder Starter チュートリアルシリーズ】シーズン2 第3回 ‟条件とループ„ [JAPAN]
- 2017/02/13 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第4回 Delphi「FunctionとProcedure(関数と手続き)」/C++「関数の作り方」
  - 【DELPHI STARTER チュートリアルシリーズ】シーズン2 第4回 ‟Function と Procedure (関数と手続き)„ [JAPAN]
  - 【C++Builder Starter チュートリアルシリーズ】シーズン2 第4回 ‟関数„ [JAPAN]
- 2017/02/20 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第5回 Delphi「配列とレコード」/C++「配列と構造体」
  - 【DELPHI STARTER チュートリアルシリーズ】シーズン2 第5回 ‟配列とレコード„ [JAPAN]
  - 【C++BUILDER STARTER チュートリアルシリーズ】シーズン2 C++Builderの部第5回 ‟関数と構造体„ [JAPAN]
- 2017/02/27 17:00-17:50(JST) Delphi / C++Builder Starter チュートリアルシリーズシーズン2『プログラミング言語をやさしく覚えよう』第6回 Delphi「文字列とオブジェクト」/C++「文字列とオブジェクト」
  - 【DELPHI STARTER チュートリアルシリーズ】シーズン2 第6回 ‟文字列とオブジェクト„ [JAPAN]
  - 【C++Builder Starter チュートリアルシリーズ】シーズン2 第6回 ‟文字列とオブジェクト„ [JAPAN]
Live Seminar
- 2017/02/03 14:00-17:00(JST) セミナー「Delphi / C++ Builder 業務アプリケーション刷新実践法」
- 2017/02/10 17:00-19:00(JST) セミナー「RAD Studioで始めるマルチデバイス・クロスプラットフォーム開発ワークショップ」
  - RAD Studioで始めるマルチデバイス・クロスプラットフォーム開発ワークショップ[JAPAN]
  - RAD Studioで始めるマルチデバイス・クロスプラットフォーム開発ワークショップ - ハンズオンセッション [JAPAN]

2017年1月12日

RAD Studio/Delphi/C++Builder 10.1 Berlin Hotfix 11 Jan 2017

RAD Studio 10.1 BerlinのHotfixがリリースされています。macOS 10.12 Sierra上でのデプロイ/デバッグの問題(RSP-16322)、macOS 10.12 Sierra上のiOS Simulatorでの実行/デバッグの問題(RSP-16368)、iOS 10上での32ビットアプリケーションのデバッグの問題(RSP-16324)を修正するものです。

30680 RAD Studio 10.1 Berlin Hotfix: 11 Jan 2017

Debugger Hotfix for macOS Sierra and the iOS Simulator
macOS Sierra および iOS Simulator 向けの Debugger Hotfix がリリースされました [JAPAN]

登録: 投稿 (Atom)