2017年10月3日

[ebook]Delphi Memory Management For Classic And ARC Compilers

FastSpring

Delphi Memory Management For Classic And ARC Compilers/Dalija Prasnikar、Neven Prasnikar Jr.著/ePix/32.50USD

を購入(日本円で税込4,090JPY)。

この本はまだ執筆途中で、First Public Beta Releaseという扱いです。First Editionは2017/10/10予定とのこと。またMemory optimizationsとMemory management toolsの章は後日の無償アップデートで追加されるとのことです。

2017年9月29日

IDE Fix Pack 6.0

Andreas HausladenさんIDE Fix PackがアップデートされてVersion 6.0となっています。RAD Studio/Delphi/C++Builder 10.2.1 Tokyo対応とWindows x64のコンパイル速度の最適化、Delphi 2009のエディタのUTF-8のブロック補完が追加されています。

IDE Fix Pack 6.0 released – dcc64 and 10.2 Update 1 support | Andy's Blog and Tools

RAD Studio/Delphi/C++Builder 10.2.1 Tokyo iOS 11 Patch

RAD Studio/Delphi/C++Builder 10.2.1 TokyoのPatchがリリースされています。iOS 11への対応と以下の問題の修正、Windows/Linux用を含むPAServerのアップデートが行われているとのことです。
iOS SDKは10.3.xと11、Xcodeは8.2.x、8.3.2/8.3.3と9.0に対応しています。またこのPatchには前回のiOS Ad Hoc Deployment Patchの内容が含まれていますが、気にせず適用して構わないとのことです(30797が適用されていてもいなくても問題ない)。

30805 RAD Studio 10.2.1 iOS 11 Patch

Build iOS 11 ready apps with RAD Studio 10.2.1

2017年8月8日

RAD Studio/Delphi/C++Builder 10.2 Tokyo Release 1

RAD Studio/Delphi/C++Builder 10.2 TokyoのRelease 1(10.2.1)がリリースされています。

30783 RAD Studio, Delphi, C++Builder 10.2 Release 1 Web Install
30785 RAD Studio, Delphi, C++Builder 10.2 Release 1 ISO

10.2 Tokyo - Release 1 - RAD Studio (en)

List of new features and customer reported issues fixed in RAD Studio 10.2 Tokyo Release 1

RAD Studio 10.2.1 Released Today
RAD Studio 10.2.1をリリース
RAD Studio 10.2 Tokyo Release 1提供開始のご案内 [JAPAN]

Delphi Tokyo Release 1 or 10.2.1 is Now Available
Creators Update BPL Loading Issue and Tokyo Release 1

ただ非常に残念なことに、Andreas HausladenさんIDE Fix Packは10.2 Tokyoを最後に、これ以降のリリースをサポートしないとアナウンスされており、既に10.2 Tokyo用のダウンロードもできなくなっています。10年近くにわたって非常に有用なソフトウェアを提供してくださったAndreas Hausladenさんに感謝するとともに、このようなパッチがなくてもよいようにIDEの品質向上にEmbarcaderoが注力することを強く望みます(Andreasさんを半年くらいパートタイムで雇用すれば解決するのでは?)。

2017年8月3日

2017年7月28日

第34回エンバカデロ・デベロッパーキャンプ・イン東京

本日10:00から第34回エンバカデロ・デベロッパーキャンプ・イン東京コングレスクエア中野で行われます。今回もUStreamによるライブ中継が行われます。

  • 第34回 エンバカデロ・デベロッパーキャンプ・イン東京
    • 【G1】ジェネラルセッション「モダナイゼーションを支援するエンバカデロのRADテクノロジー」
    • 【G2】テクニカルセッション「これが定番!RAD Studioで実践する既存システムのモダナイズ」
    • 【A3】Delphi/C++テクニカルセッション「既存のVCLアプリでもモバイル活用!簡単マルチデバイス連携術」
    • 【B3】テクニカルケーススタディ「Delphi 64bitで実現した大規模VR空間対応の新バージョン『UC-win/Road Ver.12』開発の道のり」
    • 【A4】Delphi/C++/InterBaseテクニカルセッション「基幹系だけじゃない!シーン別データベース活用術 - モバイル、デスクトップから多層、クラウドまで、コスト節約と性能実現のキモ」
    • 【B4】Delphiテクニカルセッション「Delphiで超高速OpenGL 2D/3D描画 - FireMonkey / VCLコンポーネントで驚きの性能実現」
    • 【A5】Delphiテクニカルセッション「クロスプラットフォーム開発で役立つDelphi新機能活用ポイント」
    • 【B5】Delphi / C++テクニカルセッション「プロジェクトが大きくなっても慌てない!RAD Studioチーム開発の心得」
    • 【G6】ライトニングトーク「共有!みんなの開発事例、開発経験、テクニック」
  • 第34回 エンバカデロ・デベロッパーキャンプ・イン大阪
    • 【T1】Delphiテクニカルセッション「知って得する!今日から使えるDelphi実践テクニック」
    • 【T2】Delphi/C++/InterBaseテクニカルセッション「データベースとデータアクセスを見直そう!シーン別データベース活用実践 - コスト節約と性能実現のキモ」
    • 【G3】ジェネラルセッション「モダナイゼーションを支援するエンバカデロのRADテクノロジー」
    • 【T4】テクニカルセッション「これが定番!RAD Studioで実践する既存システムのモダナイズ」
    • 【T5】Delphi/C++テクニカルセッション「既存アプリをマルチデバイス活用に進化!VCLからのモバイル連携3段活用」
    • 【G6】ライトニングトーク「共有!みんなの開発事例、開発経験、テクニック」

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,576JPY4,676JPY(暫定、1USD=114.40JPY116.900JPY)でした。

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年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,787JPY6,979JPY(暫定、1USD=111.33JPY1USD=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月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年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年3月23日

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

RAD Studio/Delphi/C++Builder 10.2 Tokyoがリリースされています。

RAD Studio 10.2 Tokyo ヘルプ (en)
リリース ノート (en)
インストール ノート (en)
新機能 (en)

RAD Studio 10.2 Tokyo 新機能および不具合修正リスト (en)

30722 RAD Studio, Delphi, C++Builder 10.2 Tokyo Web Install
30724 RAD Studio, Delphi, C++Builder 10.2 Tokyo ISO

30765 Linux libmidas file for RAD Studio, Delphi, C++Builder 10.2

30780 RAD Studio 10.2 Tokyo FireMonkey Accessibility Pack

30752 BDE Installer for RAD Studio, Delphi, C++Builder 10.2 Tokyo
30728 FastReport VCL for RAD Studio, Delphi, C++Builder 10.2 Tokyo
30729 FastReport FMX for RAD Studio, Delphi, C++Builder 10.2 Tokyo
30730 IP*Works for RAD Studio, Delphi 10.2 Tokyo
30731 IP*Works for RAD Studio, C++Builder 10.2 Tokyo
30750 Codesite for RAD Studio, Delphi, C++Builder 10.2 Tokyo

30761 Jedi Code Library Snapshot Binary Installer for 10.2
30762 Jedi Visual Component Library Snapshot Bin-Installer 10.2

GitHub - lynatan/StarterFix: Restore Form Designer Options for Starter edition.

【Delphi / C++Builder 10.2 Tokyo 新機能・改善点】C++ コンパイラ 周りの改善など - Qiita
【Delphi / C++Builder 10.2 Tokyo 新機能・改善点】FireDAC、データベース接続周りの改善など - Qiita
【Delphi / C++Builder 10.2 Tokyo 新機能・改善点】RAD Server の改善など - Qiita
【Delphi / C++Builder 10.2 Tokyo 新機能・改善点】IDEまわりの改善など - Qiita
【Delphi / C++Builder 10.2 Tokyo 新機能・改善点】ライブラリ周りの機能など - Qiita

What's New in C++Builder 10.2: Part 1 - The Linker
What's New in C++Builder 10.2: Part 2 - Code Generation
What's New in C++Builder 10.2: Part 3 - Debugging

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開催のセミナー

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日

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)

2017年2月1日

[書籍]なっとく!アルゴリズム

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

なっとく!アルゴリズム (amazon)/Aditya Bhargava著/株式会社クイープ監訳/翔泳社/ISBN 9784798143354/2,700円

を購入。

[書籍]プログラミング作法

紀伊國屋書店新宿本店The Practice of Programming (amazon US)の翻訳である

プログラミング作法 (amazon)/Brian W. KernighanRob Pike著/福崎俊博訳/KADOKAWA/ISBN 978-4-04-893052-9/3,024円

を購入。

2017/02開催のセミナー

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]

2017年1月11日