sequence.sequence

## Class RealShallowSequence

- java.lang.Object
- - sequence.sequence.RealShallowSequence

- All Implemented Interfaces:
    CommonBase, BaseSequence, ShallowSequence

      public class RealShallowSequence
      extends java.lang.Object
      implements ShallowSequence

  Implementace mělké posloupnosti určené k třídění.

  Popis: Mělká posloupnost je pomocná posloupnost nad členy jiné posloupnosti. Je určena jako pomůcka k řazení posloupností podle klíče.

  Užití: instance této třídy lze používat v aplikacích.

  Invariant: mělká posloupnost nesmí být prázdná.

  Frame condition pro všechny metody: Hlavní posloupnost se nesmí změnit (Update, Insert, Remove), dokud se používají mělké kopie!

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected int` | `count` aktuální počet prvků mělké posloupnosti
    `protected boolean` | `latchFull` Příznak zachycení běžného prvku.
    `protected ShallowList` | `list` zapouzdřený mělký seznam uvnitř implementace posloupnosti
    `protected int` | `size` kapacita mělké posloupnosti

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RealShallowSequence(ShallowList aList, int aCount, int aSize)` Vyrobí mělkou posloupnost.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `getCount()` Vrátí počet prvků v posloupnosti.
    `Element` | `getElement()` Vrátí hodnotu běžného prvku.
    `MemberReference` | `getFirstRef()` Vrátí odkaz na první člen posloupnosti.
    `MemberReference` | `getLastRef()` Vrátí odkaz na poslední člen posloupnosti.
    `int` | `getMoveCounter()` Provozní měření.
    `void` | `insertLast()` Zatřídí poslední prvek před běžný.
    `boolean` | `isEmpty()` Zjistí, zda je posloupnost prázdná.
    `boolean` | `isFirst()` Zjistí, zda běžný prvek je první.
    `boolean` | `isFull()` Zjistí, zda je posloupnost plná.
    `boolean` | `isLast()` Zjistí, zda běžný prvek je poslední.
    `boolean` | `isLatched()` Zjistí, zda byl zachycen nějaký běžný prvek.
    `Element` | `latch()` Zachytí odkaz na běžný prvek v posloupnosti a vrátí jej.
    `ShallowSequence` | `makeLowerHalfSequence()` Vyrobí mělkou kopii posloupnosti obsahující spodní polovinu.
    `ShallowSequence` | `makeShrinkSequence()` Vyrobí mělkou kopii celé posloupnosti.
    `ShallowSequence` | `makeStretchDownSequence()` Vyrobí mělkou kopii posloupnosti obsahující poslední člen.
    `ShallowSequence` | `makeStretchUpSequence()` Vyrobí mělkou kopii posloupnosti obsahující první člen.
    `ShallowSequence` | `makeUpperHalfSequence()` Vyrobí mělkou kopii posloupnosti obsahující horní polovinu.
    `void` | `moveDownTo(int index)` Učiní běžným prvkem index-tý prvek před posledním prvekm.
    `void` | `moveFirst()` Učiní hlavu běžným prvkem.
    `void` | `moveLast()` Učiní ocas běžným prvkem.
    `void` | `moveNext()` Učiní následující prvek běžným prvkem.
    `void` | `movePrev()` Učiní předcházející prvek běžným prvkem.
    `void` | `moveUpTo(int index)` Učiní běžným prvkem index-tý prvek za prvním prvekm.
    `void` | `resetMoveCounter()` Vynuluje provozní měření.
    `void` | `restore()` Obnoví posledně zachycený běžný prvek.
    `void` | `setElement(Element value)` Nastaví hodnotu běžného prvku do členu datové struktury.
    `void` | `shrinkDown()` Smrskne posloupnost o jednoho člena před posledního.
    `void` | `shrinkUp()` Smrskne posloupnost o jednoho člena za prvního.
    `void` | `stretchDown()` Roztáhne posloupnost o jednoho člena před prvního.
    `void` | `stretchUp()` Roztáhne posloupnost o jednoho člena za posledního.
    `void` | `swap(CommonBase aSeq)` Zamění běžné prvky dvou posloupností.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### list

          protected ShallowList list

      zapouzdřený mělký seznam uvnitř implementace posloupnosti

    - #### count

          protected int count

      aktuální počet prvků mělké posloupnosti

    - #### size

          protected int size

      kapacita mělké posloupnosti

    - #### latchFull

          protected boolean latchFull

      Příznak zachycení běžného prvku. Souvisí s metodami latch a restore.

  - ### Constructor Detail

    - #### RealShallowSequence

          public RealShallowSequence(ShallowList aList,
                                     int aCount,
                                     int aSize)

      Vyrobí mělkou posloupnost.

      Vyžaduje: not aList.isEmpty

      Parameters:
        `aList` - mělký seznam
        `aCount` - aktuální počet prvků
        `aSize` - kapacita posloupnosti

  - ### Method Detail

    - #### setElement

          public void setElement(Element value)

      Description copied from interface: `CommonBase`
      Nastaví hodnotu běžného prvku do členu datové struktury.

      Vyžaduje: not isEmpty

      Specified by:
        `setElement` in interface `CommonBase`
      Parameters:
        `value` - prvek, který má být uložen do členu

    - #### getElement

          public Element getElement()

      Description copied from interface: `CommonBase`
      Vrátí hodnotu běžného prvku.

      Vyžaduje: not isEmpty

      Specified by:
        `getElement` in interface `CommonBase`
      Returns:
        hodnota běžného prvku

    - #### getMoveCounter

          public int getMoveCounter()

      Description copied from interface: `CommonBase`
      Provozní měření.
      Specified by:
        `getMoveCounter` in interface `CommonBase`
      Returns:
        počet přesunů běžného prvku

    - #### resetMoveCounter

          public void resetMoveCounter()

      Description copied from interface: `CommonBase`
      Vynuluje provozní měření.
      Specified by:
        `resetMoveCounter` in interface `CommonBase`

    - #### isEmpty

          public boolean isEmpty()

      Description copied from interface: `BaseSequence`
      Zjistí, zda je posloupnost prázdná.
      Specified by:
        `isEmpty` in interface `BaseSequence`
      Returns:
        true když je prázdná, jinak false

    - #### isFull

          public boolean isFull()

      Description copied from interface: `BaseSequence`
      Zjistí, zda je posloupnost plná.
      Specified by:
        `isFull` in interface `BaseSequence`
      Returns:
        true když je plná, jinak false

    - #### getCount

          public int getCount()

      Description copied from interface: `BaseSequence`
      Vrátí počet prvků v posloupnosti.
      Specified by:
        `getCount` in interface `BaseSequence`
      Returns:
        počet prvků v posloupnosti

    - #### moveFirst

          public void moveFirst()

      Description copied from interface: `ShallowSequence`
      Učiní hlavu běžným prvkem.
      Specified by:
        `moveFirst` in interface `ShallowSequence`

    - #### moveLast

          public void moveLast()

      Description copied from interface: `ShallowSequence`
      Učiní ocas běžným prvkem.
      Specified by:
        `moveLast` in interface `ShallowSequence`

    - #### moveNext

          public void moveNext()

      Description copied from interface: `ShallowSequence`
      Učiní následující prvek běžným prvkem.
      Specified by:
        `moveNext` in interface `ShallowSequence`

    - #### movePrev

          public void movePrev()

      Description copied from interface: `ShallowSequence`
      Učiní předcházející prvek běžným prvkem.
      Specified by:
        `movePrev` in interface `ShallowSequence`

    - #### moveUpTo

          public void moveUpTo(int index)

      Description copied from interface: `ShallowSequence`
      Učiní běžným prvkem index-tý prvek za prvním prvekm.
      Specified by:
        `moveUpTo` in interface `ShallowSequence`
      Parameters:
        `index` - pořadové číslo prvku

    - #### moveDownTo

          public void moveDownTo(int index)

      Description copied from interface: `ShallowSequence`
      Učiní běžným prvkem index-tý prvek před posledním prvekm.
      Specified by:
        `moveDownTo` in interface `ShallowSequence`
      Parameters:
        `index` - pořadové číslo prvku

    - #### isFirst

          public boolean isFirst()

      Description copied from interface: `ShallowSequence`
      Zjistí, zda běžný prvek je první.
      Specified by:
        `isFirst` in interface `ShallowSequence`
      Returns:
        true když je první, jinak false

    - #### isLast

          public boolean isLast()

      Description copied from interface: `ShallowSequence`
      Zjistí, zda běžný prvek je poslední.
      Specified by:
        `isLast` in interface `ShallowSequence`
      Returns:
        true když je poslední, jinak false

    - #### isLatched

          public boolean isLatched()

      Description copied from interface: `ShallowSequence`
      Zjistí, zda byl zachycen nějaký běžný prvek.
      Specified by:
        `isLatched` in interface `ShallowSequence`
      Returns:
        true když byl zachycen, jinak false

    - #### insertLast

          public void insertLast()

      Description copied from interface: `ShallowSequence`
      Zatřídí poslední prvek před běžný.
      Specified by:
        `insertLast` in interface `ShallowSequence`

    - #### swap

          public void swap(CommonBase aSeq)

      Description copied from interface: `ShallowSequence`
      Zamění běžné prvky dvou posloupností.
      Specified by:
        `swap` in interface `ShallowSequence`
      Parameters:
        `aSeq` - druhá posloupnost, jejíž prvek se má také zaměnit

    - #### stretchUp

          public void stretchUp()

      Description copied from interface: `ShallowSequence`
      Roztáhne posloupnost o jednoho člena za posledního.

      Vyžaduje: last nesmí dosáhnout horní hranice hlavní posloupnosti.

      Specified by:
        `stretchUp` in interface `ShallowSequence`

    - #### stretchDown

          public void stretchDown()

      Description copied from interface: `ShallowSequence`
      Roztáhne posloupnost o jednoho člena před prvního.

      Vyžaduje: first nesmí dosáhnout spodní hranice hlavní posloupnosti.

      Specified by:
        `stretchDown` in interface `ShallowSequence`

    - #### shrinkUp

          public void shrinkUp()

      Description copied from interface: `ShallowSequence`
      Smrskne posloupnost o jednoho člena za prvního.
      Specified by:
        `shrinkUp` in interface `ShallowSequence`

    - #### shrinkDown

          public void shrinkDown()

      Description copied from interface: `ShallowSequence`
      Smrskne posloupnost o jednoho člena před posledního.
      Specified by:
        `shrinkDown` in interface `ShallowSequence`

    - #### getFirstRef

          public MemberReference getFirstRef()

      Description copied from interface: `ShallowSequence`
      Vrátí odkaz na první člen posloupnosti. Dá se porovnat s jiným odkazem.
      Specified by:
        `getFirstRef` in interface `ShallowSequence`
      Returns:
        odkaz na první člen posloupnosti

    - #### getLastRef

          public MemberReference getLastRef()

      Description copied from interface: `ShallowSequence`
      Vrátí odkaz na poslední člen posloupnosti. Dá se porovnat s jiným odkazem.
      Specified by:
        `getLastRef` in interface `ShallowSequence`
      Returns:
        odkaz na poslední člen posloupnosti

    - #### latch

          public Element latch()

      Description copied from interface: `ShallowSequence`
      Zachytí odkaz na běžný prvek v posloupnosti a vrátí jej.
      Specified by:
        `latch` in interface `ShallowSequence`
      Returns:
        odkaz na běžný prvek v posloupnosti

    - #### restore

          public void restore()

      Description copied from interface: `ShallowSequence`
      Obnoví posledně zachycený běžný prvek. Učiní z něj prvek běžný.
      Specified by:
        `restore` in interface `ShallowSequence`

    - #### makeShrinkSequence

          public ShallowSequence makeShrinkSequence()

      Description copied from interface: `ShallowSequence`
      Vyrobí mělkou kopii celé posloupnosti.
      Specified by:
        `makeShrinkSequence` in interface `ShallowSequence`
      Returns:
        mělká kopie celé posloupnosti

    - #### makeStretchUpSequence

          public ShallowSequence makeStretchUpSequence()

      Description copied from interface: `ShallowSequence`
      Vyrobí mělkou kopii posloupnosti obsahující první člen.
      Specified by:
        `makeStretchUpSequence` in interface `ShallowSequence`
      Returns:
        mělká kopie posloupnosti obsahující první člen

    - #### makeStretchDownSequence

          public ShallowSequence makeStretchDownSequence()

      Description copied from interface: `ShallowSequence`
      Vyrobí mělkou kopii posloupnosti obsahující poslední člen.
      Specified by:
        `makeStretchDownSequence` in interface `ShallowSequence`
      Returns:
        mělká kopie posloupnosti obsahující poslední člen

    - #### makeLowerHalfSequence

          public ShallowSequence makeLowerHalfSequence()

      Description copied from interface: `ShallowSequence`
      Vyrobí mělkou kopii posloupnosti obsahující spodní polovinu.
      Specified by:
        `makeLowerHalfSequence` in interface `ShallowSequence`
      Returns:
        mělká kopie posloupnosti obsahující spodní polovinu

    - #### makeUpperHalfSequence

          public ShallowSequence makeUpperHalfSequence()

      Description copied from interface: `ShallowSequence`
      Vyrobí mělkou kopii posloupnosti obsahující horní polovinu.
      Specified by:
        `makeUpperHalfSequence` in interface `ShallowSequence`
      Returns:
        mělká kopie posloupnosti obsahující horní polovinu