zealousduck/PicYaPal...SDViewFavorites.puml

COPY

@startuml
User -> System: Select "Favorites"
System --> User: Display saved favorites screen

@enduml

mackong/mackong.gith...uml-with-plantuml.md

COPY

@startuml
Alice -> Proxy: SIP MESSAGE 1
Proxy --> Bob: SIP MESSAGE 2
Proxy <- Bob: 200 OK 1
Alice <-- Proxy: 200 OK 2
@enduml

PolicyStat/gitlit - ...ta-flow-diagrams.txt

COPY

@startuml
title User Creates Branch of existing document

actor User
participant CreateBranchClient
participant PsychicOctoRobotServer
note right of PsychicOctoRobotServer
    Node.js server which serves the
    webpages requested by the user.
end note

User -> PsychicOctoRobotServer                 : requests page for \n creating a \n new branch
PsychicOctoRobotServer -> User                 : web page for \n CreateBranchClient
note right
    The CreateBranchClient is a 
    Javascript client made of js-git
    and our code bundled with browserify
end note
CreateBranchClient -> CreateBranchClient     : reads local "git" \n directory to check \n for repositories \n present 
CreateBranchClient -> User                   : Displays documents \n that are tracked \n in repositories and \n are branchable
User -> CreateBranchClient                   : selects document \n repository to create \n a new branch
CreateBranchClient -> User                   : Displays prompt for \n new branch name \n and parent branch
User -> CreateBranchClient                   : Selects parent branch & names new branch
CreateBranchClient -> CreateBranchClient     : Creates the branch defined by the user
CreateBranchClient -> User                   : Displays message notifying user of success/failure

@enduml

isc-projects/mini-ke...gr-mapped-reload.txt

COPY

@startuml

participant memmgr as ":b10-memmgr"
[-> memmgr: reload\n(zonename)
activate memmgr

participant list as ":Configurable\nClientList"
memmgr -> list: getCachedZoneWriter\n(zone_name)
activate list

participant CacheConfig as ":CacheConfig"

participant zt_segment as ":ZoneTable\nSegment\n(Mapped)"
participant segment as "existing:Memory\nSegment\n(Mapped)"
participant segment2 as "new:Memory\nSegment\n(Mapped)"

list -> zt_segment: isWritable()
activate zt_segment
zt_segment --> list: true
deactivate zt_segment

list -> CacheConfig: getLoadAction()
activate CacheConfig

participant ZoneTable as ":ZoneTable"
participant ZoneWriter as "zw:ZoneWriter"

participant LoadAction as "la:LoadAction"
create LoadAction
CacheConfig -> LoadAction: <<construct>>
CacheConfig --> list: la
deactivate CacheConfig

create ZoneWriter
list -> ZoneWriter: <<construct>> (la)
list --> memmgr: zw
deactivate list

memmgr -> ZoneWriter: load()
activate ZoneWriter
ZoneWriter -> LoadAction: (funcall)
activate LoadAction

participant ZoneData as "zd_existing\n:ZoneData"
participant ZoneData2 as "zd_new\n:ZoneData"

create ZoneData2
LoadAction -> ZoneData2: <<construct>> via helpers

LoadAction --> ZoneWriter: zd_new
deactivate LoadAction
deactivate ZoneWriter

memmgr -> ZoneWriter: install()
activate ZoneWriter

ZoneWriter -> ZoneTable: addZone(zd_new)
activate ZoneTable
ZoneTable --> ZoneWriter: zd_existing (old data)
deactivate ZoneTable

deactivate ZoneWriter

memmgr -> ZoneWriter: cleanup()
activate ZoneWriter

ZoneWriter -> ZoneData: <<destroy>>
destroy ZoneData
deactivate ZoneWriter

[<- memmgr: command to\nmodules\n(datasrc_name,\nsegmentparam)
[--> memmgr: ack from all\nmodules

memmgr -> list: resetMemorySegment\n(datasrc_name,\nREAD_WRITE,\nsegmentparam)
activate list

list -> zt_segment: reset\n(READ_WRITE,\nsegmentparam)
activate zt_segment

zt_segment -> segment: <<destroy>>
destroy segment
create segment2
zt_segment -> segment2: <<construct>>

deactivate zt_segment
deactivate list

note left of memmgr: (repeat the\nsame sequence\nfor loading to the\nother segment)

memmgr -> list: getCachedZoneWriter\n(zone_name)

...

@enduml

erasin/notes - planuml.md

COPY

@startuml

    title Simple communication example

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

    @enduml

aferouge/SV - plantuml_architecture.txt

COPY

@startuml

activate Controller
Controller -> Controller: openBridge

activate Signs
Controller -> Signs: setPre(Sign, on)
Signs --> Controller: commPreSigns(Sign)

Controller -> Signs: setStop(Sign, on)
Signs --> Controller: commStopSigns(Sign)

activate Barriers
Controller -> Barriers: setBarrier(Barrier, up)
Signs --> Controller: commBarrier(Barrier)

activate Bridge
Controller -> Bridge: setLock(Lock, engage)
Bridge --> Controller: commLock(Lock)
Controller -> Bridge: setDeck(up)
Bridge --> Controller: commDeck

Controller -> Controller: closeBrige

Controller -> Bridge: setDeck(down)
Bridge --> Controller: commDeck
Controller -> Bridge: setLock(Lock, disengage)
Bridge --> Controller: commLock(Lock)
deactivate Bridge

Controller -> Barriers: setBarrier(Barrier, down)
Signs --> Controller: commBarrier(Barrier)
deactivate Barrier

Controller -> Signs: setStop(Sign, off)
Signs --> Controller: commStopSigns(Sign)
deactivate Signs


@enduml

erasin/notes - planuml.md

COPY

@startuml

    participant "Famous Bob" as Bob << Generated >>
    participant Alice << (C,#ADD1B2) Testable >>

    Bob->Alice: First message

    @enduml

torgiren/dist-mon - ...cja_z_monitorami.txt

COPY

@startuml
title Synchronizacja z monitorami
autonumber

box "Monitor" #DarkSalmon
	database monitorDB
	control monitor
end box
box "Kontroler" #LightBlue
	control kontroler
	database kontrolerDB
	entity rrdtool
end box

loop dla ka¿dego monitora
	kontroler -> monitor: GET /data
	monitor --> kontroler: timestamp, pomiary
	loop dla wszystkich pomiarow
		kontroler -> kontrolerDB: dodaj pomiar do bazy
		kontroler -> rrdtool: uaktualnij baze
	end
	kontroler -> monitor: DELETE /data, timestamp
	monitor -> monitorDB: usun wszystkie pomiary\ndo timestampa
end
@enduml

audioscience/avdecc-...tream_format_seq.txt

COPY

@startuml
title AVDECC-LIB GET STREAM FORMAT Command and Response Sequence Diagram
"GUI Application" -> "Stream" :  send_get_format_cmd()
note over "Stream" : fill frame with command \nspecific data
"Stream" -> "TX Message Queue" : Queue the frame \nto be transmitted
"Stream" --> "GUI Application" : Return sequence ID
"TX Message Queue" -> "Poll Thread" : Dequeue the frame
"Poll Thread" -> "AEM Controller State Machine" : sendCommand
"AEM Controller State Machine" -> "AEM Controller State Machine" : queue to \ninflight list
"AEM Controller State Machine" -> "Network Interface" : Tx packet
"Network Interface" -> "RX Message Queue" : Queue the \nreceived packet
"RX Message Queue" -> "Poll Thread" : Dequeue packet
"Poll Thread" -> "AEM Controller State Machine" : rxPacket
"AEM Controller State Machine" -> "AEM Controller State Machine" : remove from \ninflight list
"AEM Controller State Machine" -> "Poll Thread"
"Poll Thread" -> "Stream" : process response
"Stream" -> "Stream" : Store stream \nformat fields
"Stream" -> "Poll Thread"
"Poll Thread" --> "GUI Application" : Notification for the sequence ID
"GUI Application" -> "Stream" : Read stream format field
"Stream" --> "GUI Application" : Return the field
@enduml

theovert/pweb - account_update.txt

COPY

@startuml

actor Utilisateur as user
participant "account.js" as account <<Contrôleur compte>>
participant "Account.java" as controler <<(C,#ADD1B2) Contrôleur compte>>

box "Application Web" #LightBlue
	participant account
end box

box "Serveur Play" #LightGreen
	participant controler
	
end box

user -> account : submitUpdateField()
account -> account : getParameter()
account -> account : result = checkField()

alt result

    account -> controler : update(field, captcha)
    controler -> controler : result = captcha(captcha) && checkField(field)
    
    alt result && Security.isConnected()
    	
    		controler -> controler : User user = User.getUser(Security.connected)
    		controler -> controler : user.field = field
    		controler -> controler : user.save()
    		controler --> account : render(msg)
    		account --> user : display successful update 
    	 
    else !result
    
    	controler --> account : render(msg) 
    	account --> user : display error
    	
    end
    
else !result
	account --> user : display error
end

@enduml

kaltura/DeveloperPor... - IntroductionV2.md

COPY

@startuml
	participant App
	participant "Kaltura LocalAssetsManager" as LAM

	note over App: Downloads Media to //localPath//

	App->>LAM: registerAsset(entryConfig, flavorId, localPath)
	note over LAM: SDK acquires license
	alt Success
	LAM->>App: Success
	else Failure
	LAM->>App: Failure
	end
    @enduml

alegmarra/TpSeminari...e_submitSolution.txt

COPY

@startuml

actor Professor
actor Student

participant GroupView
control GroupController
participant GroupService
participant Group
participant Member
participant Project
database Repository

Student -> GroupView : submitSolution
GroupView -> GroupController : submitSolution (userName, Solution)
GroupController -> GroupService : submitSolution (userName, Solution)

GroupService -> Repository : getGroup(groupName)
Repository --> GroupService : Group
activate Group

GroupService -> Group : hasMember(Membership)
Group -> Repository : getMember(Membership.key)

Repository --> Group : Member
activate Member

Group --> GroupService : [Member != NULL] true

GroupService -> Repository : getProject(Solution.projectID)
Repository --> GroupService : Project
activate Project

GroupService -> Group: sumbmitSolution (Membership, Solution, Project)

Group -> Group : validations

Group -> Project : addSolution(Solution)

Group -> Member : addSubmitedSolution(Solution.ID)

Group -> GroupService : notify(admin)

GroupService -> Professor: email

Group --> GroupService
GroupService -> Repository : save(Group)
Repository --> GroupService

deactivate Member
deactivate Project
deactivate Group

GroupService --> GroupController : success

GroupService -> GroupController : success

GroupController --> GroupView : renderSuccess

@enduml

erasin/notes - planuml.md

COPY

@startuml

    Alice -> Bob : Hello
    legend right
      Short
      legend
    endlegend

    @enduml

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

COPY

@startuml

'Copyright (c) 2013-2015 Ken Barker

title http_client events 

actor application
application -> http_client : connect

loop
== normal request ==

application -> http_client : request
application <- http_client : response

== expect continue request ==

application -> http_client : request
application <- http_client : response (continue)

application -> http_client : body
application <- http_client : response

== chunked request ==

application -> http_client : request
loop
application -> http_client : chunk
end
application <- http_client : response

== chunked response ==

application -> http_client : request
application <- http_client : response
loop
application <- http_client : chunk
end

end

opt socket disconnected callback
application <- http_client     : disconnected
end

@enduml

whs/ske11-lecture - 06-lecture.txt

COPY

@startuml
hide footbox

[-> Monopoly : doSomething
activate Monopoly
Monopoly -> A : doA
Monopoly -> B : doB
deactivate Monopoly
@enduml

MARTIMM/mongo-perl6-...ient-server-int1.txt

COPY

@startuml

title Client Server interaction
hide footbox

actor application as app
participant Client
participant "Client T0" as Clt0 #a0fefe
participant "Client T1" as Clt1 #fea0fe
participant Server              #a0fefe
participant "Server T" as Srvt0 #a0fea0
participant Monitor             #a0fefe
participant "Monitor T" as Mnt0 #c0c0c0
database mongod
activate mongod

app -> Client: new(uri)
activate Client

'Todo list is a structure guarded by semaphores
Client -> Client: store server\nport in todo list

Client -> Clt0: Promise.start()
activate Clt0

Clt0 -> Clt0: load server:port\nfrom todo list

Client -> app: Client object
deactivate Client

Clt0 -> Server: new()
activate Server
Server -> Monitor: new()
activate Monitor
Monitor -> Server: Monitor object
deactivate Monitor
Server -> Clt0: Server object
deactivate Server


Clt0 -> Server: server-init()
activate Server
Server -> Monitor: start-monitor()
activate Monitor
Monitor -> Mnt0: Promise.start()
activate Mnt0
Monitor -> Server: Promise
deactivate Monitor

Mnt0 -[#a000bf]-> mongod: ismaster command
mongod -[#a000bf]-> Mnt0: ismaster result
Server -> Srvt0: tap from monitor
activate Srvt0
deactivate Server

Mnt0 o-[#a000bf]->o Srvt0: monitor data
'activate Srvt0
Srvt0 -> Srvt0: Set status
'deactivate Srvt0


Clt0 -> Clt1: tap from monitor
activate Clt1
Mnt0 o-[#a000bf]->o Clt1: monitor data
deactivate Clt0

Clt1 -> Clt1: store new server\ndata in todo list

Clt1 -> Clt1: Store in\nserver list

'note right: in thread
'note right: returns immediate
'Server --> mongod: connect



app -> Client: select-server()
activate Client
Client -> Client: Get server\nfrom server\nlist
Client -> app: Server object
deactivate Client

legend
Monitor data is sent from Monitor thread using a Supply
Data in Client structures for communication are guarded with Semaphores
end legend

@enduml

audioscience/avdecc-... git_dev_seq_uml.txt

COPY

@startuml

title Git branch conventions in avdecc-lib\ndevelopment sequence

box "DeveloperX's\nenvironment" #LightBlue
	actor DeveloperX
	participant "branch\nin forked local\nDeveloperX's git repo" as LX
end box

box "DeveloperY's\nenvironment" #LightYellow
	actor DeveloperY
	participant "branch\nin forked local\nDeveloperY's git repo" as LY
end box


box "upstream git" #LightBlue
	participant "<b>staging</b> branch\nin upstream repo" as S
	participant "<b>master</b> branch\nin upstream repo" as M
end box
actor Manager

note over DeveloperX
	In this example DeveloperX is
	working on a new feature
end note

DeveloperX -> LX: commits changes to forked git repo
LX -> LX: many updates

DeveloperX -> LX: completed a new feature
LX -> S : git pull request
S -> Manager : emailed pull request
Manager -> S: do merge to staging
S -> S : git merge

Manager --> DeveloperX: email request to test staging
Manager --> DeveloperY: email request to test staging

note over DeveloperY
	DeveloperY is taking on the role
	of tester in this example
end note


loop until staging test signoff
	S -> DeveloperY: pulls staging branch for testing
	S -> LY: git pull
	DeveloperY -> LY: commits bugfixes to forked git repo
	LY -> S : git pull request
	S -> Manager : emailed pull request
	Manager -> S: do merge to staging
	S -> S : git merge
end

==Signoffs for staging tests collected from all parties==

Manager -> S: do merge
S -> M: staging merged to master branch

@enduml

ony/pjson - json-loop-overflow.txt

COPY

@startuml
title Overflow scenario

actor client as "Client"
participant parser as "some : Parser"
participant buffer1 as "buffer1 : Buffer"
participant buffer2 as "buffer2 : Buffer"
participant chunk1 as "chunk1 : Buffer"
participant chunk2 as "chunk2 : Buffer"

create buffer1
client -> buffer1: allocate
client -> parser: initialize with buffer1

create chunk1
client -> chunk1: read
client -> parser: feed chunk1
client -> parser: pull n tokens
activate parser
client <-- parser: some token
client <-- parser: overflow
note right: second token didn't fit into buffer1
deactivate parser

create buffer2
client -> buffer2: allocate
client -> parser: realloc with buffer2
activate parser
note right of parser: some part of buffer1 may be copied to buffer2
client <-- parser
deactivate parser
client -> buffer1: free
destroy buffer1

client -> parser: pull n tokens
activate parser
client <-- parser: starving
deactivate parser

create chunk2
client -> chunk2: read
client -> parser: feed chunk2
client -> parser: pull n tokens
activate parser
client <-- parser: some token
client <-- parser: starving
deactivate parser
@enduml

watermint/PlantUML4Markdown - sample.md

COPY

@startuml
PlantUML4Markdown -> "Markdown (orig)" : Read
PlantUML4Markdown -> "PlantUML (markup)" : Generate
PlantUML4Markdown -> "Markdown (converted)" : Generate
PlantUML -> "PlantUML (markup)" : Read
PlantUML -> "UML Diagram (image)" : Generate
@enduml

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

COPY

@startuml

'Copyright (c) 2015 Ken Barker

'title HTTP Expect 100 Continue Sequence 

actor client
client -> http_server : HTTP request with header,\n expects: 100-Continue
opt default
  http_server -> http_server : response status = 100 Continue
else expect continue handler
  http_server -> application : expect continue
  http_server <- application : response
end
client <- http_server : HTTP response 

@enduml

bundy-dns/bundy - me...gr-mapped-reload.txt

COPY

@startuml

participant memmgr as ":bundy-memmgr"
[-> memmgr: reload\n(zonename)
activate memmgr

participant list as ":Configurable\nClientList"
memmgr -> list: getCachedZoneWriter\n(zone_name)
activate list

participant CacheConfig as ":CacheConfig"

participant zt_segment as ":ZoneTable\nSegment\n(Mapped)"
participant segment as "existing:Memory\nSegment\n(Mapped)"
participant segment2 as "new:Memory\nSegment\n(Mapped)"

list -> zt_segment: isWritable()
activate zt_segment
zt_segment --> list: true
deactivate zt_segment

list -> CacheConfig: getLoadAction()
activate CacheConfig

participant ZoneTable as ":ZoneTable"
participant ZoneWriter as "zw:ZoneWriter"

participant LoadAction as "la:LoadAction"
create LoadAction
CacheConfig -> LoadAction: <<construct>>
CacheConfig --> list: la
deactivate CacheConfig

create ZoneWriter
list -> ZoneWriter: <<construct>> (la)
list --> memmgr: zw
deactivate list

memmgr -> ZoneWriter: load()
activate ZoneWriter
ZoneWriter -> LoadAction: (funcall)
activate LoadAction

participant ZoneData as "zd_existing\n:ZoneData"
participant ZoneData2 as "zd_new\n:ZoneData"

create ZoneData2
LoadAction -> ZoneData2: <<construct>> via helpers

LoadAction --> ZoneWriter: zd_new
deactivate LoadAction
deactivate ZoneWriter

memmgr -> ZoneWriter: install()
activate ZoneWriter

ZoneWriter -> ZoneTable: addZone(zd_new)
activate ZoneTable
ZoneTable --> ZoneWriter: zd_existing (old data)
deactivate ZoneTable

deactivate ZoneWriter

memmgr -> ZoneWriter: cleanup()
activate ZoneWriter

ZoneWriter -> ZoneData: <<destroy>>
destroy ZoneData
deactivate ZoneWriter

[<- memmgr: command to\nmodules\n(datasrc_name,\nsegmentparam)
[--> memmgr: ack from all\nmodules

memmgr -> list: resetMemorySegment\n(datasrc_name,\nREAD_WRITE,\nsegmentparam)
activate list

list -> zt_segment: reset\n(READ_WRITE,\nsegmentparam)
activate zt_segment

zt_segment -> segment: <<destroy>>
destroy segment
create segment2
zt_segment -> segment2: <<construct>>

deactivate zt_segment
deactivate list

note left of memmgr: (repeat the\nsame sequence\nfor loading to the\nother segment)

memmgr -> list: getCachedZoneWriter\n(zone_name)

...

@enduml