clang uml
0.5.6
clang-uml adalah generator diagram, urutan, paket, dan penyertaan C++ ke UML otomatis, yang digerakkan oleh file konfigurasi YAML. Ide utama di balik proyek ini adalah untuk dengan mudah memelihara diagram terkini dalam basis kode atau kode warisan dokumen. File konfigurasi atau file untuk clang-uml menentukan jenis dan konten setiap diagram yang dihasilkan. Diagram dapat dibuat dalam format PlantUML, MermaidJS dan JSON.
clang-uml saat ini mendukung C++ hingga versi 20, serta C dan Objective-C.
Dokumentasi lengkap dapat ditemukan di clang-uml.github.io.
Untuk melihat apa yang dapat dilakukan clang-uml , lihat diagram yang dihasilkan untuk kasus pengujian unit di sini atau contoh di repositori clang-uml-examples.
Fitur utama yang didukung sejauh ini meliputi:
Dokumentasi lebih lengkap bisa di clang-uml.github.io.
Petunjuk instalasi untuk Linux , macos dan Windows dapat ditemukan di sini.
clang-uml memerlukan file kompilasi_commands.json terbaru, yang berisi daftar perintah yang digunakan untuk mengkompilasi kode sumber.
Lihat di sini untuk petunjuk tentang cara membuat compile_commands.json menggunakan beberapa sistem build C++ yang ada.
Secara default, clang-uml akan berasumsi bahwa file konfigurasi .clang-uml dan file kompilasi database compile_commands.json berada di direktori saat ini, jadi jika mereka berada di direktori tingkat atas suatu proyek, jalankan saja:
clang-uml Jalur keluaran diagram, serta lokasi alternatif database kompilasi dapat ditentukan dalam file konfigurasi .clang-uml atau melalui parameter baris perintah.
Untuk opsi lain lihat bantuan:
clang-uml --help File konfigurasi ditulis dalam YAML, dan memberikan definisi diagram yang harus dihasilkan oleh clang-uml . Contoh dasarnya adalah sebagai berikut:
compilation_database_dir : .
output_directory : diagrams
diagrams :
myproject_class :
type : class
glob :
- src/*.cc
using_namespace : myproject
include :
namespaces :
- myproject
exclude :
namespaces :
- myproject::detail
plantuml :
after :
- ' note left of {{ alias("MyProjectMain") }}: Main class of myproject library. 'Lihat di sini untuk panduan referensi file konfigurasi terperinci.
Untuk melihat apa yang dapat dilakukan clang-uml , telusuri dokumentasi kasus uji di sini.
Untuk melihat diagram clang-uml itu sendiri, berdasarkan konfigurasinya, jalankan perintah berikut:
make clanguml_diagrams dan buka diagram SVG di folder docs/diagrams .
Kode C++ berikut:
template < typename T, typename P> struct A {
T t;
P p;
};
struct B {
std::string value;
};
template < typename T> using AString = A<T, std::string>;
template < typename T> using AStringPtr = A<T, std::unique_ptr<std::string>>;
template < typename T>
using PairPairBA = std::pair<std::pair<B, A< long , T>>, long >;
template < class T > using VectorPtr = std::unique_ptr<std::vector<T>>;
template < class T > using APtr = std::unique_ptr<A< double , T>>;
template < class T > using ASharedPtr = std::shared_ptr<A< double , T>>;
template < class T , class U >
using AAPtr = std::unique_ptr<std::pair<A< double , T>, A< long , U>>>;
template < typename T> using SimpleCallback = std::function< void (T, int )>;
template < typename ... T> using GenericCallback = std::function< void (T..., int )>;
using VoidCallback = GenericCallback< void *>;
using BVector = std::vector<B>;
using BVector2 = BVector;
using AIntString = AString< int >;
using ACharString = AString< char >;
using AStringString = AString<std::string>;
using BStringString = AStringString;
template < typename T> class R {
using AWCharString = AString< wchar_t >;
PairPairBA< bool > bapair;
APtr< bool > abool;
AAPtr< bool , float > aboolfloat;
ASharedPtr< float > afloat;
A< bool , std::string> boolstring;
AStringPtr< float > floatstring;
AIntString intstring;
AStringString stringstring;
BStringString bstringstring;
AAPtr<T, float > atfloat;
protected:
BVector bs;
public:
BVector2 bs2;
SimpleCallback<ACharString> cb;
GenericCallback<AWCharString> gcb;
VoidCallback vcb;
VectorPtr<B> vps;
};menghasilkan diagram berikut (melalui PlantUML):
Buka gambar mentah di sini, dan periksa tooltips hover dan hyperlink ke kelas dan metode.
Kode C++ berikut:
# include < atomic >
# include < functional >
# include < iostream >
# include < memory >
# include < string >
namespace clanguml {
namespace t20029 {
std::string encode_b64 (std::string &&content) { return std::move (content); }
template < typename T> class Encoder : public T {
public:
bool send (std::string &&msg)
{
return T::send ( std::move (
// Encode the message using Base64 encoding and pass it to the next
// layer
encode ( std::move (msg))));
}
protected:
std::string encode (std::string &&msg) { return encode_b64 ( std::move (msg)); }
};
template < typename T> class Retrier : public T {
public:
bool send (std::string &&msg)
{
std::string buffer{ std::move (msg)};
int retryCount = 5 ;
// Repeat until send() succeeds or retry count is exceeded
while (retryCount--) {
if ( T::send (buffer))
return true ;
}
return false ;
}
};
class ConnectionPool {
public:
void connect ()
{
if (!is_connected_. load ())
connect_impl ();
}
bool send ( const std::string &msg) { return true ; }
private:
void connect_impl () { is_connected_ = true ; }
std::atomic< bool > is_connected_;
};
int tmain ()
{
auto pool = std::make_shared<Encoder<Retrier<ConnectionPool>>>();
// Establish connection to the remote server synchronously
pool-> connect ();
// Repeat for each line in the input stream
for (std::string line; std::getline (std::cin, line);) {
if (!pool-> send ( std::move (line)))
break ;
}
return 0 ;
}
}
}menghasilkan diagram berikut (melalui PlantUML):
Kode C++ berikut:
namespace clanguml {
namespace t30003 {
namespace ns1 {
namespace ns2_v1_0_0 {
class A {
};
}
namespace [ [deprecated]] ns2_v0_9_0 {
class A {
};
}
namespace {
class Anon final {
};
}
}
namespace [ [deprecated]] ns3 {
namespace ns1 ::ns2 {
class Anon : public t30003 ::ns1::ns2_v1_0_0::A {
};
}
class B : public ns1 ::ns2::Anon {
};
}
}
}menghasilkan diagram berikut (melalui PlantUML):
Jika Anda mencari alat yang lebih sederhana untuk memvisualisasikan dan menganalisis grafik sertakan, lihat alat saya yang lain - clang-include-graph
Struktur kode C++ berikut:
tests/t40001
├── include
│ ├── lib1
│ │ └── lib1.h
│ └── t40001_include1.h
└── src
└── t40001.cc
menghasilkan diagram berikut (melalui PlantUML) berdasarkan arahan yang disertakan dalam kode:
| UML | TanamanUML | Putri DuyungJS |
|---|---|---|
| Warisan |  |  |
| Asosiasi |  |  |
| Ketergantungan |  |  |
| Pengumpulan |  |  |
| Komposisi |  |  |
| Spesialisasi/instansiasi templat |  |  |
| Bersarang (kelas dalam/enum) |  |  |
| Sertakan (lokal) | | |
| Sertakan (sistem) | | |
Untuk basis kode pada umumnya, satu diagram yang dihasilkan dari keseluruhan kode atau bahkan satu namespace bisa jadi terlalu besar untuk berguna, misalnya sebagai bagian dari dokumentasi. clang-uml memungkinkan penentuan konten untuk disertakan dan dikecualikan dari setiap diagram menggunakan konfigurasi YAML sederhana:
include :
# Include only elements from these namespaces
namespaces :
- clanguml::common
- clanguml::config
# Include all subclasses of ClassA (including ClassA)
subclasses :
- clanguml::common::ClassA
# and specializations of template Class<T> (including Class<T>)
specializations :
- clanguml::common::ClassT<T>
# and all classes depending on Class D
dependants :
- clanguml::common::ClassD
# and all dependencies of ClassE
dependencies :
- clanguml::common::ClassE
# and classes in direct relation to ClassB (including ClassB)
context :
- clanguml::common::ClassB
# Include only inheritance relationships
relationships :
- inheritance
exclude :
# Exclude all elements from detail namespace
namespaces :
- clanguml::common::detail
# and also exclude ClassF
elements :
- clanguml::common::ClassFDetail lebih lanjut mengenai hal ini dapat ditemukan di bagian dokumentasi diagram filter.
Kasus uji bawaan yang digunakan untuk pengujian unit clang-uml , dapat dilihat di sini.
Proyek ini bergantung pada alat-alat hebat berikut:
Jika Anda ingin berkontribusi pada proyek ini, silakan lihat pedoman berkontribusi.
Copyright 2021-present Bartek Kryza <[email protected]>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
