7890/jack_tools - diag003.uml.txt

COPY

@startuml
title audio_rxtx Interaction Diagram\nEstablishing Transmission

participant proc
participant sender
participant receiver

activate proc #FFBBBB

autonumber

proc --> receiver: configure & start
receiver -> receiver: start listening for audio
activate receiver #FFBBBB

proc --> sender: configure & start
sender -> sender: start offering audio
activate sender #FFBBBB

sender --> receiver: /offer
activate sender #DarkSalmon

receiver -> receiver: check compatibilty
activate receiver #DarkSalmon

receiver --> sender: /accept
deactivate receiver
deactivate sender

sender -> sender: start sending audio
activate sender #FF0000

loop Until Receiver pre-play Buffer filled
sender --> receiver: /audio
receiver -> receiver: fill pre-play buffer
activate receiver #00FF00
end

'note right: pre-play buffer 100% filled
deactivate receiver

receiver -> receiver: start playout
activate receiver #0000FF

loop
sender --> receiver: /audio
end

@enduml

Distrotech/docutils - 000058.txt

COPY

@startuml
skinparam backgroundColor #EEEBDC
skinparam sequenceArrowColor DeepSkyBlue
skinparam sequenceParticipantBorderColor DeepSkyBlue
skinparam sequenceActorBorderColor DeepSkyBlue
skinparam sequenceLifeLineBorderColor blue
actor User
participant "First Class" as A
participant "Second Class" as B
participant "Last Class" as C

User -> A: DoWork
activate A
@enduml

kaltura/DeveloperPor...ocs - Android-DTG.md

COPY

@startuml
    
    participant "app: App" as app
    participant "item: DownloadItem" as item
    participant "selector: TrackSelector" as selector
    
    group for type in VIDEO, AUDIO, TEXT
        app->selector: tracks = getAvailableTracks(type)
        note over app: filter tracks
        app->selector: setSelectedTracks(type, filteredTracks)
    end group
    app->selector: apply()
    
    @enduml

kenba/via-httplib - ...sequence_diagram.txt

COPY

@startuml

'Copyright (c) 2013-2015 Ken Barker

title Server Connection Sequence

'autonumber
actor user
opt ssl
user -> server : set_password
user -> server : set_ssl_files
end

user -> server : accept_connections(port)
server -> acceptor : configure
server -> acceptor : async_accept

loop
server <- acceptor : accept_handler
server -> connection : start
connection -> socket_adaptor : handshake
alt ssl
socket_adaptor -> asio.socket : async_handshake
connection <- asio.socket : handshake_callback
else
connection <- socket_adaptor : handshake_callback
note right
The tcp_adaptor always
accepts the handshake
end note
end alt
server <- connection : connected
user  <- server : connected

end loop

... connection open for transmission and reception ...

@enduml

gavinc88/YANA - UML_YANA_UI.txt

COPY

@startuml
participant APIHelper
participant User
participant Login
participant CreateUser
participant UserProfile
participant Main
participant MealRequestsTable
participant CreateMealRequest
participant FriendsTable
participant SearchFriend

Login -> APIHelper : POST login
APIHelper -> Login : return login credential

Login -> CreateUser : click "create user"
CreateUser -> APIHelper : POST create_user
APIHelper -> User : instantiate user
User -> Main : open main page

Login -> Main: open main page

Main -> UserProfile : click on "settings"
UserProfile -> APIHelper : GET user_by_id
APIHelper -> User : update user detail
User -> UserProfile : display user update

UserProfile -> Login : click "logout"

Main-> MealRequestsTable : click on "Requests"" tab
MealRequestsTable -> APIHelper : GET view_requests
APIHelper -> User : return all meal requests
User -> MealRequestsTable : updateTableView()

Main -> FriendsTable : click on "Friends" tab
FriendsTable-> APIHelper : GET get_friend_list
APIHelper -> User : return all friends
User -> FriendsTable : updateTableView()

MealRequestsTable -> CreateMealRequest :click on "Add"
CreateMealRequest -> APIHelper : POST meal request
APIHelper -> MealRequestsTable : add request to MealRequestsTable

FriendsTable -> SearchFriend : open search
SearchFriend -> APIHelper : GET user_by_name
APIHelper -> SearchFriend : display search result
SearchFriend -> APIHelper: POST add_friend
APIHelper -> User : update friend list
User -> FriendsTable : updateTableView()

FriendsTable -> FriendProfile : click on Friend in table
FriendProfile -> APIHelper : GET user_by_id
APIHelper -> FriendProfile : return friend profile detail
FriendProfile -> APIHelper : POST delete_friend
APIHelper ->  User : update friend list
User -> FriendsTable : updateTableView()

@enduml

tony/docutils-oldmigraton - 000032.txt

COPY

@startuml
skinparam backgroundColor #EEEBDC
skinparam sequenceArrowColor DeepSkyBlue
skinparam sequenceParticipantBorderColor DeepSkyBlue
skinparam sequenceActorBorderColor DeepSkyBlue
skinparam sequenceLifeLineBorderColor blue
actor User
participant "First Class" as A
participant "Second Class" as B
participant "Last Class" as C

User -> A: DoWork
activate A

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

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

B --> A: Request <u>Created</u>
deactivate B

A --> User: Done
deactivate A
@enduml

rickgit/rickgit.gith... - test.plantuml.txt

COPY

@startuml

skinparam monochrome true
skinparam classBackgroundColor transparent
skinparam style strictuml

InstrumentationTestCase->TestCase
SingleLaunchActivityTestCase->TestCase
ActivityTestCase->TestCase
ActivityInstrumentationTestCase2->ActivityTestCase
ActivityUnitTestCase->ActivityTestCase
'@Deprecated
ActivityInstrumentationTestCase->ActivityTestCase
SyncBaseInstrumentation->TestCase
'@Deprecated
ProviderTestCase->TestCase

@enduml

edeposit/edeposit.am...ommunication.uml.txt

COPY

@startuml
participant "AMQP User" as User
participant AlephDaemon << (C, #ADD1B2) >>
participant reactToAMQPMessage << (F, red) >>
participant aleph.py << (M, green) >>

box "edeposit.amqp"
    participant AlephDaemon
end box

box "edeposit.amqp.aleph"
    participant reactToAMQPMessage
    participant aleph.py
end box

User -> AlephDaemon: <<JSON Request>>
activate AlephDaemon

note right of User
  AMQP message with data
  serialized using
  edeposit.amqp.serializers.
end note

AlephDaemon -> reactToAMQPMessage: <<Request namedtuple>>
activate reactToAMQPMessage

reactToAMQPMessage -> aleph.py: Query Aleph
activate aleph.py

note left of aleph.py
  EPublications structure
  contains parsed data and
  also original XML structure
  returned from Aleph.
end note

aleph.py -> reactToAMQPMessage: <<EPublication namedtuple>>
deactivate aleph.py

reactToAMQPMessage -> AlephDaemon: <<Result namedtuple>>
deactivate reactToAMQPMessage

AlephDaemon --> User: <<Response class in JSON>>
AlephDaemon --> User: <<Exception in AMQP>>
deactivate AlephDaemon

note right of User
  Exceptions have all
  information stored
  in headers.
end note
@enduml

michielhildebrand/tk... components-flow.txt

COPY

@startuml

title Application components flow

participant "Application" as app #red
participant "Model" as model
participant "Play screen" as play
participant "Player component" as player
participant "Tv screen" as tv

app -> model : Loads videos

model ->o play : Notified when videos are available
play -> model : Take url parameters and set the video and chapter
play ->> tv : Send msg set-video with video and chapter

model ->o player : Notified when the video has changed\nThe player loads the video and sets the current time


@enduml

dm03514/blog - udp-async-test-driver.txt

COPY

@startuml

title UDP Integration Test Workflow

participant "Test" as test
participant "SUT" as sut
participant "UDP Stub Server" as udp
participant "TCP Status Server" as tcp

test -> tcp : subscribe
test <- tcp : subscribed
activate test

test -> sut : exercise SUT

sut -> udp : logging call 1
udp -> tcp : call received
test <- tcp : "logging call 1" event
test -> sut : "logging call 1" assertion

deactivate test

@enduml

atsuoishimoto/docuti...s - myDiagram123.txt

COPY

@startuml
skinparam backgroundColor #EEEBDC
skinparam sequenceArrowColor DeepSkyBlue
skinparam sequenceParticipantBorderColor DeepSkyBlue
skinparam sequenceActorBorderColor DeepSkyBlue
skinparam sequenceLifeLineBorderColor blue
actor User
participant "First Class" as A
participant "Second Class" as B
participant "Last Class" as C

User -> A: DoMoreWork
activate A
@enduml

devshark/CardManager - credit_flow.txt

COPY

@startuml
participant card as "Card Account"
participant merchant as "Merchant Account"
participant float as "Float Account"
participant fee as "Fee Account"

==Payment==
card -> merchant : $100
merchant -> float : $97.3
merchant -> fee : $2.7
==Refund==
float -> merchant : $100
merchant -> card : $100
float -> fee : $5
@enduml

gabrielgio/Vivacity - Flow%20Cities.puml

COPY

@startuml

Parser --> Project : List of files
Project --> LayoutGenerator : Creates entities and its tree
LayoutGenerator --> View : Generate street's layout

@enduml

Phalexei/Modeleur - delete.puml

COPY

@startuml
    actor User as U
    participant System as S

    opt class exits
        U -> S: delete an object (class, interface, package, relation, object) 
        S --> U: confirmation demand (deletion consequences)
        U -> S: confirmation answer
        opt user confirmed the operation
            S --> U: objet deleted
        end
    end
@enduml

POV-Ray/povray - povms.md

COPY

@startuml
    participant Frontend
    participant Backend

    Frontend ->> Backend: kPOVMsgClass_RenderControl, kPOVMsgIdent_RenderOptions
    Frontend ->> Backend: kPOVMsgClass_RenderControl, kPOVMsgIdent_RenderAll
    activate Backend
    loop more chunks to render
        Frontend <<- Backend: kPOVMsgClass_RenderOutput
    end
    Frontend <<- Backend: (done)
    deactivate Backend
@enduml

BarzaH/watcher - seq...ecture_cdmc_sync.txt

COPY

@startuml
skinparam maxMessageSize 100

actor "Administrator"

== Initialization ==

"Administrator" -> "Decision Engine" : Start all services
"Decision Engine" -> "Background Task Scheduler" : Start

activate "Background Task Scheduler"
"Background Task Scheduler" -> "Cluster Model Collector Loader"\
: List available cluster data models
"Cluster Model Collector Loader" --> "Background Task Scheduler"\
: list of BaseClusterModelCollector instances

loop for every available cluster data model collector
    "Background Task Scheduler" -> "Background Task Scheduler"\
    : add periodic synchronization job
    create "Jobs Pool"
    "Background Task Scheduler" -> "Jobs Pool" : Create sync job
end
deactivate "Background Task Scheduler"

hnote over "Background Task Scheduler" : Idle

== Job workflow ==

"Background Task Scheduler" -> "Jobs Pool" : Trigger synchronization job
"Jobs Pool" -> "Nova Cluster Data Model Collector" : synchronize

activate "Nova Cluster Data Model Collector"
    "Nova Cluster Data Model Collector" -> "Nova API"\
    : Fetch needed data to build the cluster data model
    "Nova API" --> "Nova Cluster Data Model Collector" : Needed data
    "Nova Cluster Data Model Collector" -> "Nova Cluster Data Model Collector"\
    : Build an in-memory cluster data model
    ]o<-- "Nova Cluster Data Model Collector" : Done
deactivate "Nova Cluster Data Model Collector"

@enduml

teamflat/enflatme - DSMtf.txt

COPY

@startuml

hide footbox

actor Utilisateur

Utilisateur->Application: clic
activate Application

Application->sendButton: Evt clic
activate sendButton

create GreetingService
GWT->GreetingService: new

sendButton->handler: onClic()
activate handler

handler->handler: sendNameToServer
activate handler

handler->loginField: getText()
deactivate loginField
deactivate sendButton

handler->passwordField: getText()
deactivate passwordField
deactivate sendButton

handler->u: new Instance
activate u

u-> handler: credentialsAreValid
deactivate u

handler->texteToServerLabel: setText()
activate texteToServerLabel
deactivate texteToServerLabel

handler->greetingService: textToServer
activate greetingService

greetingService->GWT: Relayer textToServer
activate GWT
deactivate greetingService

GWT->GreetingService:textToServer
activate GreetingService
deactivate GreetingService

GWT->handlerasync:onSuccess
deactivate GWT

handlerasync->dialogBox: setText
activate dialogBox
deactivate dialogBox
deactivate handler
deactivate handler

handlerasync->ServerResponseLabel: setHTML
activate ServerResponseLabel
deactivate ServerResponseLabel
deactivate Application

@enduml

theovert/pweb - signout.txt

COPY

@startuml

actor Utilisateur as user
participant "formSign.js" as form <<Contrôleur formulaire>>
participant "Sign.java" as controler <<(C,#ADD1B2) Contrôleur formulaire>>
participant "Secure.java" as secure <<(C,#ADD1B2) authentification>>
participant "Security.java" as security <<(C,#ADD1B2) sécurité>>

box "Application Web" #LightBlue
	participant form
end box

box "Serveur Play" #LightGreen
	participant controler
	participant secure
	participant security
end box

user -> form : submitSignOut()

form -> controler : formSignout()
controler -> secure : Secure.logout();
secure -> security : ononDisconnected()
security --> form : render("/");
form --> user : display main page

@enduml

tex/vimpreviewpandoc - README.md

COPY

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

    Alice -> Bob: Another authentication Request
    Alice <-- Bob: another authentication Response
    @enduml

edeposit/edeposit.amqp.calibre - uml.txt

COPY

@startuml
participant "AMQP User" as User
participant Calibredaemon.py << (C, #ADD1B2) >>
participant reactToAMQPMessage << (F, red) >>
participant calibre.py << (M, green) >>
participant econvert as "ebook-convert" << (P, white) >>

box "edeposit.amqp"
    participant Calibredaemon.py
end box

box "edeposit.amqp.calibre"
    participant reactToAMQPMessage
    participant calibre.py
end box

box "Calibre"
    participant econvert
end box

User -> Calibredaemon.py: <<JSON Request>>
activate Calibredaemon.py

note right of User
  AMQP message with data
  serialized using
  edeposit.amqp.serializers.
end note

Calibredaemon.py -> reactToAMQPMessage: <<ConversionRequest>>
activate reactToAMQPMessage

reactToAMQPMessage -> calibre.py: in/out format, b64 data
activate calibre.py

activate econvert
calibre.py -> econvert: commandline switches

note left of econvert
  Create temporary file
  and convert it to the
  output format.
end note

econvert --> calibre.py: /tmp/outputfile
deactivate econvert

calibre.py -> reactToAMQPMessage: <<ConversionResponse>>
deactivate calibre.py

reactToAMQPMessage -> Calibredaemon.py: <<ConversionResponse>>
deactivate reactToAMQPMessage

Calibredaemon.py --> User: <<Response class in JSON>>
Calibredaemon.py --> User: <<Exception in AMQP>>
deactivate Calibredaemon.py

note right of User
  Exceptions have all
  information stored
  in headers.
end note
@enduml

erasin/notes - planuml.md

COPY

@startuml
    Bob -[#red]> Alice : hello
    Alice -[#0000FF]->Bob : ok
    @enduml