cinch
Release 1.0
Cinch เป็นชุดของยูทิลิตี้และตัวเลือกการกำหนดค่าที่ออกแบบมาเพื่อให้ CMake สร้างและจัดการได้ง่าย
Cinch ใช้คุณสมบัติการติดตั้ง CMake มาตรฐาน อย่างไรก็ตามเนื่องจาก Cinch ขึ้นอยู่กับเครื่องมือบรรทัดคำสั่งของตัวเอง (cinch-utils) เพื่อสร้างเอกสารของมันจึงต้องติดตั้งในขั้นตอนที่บันทึกไว้ในส่วนนี้
เส้นทางสำหรับการติดตั้ง cinch-utils อยู่ที่นี่
ในการติดตั้งเอกสารประกอบ CINCH คุณควรเรียกใช้ CMAKE ในไดเรกทอรี CINCH Build พร้อมเอกสารประกอบ: เปิดใช้งานเอกสาร:
% cmake -DCMAKE_INSTALL_PREFIX=/path/to/install -DENABLE_DOCUMENTATION=ON ..
% make install
ระบบสร้าง Cinch ได้รับการออกแบบมาเพื่อให้การพัฒนารหัสแบบแยกส่วนง่ายขึ้น โดย Modular เราหมายความว่าโครงการย่อยสามารถรวมเข้ากับโครงการระดับบนสุดที่ใช้ CINCH และพวกเขาจะถูกเพิ่มเข้าไปในเป้าหมายการสร้างของโครงการระดับบนสุดโดยอัตโนมัติ สิ่งนี้ทำให้ง่ายต่อการสร้างโครงการใหม่ที่รวมความสามารถของชุดย่อยชุดย่อย สิ่งนี้ช่วยให้ผู้ใช้สามารถสร้างฟังก์ชั่นและควบคุมการทำงานของโครงการระดับบนสุด
Cinch ห้ามมิให้ผู้ใช้สร้างการสร้างในสถานที่เช่นสร้างที่หยั่งรากในไดเรกทอรีโครงการระดับบนสุดของโครงการ CINCH หากผู้ใช้พยายามกำหนดค่าการสร้างดังกล่าว CMake จะออกจากข้อผิดพลาดและคำแนะนำสำหรับวิธีการทำความสะอาดและสร้างงานสร้างที่ไม่ได้รับแหล่ง
cinch ช่วยลดการบำรุงรักษาระบบโดยกำหนดโครงสร้างเฉพาะบนเค้าโครงแหล่งที่มาของโครงการ
project/
app/ (optional application subdirectory)
cinch/
CMakeLists.txt -> cinch/cmake/ProjectLists.txt
config/
documentation.cmake
packages.cmake
project.cmake
doc/
src/ (optional library source subdirectory)
CMakeLists.txt -> cinch/cmake/SourceLists.txt
คุณอาจมี submodules จำนวนมากภายใต้ไดเรกทอรีโครงการ
ไดเรกทอรีระดับบนสุดของโครงการ
ไดเรกทอรีย่อยเป้าหมายแอปพลิเคชัน เป้าหมายแอปพลิเคชันสามารถเพิ่มได้โดยใช้ cinch_add_application_directory ที่บันทึกไว้ด้านล่าง ไดเรกทอรีย่อยนี้ควรมีไฟล์ cmakelists.txt ที่เพิ่มเป้าหมาย CMake ใด ๆ ที่จำเป็นสำหรับแอปพลิเคชันเฉพาะ
ไดเรกทอรีย่อย Cinch สิ่งนี้ควรตรวจสอบจากเซิร์ฟเวอร์ Cinch Git: 'Git Clone-recursive [email protected]: Losalamos/cinch.git'
สร้างไฟล์ซึ่งตั้งค่า cmake_minimum_required () และรวมไฟล์ cinch projectlists.txt
ไดเรกทอรีการกำหนดค่าโครงการ ไดเรกทอรีนี้ครอบคลุมรายละเอียดด้านล่าง
ไดเรกทอรีย่อยเอกสาร ไดเรกทอรีย่อยนี้ควรมีไฟล์การกำหนดค่าสำหรับเอกสารคู่มือที่สร้างจาก CINCH และสำหรับเอกสารอินเทอร์เฟซ Doxygen
ไดเรกทอรีย่อยแหล่งที่มาของไลบรารีเป้าหมาย เป้าหมายห้องสมุดสามารถเพิ่มได้โดยใช้ cinch_add_library_target ที่บันทึกไว้ด้านล่าง
ไดเรกทอรีย่อย config ต้องมีไฟล์ต่อไปนี้ที่ให้ความเชี่ยวชาญของโครงการ แม้ว่าไฟล์ทั้งหมดจะต้องมีอยู่ แต่ไฟล์เดียวที่จำเป็นต้องมีเนื้อหาคือไฟล์ Project.cmake
ไฟล์นี้ไม่สามารถว่างเปล่า อย่างน้อยที่สุดจะต้องระบุชื่อของโครงการระดับบนสุดโดยเรียกใช้ฟังก์ชัน โครงการ CMake เพื่อตั้งค่าชื่อเวอร์ชันและภาษาที่เปิดใช้งานสำหรับโครงการทั้งหมด สำหรับเอกสารเพิ่มเติมที่พรอมต์บนเครื่องที่มีการติดตั้ง CMake ที่ถูกต้องพิมพ์:
% cmake -โครงการช่วยเหลือ
นอกจากนี้ไฟล์นี้อาจเรียกใช้ฟังก์ชัน cinch ต่อไปนี้ (อาจถูกทิ้งไว้):
cinch_add_application_directory (บันทึกไว้ที่นี่)
เพิ่มไดเรกทอรีบิลด์เฉพาะโครงการที่ควรรวมไว้โดย CMAKE เมื่อค้นหาไฟล์รายการ ไดเรกทอรีนี้ควรมีไฟล์ cmakelists.txt ที่ถูกต้องที่กำหนดค่าเป้าหมายการสร้างเพิ่มเติม
cinch_add_library_target (บันทึกไว้ที่นี่)
เพิ่มเป้าหมายห้องสมุดเพื่อสร้างสำหรับโครงการนี้
cinch_add_subproject (บันทึกไว้ที่นี่)
เพิ่มโครงการย่อยในโครงการนี้
ไฟล์นี้ใช้เพื่อระบุข้อกำหนด CMAKE Find_Package สำหรับการค้นหาแพ็คเกจบุคคลที่สามที่ติดตั้ง เนื้อหาของไฟล์นี้สามารถเป็นชุดคำสั่ง CMake ที่ถูกต้อง ค่าที่ตั้งไว้ในไฟล์นี้จะพร้อมใช้งานสำหรับไฟล์ cmakelists.txt ระดับต่ำสำหรับการกำหนดค่าตัวเลือกการสร้างระดับต้นทาง
ไฟล์นี้ใช้เพื่อเพิ่มเป้าหมายเอกสารด้วยอินเทอร์เฟซ cinch_add_doc (เอกสาร Doxygen ได้รับการจัดการแยกกัน)
CINCH มีตัวเลือกบรรทัดคำสั่งต่าง ๆ ที่อาจส่งผ่านในสายการกำหนดค่า CMAKE เพื่อส่งผลกระทบต่อพฤติกรรมของมัน
ตัวเลือก cmake: enable_cinch_development (ปิดเริ่มต้น)
ใส่ cinch เข้าสู่โหมดการพัฒนา ตัวเลือกนี้มีผลต่อข้อมูลบางส่วนที่สร้างขึ้นโดย CINCH ซึ่งเป็นประโยชน์สำหรับผู้สมัครที่ไม่ได้เปิดตัว หากเปิดใช้งานตัวเลือกนี้จะเปิดคุณสมบัติต่อไปนี้:
ตัวเลือก cmake: enable_cinch_verbose (ปิดเริ่มต้น)
เปิดใช้งานการสร้างรายละเอียดเพิ่มเติม
ตัวเลือก cmake: enable_documentation (ปิดเริ่มต้น)
Cinch มีสิ่งอำนวยความสะดวกเอกสารที่ทรงพลังนำมาใช้โดยใช้ยูทิลิตี้บรรทัดคำสั่ง CINCH และ PANDOC ในการสร้างเอกสารให้กำหนดไฟล์การกำหนดค่าสำหรับแต่ละเอกสารที่ควรสร้างในไดเรกทอรีย่อย 'DOC' จากนั้นเพิ่มไฟล์ markdown (.MD) หรือ laTex (.tex) ลงในแผนผังต้นทางซึ่งเอกสารใดก็ตามของโครงการควรรวมไว้ด้วย ข้อแม้คือชิ้นส่วนเอกสารเหล่านี้ควรมีส่วนหัวความคิดเห็นพิเศษที่จุดเริ่มต้นของแต่ละแบบฟอร์ม:
<!-- CINCHDOC DOCUMENT(Name of Document) SECTION(Name of Section) -->
ส่วนหัวพิเศษนี้ระบุว่าเอกสารใดที่มีจุดประสงค์และส่วนที่ควรปรากฏ ส่วนหัวอาจครอบคลุมหลายบรรทัดโดยที่ <!-- CINCHDOC เริ่มความคิดเห็น หากไม่มีการระบุแอตทริบิวต์ (เอกสารส่วน ฯลฯ ) ยูทิลิตี้จะใช้เอกสารเริ่มต้นและส่วน ('เริ่มต้น' และ 'เริ่มต้น') หลายชิ้นส่วนที่มีไว้สำหรับเอกสารและส่วนต่าง ๆ อาจรวมอยู่ในไฟล์อินพุตเดียว สำหรับชิ้นส่วนยางพาราให้ใช้ส่วนหัวของแบบฟอร์ม:
% CINCHDOC DOCUMENT(Name of Document) SECTION(Name of Section)
ส่วนหัว cinchdoc สไตล์น้ำยางต้องอยู่ในบรรทัดเดียว
สามารถเพิ่มเป้าหมายการสร้างลงในเอกสาร CMMAKE ในไดเรกทอรี config แต่ละเป้าหมายควรสร้างโดยการโทร:
cinch_add_doc (target-name config.py เอาท์พุทระดับบนสุด-การค้นหา-ไดเรกทอรี)
Target-name ป้ายกำกับการสร้างเป้าหมายเช่นการสร้างเป้าหมายจะถูกสร้างขึ้นซึ่งสามารถเรียกใช้ 'make-name' เพื่อสร้างเป้าหมายเอกสาร
config.py ไฟล์การกำหนดค่าที่ต้องอยู่ในไดเรกทอรีย่อย 'Doc' ของไดเรกทอรีระดับบนสุดของโครงการของคุณ ไฟล์นี้ควรมี การเลือก พจนานุกรม Python เดียวที่ตั้งค่าตัวเลือกอินเทอร์เฟซบรรทัดคำสั่ง CINCH สำหรับเอกสารของคุณ
การค้นหาระดับสูงสุด-ไดเรกทอรี เส้นทาง สัมพัทธ์ ไปยังหัวของแผนผังไดเรกทอรีภายในเพื่อค้นหาไฟล์เอกสารมาร์เดอร์
เอาต์พุต ชื่อของไฟล์เอาต์พุตที่ควรผลิตโดย Pandoc
ตัวเลือก cmake: enable_doxygen (ปิดเริ่มต้น) ตัวเลือก cmake: enable_doxygen_warn (ปิดเริ่มต้น)
CINCH รองรับเอกสารอินเทอร์เฟซโดยใช้ Doxygen ไฟล์กำหนดค่า doxygen ควรเรียกว่า 'doxygen.conf.in' และควรอยู่ในไดเรกทอรีย่อย 'Doc' สำหรับเอกสารเกี่ยวกับการใช้ Doxygen โปรดดูหน้าแรกของ Doxygen
หากตั้งค่า enable_doxygen_warn เป็น ON การวินิจฉัย doxygen ปกติและคำเตือนจะไม่ถูกระงับ
ตัวเลือก cmake: enable_unit_tests (ปิดเริ่มต้น)
CINCH มีการสนับสนุนการทดสอบหน่วยโดยใช้การรวมกันของ CTEST (สถานที่ทดสอบ CMAKE ดั้งเดิม) และ GOOGLETEST (สำหรับการสนับสนุน C ++) หากเปิดใช้งานการทดสอบหน่วย CINCH จะสร้างเป้าหมาย 'ทดสอบ' การทดสอบหน่วยอาจถูกเพิ่มในไดเรกทอรีย่อยใด ๆ ของโครงการเพียงแค่สร้างซอร์สโค้ดทดสอบและเพิ่มเป้าหมายโดยใช้ฟังก์ชั่น 'cinch_add_unit (เป้าหมาย [รายการแหล่งที่มา])'
Cinch จะตรวจสอบการติดตั้ง googletest ในท้องถิ่นบนระบบในระหว่างขั้นตอนการกำหนดค่า CMake หากไม่พบ googletest มันจะถูกสร้างขึ้นโดย cinch (ซอร์สโค้ด googletest รวมอยู่ใน cinch)
ตัวเลือก cmake: clog_enable_stdlog (ปิดเริ่มต้น)
ตัวเลือก cmake: clog_strip_level (ค่าเริ่มต้น "0")
ตัวเลือก cmake: clog_tag_bits (ค่าเริ่มต้น "16")
ตัวเลือก cmake: clog_color_output (ค่าเริ่มต้น)
Cinch มีการสนับสนุนสำหรับการติดตามข้อมูลข้อมูลเตือนข้อผิดพลาดและการรายงานการบันทึกร้ายแรง (คล้ายกับ Google Log) มีสองรูปแบบอินเทอร์เฟซสำหรับการบันทึกข้อมูลโดยใช้การอุดตัน: สไตล์การแทรกเช่น
clog (info) << "This is some information" << std::endl;และอินเทอร์เฟซวิธีการเช่น
clog_info ( " This is some information " );รูปแบบอินเทอร์เฟซทั้งสองมีให้สำหรับทุกระดับความรุนแรง (กล่าวถึงด้านล่าง)
หมายเหตุ: การอุดตันพร้อมใช้งานโดยอัตโนมัติสำหรับการทดสอบหน่วย CINCH
clog_init ( " group1,group2,group3 " ); clog (error) << "This is an error level severity message" << std::endl; clog_info ( " The number is " << number); clog_every_n (ความรุนแรง, ข้อความ, n)
เอาต์พุตทุกการทำซ้ำครั้งที่ n โดยใช้ ความรุนแรง และ ข้อความ วิธีนี้ไม่ได้กำหนดไว้สำหรับระดับความรุนแรงที่ร้ายแรงหรือการยืนยัน
clog_assert (ทดสอบข้อความ)
ยืนยันว่า การทดสอบ นั้นเป็นจริง หาก การทดสอบ เป็นเท็จการโทรนี้จะดำเนินการ clog_fatal (ข้อความ)
clog_add_buffer (ชื่อ, ostream, สี)
เพิ่มบัฟเฟอร์ที่กำหนดโดยอาร์กิวเมนต์ Ostream ใน RDBUF () ชื่อ พารามิเตอร์ที่สองคือชื่อสตริงที่จะเชื่อมโยงกับบัฟเฟอร์และสามารถใช้ในการโทรไปยังอินเตอร์เฟสบัฟเฟอร์อุดตันในภายหลัง พารามิเตอร์สุดท้ายระบุว่าบัฟเฟอร์รองรับเอาต์พุตสีหรือไม่
clog_enable_buffer (ชื่อ)
เปิดใช้งานบัฟเฟอร์ที่ระบุตาม ชื่อ
clog_disable_buffer (ชื่อ)
ปิดการใช้งานบัฟเฟอร์ที่ระบุตาม ชื่อ
อุดตันสามารถเขียนเอาต์พุตไปยังสตรีมเอาท์พุทหลายตัวในครั้งเดียว ผู้ใช้สามารถควบคุมไฟล์บันทึกและเอาต์พุตที่สร้างขึ้นโดยการเพิ่มและเปิดใช้งาน/ปิดการใช้งานสตรีมเอาต์พุตต่างๆ โดยค่าเริ่มต้นการอุดตันจะส่งเอาต์พุตไปยัง std :: clog (นี่คือ iostream บันทึก C ++ เริ่มต้นและไม่ได้เป็นส่วนหนึ่งของการอุดตัน) เมื่อมีการกำหนดตัวแปรสภาพแวดล้อม clog_enable_stdlog สตรีมเอาท์พุทอื่น ๆ จะต้องเพิ่มโดยแอปพลิเคชันผู้ใช้ ตัวอย่างเช่นหากแอปพลิเคชันผู้ใช้ต้องการปิดการอุดตันไปที่ไฟล์ชื่อ output.log หนึ่งสามารถทำสิ่งต่อไปนี้:
# include < ofstream >
# include " cinchlog.h "
int main ( int argc, char ** argv) {
// Initialize CLOG with output for all tag groups (discussed below)
clog_init ( " all " );
// Open an output stream for "output.log"
std::ofstream output ( " output.log " );
// Add the stream to CLOG:
// param 1 ("output") The string name of the buffer.
// param 2 (output) The stream (CLOG will call stream.rdbuf() on this).
// param 3 (false) A boolean denoting whether or not the buffer
// supports colorization.
//
// Note that output is automatically enabled for buffers when they
// are added. Buffers can be disable with clog_disable_buffer(string name),
// and re-enabled with clog_enable_buffer(string name).
clog_add_buffer ( " output " , output, false );
// Write some information to the output file (and to std::clog if enabled)
clog (info) << " This will go to output.log " << std::endl;
return 0 ;
} // mainเอาต์พุตอุดตันสามารถควบคุมได้ในเวลารวบรวมโดยการระบุระดับความรุนแรงโดยเฉพาะ ข้อความการบันทึกใด ๆ ที่มีระดับความรุนแรงต่ำกว่าข้อความที่ระบุโดย clog_strip_level จะถูกปิดใช้งาน โปรดทราบว่านี่หมายความว่าการอุดตันจะไม่สร้างผลลัพธ์สำหรับ clog_strip_level> = 5
ระดับความรุนแรงที่แตกต่างมีพฤติกรรมดังต่อไปนี้:
ติดตาม
เปิดใช้งานสำหรับระดับความรุนแรง 0 (น้อยกว่า 1)
ร่องรอยเอาท์พุทเหมาะสำหรับข้อมูลการบันทึกอย่างละเอียด
ข้อมูล
เปิดใช้งานสำหรับระดับความรุนแรงน้อยกว่า 2
เอาต์พุตข้อมูลเหมาะสำหรับข้อมูลการบันทึกปกติ
เตือน
เปิดใช้งานสำหรับระดับความรุนแรงน้อยกว่า 3
เตือนเอาท์พุทมีประโยชน์สำหรับการออกคำเตือน เมื่อเปิดใช้งาน CLOG_COLOR_OUTPUT ข้อความเตือนจะแสดงเป็นสีเหลือง
ข้อผิดพลาด
เปิดใช้งานสำหรับระดับความรุนแรงน้อยกว่า 4
เอาท์พุทข้อผิดพลาดมีประโยชน์สำหรับการออกข้อผิดพลาดที่ไม่ใช่อันตราย เมื่อเปิดใช้งาน CLOG_COLOR_OUTPUT ข้อความแสดงข้อผิดพลาดจะปรากฏเป็นสีแดง
ร้ายแรง
เปิดใช้งานสำหรับระดับความรุนแรงน้อยกว่า 5
เอาต์พุตข้อผิดพลาดร้ายแรงมีประโยชน์สำหรับการออกข้อผิดพลาดร้ายแรง ข้อผิดพลาดร้ายแรงพิมพ์ข้อความถ่ายโอนร่องรอยสแต็กปัจจุบันและโทรหา std :: ออก (1) เมื่อเปิดใช้งาน CLOG_COLOR_OUTPUT ข้อความที่ร้ายแรงจะปรากฏเป็นสีแดง
การควบคุมรันไทม์ของเอาต์พุตอุดตันเป็นไปได้โดยการเพิ่มส่วนการเลื่อนในซอร์สโค้ด สิ่งเหล่านี้เรียกว่า กลุ่มแท็ก เนื่องจากส่วนที่กำหนดขอบเขตมีป้ายกำกับด้วยแท็ก จำนวนกลุ่มแท็กที่เป็นไปได้ถูกควบคุมโดย clog_tag_bits (ค่าเริ่มต้น 16) กลุ่มแท็กสามารถเปิดใช้งานหรือปิดใช้งานได้ที่รันไทม์โดยระบุรายการของกลุ่มแท็กไปยังฟังก์ชัน clog_init โดยทั่วไปสิ่งเหล่านี้จะถูกควบคุมโดยธงบรรทัดคำสั่งที่ตีความโดยแอปพลิเคชันของผู้ใช้ นี่คือรหัสตัวอย่างที่ใช้ GFLAGS เพื่อควบคุมเอาต์พุต:
# include < gflags/gflags.h >
// Create a command-line flag "--groups" with default value "all"
DEFINE_string (groups, " all " , " Specify the active tag groups " );
# include " cinchlog.h "
int main ( int argc, char ** argv) {
// Parse the command-line arguments
gflags::ParseCommandLineFlags (&argc, &argv, true );
// If the user has specified tag groups with --groups=group1, ...
// these groups will be enabled. Recall that the default is "all".
clog_init (FLAGS_groups);
{
// Create a new tag scope. Log messages within this scope will
// only be output if tag group "tag1" or tag group "all" is enabled.
clog_tag_scope (tag1);
clog (info) << " Enabled for tag group tag1 " << std::endl;
clog (warn) << " This is a warning in group tag1 " << std::endl;
} // scope
{
// Create a new tag scope. Log messages within this scope will
// only be output if tag group "tag2" or tag group "all" is enabled.
clog_tag_scope (tag2);
clog (info) << " Enabled for tag group tag2 " << std::endl;
clog (error) << " This is an error in group tag2 " << std::endl;
} // scope
clog (info) << " This output is not scoped " << std::endl;
return 0 ;
} // mainตัวอย่างรหัสรัน:
% ./example --groups=tag1
% [I1225 11:59:59 example.cc:22] Enabled for tag group tag1
% [W1225 11:59:59 example.cc:24] This is a warning in group tag1
% [I1225 11:59:59 example.cc:37] This output is not scoped
% ./example --groups=tag2
% [I1225 11:59:59 example.cc:32] Enabled for tag group tag1
% [E1225 11:59:59 example.cc:34] This is an error in group tag2
% [I1225 11:59:59 example.cc:37] This output is not scoped
% ./example
% [I1225 11:59:59 example.cc:22] Enabled for tag group tag1
% [W1225 11:59:59 example.cc:24] This is a warning in group tag1
% [I1225 11:59:59 example.cc:32] Enabled for tag group tag1
% [E1225 11:59:59 example.cc:34] This is an error in group tag2
% [I1225 11:59:59 example.cc:37] This output is not scoped
อินเทอร์เฟซ CLOG ปกติถูกนำมาใช้ผ่านชุดของมาโคร ผู้ใช้ขั้นสูงที่ต้องการการควบคุมการอุดตันมากขึ้นสามารถสร้างอินเทอร์เฟซของตัวเอง (แมโครหรืออื่น ๆ ) เพื่อเข้าถึงอินเทอร์เฟซ clog ระดับต่ำโดยตรง บันทึกข้อความในการอุดตันมาจากประเภท cinch :: log_message_t ซึ่งให้ตัวสร้าง, destructor เสมือนจริงและวิธีสตรีมเสมือนจริง:
template < typename P>
struct log_message_t
{
// Constructor:
// param 1 (file) The originating file of the message (__FILE__)
// param 2 (line) The originating line of the mesasge (__LINE__)
// param 3 (predicate) A predicate function that can be used to
// control output.
log_message_t (
const char * file,
int line,
P && predicate
)
{
// See cinchlog.h for implementation.
} // log_message_t
// Destructor.
virtual
~log_message_t ()
{
// See cinchlog.h for implementation.
} // ~log_message_t
// Stream method.
virtual
std::ostream &
stream ()
{
// See cinchlog.h for implementation.
} // stream
}; // struct log_message_tผู้ใช้ที่ต้องการปรับแต่งการอุดตันสามารถเปลี่ยนพฤติกรรมเริ่มต้นโดยการเอาชนะวิธีการเสมือนของประเภทนี้และโดยการจัดทำเพรดิเคตที่กำหนดเอง ฟังก์ชั่นการอุดตันพื้นฐานส่วนใหญ่ดำเนินการในลักษณะนี้เช่นรหัสต่อไปนี้ใช้เอาต์พุตความรุนแรงระดับการติดตาม:
# define severity_message_t ( severity, P, format )
struct severity ## _log_message_t
: public log_message_t <P>
{
severity ## _log_message_t (
const char * file,
int line,
P && predicate = true_state)
: log_message_t <P>(file, line, predicate) {}
~severity ## _log_message_t ()
{
/* Clean colors from the stream */
clog_t::instance (). stream () << COLOR_PLAIN;
}
std::ostream &
stream () override
/* This is replaced by the scoped logic */
format
};
// ----------------------------------------------------------------------------//
// Define the insertion style severity levels.
// ----------------------------------------------------------------------------//
# define message_stamp
timestamp () << " " << rstrip<'/'>(file_) << ":" << line_
severity_message_t(trace, decltype(cinch::true_state),
{
# if CLOG_STRIP_LEVEL < 1
if ( clog_t::instance (). tag_enabled () && predicate_ ()) {
std::ostream & stream = clog_t::instance (). stream ();
stream << OUTPUT_CYAN ( " [T " ) << OUTPUT_LTGRAY (message_stamp);
stream << OUTPUT_CYAN ( " ] " );
return stream;
}
else {
return clog_t::instance (). null_stream ();
} // if
# else
return clog_t::instance (). null_stream ();
# endif
});ผู้ใช้ที่สนใจควรดูซอร์สโค้ดสำหรับตัวอย่างเพิ่มเติม
ตัวเลือก cmake: version_creation (ค่าเริ่มต้น 'git descrile')
Cinch สามารถสร้างข้อมูลเวอร์ชันสำหรับโครงการที่ใช้ Git โดยอัตโนมัติ คุณลักษณะนี้ใช้ฟังก์ชัน 'Git Design' ซึ่งสร้างเวอร์ชันจากแท็กคำอธิบายประกอบล่าสุดที่มีระดับแพตช์ตามจำนวนการคอมมิทเนื่องจากแท็กนั้นและคีย์แฮชบางส่วน ตัวอย่างเช่นหากแท็กคำอธิบายประกอบล่าสุดคือ "1.0" และมี 35 รายการตั้งแต่รุ่นที่สร้างขึ้น cinch จะคล้ายกับ: 1.0-35-G2F657A
สำหรับการเผยแพร่จริงวิธีนี้อาจไม่เหมาะสม ในกรณีนี้ CINCH ช่วยให้คุณสามารถแทนที่เวอร์ชันอัตโนมัติโดยการระบุเวอร์ชันคงที่เพื่อ CMAKE ผ่านตัวเลือกเวอร์ชัน _Creation เพียงตั้งค่าสิ่งนี้เป็นเวอร์ชันที่ต้องการและจะใช้
ซอฟต์แวร์นี้ได้รับการอนุมัติสำหรับการเปิดตัวโอเพ่นซอร์สและได้รับมอบหมาย LA-CC-15-070
ลิขสิทธิ์ (C) 2016, Los Alamos ความมั่นคงแห่งชาติ, LLC สงวนลิขสิทธิ์
ลิขสิทธิ์ 2016. Los Alamos ความมั่นคงแห่งชาติ, LLC. ซอฟต์แวร์นี้ผลิตภายใต้สัญญาของรัฐบาลสหรัฐ DE-AC52-06NA25396 สำหรับ Los Alamos National Laboratory (LANL) ซึ่งดำเนินการโดย Los Alamos National Security, LLC สำหรับกระทรวงพลังงานของสหรัฐอเมริกา รัฐบาลสหรัฐมีสิทธิ์ในการใช้ทำซ้ำและแจกจ่ายซอฟต์แวร์นี้ ทั้งรัฐบาลและ Los Alamos ความมั่นคงแห่งชาติ, LLC ไม่รับประกันใด ๆ โดยชัดแจ้งหรือบอกเป็นนัยหรือรับผิดชอบใด ๆ สำหรับการใช้ซอฟต์แวร์นี้ หากซอฟต์แวร์ได้รับการแก้ไขเพื่อสร้างงานอนุพันธ์ซอฟต์แวร์ที่ได้รับการแก้ไขควรทำเครื่องหมายไว้อย่างชัดเจนเพื่อไม่ให้สับสนกับเวอร์ชันที่มีให้จาก LANL
นอกจากนี้ยังอนุญาตให้มีการแจกจ่ายซ้ำและใช้ในรูปแบบแหล่งที่มาและไบนารีโดยมีหรือไม่มีการแก้ไขได้รับอนุญาตหากเป็นไปตามเงื่อนไขต่อไปนี้:
การแจกจ่ายซ้ำของซอร์สโค้ดจะต้องรักษาประกาศลิขสิทธิ์ข้างต้นรายการเงื่อนไขและข้อจำกัดความรับผิดชอบต่อไปนี้
การแจกจ่ายซ้ำในรูปแบบไบนารีจะต้องทำซ้ำประกาศลิขสิทธิ์ข้างต้นรายการเงื่อนไขและข้อจำกัดความรับผิดชอบต่อไปนี้ในเอกสารและ/หรือวัสดุอื่น ๆ ที่ได้รับการแจกจ่าย
ไม่ว่าจะเป็นชื่อของ Los Alamos Security, LLC, Los Alamos National Laboratory, Lanl, รัฐบาลสหรัฐฯหรือชื่อของผู้มีส่วนร่วมอาจถูกนำมาใช้เพื่อรับรองหรือส่งเสริมผลิตภัณฑ์ที่ได้จากซอฟต์แวร์นี้โดยไม่ได้รับอนุญาตเป็นลายลักษณ์อักษร
ซอฟต์แวร์นี้จัดทำโดย Los Alamos National Security, LLC และผู้สนับสนุน "ตามที่เป็นอยู่" และการรับประกันโดยชัดแจ้งหรือโดยนัยใด ๆ รวมถึง แต่ไม่ จำกัด เพียงการรับประกันโดยนัยของความสามารถในการค้าและความเหมาะสมสำหรับวัตถุประสงค์เฉพาะ ไม่ว่าในกรณีใด Los Alamos Security, LLC หรือผู้มีส่วนร่วมจะต้องรับผิดชอบต่อความเสียหายทางตรงทางอ้อม, โดยบังเอิญ, พิเศษ, เป็นแบบอย่างหรือความเสียหายที่ตามมา (รวมถึง แต่ไม่ จำกัด เพียงการจัดหาสินค้าหรือบริการทดแทนการสูญเสียการใช้ข้อมูล หรือผลกำไรหรือการหยุดชะงักทางธุรกิจ) อย่างไรก็ตามเกิดขึ้นและทฤษฎีความรับผิดใด ๆ ไม่ว่าจะเป็นในสัญญาความรับผิดที่เข้มงวดหรือการละเมิด (รวมถึงความประมาทเลินเล่อหรืออื่น ๆ ) ความเสียหายดังกล่าว
