newtypes.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2018
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:48+0900\n"
"PO-Revision-Date: 2018-06-29 17:45+0000\n"
"Last-Translator: tomo, 2018\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../extending/newtypes.rst:5
msgid "Defining Extension Types: Assorted Topics"
msgstr ""

#: ../../extending/newtypes.rst:9
msgid ""
"This section aims to give a quick fly-by on the various type methods you can "
"implement and what they do."
msgstr ""
"この節ではさまざまな実装可能なタイプメソッドと、それらが何をするものであるか"
"について、ざっと説明します。"

#: ../../extending/newtypes.rst:12
msgid ""
"Here is the definition of :c:type:`PyTypeObject`, with some fields only used "
"in debug builds omitted:"
msgstr ""
"以下は :c:type:`PyTypeObject` の定義です。デバッグビルドでしか使われないいく"
"つかのメンバは省いてあります:"

#: ../../extending/newtypes.rst:18
msgid ""
"Now that's a *lot* of methods.  Don't worry too much though -- if you have a "
"type you want to define, the chances are very good that you will only "
"implement a handful of these."
msgstr ""
"*たくさんの* メソッドがありますね。でもそんなに心配する必要はありません。定義"
"したい型があるなら、実装するのはこのうちのごくわずかですむことがほとんどで"
"す。"

#: ../../extending/newtypes.rst:22
msgid ""
"As you probably expect by now, we're going to go over this and give more "
"information about the various handlers.  We won't go in the order they are "
"defined in the structure, because there is a lot of historical baggage that "
"impacts the ordering of the fields.  It's often easiest to find an example "
"that includes the fields you need and then change the values to suit your "
"new type. ::"
msgstr ""
"すでに予想されているでしょうが、この構造体について入念に見ていき、様々なハン"
"ドラについてより詳しい情報を提供します。\n"
"しかしこれらのメンバが構造体中で定義されている順番は無視します。というのは、"
"これらのメンバの現れる順序は歴史的な遺産によるものだからです。\n"
"多くの場合いちばん簡単なのは、必要とするメンバがすべて含まれている例をとって"
"きて、新しく作る型に合わせて値を変更することです。 ::"

#: ../../extending/newtypes.rst:31
msgid ""
"The name of the type -- as mentioned in the previous chapter, this will "
"appear in various places, almost entirely for diagnostic purposes. Try to "
"choose something that will be helpful in such a situation! ::"
msgstr ""
"これは型の名前です。前の章で説明したように、これは色々な場面で現れ、ほとんど"
"は診断目的で使われるものです。\n"
"それなので、そのような場面で役に立つであろう名前を選んでください! ::"

#: ../../extending/newtypes.rst:37
msgid ""
"These fields tell the runtime how much memory to allocate when new objects "
"of this type are created.  Python has some built-in support for variable "
"length structures (think: strings, tuples) which is where the :c:member:"
"`~PyTypeObject.tp_itemsize` field comes in.  This will be dealt with "
"later. ::"
msgstr ""
"これらのフィールドは、この型のオブジェクトが新しく作成されるときにどれだけの"
"メモリを割り当てればよいのかをランタイムに指示します。Python には可変長の構造"
"体 (文字列やタプルなどを想像してください) に対する組み込みのサポートがある程"
"度あり、ここで :c:member:`~PyTypeObject.tp_itemsize` メンバが使われます。これ"
"らについてはあとでふれます。 ::"

#: ../../extending/newtypes.rst:44
msgid ""
"Here you can put a string (or its address) that you want returned when the "
"Python script references ``obj.__doc__`` to retrieve the doc string."
msgstr ""
"ここには Python スクリプトリファレンス ``obj.__doc__`` が doc string を返すと"
"きの文字列 (あるいはそのアドレス) を入れます。"

#: ../../extending/newtypes.rst:47
msgid ""
"Now we come to the basic type methods -- the ones most extension types will "
"implement."
msgstr ""
"では次に、型の基本的なメソッドに進みます。ほとんどの拡張の型がこのメソッドを"
"実装します。"

#: ../../extending/newtypes.rst:52
msgid "Finalization and De-allocation"
msgstr "ファイナライズとメモリ解放"

#: ../../extending/newtypes.rst:64
msgid ""
"This function is called when the reference count of the instance of your "
"type is reduced to zero and the Python interpreter wants to reclaim it.  If "
"your type has memory to free or other clean-up to perform, you can put it "
"here.  The object itself needs to be freed here as well.  Here is an example "
"of this function::"
msgstr ""
"型のインスタンスの参照カウントがゼロになり、Python インタプリタがそれを潰して"
"再利用したくなると、この関数が呼ばれます。解放すべきメモリをその型が保持して"
"いたり、それ以外にも実行すべき後処理がある場合は、それらをここに入れられま"
"す。オブジェクトそれ自体もここで解放される必要があります。この関数の例は、以"
"下のようなものです::"

#: ../../extending/newtypes.rst:81
msgid ""
"One important requirement of the deallocator function is that it leaves any "
"pending exceptions alone.  This is important since deallocators are "
"frequently called as the interpreter unwinds the Python stack; when the "
"stack is unwound due to an exception (rather than normal returns), nothing "
"is done to protect the deallocators from seeing that an exception has "
"already been set.  Any actions which a deallocator performs which may cause "
"additional Python code to be executed may detect that an exception has been "
"set.  This can lead to misleading errors from the interpreter.  The proper "
"way to protect against this is to save a pending exception before performing "
"the unsafe action, and restoring it when done.  This can be done using the :"
"c:func:`PyErr_Fetch` and :c:func:`PyErr_Restore` functions::"
msgstr ""
"メモリ解放関数でひとつ重要なのは、処理待ちの例外にいっさい手をつけないことで"
"す。なぜなら、解放用の関数は Python インタプリタがスタックを元の状態に戻すと"
"きに呼ばれることが多いからです。そして (通常の関数からの復帰でなく) 例外のた"
"めにスタックが巻き戻されるときは、すでに発生している例外からメモリ解放関数を"
"守るものはありません。解放用の関数がおこなう動作が追加の Python のコードを実"
"行してしまうと、それらは例外が発生していることを検知するかもしれません。これ"
"はインタプリタが誤解させるエラーを発生させることにつながります。これを防ぐ正"
"しい方法は、安全でない操作を実行する前に処理待ちの例外を保存しておき、終わっ"
"たらそれを元に戻すことです。これは :c:func:`PyErr_Fetch` および :c:func:"
"`PyErr_Restore` 関数を使うことによって可能になります::"

#: ../../extending/newtypes.rst:120
msgid ""
"There are limitations to what you can safely do in a deallocator function. "
"First, if your type supports garbage collection (using :c:member:"
"`~PyTypeObject.tp_traverse` and/or :c:member:`~PyTypeObject.tp_clear`), some "
"of the object's members can have been cleared or finalized by the time :c:"
"member:`~PyTypeObject.tp_dealloc` is called.  Second, in :c:member:"
"`~PyTypeObject.tp_dealloc`, your object is in an unstable state: its "
"reference count is equal to zero.  Any call to a non-trivial object or API "
"(as in the example above) might end up calling :c:member:`~PyTypeObject."
"tp_dealloc` again, causing a double free and a crash."
msgstr ""
"メモリ解放関数の中で安全に行えることにはいくつか制限があります。\n"
"1つ目は、その型が (:c:member:`~PyTypeObject.tp_traverse` および :c:member:"
"`~PyTypeObject.tp_clear` を使って) ガベージコレクションをサポートしている場"
"合、 :c:member:`~PyTypeObject.tp_dealloc` が呼び出されるまでに、消去されファ"
"イナライズされてしまうオブジェクトのメンバーが有り得ることです。\n"
"2つ目は、 :c:member:`~PyTypeObject.tp_dealloc` の中ではオブジェクトは不安定な"
"状態にあることです: つまり参照カウントが0であるということです。\n"
"(上の例にあるような) 複雑なオブジェクトや API の呼び出しでは、 :c:member:"
"`~PyTypeObject.tp_dealloc` を再度呼び出し、二重解放からクラッシュすることにな"
"るかもしれません。"

#: ../../extending/newtypes.rst:129
msgid ""
"Starting with Python 3.4, it is recommended not to put any complex "
"finalization code in :c:member:`~PyTypeObject.tp_dealloc`, and instead use "
"the new :c:member:`~PyTypeObject.tp_finalize` type method."
msgstr ""
"Python 3.4 からは、複雑なファイナライズのコードは :c:member:`~PyTypeObject."
"tp_dealloc` に置かず、代わりに新しく導入された :c:member:`~PyTypeObject."
"tp_finalize` という型メソッドを使うことが推奨されています。"

#: ../../extending/newtypes.rst:134
msgid ":pep:`442` explains the new finalization scheme."
msgstr ":pep:`442` で新しいファイナライズの仕組みが説明されています。"

#: ../../extending/newtypes.rst:141
msgid "Object Presentation"
msgstr "オブジェクト表現"

#: ../../extending/newtypes.rst:143
msgid ""
"In Python, there are two ways to generate a textual representation of an "
"object: the :func:`repr` function, and the :func:`str` function.  (The :func:"
"`print` function just calls :func:`str`.)  These handlers are both optional."
msgstr ""
"Python では、オブジェクトの文字列表現を生成するのに 2つのやり方があります: :"
"func:`repr` 関数を使う方法と、 :func:`str`  関数を使う方法です。 (:func:"
"`print` 関数は単に :func:`str` を呼び出します。) これらのハンドラはどちらも省"
"略できます。"

#: ../../extending/newtypes.rst:152
msgid ""
"The :c:member:`~PyTypeObject.tp_repr` handler should return a string object "
"containing a representation of the instance for which it is called.  Here is "
"a simple example::"
msgstr ""
":c:member:`~PyTypeObject.tp_repr` ハンドラは呼び出されたインスタンスの文字列"
"表現を格納した文字列オブジェクトを返す必要があります。簡単な例は以下のような"
"ものです::"

#: ../../extending/newtypes.rst:163
msgid ""
"If no :c:member:`~PyTypeObject.tp_repr` handler is specified, the "
"interpreter will supply a representation that uses the type's :c:member:"
"`~PyTypeObject.tp_name` and a uniquely-identifying value for the object."
msgstr ""
":c:member:`~PyTypeObject.tp_repr` ハンドラが指定されていなければ、インタプリ"
"タはその型の :c:member:`~PyTypeObject.tp_name` とそのオブジェクトの一意な識別"
"値をもちいて文字列表現を作成します。"

#: ../../extending/newtypes.rst:167
msgid ""
"The :c:member:`~PyTypeObject.tp_str` handler is to :func:`str` what the :c:"
"member:`~PyTypeObject.tp_repr` handler described above is to :func:`repr`; "
"that is, it is called when Python code calls :func:`str` on an instance of "
"your object.  Its implementation is very similar to the :c:member:"
"`~PyTypeObject.tp_repr` function, but the resulting string is intended for "
"human consumption.  If :c:member:`~PyTypeObject.tp_str` is not specified, "
"the :c:member:`~PyTypeObject.tp_repr` handler is used instead."
msgstr ""
":c:member:`~PyTypeObject.tp_str` ハンドラと :func:`str` の関係は、上の :c:"
"member:`~PyTypeObject.tp_repr` ハンドラと :func:`repr` の関係に相当します。つ"
"まり、これは Python のコードがオブジェクトのインスタンスに対して :func:`str` "
"を呼び出したときに呼ばれます。この関数の実装は :c:member:`~PyTypeObject."
"tp_repr` ハンドラのそれと非常に似ていますが、得られる文字列表現は人間が読むこ"
"とを意図されています。 :c:member:`~PyTypeObject.tp_str` が指定されていない場"
"合、かわりに :c:member:`~PyTypeObject.tp_repr` ハンドラが使われます。"

#: ../../extending/newtypes.rst:174
msgid "Here is a simple example::"
msgstr "以下は簡単な例です::"

#: ../../extending/newtypes.rst:186
msgid "Attribute Management"
msgstr "属性を管理する"

#: ../../extending/newtypes.rst:188
msgid ""
"For every object which can support attributes, the corresponding type must "
"provide the functions that control how the attributes are resolved.  There "
"needs to be a function which can retrieve attributes (if any are defined), "
"and another to set attributes (if setting attributes is allowed).  Removing "
"an attribute is a special case, for which the new value passed to the "
"handler is *NULL*."
msgstr ""
"属性をもつどのオブジェクトに対しても、その型は、それらオブジェクトの属性をど"
"のように解決するか制御する関数を提供する必要があります。必要な関数としては、"
"属性を (それが定義されていれば) 取り出すものと、もうひとつは属性に (それが許"
"可されていれば) 値を設定するものです。属性を削除するのは特殊なケースで、この"
"場合は新しい値としてハンドラに *NULL* が渡されます。"

#: ../../extending/newtypes.rst:194
msgid ""
"Python supports two pairs of attribute handlers; a type that supports "
"attributes only needs to implement the functions for one pair.  The "
"difference is that one pair takes the name of the attribute as a :c:type:"
"`char\\*`, while the other accepts a :c:type:`PyObject\\*`.  Each type can "
"use whichever pair makes more sense for the implementation's convenience. ::"
msgstr ""
"Python は 2つの属性ハンドラの組をサポートしています。属性をもつ型はどちらか一"
"組を実装するだけでよく、それらの違いは一方の組が属性の名前を :c:type:"
"`char\\*` として受け取るのに対してもう一方の組は属性の名前を :c:type:"
"`PyObject\\*` として受け取る、というものです。それぞれの型はその実装にとって"
"都合がよい方を使えます。 ::"

#: ../../extending/newtypes.rst:206
msgid ""
"If accessing attributes of an object is always a simple operation (this will "
"be explained shortly), there are generic implementations which can be used "
"to provide the :c:type:`PyObject\\*` version of the attribute management "
"functions. The actual need for type-specific attribute handlers almost "
"completely disappeared starting with Python 2.2, though there are many "
"examples which have not been updated to use some of the new generic "
"mechanism that is available."
msgstr ""
"オブジェクトの属性へのアクセスがつねに (すぐあとで説明する) 単純な操作だけな"
"らば、 :c:type:`PyObject\\*` を使って属性を管理する関数として、総称的 "
"(generic) な実装を使えます。特定の型に特化した属性ハンドラの必要性は Python "
"2.2 からほとんど完全になくなりました。しかし、多くの例はまだ、この新しく使え"
"るようになった総称的なメカニズムを使うよう更新されてはいません。"

#: ../../extending/newtypes.rst:217
msgid "Generic Attribute Management"
msgstr "総称的な属性を管理する"

#: ../../extending/newtypes.rst:219
msgid ""
"Most extension types only use *simple* attributes.  So, what makes the "
"attributes simple?  There are only a couple of conditions that must be met:"
msgstr ""
"ほとんどの型は *単純な* 属性を使うだけです。では、どのような属性が単純だとい"
"えるのでしょうか? それが満たすべき条件はごくわずかです:"

#: ../../extending/newtypes.rst:222
msgid ""
"The name of the attributes must be known when :c:func:`PyType_Ready` is "
"called."
msgstr ""
":c:func:`PyType_Ready` が呼ばれたとき、すでに属性の名前がわかっていること。"

#: ../../extending/newtypes.rst:225
msgid ""
"No special processing is needed to record that an attribute was looked up or "
"set, nor do actions need to be taken based on the value."
msgstr ""
"属性を参照したり設定したりするときに、特別な記録のための処理が必要でなく、ま"
"た参照したり設定した値に対してどんな操作も実行する必要がないこと。"

#: ../../extending/newtypes.rst:228
msgid ""
"Note that this list does not place any restrictions on the values of the "
"attributes, when the values are computed, or how relevant data is stored."
msgstr ""
"これらの条件は、属性の値や、値が計算されるタイミング、または格納されたデータ"
"がどの程度妥当なものであるかといったことになんら制約を課すものではないことに"
"注意してください。"

#: ../../extending/newtypes.rst:231
msgid ""
"When :c:func:`PyType_Ready` is called, it uses three tables referenced by "
"the type object to create :term:`descriptor`\\s which are placed in the "
"dictionary of the type object.  Each descriptor controls access to one "
"attribute of the instance object.  Each of the tables is optional; if all "
"three are *NULL*, instances of the type will only have attributes that are "
"inherited from their base type, and should leave the :c:member:"
"`~PyTypeObject.tp_getattro` and :c:member:`~PyTypeObject.tp_setattro` fields "
"*NULL* as well, allowing the base type to handle attributes."
msgstr ""
":c:func:`PyType_Ready` が呼ばれると、これはそのタイプオブジェクトに参照されて"
"いる 3つのテーブルを使って、そのタイプオブジェクトの辞書中にデスクリプタ(:"
"term:`descriptor`) を作成します。各デスクリプタは、インスタンスオブジェクトの"
"属性に対するアクセスを制御します。それぞれのテーブルはなくてもかまいません。"
"もしこれら 3つがすべて *NULL* だと、その型のインスタンスはその基底型から継承"
"した属性だけを持つことになります。また、 :c:member:`~PyTypeObject."
"tp_getattro` および :c:member:`~PyTypeObject.tp_setattro` が *NULL* のまま"
"だった場合も、基底型にこれらの属性の操作がまかせられます。"

#: ../../extending/newtypes.rst:239
msgid "The tables are declared as three fields of the type object::"
msgstr "テーブルはタイプオブジェクト中の 3つのメンバとして宣言されています::"

#: ../../extending/newtypes.rst:245
msgid ""
"If :c:member:`~PyTypeObject.tp_methods` is not *NULL*, it must refer to an "
"array of :c:type:`PyMethodDef` structures.  Each entry in the table is an "
"instance of this structure::"
msgstr ""
":c:member:`~PyTypeObject.tp_methods` が *NULL* でない場合、これは :c:type:"
"`PyMethodDef` 構造体への配列を指している必要があります。テーブル中の各エント"
"リは、つぎのような構造体のインスタンスです::"

#: ../../extending/newtypes.rst:256
msgid ""
"One entry should be defined for each method provided by the type; no entries "
"are needed for methods inherited from a base type.  One additional entry is "
"needed at the end; it is a sentinel that marks the end of the array.  The :"
"attr:`ml_name` field of the sentinel must be *NULL*."
msgstr ""
"その型が提供する各メソッドについてひとつのエントリを定義する必要があります。"
"基底型から継承してきたメソッドについてはエントリは必要ありません。これの最後"
"には、配列の終わりを示すための見張り番 (sentinel) として追加のエントリがひと"
"つ必要です。この場合、 :attr:`ml_name` メンバが sentinel として使われ、その値"
"は *NULL* でなければなりません。"

#: ../../extending/newtypes.rst:261
msgid ""
"The second table is used to define attributes which map directly to data "
"stored in the instance.  A variety of primitive C types are supported, and "
"access may be read-only or read-write.  The structures in the table are "
"defined as::"
msgstr ""
"2番目のテーブルは、インスタンス中に格納されるデータと直接対応づけられた属性を"
"定義するのに使います。いくつもの C の原始的な型がサポートされており、アクセス"
"を読み出し専用にも読み書き可能にもできます。このテーブルで使われる構造体は次"
"のように定義されています::"

#: ../../extending/newtypes.rst:273
msgid ""
"For each entry in the table, a :term:`descriptor` will be constructed and "
"added to the type which will be able to extract a value from the instance "
"structure.  The :attr:`type` field should contain one of the type codes "
"defined in the :file:`structmember.h` header; the value will be used to "
"determine how to convert Python values to and from C values.  The :attr:"
"`flags` field is used to store flags which control how the attribute can be "
"accessed."
msgstr ""
"このテーブルの各エントリに対してデスクリプタ(:term:`descriptor`)が作成され、"
"値をインスタンスの構造体から抽出しうる型に対してそれらが追加されます。 :attr:"
"`type` メンバは :file:`structmember.h` ヘッダで定義された型のコードをひとつ含"
"んでいる必要があります。この値は Python における値と C における値をどのように"
"変換しあうかを定めるものです。 :attr:`flags` メンバはこの属性がどのようにアク"
"セスされるかを制御するフラグを格納するのに使われます。"

#: ../../extending/newtypes.rst:280
msgid ""
"The following flag constants are defined in :file:`structmember.h`; they may "
"be combined using bitwise-OR."
msgstr ""
"以下のフラグ用定数は :file:`structmember.h` で定義されており、これらはビット"
"ごとの OR を取って組み合わせられます。"

#: ../../extending/newtypes.rst:284
msgid "Constant"
msgstr "定数"

#: ../../extending/newtypes.rst:284
msgid "Meaning"
msgstr "意味"

#: ../../extending/newtypes.rst:286
msgid ":const:`READONLY`"
msgstr ":const:`READONLY`"

#: ../../extending/newtypes.rst:286
msgid "Never writable."
msgstr "絶対に変更できない。"

#: ../../extending/newtypes.rst:288
msgid ":const:`READ_RESTRICTED`"
msgstr ":const:`READ_RESTRICTED`"

#: ../../extending/newtypes.rst:288
msgid "Not readable in restricted mode."
msgstr "制限モード (restricted mode) では参照できない。"

#: ../../extending/newtypes.rst:290
msgid ":const:`WRITE_RESTRICTED`"
msgstr ":const:`WRITE_RESTRICTED`"

#: ../../extending/newtypes.rst:290
msgid "Not writable in restricted mode."
msgstr "制限モード (restricted mode) では変更できない。"

#: ../../extending/newtypes.rst:292
msgid ":const:`RESTRICTED`"
msgstr ":const:`RESTRICTED`"

#: ../../extending/newtypes.rst:292
msgid "Not readable or writable in restricted mode."
msgstr "制限モード (restricted mode) では参照も変更もできない。"

#: ../../extending/newtypes.rst:301
msgid ""
"An interesting advantage of using the :c:member:`~PyTypeObject.tp_members` "
"table to build descriptors that are used at runtime is that any attribute "
"defined this way can have an associated doc string simply by providing the "
"text in the table.  An application can use the introspection API to retrieve "
"the descriptor from the class object, and get the doc string using its :attr:"
"`__doc__` attribute."
msgstr ""
":c:member:`~PyTypeObject.tp_members` を使ったひとつの面白い利用法は、実行時に"
"使われるデスクリプタを作成しておき、単にテーブル中にテキストを置いておくこと"
"によって、この方法で定義されたすべての属性に doc string を関連付けられるよう"
"にすることです。アプリケーションはこのイントロスペクション用 API を使って、ク"
"ラスオブジェクトからデスクリプタを取り出し、その :attr:`__doc__` 属性を使っ"
"て doc string を得られます。"

#: ../../extending/newtypes.rst:307
msgid ""
"As with the :c:member:`~PyTypeObject.tp_methods` table, a sentinel entry "
"with a :attr:`name` value of *NULL* is required."
msgstr ""
":c:member:`~PyTypeObject.tp_methods` テーブルと同じように、ここでも :attr:"
"`name` メンバの値を *NULL* にした見張り用エントリが必要です。"

#: ../../extending/newtypes.rst:321
msgid "Type-specific Attribute Management"
msgstr "特定の型に特化した属性の管理"

#: ../../extending/newtypes.rst:323
msgid ""
"For simplicity, only the :c:type:`char\\*` version will be demonstrated "
"here; the type of the name parameter is the only difference between the :c:"
"type:`char\\*` and :c:type:`PyObject\\*` flavors of the interface. This "
"example effectively does the same thing as the generic example above, but "
"does not use the generic support added in Python 2.2.  It explains how the "
"handler functions are called, so that if you do need to extend their "
"functionality, you'll understand what needs to be done."
msgstr ""
"話を単純にするため、ここでは :c:type:`char\\*` を使ったバージョンのみを示しま"
"す。name パラメータの型はインターフェイスとして :c:type:`char\\*` を使うか :"
"c:type:`PyObject\\*` を使うかの違いしかありません。この例では、上の総称的な例"
"と同じことを効率的にやりますが、 Python 2.2 で追加された総称的な型のサポート"
"を使わずにやります。これはハンドラの関数がどのようにして呼ばれるのかを説明し"
"ます。これで、たとえその機能を拡張する必要があるとき、何をどうすればいいかわ"
"かるでしょう。"

#: ../../extending/newtypes.rst:331
msgid ""
"The :c:member:`~PyTypeObject.tp_getattr` handler is called when the object "
"requires an attribute look-up.  It is called in the same situations where "
"the :meth:`__getattr__` method of a class would be called."
msgstr ""
":c:member:`~PyTypeObject.tp_getattr` ハンドラはオブジェクトが属性への参照を要"
"求するときに呼ばれます。これは、そのクラスの :meth:`__getattr__` メソッドが呼"
"ばれるであろう状況と同じ状況下で呼び出されます。"

#: ../../extending/newtypes.rst:335
msgid "Here is an example::"
msgstr "以下に例を示します。::"

#: ../../extending/newtypes.rst:351
msgid ""
"The :c:member:`~PyTypeObject.tp_setattr` handler is called when the :meth:"
"`__setattr__` or :meth:`__delattr__` method of a class instance would be "
"called.  When an attribute should be deleted, the third parameter will be "
"*NULL*.  Here is an example that simply raises an exception; if this were "
"really all you wanted, the :c:member:`~PyTypeObject.tp_setattr` handler "
"should be set to *NULL*. ::"
msgstr ""
":c:member:`~PyTypeObject.tp_setattr` ハンドラは、クラスのインスタンスの :"
"meth:`__setattr__` または :meth:`__delattr__` メソッドが呼ばれるであろう状況"
"で呼び出されます。ある属性が削除されるとき、3番目のパラメータは *NULL* になり"
"ます。以下の例はたんに例外を発生させるものですが、もし本当にこれと同じことを"
"したいなら、 :c:member:`~PyTypeObject.tp_setattr` ハンドラを *NULL* に設定す"
"べきです。 ::"

#: ../../extending/newtypes.rst:365
msgid "Object Comparison"
msgstr "オブジェクトの比較"

#: ../../extending/newtypes.rst:371
msgid ""
"The :c:member:`~PyTypeObject.tp_richcompare` handler is called when "
"comparisons are needed.  It is analogous to the :ref:`rich comparison "
"methods <richcmpfuncs>`, like :meth:`__lt__`, and also called by :c:func:"
"`PyObject_RichCompare` and :c:func:`PyObject_RichCompareBool`."
msgstr ""
":c:member:`~PyTypeObject.tp_richcompare` ハンドラは比較処理が要求されたときに"
"呼び出されます。\n"
":meth:`__lt__` のような :ref:`拡張比較メソッド <richcmpfuncs>` に類似してお"
"り、 :c:func:`PyObject_RichCompare` と :c:func:`PyObject_RichCompareBool` か"
"らも呼び出されます。"

#: ../../extending/newtypes.rst:376
msgid ""
"This function is called with two Python objects and the operator as "
"arguments, where the operator is one of ``Py_EQ``, ``Py_NE``, ``Py_LE``, "
"``Py_GT``, ``Py_LT`` or ``Py_GT``.  It should compare the two objects with "
"respect to the specified operator and return ``Py_True`` or ``Py_False`` if "
"the comparison is successful, ``Py_NotImplemented`` to indicate that "
"comparison is not implemented and the other object's comparison method "
"should be tried, or *NULL* if an exception was set."
msgstr ""
"この関数は 2 つの Python オブジェクトと演算子を引数に取り、演算子は "
"``Py_EQ``, ``Py_NE``, ``Py_LE``, ``Py_GT``, ``Py_LT``, ``Py_GT`` のどれか 1 "
"つです。関数は指定された演算子に従って 2 つのオブジェクトを比較し、比較に成功"
"した場合の ``Py_True`` および ``Py_False`` か、比較処理が実装されておらず、も"
"う一方のオブジェクトの比較処理を試行することを示す ``Py_NotImplemented`` か、"
"例外が設定された場合の *NULL* のいづれかを返します。"

#: ../../extending/newtypes.rst:384
msgid ""
"Here is a sample implementation, for a datatype that is considered equal if "
"the size of an internal pointer is equal::"
msgstr ""
"これは内部ポインタのサイズが等しければ等しいと見なすデータ型のサンプル実装で"
"す::"

#: ../../extending/newtypes.rst:414
msgid "Abstract Protocol Support"
msgstr "抽象的なプロトコルのサポート"

#: ../../extending/newtypes.rst:416
msgid ""
"Python supports a variety of *abstract* 'protocols;' the specific interfaces "
"provided to use these interfaces are documented in :ref:`abstract`."
msgstr ""
"Python はいくつもの *抽象的な* “プロトコル”をサポートしています。これらを使用"
"する特定のインターフェイスについては :ref:`abstract` で解説されています。"

#: ../../extending/newtypes.rst:420
msgid ""
"A number of these abstract interfaces were defined early in the development "
"of the Python implementation.  In particular, the number, mapping, and "
"sequence protocols have been part of Python since the beginning.  Other "
"protocols have been added over time.  For protocols which depend on several "
"handler routines from the type implementation, the older protocols have been "
"defined as optional blocks of handlers referenced by the type object.  For "
"newer protocols there are additional slots in the main type object, with a "
"flag bit being set to indicate that the slots are present and should be "
"checked by the interpreter.  (The flag bit does not indicate that the slot "
"values are non-*NULL*. The flag may be set to indicate the presence of a "
"slot, but a slot may still be unfilled.) ::"
msgstr ""
"これら多数の抽象的なインターフェイスは、Python の実装が開発される初期の段階で"
"定義されていました。とりわけ数値や辞書、そしてシーケンスなどのプロトコルは最"
"初から Python の一部だったのです。それ以外のプロトコルはその後追加されまし"
"た。型の実装にあるいくつかのハンドラルーチンに依存するようなプロトコルのため"
"に、古いプロトコルはハンドラの入ったオプションのブロックとして定義し、型オブ"
"ジェクトから参照するようになりました。タイプオブジェクトの主部に追加のスロッ"
"トをもつ新しいプロトコルについては、フラグ用のビットを立てることでそれらのス"
"ロットが存在しており、インタプリタがチェックすべきであることを指示できます。"
"(このフラグ用のビットは、そのスロットの値が非 *NULL* であることを示しているわ"
"けではありません。フラグはスロットの存在を示すのに使えますが、そのスロットは"
"まだ埋まっていないかもしれないのです。) ::"

#: ../../extending/newtypes.rst:435
msgid ""
"If you wish your object to be able to act like a number, a sequence, or a "
"mapping object, then you place the address of a structure that implements "
"the C type :c:type:`PyNumberMethods`, :c:type:`PySequenceMethods`, or :c:"
"type:`PyMappingMethods`, respectively. It is up to you to fill in this "
"structure with appropriate values. You can find examples of the use of each "
"of these in the :file:`Objects` directory of the Python source "
"distribution. ::"
msgstr ""
"お使いのオブジェクトを数値やシーケンス、あるいは辞書のようにふるまうようにし"
"たいならば、それぞれに C の :c:type:`PyNumberMethods` 構造体、 :c:type:"
"`PySequenceMethods` 構造体、または :c:type:`PyMappingMethods` 構造体のアドレ"
"スを入れます。これらに適切な値を入れても入れなくてもかまいません。これらを"
"使った例は Python の配布ソースにある :file:`Objects` でみつけることができるで"
"しょう。 ::"

#: ../../extending/newtypes.rst:444
msgid ""
"This function, if you choose to provide it, should return a hash number for "
"an instance of your data type. Here is a simple example::"
msgstr ""
"この関数は、もし使うことにしたならば、データ型のインスタンスのハッシュ番号を"
"返すようにします。次のは単純な例です::"

#: ../../extending/newtypes.rst:457
msgid ""
":c:type:`Py_hash_t` is a signed integer type with a platform-varying width. "
"Returning ``-1`` from :c:member:`~PyTypeObject.tp_hash` indicates an error, "
"which is why you should be careful to avoid returning it when hash "
"computation is successful, as seen above."
msgstr ""

#: ../../extending/newtypes.rst:466
msgid ""
"This function is called when an instance of your data type is \"called\", "
"for example, if ``obj1`` is an instance of your data type and the Python "
"script contains ``obj1('hello')``, the :c:member:`~PyTypeObject.tp_call` "
"handler is invoked."
msgstr ""
"この関数は、その型のインスタンスが「関数として呼び出される」ときに呼ばれま"
"す。たとえばもし ``obj1`` にそのインスタンスが入っていて、Python スクリプト"
"で ``obj1('hello')`` を実行したとすると、 :c:member:`~PyTypeObject.tp_call` "
"ハンドラが呼ばれます。"

#: ../../extending/newtypes.rst:470
msgid "This function takes three arguments:"
msgstr "この関数は 3つの引数をとります:"

#: ../../extending/newtypes.rst:472
msgid ""
"*self* is the instance of the data type which is the subject of the call. If "
"the call is ``obj1('hello')``, then *self* is ``obj1``."
msgstr ""
"*self* は呼び出しの対象となるデータ型のインスタンスです。\n"
"たとえば呼び出しが ``obj1('hello')`` の場合、*self* は ``obj1`` になります。"

#: ../../extending/newtypes.rst:475
msgid ""
"*args* is a tuple containing the arguments to the call.  You can use :c:func:"
"`PyArg_ParseTuple` to extract the arguments."
msgstr ""
"*args* は呼び出しの引数を格納しているタプルです。ここから引数を取り出すには :"
"c:func:`PyArg_ParseTuple` を使います。"

#: ../../extending/newtypes.rst:478
msgid ""
"*kwds* is a dictionary of keyword arguments that were passed. If this is non-"
"*NULL* and you support keyword arguments, use :c:func:"
"`PyArg_ParseTupleAndKeywords` to extract the arguments.  If you do not want "
"to support keyword arguments and this is non-*NULL*, raise a :exc:"
"`TypeError` with a message saying that keyword arguments are not supported."
msgstr ""
"*kwds* はキーワード引数のための辞書です。これが *NULL* でなく、キーワード引数"
"をサポートしている場合は、 :c:func:`PyArg_ParseTupleAndKeywords` をつかって引"
"数を取り出せます。キーワード引数をサポートしていないのにこれが *NULL* でない"
"場合は、キーワード引数はサポートしていない旨のメッセージとともに :exc:"
"`TypeError` を発生させてください。"

#: ../../extending/newtypes.rst:484
msgid "Here is a toy ``tp_call`` implementation::"
msgstr "以下は ``tp_call`` の簡易な実装です::"

#: ../../extending/newtypes.rst:510
msgid ""
"These functions provide support for the iterator protocol.  Both handlers "
"take exactly one parameter, the instance for which they are being called, "
"and return a new reference.  In the case of an error, they should set an "
"exception and return *NULL*.  :c:member:`~PyTypeObject.tp_iter` corresponds "
"to the Python :meth:`__iter__` method, while :c:member:`~PyTypeObject."
"tp_iternext` corresponds to the Python :meth:`~iterator.__next__` method."
msgstr ""

#: ../../extending/newtypes.rst:517
msgid ""
"Any :term:`iterable` object must implement the :c:member:`~PyTypeObject."
"tp_iter` handler, which must return an :term:`iterator` object.  Here the "
"same guidelines apply as for Python classes:"
msgstr ""

#: ../../extending/newtypes.rst:521
msgid ""
"For collections (such as lists and tuples) which can support multiple "
"independent iterators, a new iterator should be created and returned by each "
"call to :c:member:`~PyTypeObject.tp_iter`."
msgstr ""

#: ../../extending/newtypes.rst:524
msgid ""
"Objects which can only be iterated over once (usually due to side effects of "
"iteration, such as file objects) can implement :c:member:`~PyTypeObject."
"tp_iter` by returning a new reference to themselves -- and should also "
"therefore implement the :c:member:`~PyTypeObject.tp_iternext`  handler."
msgstr ""

#: ../../extending/newtypes.rst:529
msgid ""
"Any :term:`iterator` object should implement both :c:member:`~PyTypeObject."
"tp_iter` and :c:member:`~PyTypeObject.tp_iternext`.  An iterator's :c:member:"
"`~PyTypeObject.tp_iter` handler should return a new reference to the "
"iterator.  Its :c:member:`~PyTypeObject.tp_iternext` handler should return a "
"new reference to the next object in the iteration, if there is one. If the "
"iteration has reached the end, :c:member:`~PyTypeObject.tp_iternext` may "
"return *NULL* without setting an exception, or it may set :exc:"
"`StopIteration` *in addition* to returning *NULL*; avoiding the exception "
"can yield slightly better performance.  If an actual error occurs, :c:member:"
"`~PyTypeObject.tp_iternext` should always set an exception and return *NULL*."
msgstr ""

#: ../../extending/newtypes.rst:545
msgid "Weak Reference Support"
msgstr "弱参照(Weak Reference)のサポート"

#: ../../extending/newtypes.rst:547
msgid ""
"One of the goals of Python's weak reference implementation is to allow any "
"type to participate in the weak reference mechanism without incurring the "
"overhead on performance-critical objects (such as numbers)."
msgstr ""

#: ../../extending/newtypes.rst:552
msgid "Documentation for the :mod:`weakref` module."
msgstr ""

#: ../../extending/newtypes.rst:554
msgid ""
"For an object to be weakly referencable, the extension type must do two "
"things:"
msgstr ""

#: ../../extending/newtypes.rst:556
msgid ""
"Include a :c:type:`PyObject\\*` field in the C object structure dedicated to "
"the weak reference mechanism.  The object's constructor should leave it "
"*NULL* (which is automatic when using the default :c:member:`~PyTypeObject."
"tp_alloc`)."
msgstr ""

#: ../../extending/newtypes.rst:561
msgid ""
"Set the :c:member:`~PyTypeObject.tp_weaklistoffset` type member to the "
"offset of the aforementioned field in the C object structure, so that the "
"interpreter knows how to access and modify that field."
msgstr ""

#: ../../extending/newtypes.rst:565
msgid ""
"Concretely, here is how a trivial object structure would be augmented with "
"the required field::"
msgstr ""

#: ../../extending/newtypes.rst:573
msgid "And the corresponding member in the statically-declared type object::"
msgstr ""

#: ../../extending/newtypes.rst:581
msgid ""
"The only further addition is that ``tp_dealloc`` needs to clear any weak "
"references (by calling :c:func:`PyObject_ClearWeakRefs`) if the field is non-"
"*NULL*::"
msgstr ""

#: ../../extending/newtypes.rst:597
msgid "More Suggestions"
msgstr "その他いろいろ"

#: ../../extending/newtypes.rst:599
msgid ""
"In order to learn how to implement any specific method for your new data "
"type, get the :term:`CPython` source code.  Go to the :file:`Objects` "
"directory, then search the C source files for ``tp_`` plus the function you "
"want (for example, ``tp_richcompare``).  You will find examples of the "
"function you want to implement."
msgstr ""

#: ../../extending/newtypes.rst:605
msgid ""
"When you need to verify that an object is a concrete instance of the type "
"you are implementing, use the :c:func:`PyObject_TypeCheck` function.  A "
"sample of its use might be something like the following::"
msgstr ""

#: ../../extending/newtypes.rst:616
msgid "Download CPython source releases."
msgstr ""

#: ../../extending/newtypes.rst:616
msgid "https://www.python.org/downloads/source/"
msgstr ""

#: ../../extending/newtypes.rst:618
msgid ""
"The CPython project on GitHub, where the CPython source code is developed."
msgstr ""

#: ../../extending/newtypes.rst:619
msgid "https://github.com/python/cpython"
msgstr ""