assistant.xml

<assistants>
    <assistant name="Class Diagrams">
        <item name="Relations"><![CDATA[
            Class01 <|-- Class02
            Class03 *-- Class04
            Class05 o-- Class06
            Class07 .. Class08
            Class09 -- Class10
            Class11 <|.. Class12
            Class13 --> Class14
            Class15 ..> Class16
            Class17 ..|> Class18
            Class19 <--* Class20
            ]]>
        </item>
        <item name="Label on relations"><![CDATA[
            Class01 "1" *-- "many" Class02 : contains

            Class03 o-- Class04 : agregation

            Class05 --> "1" Class06
            ]]>
            <notes><![CDATA[
            <ul>
            <li>To add a label, use <b>":"</b>, followed by the text of the label.
            <li>For cardinality, you can use double-quotes <b>""</b> on each side of the relation.
            </ul>
            ]]></notes>
        </item>
        <item name="Directed labels on relations"><![CDATA[
            class Car

            Driver - Car : drives >
            Car *- Wheel : have 4 >
            Car -- Person : < owns
            ]]>
        </item>
        <item name="Adding methods"><![CDATA[
            Object <|-- ArrayList

            Object : equals()
            ArrayList : Object[] elementData
            ArrayList : size()
            ]]>
        </item>
        <item name="Adding methods with brackets"><![CDATA[
            class Dummy {
              String data
              void methods()
            }
            ]]>
        </item>
        <item name="Defining visibility"><![CDATA[
            class Dummy {
             -field1
             #field2
             ~method1()
             +method2()
            }
            ]]>
        </item>
        <item name="Defining unskinned visibility"><![CDATA[
            skinparam classAttributeIconSize 0
            class Dummy {
             -field1
             #field2
             ~method1()
             +method2()
            }
            ]]>
        </item>
        <item name="Abstract and static"><![CDATA[
            class Dummy {
              {static} String id
              {abstract} void methods()
            }
            ]]>
        </item>
        <item name="Advanced class body"><![CDATA[
            class Foo1 {
              You can use
              several lines
              ..
              as you want
              and group
              ==
              things together.
              __
              You can have as many groups
              as you want
              --
              End of class
            }

            class User {
              .. Simple Getter ..
              + getName()
              + getAddress()
              .. Some setter ..
              + setName()
              __ private data __
              int age
              -- crypted --
              String password
            }
            ]]>
        </item>
        <item name="Notes and stereotypes"><![CDATA[
            class Object << general >>
            Object <|--- ArrayList

            note top of Object : In java, every class\nextends this one.

            note "This is a floating note" as N1
            note "This note is connected\nto several objects." as N2
            Object .. N2
            N2 .. ArrayList

            class Foo
            note left: On last defined class
            ]]>
        </item>
        <item name="More on notes"><![CDATA[
            class Foo
            note left: On last defined class

            note top of Object
              In java, <size:18>every</size> <u>class</u>
              <b>extends</b>
              <i>this</i> one.
            end note

            note as N1
              This note is <u>also</u>
              <b><color:royalBlue>on several</color>
              <s>words</s> lines
              And this is hosted by <img:sourceforge.jpg>
            end note
            ]]>
        </item>
        <item name="Note on links"><![CDATA[
            class Dummy
            Dummy --> Foo : A link
            note on link #red: note that is red

            Dummy --> Foo2 : Another link
            note right on link #blue
                this is my note on right link
                and in blue
            end note
            ]]>
        </item>
        <item name="Abstract class and interface"><![CDATA[
            abstract class AbstractList
            abstract AbstractCollection
            interface List
            interface Collection

            List <|-- AbstractList
            Collection <|-- AbstractCollection

            Collection <|- List
            AbstractCollection <|- AbstractList
            AbstractList <|-- ArrayList

            class ArrayList {
              Object[] elementData
              size()
            }

            enum TimeUnit {
              DAYS
              HOURS
              MINUTES
            }
            ]]>
        </item>
        <item name="Using non-letters"><![CDATA[
            class "This is my class" as class1
            class class2 as "It works this way too"

            class2 *-- "foo/dummy" : use
            ]]>
        </item>
        <item name="Hide stuff"><![CDATA[
            class Dummy1 {
              +myMethods()
            }

            class Dummy2 {
              +hiddenMethod()
            }

            class Dummy3 <<Serializable>> {
                String name
            }

            hide members
            hide <<Serializable>> circle
            show Dummy1 method
            show <<Serializable>> fields
            ]]>
        </item>
        <item name="Use generics"><![CDATA[
            class Foo<? extends Element> {
              int size()
            }
            Foo *- Element
            ]]>
        </item>
        <item name="Specific spot"><![CDATA[
            class System << (S,#FF7700) Singleton >>
            class Date << (D,orchid) >>
            ]]>
        </item>
        <item name="Packages"><![CDATA[
            package "Classic Collections" #DDDDDD {
              Object <|-- ArrayList
            }

            package net.sourceforge.plantuml
              Object <|-- Demo1
              Demo1 *- Demo2
            end package
            ]]>
        </item>
        <item name="Packages styles"><![CDATA[
            package foo1 <<Node>> {
              class Class1
            }

            package foo2 <<Rect>> {
              class Class2
            }

            package foo3 <<Folder>> {
              class Class3
            }

            package foo4 <<Frame>> {
              class Class4
            }

            package foo5 <<Cloud>> {
              class Class5
            }

            package foo6 <<Database>> {
              class Class6
            }
            ]]>
        </item>
        <item name="Links between packages"><![CDATA[
            skinparam packageStyle rect

            package foo1.foo2
            end package

            package foo1.foo2.foo3 {
              class Object
            }

            foo1.foo2 +-- foo1.foo2.foo3
            ]]>
        </item>
        <item name="Namespaces"><![CDATA[
            namespace net.dummy #DDDDDD
                .BaseClass <|-- Person
                Meeting o-- Person

                .BaseClass <|- Meeting

            end namespace

            namespace net.foo {
              net.dummy.Person  <|- Person
              .BaseClass <|-- Person

              net.dummy.Meeting o-- Person
            }

            BaseClass <|-- net.unused.Person
            ]]>
        </item>
        <item name="Lollipop interface"><![CDATA[
            class foo
            bar ()- foo
            ]]>
        </item>
        <item name="Changing arrows direction 1"><![CDATA[
            Room o- Studient
            Room *-- Chair
            ]]>
        </item>
        <item name="Changing arrows direction 2"><![CDATA[
            Studient -o Room
            Chair --* Room
            ]]>
        </item>
        <item name="Changing arrows direction 3"><![CDATA[
            foo -left-> dummyLeft
            foo -right-> dummyRight
            foo -up-> dummyUp
            foo -down-> dummyDown
            ]]>
        </item>
        <item name="Title"><![CDATA[
            title Simple <b>example</b>\nof title

            Object <|-- ArrayList
            ]]>
        </item>
        <item name="Association classes 1"><![CDATA[
            class Student {
              Name
            }
            Student "0..*" - "1..*" Course
            (Student, Course) .. Enrollment

            class Enrollment {
              drop()
              cancel()
            }
            ]]>
        </item>
        <item name="Association classes 2"><![CDATA[
            class Student {
              Name
            }
            Student "0..*" -- "1..*" Course
            (Student, Course) . Enrollment

            class Enrollment {
              drop()
              cancel()
            }
            ]]>
        </item>
        <item name="Skinparam"><![CDATA[
            skinparam class {
                BackgroundColor PaleGreen
                ArrowColor SeaGreen
                BorderColor SpringGreen
            }
            skinparam stereotypeCBackgroundColor YellowGreen

            Class01 "1" *-- "many" Class02 : contains

            Class03 o-- Class04 : agregation
            ]]>
        </item>
    </assistant>

    <assistant name="Sequence Diagrams">
        <item name="Simple sequence"><![CDATA[
            Alice -> Bob: Authentication Request
            Bob --> Alice: Authentication Response

            Alice -> Bob: Another authentication Request
            Alice <-- Bob: another authentication Response
            ]]>
        </item>
        <item name="Declaring a participant"><![CDATA[
            actor Bob #red
            ' The only difference between actor and participant is the drawing
            participant Alice
            participant "I have a really\nlong name" as L #99FF99
            /' You can also declare:
               participant L as "I have a really\nlong name"  #99FF99
              '/

            Alice->Bob: Authentication Request
            Bob->Alice: Authentication Response
            Bob->L: Log transaction
            ]]>
        </item>
        <item name="Message to Self"><![CDATA[
            Alice->Alice: This is a signal to self.\nIt also demonstrates\nmultiline \ntext
            ]]>
        </item>
        <item name="Change arrow style"><![CDATA[
            Bob -> Alice
            Bob ->> Alice
            Bob -\ Alice
            Bob \\- Alice
            Bob //-- Alice

            Bob ->o Alice
            Bob o\\-- Alice
            ]]>
        </item>
        <item name="Message sequence numbering"><![CDATA[
            autonumber
            Bob -> Alice : Authentication Request
            Bob <- Alice : Authentication Response
            ]]>
        </item>
        <item name="Message sequence numbering with a start"><![CDATA[
            autonumber
            Bob -> Alice : Authentication Request
            Bob <- Alice : Authentication Response

            autonumber 15
            Bob -> Alice : Another authentication Request
            Bob <- Alice : Another authentication Response

            autonumber 40 10
            Bob -> Alice : Yet another authentication Request
            Bob <- Alice : Yet another authentication Response
            ]]>
        </item>
        <item name="Formatted message sequence numbering"><![CDATA[
            autonumber "<b>[000]"
            Bob -> Alice : Authentication Request
            Bob <- Alice : Authentication Response

            autonumber 15 "<b>(<u>##</u>)"
            Bob -> Alice : Another authentication Request
            Bob <- Alice : Another authentication Response

            autonumber 40 10 "<font color=red><b>Message 0  "
            Bob -> Alice : Yet another authentication Request
            Bob <- Alice : Yet another authentication Response
            ]]>
        </item>
        <item name="Title"><![CDATA[
            title Simple communication example

            Alice -> Bob: Authentication Request
            Bob --> Alice: Authentication Response
            ]]>
        </item>
        <item name="Grouping message"><![CDATA[
            Alice -> Bob: Authentication Request

            alt successful case

                Bob -> Alice: Authentication Accepted

            else some kind of failure

                Bob -> Alice: Authentication Failure
                group My own label
                    Alice -> Log : Log attack start
                    loop 1000 times
                        Alice -> Bob: DNS Attack
                    end
                    Alice -> Log : Log attack end
                end

            else Another type of failure

               Bob -> Alice: Please repeat

            end
            ]]>
        </item>
        <item name="Notes on messages"><![CDATA[
            Alice->Bob : hello
            note left: this is a first note

            Bob->Alice : ok
            note right: this is another note

            Bob->Bob : I am thinking
            note left
                a note
                can also be defined
                on several lines
            end note
            ]]>
        </item>
        <item name="Some other notes"><![CDATA[
            participant Alice
            participant Bob
            note left of Alice #aqua
                This is displayed
                left of Alice.
            end note

            note right of Alice: This is displayed right of Alice.

            note over Alice: This is displayed over Alice.

            note over Alice, Bob #FFAAAA: This is displayed\n over Bob and Alice.

            note over Bob, Alice
                This is yet another
                example of
                a long note.
            end note
            ]]>
        </item>
        <item name="Divider"><![CDATA[
            == Initialisation ==

            Alice -> Bob: Authentication Request
            Bob --> Alice: Authentication Response

            == Repetition ==

            Alice -> Bob: Another authentication Request
            Alice <-- Bob: another authentication Response
            ]]>
        </item>
        <item name="Space"><![CDATA[
            Alice -> Bob: message 1
            Bob --> Alice: ok
            |||
            Alice -> Bob: message 2
            Bob --> Alice: ok
            ||45||
            Alice -> Bob: message 3
            Bob --> Alice: ok
            ]]>
        </item>
        <item name="Lifeline activation and destruction"><![CDATA[
            participant User

            User -> A: DoWork
            activate A

            A -> B: << createRequest >>
            activate B

            B -> C: DoWork
            activate C
            C --> B: WorkDone
            destroy C

            B --> A: RequestCreated
            deactivate B

            A -> User: Done
            deactivate A
            ]]>
        </item>
        <item name="Nested lifeline activation and destruction"><![CDATA[
            participant User

            User -> A: DoWork
            activate A #FFBBBB

            A -> A: Internal call
            activate A #DarkSalmon

            A -> B: << createRequest >>
            activate B

            B --> A: RequestCreated
            deactivate B
            deactivate A
            A -> User: Done
            deactivate A
            ]]>
        </item>
        <item name="Participant creation"><![CDATA[
            Bob -> Alice : hello

            create Other
            Alice -> Other : new

            create String
            Alice -> String
            note right : You can also put notes!

            Alice --> Bob : ok
            ]]>
        </item>
        <item name="Incomming and outgoing messages"><![CDATA[
            [-> A: DoWork

            activate A

            A -> A: Internal call
            activate A

            A ->] : << createRequest >>

            A<--] : RequestCreated
            deactivate A
            [<- A: Done
            deactivate A
            ]]>
        </item>
        <item name="Stereotypes and spots"><![CDATA[
            participant "Famous Bob" as Bob << Generated >>
            participant Alice << (C,#ADD1B2) Testable >>

            Bob->Alice: First message
            ]]>
        </item>
        <item name="Participants englober"><![CDATA[
            box "Internal Service" #LightBlue
                participant Bob
                participant Alice
            end box
            participant Other

            Bob -> Alice : hello
            Alice -> Other : hello
            ]]>
        </item>
        <item name="Removing footer"><![CDATA[
            hide footbox
            title Footer removed

            Alice -> Bob: Authentication Request
            Bob --> Alice: Authentication Response
            ]]>
        </item>
    </assistant>

    <assistant name="Use Case Diagrams">
    <item name="Usecases"><![CDATA[
        (First usecase)
        (Another usecase) as (UC2)
        usecase UC3
        usecase (Last\nusecase) as UC4
        ]]>
    </item>
    <item name="Actors"><![CDATA[
        :First Actor:
        :Another\nactor: as Men2
        actor Men3
        actor :Last actor: as Men4
        ]]>
    </item>
    <item name="Basic example"><![CDATA[
        User -> (Start)
        User --> (Use the application) : A small label

        :Main Admin: ---> (Use the application) : This is\nyet another\nlabel
        ]]>
    </item>
    <item name="Extension"><![CDATA[
        :Main Admin: as Admin
        (Use the application) as (Use)

        User <|-- Admin
        (Start) <|-- (Use)
        ]]>
    </item>
    <item name="Using notes"><![CDATA[
        :Main Admin: as Admin
        (Use the application) as (Use)

        User -> (Start)
        User --> (Use)

        Admin ---> (Use)

        note right of Admin : This is an example.

        note right of (Use)
          A note can also
          be on several lines
        end note

        note "This note is connected\nto several objects." as N2
        (Start) .. N2
        N2 .. (Use)
        ]]>
    </item>
    <item name="Stereotypes"><![CDATA[
        User << Human >>
        :Main Database: as MySql << Application >>
        (Start) << One Shot >>
        (Use the application) as (Use) << Main >>

        User -> (Start)
        User --> (Use)

        MySql --> (Use)
        ]]>
    </item>
    <item name="Changing arrows direction 1"><![CDATA[
        :user: --> (Use case 1)
        :user: -> (Use case 2)
        ]]>
    </item>
    <item name="Changing arrows direction 2"><![CDATA[
        (Use case 1) <.. :user:
        (Use case 2) <- :user:
        ]]>
    </item>
    <item name="Changing arrows direction 3"><![CDATA[
        :user: -left-> (dummyLeft)
        :user: -right-> (dummyRight)
        :user: -up-> (dummyUp)
        :user: -down-> (dummyDown)
        ]]>
    </item>
    <item name="Title"><![CDATA[
        title Simple <b>Usecase</b>\nwith one actor

        usecase (Use the application) as (Use)
        User -> (Use)
        ]]>
    </item>
    <item name="Top to bottom direction"><![CDATA[
        'default
        top to bottom direction
        user1 --> (Usecase 1)
        user2 --> (Usecase 2)
        ]]>
    </item>
    <item name="Left to right direction"><![CDATA[
        left to right direction
        user1 --> (Usecase 1)
        user2 --> (Usecase 2)
        ]]>
    </item>
    <item name="Complete example"><![CDATA[
        left to right direction
        skinparam packageStyle rect
        actor customer
        actor clerk
        package checkout {
          customer -- (checkout)
          (checkout) .> (payment) : <>
          (help) .> (checkout) : <>
          (checkout) -- clerk
        }
        ]]>
        </item>
    </assistant>
</assistants>