sequence.dualstacksequence

## Class DualStackSequence

- java.lang.Object
- - sequence.dualstacksequence.DualStackSequence

- All Implemented Interfaces:
    CommonBase, BaseSequence, Sequence
  Direct Known Subclasses:
    ReorganizableDualStackSequence

      class DualStackSequence
      extends java.lang.Object
      implements Sequence

  Implementace posloupnosti dvojicí zásobníků.

  Popis: Posloupnost je implementována dvojicí zásobníků, předním a zadním. Hlava posloupnosti se nachází na dně předního zásobníku. Ocas posloupnosti se nachází na dně zadního zásobníku. Běžný prvek se nachází na vrcholu zadního zásobníku.

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

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private int` | `count` aktuální počet prvků v posloupnosti
    `private int` | `currentIndex` index běžného prvku
    `private Stack` | `front` přední zásobník
    `private int` | `moveCounter` počítadlo provozního měření
    `private Stack` | `rear` zadní zásobník
    `private int` | `size` kapacita posloupnosti

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DualStackSequence(StackFactory factory, int aSize)` Vyrobí posloupnost implementovanou dvojicí zásobníků.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `append(Element elem)` Vloží elem za poslední prvek posloupnosti.
    `int` | `getCount()` Vrátí počet prvků v posloupnosti.
    `Element` | `getElement()` Vrátí hodnotu běžného prvku.
    `int` | `getMoveCounter()` Provozní měření.
    `void` | `insert(Element elem)` Vloží elem před běžný prvek.
    `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í.
    `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` | `moveTo(int index)` Učiní index-tý prvek běžným prvkem.
    `Element` | `remove()` Odstraní běžný prvek.
    `void` | `resetMoveCounter()` Vynuluje provozní měření.
    `void` | `setElement(Element value)` Nastaví hodnotu běžného prvku posloupnosti.

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

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

- - ### Field Detail

    - #### front

          private Stack front

      přední zásobník

    - #### rear

          private Stack rear

      zadní zásobník

    - #### count

          private int count

      aktuální počet prvků v posloupnosti

    - #### size

          private int size

      kapacita posloupnosti

    - #### currentIndex

          private int currentIndex

      index běžného prvku

    - #### moveCounter

          private int moveCounter

      počítadlo provozního měření

  - ### Constructor Detail

    - #### DualStackSequence

          public DualStackSequence(StackFactory factory,
                                   int aSize)

      Vyrobí posloupnost implementovanou dvojicí zásobníků.
      Parameters:
        `factory` - továrna na zásobníky
        `aSize` - požadovaná kapacita posloupnosti

  - ### Method Detail

    - #### setElement

          public void setElement(Element value)

      Nastaví hodnotu běžného prvku posloupnosti.

      Vyžaduje: not isEmpty

      Specified by:
        `setElement` in interface `CommonBase`
      Parameters:
        `value` - nová hodnota běžného prvku

    - #### 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

    - #### insert

          public void insert(Element elem)

      Description copied from interface: `Sequence`
      Vloží elem před běžný prvek.

      Vyžaduje: not isFull

      Specified by:
        `insert` in interface `Sequence`
      Parameters:
        `elem` - nový prvek, který se má vložit do posloupnosti

    - #### append

          public void append(Element elem)

      Description copied from interface: `Sequence`
      Vloží elem za poslední prvek posloupnosti.

      Vyžaduje: not isFull

      Specified by:
        `append` in interface `Sequence`
      Parameters:
        `elem` - nový prvek, který se má připojit k posloupnosti

    - #### remove

          public Element remove()

      Description copied from interface: `Sequence`
      Odstraní běžný prvek.

      Vyžaduje: not isEmpty

      Specified by:
        `remove` in interface `Sequence`
      Returns:
        odstraněný prvek

    - #### moveFirst

          public void moveFirst()

      Description copied from interface: `Sequence`
      Učiní hlavu běžným prvkem.

      Vyžaduje: not isEmpty

      Specified by:
        `moveFirst` in interface `Sequence`

    - #### moveLast

          public void moveLast()

      Description copied from interface: `Sequence`
      Učiní ocas běžným prvkem.

      Vyžaduje: not isEmpty

      Specified by:
        `moveLast` in interface `Sequence`

    - #### moveNext

          public void moveNext()

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

      Vyžaduje: not isEmpty

      Specified by:
        `moveNext` in interface `Sequence`

    - #### movePrev

          public void movePrev()

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

      Vyžaduje: not isEmpty

      Specified by:
        `movePrev` in interface `Sequence`

    - #### moveTo

          public void moveTo(int index)

      Description copied from interface: `Sequence`
      Učiní index-tý prvek běžným prvkem.

      Vyžaduje: not isEmpty

      Specified by:
        `moveTo` in interface `Sequence`
      Parameters:
        `index` - index prvku, který se má stát běžným prvkem

    - #### isFirst

          public boolean isFirst()

      Description copied from interface: `Sequence`
      Zjistí, zda běžný prvek je první.

      Vyžaduje: not isEmpty

      Specified by:
        `isFirst` in interface `Sequence`
      Returns:
        true když je první, jinak false

    - #### isLast

          public boolean isLast()

      Description copied from interface: `Sequence`
      Zjistí, zda běžný prvek je poslední.

      Vyžaduje: not isEmpty

      Specified by:
        `isLast` in interface `Sequence`
      Returns:
        true když je poslední, jinak false

    - #### 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

    - #### 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`