archived-doc-tr/language/oop5/basic.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: f94d903985119d3ac00f4528551df947f57b667f Maintainer: nilgun Status: ready-->
 <sect1 xml:id="language.oop5.basic" xmlns="http://docbook.org/ns/docbook">
  <title>Temel Kavramlar</title>

  <sect2 xml:id="language.oop5.basic.class">
   <title><code>class</code> Anahtar Sözcüğü</title>
   <para>
    Temel sınıf tanımı <literal>class</literal> anahtar sözcüğü ile başlar
    sınıf isminin ardından gelen bir çift kaşlı ayracın arasında sınıfa ait
    özelliklerin ve yöntemlerin tanımları bulunur.
   </para>
   <para>
    Sınıf ismi olarak herhangi bir geçerli yafta kullanılabilir ancak bu PHP
    için <link linkend="reserved">ayrılmış sözcüklerden biri</link>
    olmamalıdır. Geçerli bir sınıf ısmı bir harf veya alt çizgi ile başlar,
    sayılar, harfler veya alt çizgiler içerebilir. Bir düzenli ifade olarak
    şöyle bir şablonla eşleşmelidir:
    <code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>.
   </para>
   <para>
    Bir sınıfın kendi <link linkend="language.oop5.constants">sabitleri</link>,
    <link linkend="language.oop5.properties">değişkenleri</link>
    (bunlara "özellik" de denir) ve işlevleri (bunlara "yöntem" de denir)
    olabilir.
   </para>
   <example>
    <title>- Basit bir sınıf tanımı</title>
    <programlisting role="php">
<![CDATA[
<?php
class BasitSınıf
{
    // özellik bildirimi
    public $öntanımlı = 'öntanımlı bir değer';

    // yöntem tanımı
    public function ÖntanımlıyıGöster() {
        echo $this->öntanımlı;
    }
}
?>
]]>
    </programlisting>
   </example>
   <para>
    Bir nesne bağlamı içinden bir yöntem çağırmak için <varname>$this</varname>
    diye bir sözde değişken kullanılır. <varname>$this</varname> çağrılan
    nesnenin değeridir.
   </para>
   <warning>
    <para>
     Statik olmayan yöntemin statik olarak çağrılması
     <classname>Error</classname> yavrulanmasına sebep olur.
     PHP 8.0.0 öncesinde bunun kullanımdışı olduğuna dair bir uyarı verilir ve
     tanımlanmamış olarak $this ile sonuçlanırdı.
   </para>
   <example xml:id="language.oop5.basic.class.this">
    <title>- <varname>$this</varname> sözde değişkeninin kullanımı</title>
    <programlisting role="php">
<![CDATA[
<?php
class A
{
    function foo()
    {
        if (isset($this)) {
            echo '$this tanımlı (';
            echo get_class($this);
            echo ")\n";
        } else {
            echo "\$this tanımsız.\n";
        }
    }
}

class B
{
    function bar()
    {
        A::foo();
    }
}

$a = new A();
$a->foo();

A::foo();

$b = new B();
$b->bar();

B::bar();
?>
]]>
     </programlisting>
     &example.outputs.7;
     <screen>
<![CDATA[
$this is defined (A)

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 27
$this is not defined.

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 20
$this is not defined.

Deprecated: Non-static method B::bar() should not be called statically in %s  on line 32

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 20
$this is not defined.
]]>
     </screen>
     &example.outputs.8;
     <screen>
<![CDATA[
$this is defined (A)

Fatal error: Uncaught Error: Non-static method A::foo() cannot be called statically in %s :27
Stack trace:
#0 {main}
  thrown in %s  on line 27
]]>
     </screen>
    </example>
   </warning>

   <sect3 xml:id="language.oop5.basic.class.readonly">
    <title>Salt okunur sınıflar</title>
    <para>
     PHP 8.2.0 ve sonrasında, bir sınıf <modifier>readonly</modifier>
     değiştiricisi ile imlenebilmektedir. Bir sınıfın
     <modifier>readonly</modifier> imlenmesi bildirilen her özelliğe <link
     linkend="language.oop5.properties.readonly-properties">
     <modifier>readonly</modifier> değiştiricisi</link> eklenmesine ve
     <link linkend="language.oop5.properties.dynamic-properties">dinamik
     özelliklerin</link> oluşturulmasının engellenmesine neden olur. Dahası,
     <classname>AllowDynamicProperties</classname> özniteliği kullanılarak bu
     engelleme kaldırılamamakta, böyle bir çaba bir derleme anı hatasını  tetiklemektedir.
    </para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
#[\AllowDynamicProperties]
readonly class Foo {
}

// Ölümcül hata: #[AllowDynamicProperties] readonly class Foo'ya uygulanamaz
?>
]]>
     </programlisting>
    </informalexample>

    <para>
     Türsüz ve statik özellikler <literal>readonly</literal> değiştiricisi
     ile imlenemez ve salt okunur sınıflarda bildirilemez:
    </para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
readonly class Foo
{
    public $bar;
}

// Ölümcül hata: Salt okunur Foo::$bar özelliğinin bir türü olmalı
?>
]]>
     </programlisting>
     <programlisting role="php">
<![CDATA[
<?php
readonly class Foo
{
    public static int $bar;
}

// Ölümcül hata: Salt okunur class Foo statik özellikler bildiremez
?>
]]>
     </programlisting>
    </informalexample>
    <para>
     Salt okunur (<modifier>readonly</modifier> bildirimli) bir sınıfın
     <link linkend="language.oop5.basic.extends">genişletilebilmesi</link>
     için gerek ve yeter koşul çocuk sınıfının da salt okunur sınıf olmasıdır.
    </para>
   </sect3>
  </sect2>

  <sect2 xml:id="language.oop5.basic.new">
   <title><code>new</code> Anahtar Sözcüğü</title>
   <para>
    Bir sınıfın örneğini oluşturmak için <literal>new</literal> anahtar sözcüğü
    kullanılmalıdır. Nesnenin hata durumunda daima yeni bir değişkene
    atanarak oluşturulması için <link linkend="language.oop5.decon"
    >kurucu</link>sunun bir <link linkend="language.exceptions"
    >istisna</link> oluşturmaması gerekir. Sınıflar, örnekleme öncesi
    tanımlanmış olmalıdır (ve bu, bazı durumlarda bir gereksinimdir).
   </para>
   <para>
    <type>string</type> türünde b,r değişken <literal>new</literal> ile
    kullanılmış bir sınıf ismi içeriyorsa bu sınıfın yeni bir örneği
    oluşturulur. Eğer sınıf bir isim alanı içersindeyse bu yapılırken sınıfın
    tam nitelenmiş ismi kullanılmalıdır.
   </para>
   <note>
    <para>
     Sınıfın yapıcısına iletilecek hiçbir bağımsız değişken yoksa, sınıf
     adından sonra parantez kullanmak gerekmez.
    </para>
   </note>
   <example>
    <title>- Bir sınıf örneğinin oluşturulması</title>
    <programlisting role="php">
<![CDATA[
<?php
$örnek = new BasitSınıf();

// Bu bir değişkenle de yapılabilir:
$sınıf = 'BasitSınıf';
$örnek = new $sınıf(); // new BasitSınıf()
?>
]]>
    </programlisting>
   </example>
   <para>
    PHP 8.0.0 ve sonrasında, keyfi ifadelerde <literal>new</literal>
    kullanımı desteklenmektedir. İfade bir dizge üretiyorsa daha karmaşık
    örneklemeler mümkündür. İfadelerin parantez içine alınması gerekir.
   </para>
   <example>
    <title>- Keyfi ifadelerle örnekleme</title>
    <para>
     Örnekte sınıf ismini üretmekte kullanılan çeşitli ifadeler
     gösterilmiştir. Bir işlev çağrısı, dizge birleştirme ve
     <constant>::class</constant> sabiti.
    </para>
    <programlisting role="php">
     <![CDATA[
<?php

class ClassA extends \stdClass {}
class ClassB extends \stdClass {}
class ClassC extends ClassB {}
class ClassD extends ClassA {}

function getSomeClass(): string
{
    return 'ClassA';
}

var_dump(new (getSomeClass()));
var_dump(new ('Class' . 'B'));
var_dump(new ('Class' . 'C'));
var_dump(new (ClassD::class));
?>
]]>
    </programlisting>
    &example.outputs.8;
    <screen>
     <![CDATA[
object(ClassA)#1 (0) {
}
object(ClassB)#1 (0) {
}
object(ClassC)#1 (0) {
}
object(ClassD)#1 (0) {
}

]]>
    </screen>
   </example>
   <para>
    Sınıf bağlamında yeni bir nesneyi <literal>new self</literal> veya
    <literal>new parent</literal> kullanarak oluşturmak mümkündür.
   </para>
   <para>
    Oluşturulmuş bir sınıf örneğinin yeni bir değişkene atanması sırasında,
    yeni değişken, atanan nesneyle aynı örneğe erişecektir. Bu davranışın
    örneklerin bir işleve aktarılmasından bir farkı yoktur. <link
    linkend="language.oop5.cloning">Kopyalamak</link> suretiyle oluşturulmuş
    bir nesnenin daima bir kopyası yapılabilir.
   </para>
   <example>
    <title>- Nesne Atama</title>
    <programlisting role="php">
<![CDATA[
<?php
$örnek = new BasitSınıf();

$atama     =  $örnek;
$gönderim  =& $örnek;

$örnek->var = '$atama bu değere sahip olacak';

$örnek = null; // $örnek ve $gönderim null olur

var_dump($örnek);
var_dump($gönderim);
var_dump($atama);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
NULL
NULL
object(BasitSınıf)#1 (1) {
  ["var"]=>
  string(30) "$atama bu değere sahip olacak"
}
]]>
    </screen>
   </example>
   <para>
    Bir nesnenin örneğini oluşturmak için yeni yollar kullanılabilmektedir:
   </para>
   <example>
    <title>- Yeni nesneler oluşturmak</title>
    <programlisting role="php">
<![CDATA[
<?php
class Test
{
    public static function getNew()
    {
        return new static();
    }
}

class Child extends Test {}

$obj1 = new Test(); // sınıf adına göre
$obj2 = new $obj1;  // bir nesne içeren değişken üzerinden
var_dump($obj1 !== $obj2);

$obj3 = Test::getNew(); // sınıf yöntemine göre
var_dump($obj3 instanceof Test);

$obj4 = Child::getNew(); // çocuk sınıf yöntemi üzerinden
var_dump($obj4 instanceof Child);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
bool(true)
bool(true)
bool(true)
]]>
    </screen>
   </example>
   <para>
    Yeni oluşturulmuş bir nesnenin üyesine tek bir ifadede erişmek
    mümkündür:
   </para>
   <example>
    <title>- Yeni oluşturulmuş bir nesnenin üyesine erişim</title>
    <programlisting role="php">
<![CDATA[
<?php
echo (new DateTime())->format('Y');
?>
]]>
    </programlisting>
    &example.outputs.similar;
    <screen>
<![CDATA[
2016
]]>
    </screen>
   </example>
   <note>
    <simpara>
     PHP 7.1'den önce, bir yapıcı işlev tanımlanmamışsa bağımsız değişkenler
     değerlendirilmez.
    </simpara>
   </note>
  </sect2>

  <sect2 xml:id="language.oop5.basic.properties-methods">
   <title>Özellikler ve Yöntemler</title>
   <para>
    Sınıf özellikleri ve yöntemleri ayrı isim alanlarında ("namespace") yer
    alır, dolayısıyla bunlar aynı isimde olabilir. Sadece bağlama bağlı
    kalarak, bir özelliğin mi yoksa bir yöntemin mi çağrıldığına (yani, bir
    değişkene erişim veya işlev çağrısı) bakmadan her ikisi de aynı gösterimle
    kullanılabilir.
   </para>
   <example>
    <title>- Özelliğe erişim ya da yöntem çağrısı</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    public $bar = 'özellik';

    public function bar() {
        return 'yöntem';
    }
}

$obj = new Foo();
echo $obj->bar, PHP_EOL, $obj->bar(), PHP_EOL;
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
özellik
yöntem
]]>
    </screen>
   </example>
   <para>
    Bunun anlamı: Bir özelliğe atanmış bir
    <link linkend="functions.anonymous">anonim işlevi</link> doğrudan çağırmak
    mümkün değildir. Bunun yerine, özellik önce örneğin bir değişkene
    atanmalıdır. Böyle bir özelliği parantez içine
    alarak doğrudan çağırmak mümkündür.
   </para>
   <example>
    <title>- Bir özelliğe atanmış bir anonim işlevi çağırmak</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    public $bar;

    public function __construct() {
        $this->bar = function() {
            return 42;
        };
    }
}

$obj = new Foo();

echo ($obj->bar)(), PHP_EOL;
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
42
]]>
    </screen>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.basic.extends">
   <title><code>extends</code> Anahtar Sözcüğü</title>
   <para>
    Bir sınıfın bildiriminde <code>extends</code> anahtar sözcüğü
    kullanılarak başka bir sınıfın sabit, yöntem ve özellikleri miras alınabilir.
    Çok sayıda sınıfı miras alarak genişlemek mümkün değildir, bir sınıf
    sadece bir ana sınıfı miras alabilir.
   </para>
   <para>
    Miras alınan sabit, yöntem ve özellikler, ebeveyn sınıfta tanımlı
    isimleriyle yeniden bildirilerek geçersiz kılınabilir; bu sadece ebeveyn
    sınıfın <link linkend="language.oop5.final">final</link> tanımlı yöntemleri
    ve sabitleri için yapılamaz. Geçersiz kılınmış yöntemlere ve statik
    özelliklere <link
    linkend="language.oop5.paamayim-nekudotayim">parent::</link> öneki ile
    atıfta bulunarak erişilebilir.
   </para>
   <note>
    <simpara>
     PHP 8.1.0 itibariyle, sabitler final olarak bildirilebilmektedir.
    </simpara>
   </note>
   <example>
    <title>- Basit bir sınıfın miras alınması</title>
    <programlisting role="php">
<![CDATA[
<?php
class EkSınıf extends BasitSınıf
{
    // ebeveyn yöntemi yeniden bildirelim
    function değerGöster()
    {
        echo "Sınıf genişletiliyor\n";
        parent::değerGöster();
    }
}

$ek = new EkSınıf();
$ek->değerGöster();
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Sınıf genişletiliyor
bir öntanımlı değer
]]>
    </screen>
   </example>

   <sect3 xml:id="language.oop.lsp">
    <title>Bağımsız değişken sırası uyumluluk kuralları</title>
    <para>
     Bir yöntem geçersiz kılınırken bağımsız değişkenlerin yerleri ebeveyn
     yöntem ile uyumlu olmalıdır. Aksi takdirde, ölümcül bir hata üretilir.
     PHP 8.0.0 öncesinde  <constant>E_WARNING</constant> seviyesinde bir hata
     üretilirdi. Bağımsız değişkenlerin yerleri,
     <link linkend="language.oop5.variance">özgüllük</link>
     kurallarına uyuyorsa, zorunlu bir bağımsız değişkeni isteğe bağlı duruma
     getiriyorsa ve yalnızca isteğe bağlı yeni bağımsız değişkenler ekliyor ve
     görünürlüğü kısıtlamıyor, yalnızca rahatlatıyorsa uyumludur. Bu,
     Liskov İkame İlkesi olarak bilinir. Kurucu ve özel yöntemler bu uyumluluk
     kurallarından muaf olduğundan bir uyuşmazlık durumunda ölümcül bir hata
     oluşmaz.
    </para>
    <example>
     <title>- Uyumlu çocuk yöntemler</title>
     <programlisting role="php">
<![CDATA[
<?php

class Base
{
    public function foo(int $a) {
        echo "Geçerli\n";
    }
}

class Extend1 extends Base
{
    function foo(int $a = 5)
    {
        parent::foo($a);
    }
}

class Extend2 extends Base
{
    function foo(int $a, $b = 5)
    {
        parent::foo($a);
    }
}

$extended1 = new Extend1();
$extended1->foo();
$extended2 = new Extend2();
$extended2->foo(1);
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Geçerli
Geçerli
]]>
     </screen>
    </example>

    <para>
     Aşağıdaki örnekler, bir bağımsız değişkeni kaldıran veya isteğe bağlı bir
     bağımsız değişkeni zorunlu kılan bir çocuk yöntemin ebeveyn yöntemle uyumlu
     olmadığını gösterir.
    </para>
    <example>
     <title>- Bir çocuk yöntem bir bağımsız değişkeni kaldırdığında ölümcül hata
       oluşur</title>
     <programlisting role="php">
<![CDATA[
<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Geçerli\n";
    }
}

class Extend extends Base
{
    function foo()
    {
        parent::foo(1);
    }
}
]]>
     </programlisting>
     &example.outputs.8.similar;
     <screen>
<![CDATA[
Fatal error: Declaration of Extend::foo() must be compatible with Base::foo(int $a = 5) in /in/evtlq on line 13
]]>
     </screen>
    </example>
    <example>
     <title>- Bir çocuk yöntem isteğe bağlı bir bağımsız değişkeni zorunlu
       kıldığında ölümcül hata oluşur</title>
     <programlisting role="php">
<![CDATA[
<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Geçerli\n";
    }
}

class Extend extends Base
{
    function foo(int $a)
    {
        parent::foo($a);
    }
}
]]>
     </programlisting>
     &example.outputs.8.similar;
     <screen>
<![CDATA[
Fatal error: Declaration of Extend::foo(int $a) must be compatible with Base::foo(int $a = 5) in /in/qJXVC on line 13
]]>
     </screen>
    </example>

    <warning>
     <para>
      Bir çocuk sınıfta bir yöntemin bağımsız değişkenini yeniden adlandırmak
      bağımsız değişken sırası uyumsuzluğu değildir. Ancak,
      <link linkend="functions.named-arguments">isimli bağımsız değişkenler</link>
      kullanılırsa çalışma zamanı hatasına (<classname>Error</classname>)
      neden olacağından bu önerilmez.
     </para>
     <example>
      <title>- Bir çocuk sınıfta isimli bağımsız değişkenler yeniden adlandırıldığında
        hata oluşur</title>
      <programlisting role="php">
<![CDATA[
<?php

class A {
    public function test($foo, $bar) {}
}

class B extends A {
    public function test($a, $b) {}
}

$obj = new B;

// Pass parameters according to A::test() contract
$obj->test(foo: "foo", bar: "bar"); // HATA!
]]>
      </programlisting>
      &example.outputs.similar;
      <screen>
<![CDATA[
Fatal error: Uncaught Error: Unknown named parameter $foo in /in/XaaeN:14
Stack trace:
#0 {main}
  thrown in /in/XaaeN on line 14
]]>
      </screen>
     </example>
    </warning>
   </sect3>
  </sect2>

  <sect2 xml:id="language.oop5.basic.class.class">
   <title>::class</title>

   <para>
    <literal>class</literal> anahtar sözcüğü, ayrıca
    sınıf isim çözünürlüğü için de kullanılabilmektedir.
    <literal>SınıfAdı</literal> sınıfının tam nitelenmiş ismini
    <literal>SınıfAdı::class</literal> biçeminde kullanarak bir dizge elde
    edilebilir. Bu, özellikle <link linkend="language.namespaces">isim
    alanlı</link> sınıflarda çok kullanışlıdır.
   </para>
   <para>
    <example xml:id="language.oop5.basic.class.class.name">
     <title>- Sınıf adı çözünürlüğü</title>
     <programlisting role="php">
<![CDATA[
<?php
namespace NS {
    class SınıfAdı {
    }

    echo SınıfAdı::class;
}
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
NS\SınıfAdı
]]>
     </screen>
    </example>
   </para>
   <note>
    <para>
      <literal>::class</literal> kullanarak sınıf ismi çözünürlüğü bir
      derleme zamanı dönüşümüdür. Yani, sınıf ismi dizgesi oluşturulduğu
      sırada otomatik bir yükleme henüz oluşmamıştır. Sonuç olarak, sınıf
      henüz mevcut değilken bile sınıf isimleri genişletilir. Bu durumda
      hiçbir hata oluşmaz.
    </para>
    <example xml:id="language.oop5.basic.class.class.fail">
     <title>- Eksik sınıf adı çözümlemesi</title>
     <programlisting role="php">
<![CDATA[
<?php
print Does\Not\Exist::class;
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Does\Not\Exist
]]>
     </screen>
    </example>
   </note>
   <para>
    PHP 8.0.0'dan itibaren, <literal>::class</literal> nesnelerde de
    kullanılabilir. Bu çözümleme derleme zamanında değil çalışma zamanında
    gerçekleşir. Etkisi, nesne üzerinde <function>get_class</function> işlevini
    çağırmakla aynıdır.
   </para>
   <example xml:id="language.oop5.basic.class.class.object">
    <title>- Nesne adı çözümlemesi</title>
    <programlisting role="php">
<![CDATA[
<?php
namespace NS {
    class ClassName {
    }
}
$c = new ClassName();
print $c::class;
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
NS\ClassName
]]>
    </screen>
   </example>
  </sect2>

 <sect2 xml:id="language.oop5.basic.nullsafe">
  <title>Güvenli Null yöntemler ve özellikler</title>
  <para>
   PHP 8.0.0'dan itibaren, özelliklere ve yöntemlere, "güvenli null" işleci ile
   de erişilebilir: <literal>?-></literal>. Güvenli null işleci, yukarıdaki
   özellik veya yöntem erişimiyle aynı şekilde çalışır, tek fark, başvurulan
   nesne &null; ise bir istisna yerine &null; döner. Başvurulan nesne bir
   zincirin parçasıysa, zincirin geri kalanı atlanır.
  </para>
  <para>
   Etkisi, her bir erişimi önce <function>is_null</function> denetiminden
   geçirmeye benzer, ancak daha karmaşıktır.
  </para>
  <para>
   <example>
    <title>- Güvenli Null İşleci</title>
    <programlisting role="php">
<![CDATA[
<?php

// PHP 8.0.0 ve sonrasında, bu satır:
$result = $repository?->getUser(5)?->name;

// aşağıdaki kod kümesi ile aynıdır:
if (is_null($repository)) {
    $result = null;
} else {
    $user = $repository->getUser(5);
    if (is_null($user)) {
        $result = null;
    } else {
        $result = $user->name;
    }
}
?>
]]>
    </programlisting>
   </example>
  </para>
  <note>
   <para>
    Güvenli Null işleci işleci, en iyi, null değerinin bir özellik veya yöntem
    dönüşü için geçerli ve beklenen olası bir değer olarak kabul edilmesi
    durumunda kullanılır. Bir hatayı belirtmek için, bir istisna oluşturmak
    tercih edilebilir.
   </para>
  </note>
 </sect2>
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->